From eaf4444c574755542c8c55ec56a00d323455ddd9 Mon Sep 17 00:00:00 2001 From: UNV Date: Sat, 12 Apr 2025 18:32:18 +0300 Subject: [PATCH 1/2] Reformatting query executors. --- .../PyDotNetSuperMethodsSearchExecutor.java | 39 +++---- .../PyJavaSuperMethodsSearchExecutor.java | 45 ++++---- ...efaultPyClassInheritorsSearchExecutor.java | 89 ++++++++------- ...aultPyOverridingMethodsSearchExecutor.java | 54 ++++----- .../DefaultPySuperMethodsSearchExecutor.java | 103 +++++++++--------- .../impl/psi/search/PyDefinitionsSearch.java | 44 ++++---- .../search/PyInitReferenceSearchExecutor.java | 67 ++++++------ .../PyKeywordArgumentSearchExecutor.java | 57 +++++----- .../psi/search/PyStringReferenceSearch.java | 42 +++---- 9 files changed, 276 insertions(+), 264 deletions(-) diff --git a/iron-python/src/main/java/consulo/ironPython/psi/impl/PyDotNetSuperMethodsSearchExecutor.java b/iron-python/src/main/java/consulo/ironPython/psi/impl/PyDotNetSuperMethodsSearchExecutor.java index 53155fd2..3ec5ed5b 100644 --- a/iron-python/src/main/java/consulo/ironPython/psi/impl/PyDotNetSuperMethodsSearchExecutor.java +++ b/iron-python/src/main/java/consulo/ironPython/psi/impl/PyDotNetSuperMethodsSearchExecutor.java @@ -28,23 +28,24 @@ /** * @author yole */ -public class PyDotNetSuperMethodsSearchExecutor implements QueryExecutor -{ - @Override - public boolean execute(@Nonnull final PySuperMethodsSearch.SearchParameters queryParameters, @Nonnull final Processor consumer) - { - PyFunction func = queryParameters.getDerivedMethod(); - PyClass containingClass = func.getContainingClass(); - /*if (containingClass != null) { - for (PyClassLikeType type : containingClass.getSuperClassTypes(TypeEvalContext.codeInsightFallback())) { - if (type instanceof PyDotNetClassType) { - final DotNetTypeDeclaration psiClass = ((PyDotNetClassType)type).getPsiClass(); - PsiMethod[] methods = psiClass.findMethodsByName(func.getName(), true); - // the Python method actually does override/implement all of Java super methods with the same name - if (!ContainerUtil.process(methods, consumer)) return false; - } - } - } */ - return true; - } +public class PyDotNetSuperMethodsSearchExecutor implements QueryExecutor { + @Override + public boolean execute( + @Nonnull final PySuperMethodsSearch.SearchParameters queryParameters, + @Nonnull final Processor consumer + ) { + PyFunction func = queryParameters.getDerivedMethod(); + PyClass containingClass = func.getContainingClass(); + /*if (containingClass != null) { + for (PyClassLikeType type : containingClass.getSuperClassTypes(TypeEvalContext.codeInsightFallback())) { + if (type instanceof PyDotNetClassType) { + final DotNetTypeDeclaration psiClass = ((PyDotNetClassType)type).getPsiClass(); + PsiMethod[] methods = psiClass.findMethodsByName(func.getName(), true); + // the Python method actually does override/implement all of Java super methods with the same name + if (!ContainerUtil.process(methods, consumer)) return false; + } + } + }*/ + return true; + } } diff --git a/jython/src/main/java/com/jetbrains/python/jython/psi/impl/PyJavaSuperMethodsSearchExecutor.java b/jython/src/main/java/com/jetbrains/python/jython/psi/impl/PyJavaSuperMethodsSearchExecutor.java index bdcac08f..d3c198f3 100644 --- a/jython/src/main/java/com/jetbrains/python/jython/psi/impl/PyJavaSuperMethodsSearchExecutor.java +++ b/jython/src/main/java/com/jetbrains/python/jython/psi/impl/PyJavaSuperMethodsSearchExecutor.java @@ -34,28 +34,25 @@ * @author yole */ @ExtensionImpl -public class PyJavaSuperMethodsSearchExecutor implements PySuperMethodsSearchExecutor -{ - public boolean execute(@Nonnull final PySuperMethodsSearch.SearchParameters queryParameters, @Nonnull final Processor consumer) - { - PyFunction func = queryParameters.getDerivedMethod(); - PyClass containingClass = func.getContainingClass(); - if(containingClass != null) - { - for(PyClassLikeType type : containingClass.getSuperClassTypes(TypeEvalContext.codeInsightFallback(containingClass.getProject()))) - { - if(type instanceof PyJavaClassType) - { - final PsiClass psiClass = ((PyJavaClassType) type).getPsiClass(); - PsiMethod[] methods = psiClass.findMethodsByName(func.getName(), true); - // the Python method actually does override/implement all of Java super methods with the same name - if(!ContainerUtil.process(methods, consumer)) - { - return false; - } - } - } - } - return true; - } +public class PyJavaSuperMethodsSearchExecutor implements PySuperMethodsSearchExecutor { + public boolean execute( + @Nonnull final PySuperMethodsSearch.SearchParameters queryParameters, + @Nonnull final Processor consumer + ) { + PyFunction func = queryParameters.getDerivedMethod(); + PyClass containingClass = func.getContainingClass(); + if (containingClass != null) { + for (PyClassLikeType type : containingClass.getSuperClassTypes(TypeEvalContext.codeInsightFallback(containingClass.getProject()))) { + if (type instanceof PyJavaClassType) { + final PsiClass psiClass = ((PyJavaClassType)type).getPsiClass(); + PsiMethod[] methods = psiClass.findMethodsByName(func.getName(), true); + // the Python method actually does override/implement all of Java super methods with the same name + if (!ContainerUtil.process(methods, consumer)) { + return false; + } + } + } + } + return true; + } } diff --git a/python-impl/src/main/java/com/jetbrains/python/impl/psi/search/DefaultPyClassInheritorsSearchExecutor.java b/python-impl/src/main/java/com/jetbrains/python/impl/psi/search/DefaultPyClassInheritorsSearchExecutor.java index 2395ad45..bcf337a6 100644 --- a/python-impl/src/main/java/com/jetbrains/python/impl/psi/search/DefaultPyClassInheritorsSearchExecutor.java +++ b/python-impl/src/main/java/com/jetbrains/python/impl/psi/search/DefaultPyClassInheritorsSearchExecutor.java @@ -26,6 +26,7 @@ import consulo.project.content.scope.ProjectScopes; import jakarta.annotation.Nonnull; + import java.util.Collection; import java.util.HashSet; import java.util.Set; @@ -36,50 +37,56 @@ @ExtensionImpl public class DefaultPyClassInheritorsSearchExecutor implements PyClassInheritorsSearchExecutor { - /** - * These base classes are to general to look for inheritors list. - */ - protected static final ImmutableSet IGNORED_BASES = ImmutableSet.of("object", "BaseException", "Exception"); - - public boolean execute(@Nonnull final PyClassInheritorsSearch.SearchParameters queryParameters, - @Nonnull final Processor consumer) { - Set processed = new HashSet<>(); + /** + * These base classes are to general to look for inheritors list. + */ + protected static final ImmutableSet IGNORED_BASES = ImmutableSet.of("object", "BaseException", "Exception"); - return ReadAction.compute(() -> processDirectInheritors(queryParameters.getSuperClass(), - consumer, - queryParameters.isCheckDeepInheritance(), - processed)); - } + public boolean execute( + @Nonnull final PyClassInheritorsSearch.SearchParameters queryParameters, + @Nonnull final Processor consumer + ) { + Set processed = new HashSet<>(); - private static boolean processDirectInheritors(final PyClass superClass, - final Processor consumer, - final boolean checkDeep, - final Set processed) { - final String superClassName = superClass.getName(); - if (superClassName == null || IGNORED_BASES.contains(superClassName)) { - return true; // we don't want to look for inheritors of overly general classes - } - if (processed.contains(superClass)) { - return true; + return ReadAction.compute(() -> processDirectInheritors( + queryParameters.getSuperClass(), + consumer, + queryParameters.isCheckDeepInheritance(), + processed + )); } - processed.add(superClass); - Project project = superClass.getProject(); - final Collection candidates = - StubIndex.getElements(PySuperClassIndex.KEY, superClassName, project, ProjectScopes.getAllScope(project), PyClass.class); - for (PyClass candidate : candidates) { - final PyClass[] classes = candidate.getSuperClasses(null); - for (PyClass superClassCandidate : classes) { - if (superClassCandidate.isEquivalentTo(superClass)) { - if (!consumer.process(candidate)) { - return false; - } - if (checkDeep && !processDirectInheritors(candidate, consumer, checkDeep, processed)) { - return false; - } - break; + + private static boolean processDirectInheritors( + final PyClass superClass, + final Processor consumer, + final boolean checkDeep, + final Set processed + ) { + final String superClassName = superClass.getName(); + if (superClassName == null || IGNORED_BASES.contains(superClassName)) { + return true; // we don't want to look for inheritors of overly general classes + } + if (processed.contains(superClass)) { + return true; + } + processed.add(superClass); + Project project = superClass.getProject(); + final Collection candidates = + StubIndex.getElements(PySuperClassIndex.KEY, superClassName, project, ProjectScopes.getAllScope(project), PyClass.class); + for (PyClass candidate : candidates) { + final PyClass[] classes = candidate.getSuperClasses(null); + for (PyClass superClassCandidate : classes) { + if (superClassCandidate.isEquivalentTo(superClass)) { + if (!consumer.process(candidate)) { + return false; + } + if (checkDeep && !processDirectInheritors(candidate, consumer, checkDeep, processed)) { + return false; + } + break; + } + } } - } + return true; } - return true; - } } diff --git a/python-impl/src/main/java/com/jetbrains/python/impl/psi/search/DefaultPyOverridingMethodsSearchExecutor.java b/python-impl/src/main/java/com/jetbrains/python/impl/psi/search/DefaultPyOverridingMethodsSearchExecutor.java index a650f71b..3d32a07a 100644 --- a/python-impl/src/main/java/com/jetbrains/python/impl/psi/search/DefaultPyOverridingMethodsSearchExecutor.java +++ b/python-impl/src/main/java/com/jetbrains/python/impl/psi/search/DefaultPyOverridingMethodsSearchExecutor.java @@ -28,34 +28,36 @@ */ @ExtensionImpl public class DefaultPyOverridingMethodsSearchExecutor implements PyOverridingMethodsSearchExecutor { - @Override - public boolean execute(@Nonnull final PyOverridingMethodsSearch.SearchParameters queryParameters, - @Nonnull final Processor consumer) { - final PyFunction baseMethod = queryParameters.getFunction(); + @Override + public boolean execute( + @Nonnull final PyOverridingMethodsSearch.SearchParameters queryParameters, + @Nonnull final Processor consumer + ) { + final PyFunction baseMethod = queryParameters.getFunction(); - final PyClass containingClass = ReadAction.compute(baseMethod::getContainingClass); + final PyClass containingClass = ReadAction.compute(baseMethod::getContainingClass); - return PyClassInheritorsSearch.search(containingClass, queryParameters.isCheckDeep()).forEach(pyClass -> { - PyFunction overridingMethod = ReadAction.compute(() -> { - PyFunction func = pyClass.findMethodByName(baseMethod.getName(), false, null); - if (func != null) { - final Property baseProperty = baseMethod.getProperty(); - final Property overridingProperty = func.getProperty(); - if (baseProperty != null && overridingProperty != null) { - final AccessDirection direction = PyUtil.getPropertyAccessDirection(baseMethod); - final PyCallable callable = overridingProperty.getByDirection(direction).valueOrNull(); - func = (callable instanceof PyFunction) ? (PyFunction)callable : null; - } - } + return PyClassInheritorsSearch.search(containingClass, queryParameters.isCheckDeep()).forEach(pyClass -> { + PyFunction overridingMethod = ReadAction.compute(() -> { + PyFunction func = pyClass.findMethodByName(baseMethod.getName(), false, null); + if (func != null) { + final Property baseProperty = baseMethod.getProperty(); + final Property overridingProperty = func.getProperty(); + if (baseProperty != null && overridingProperty != null) { + final AccessDirection direction = PyUtil.getPropertyAccessDirection(baseMethod); + final PyCallable callable = overridingProperty.getByDirection(direction).valueOrNull(); + func = (callable instanceof PyFunction) ? (PyFunction)callable : null; + } + } - return func; - }); + return func; + }); - //noinspection SimplifiableIfStatement - if (overridingMethod != null) { - return consumer.process(overridingMethod); - } - return true; - }); - } + //noinspection SimplifiableIfStatement + if (overridingMethod != null) { + return consumer.process(overridingMethod); + } + return true; + }); + } } diff --git a/python-impl/src/main/java/com/jetbrains/python/impl/psi/search/DefaultPySuperMethodsSearchExecutor.java b/python-impl/src/main/java/com/jetbrains/python/impl/psi/search/DefaultPySuperMethodsSearchExecutor.java index 90d6fd57..f6138f86 100644 --- a/python-impl/src/main/java/com/jetbrains/python/impl/psi/search/DefaultPySuperMethodsSearchExecutor.java +++ b/python-impl/src/main/java/com/jetbrains/python/impl/psi/search/DefaultPySuperMethodsSearchExecutor.java @@ -25,6 +25,7 @@ import consulo.language.psi.PsiElement; import jakarta.annotation.Nonnull; + import java.util.HashSet; import java.util.Set; @@ -33,59 +34,61 @@ */ @ExtensionImpl public class DefaultPySuperMethodsSearchExecutor implements PySuperMethodsSearchExecutor { - @Override - public boolean execute(@Nonnull final PySuperMethodsSearch.SearchParameters queryParameters, - @Nonnull final Processor consumer) { - final PyFunction func = queryParameters.getDerivedMethod(); - final String name = func.getName(); - final PyClass containingClass = func.getContainingClass(); - final Set foundMethodContainingClasses = new HashSet<>(); - final TypeEvalContext context = queryParameters.getContext(); - if (name != null && containingClass != null) { - for (PyClass superClass : containingClass.getAncestorClasses(context)) { - if (!queryParameters.isDeepSearch()) { - boolean isAlreadyFound = false; - for (PyClass alreadyFound : foundMethodContainingClasses) { - if (alreadyFound.isSubclass(superClass, context)) { - isAlreadyFound = true; - } - } - if (isAlreadyFound) { - continue; - } - } - PyFunction superMethod = superClass.findMethodByName(name, false, null); - if (superMethod != null) { - final Property property = func.getProperty(); - final Property superProperty = superMethod.getProperty(); - if (property != null && superProperty != null) { - final AccessDirection direction = PyUtil.getPropertyAccessDirection(func); - final PyCallable callable = superProperty.getByDirection(direction).valueOrNull(); - superMethod = (callable instanceof PyFunction) ? (PyFunction)callable : null; - } - } + @Override + public boolean execute( + @Nonnull final PySuperMethodsSearch.SearchParameters queryParameters, + @Nonnull final Processor consumer + ) { + final PyFunction func = queryParameters.getDerivedMethod(); + final String name = func.getName(); + final PyClass containingClass = func.getContainingClass(); + final Set foundMethodContainingClasses = new HashSet<>(); + final TypeEvalContext context = queryParameters.getContext(); + if (name != null && containingClass != null) { + for (PyClass superClass : containingClass.getAncestorClasses(context)) { + if (!queryParameters.isDeepSearch()) { + boolean isAlreadyFound = false; + for (PyClass alreadyFound : foundMethodContainingClasses) { + if (alreadyFound.isSubclass(superClass, context)) { + isAlreadyFound = true; + } + } + if (isAlreadyFound) { + continue; + } + } + PyFunction superMethod = superClass.findMethodByName(name, false, null); + if (superMethod != null) { + final Property property = func.getProperty(); + final Property superProperty = superMethod.getProperty(); + if (property != null && superProperty != null) { + final AccessDirection direction = PyUtil.getPropertyAccessDirection(func); + final PyCallable callable = superProperty.getByDirection(direction).valueOrNull(); + superMethod = (callable instanceof PyFunction) ? (PyFunction)callable : null; + } + } - if (superMethod == null && context != null) { - // If super method still not found and we have context, we may use it to find method - final PyClassLikeType classLikeType = PyUtil.as(context.getType(superClass), PyClassLikeType.class); - if (classLikeType != null) { - for (final PyFunction function : PyTypeUtil.getMembersOfType(classLikeType, PyFunction.class, true, context)) { - final String elemName = function.getName(); - if (elemName != null && elemName.equals(func.getName())) { - consumer.process(function); - } + if (superMethod == null && context != null) { + // If super method still not found and we have context, we may use it to find method + final PyClassLikeType classLikeType = PyUtil.as(context.getType(superClass), PyClassLikeType.class); + if (classLikeType != null) { + for (final PyFunction function : PyTypeUtil.getMembersOfType(classLikeType, PyFunction.class, true, context)) { + final String elemName = function.getName(); + if (elemName != null && elemName.equals(func.getName())) { + consumer.process(function); + } + } + } + } + if (superMethod != null) { + foundMethodContainingClasses.add(superClass); + if (!consumer.process(superMethod)) { + return false; + } + } } - } - } - if (superMethod != null) { - foundMethodContainingClasses.add(superClass); - if (!consumer.process(superMethod)) { - return false; - } } - } + return true; } - return true; - } } diff --git a/python-impl/src/main/java/com/jetbrains/python/impl/psi/search/PyDefinitionsSearch.java b/python-impl/src/main/java/com/jetbrains/python/impl/psi/search/PyDefinitionsSearch.java index dc1234b8..34c2aa3c 100644 --- a/python-impl/src/main/java/com/jetbrains/python/impl/psi/search/PyDefinitionsSearch.java +++ b/python-impl/src/main/java/com/jetbrains/python/impl/psi/search/PyDefinitionsSearch.java @@ -34,27 +34,29 @@ */ @ExtensionImpl public class PyDefinitionsSearch implements DefinitionsScopedSearchExecutor { - public boolean execute(@Nonnull final DefinitionsScopedSearch.SearchParameters parameters, - @Nonnull final Processor consumer) { - PsiElement element = parameters.getElement(); - if (element instanceof PyClass) { - final Query query = PyClassInheritorsSearch.search((PyClass)element, true); - return query.forEach(consumer::process); - } - else if (element instanceof PyFunction) { - final Query query = PyOverridingMethodsSearch.search((PyFunction)element, true); - return query.forEach(new Processor() { - public boolean process(final PyFunction pyFunction) { - return consumer.process(pyFunction); + public boolean execute( + @Nonnull final DefinitionsScopedSearch.SearchParameters parameters, + @Nonnull final Processor consumer + ) { + PsiElement element = parameters.getElement(); + if (element instanceof PyClass) { + final Query query = PyClassInheritorsSearch.search((PyClass)element, true); + return query.forEach(consumer::process); } - }); - } - else if (element instanceof PyTargetExpression) { // PY-237 - final PsiElement parent = element.getParent(); - if (parent instanceof PyAssignmentStatement) { - return consumer.process(parent); - } + else if (element instanceof PyFunction) { + final Query query = PyOverridingMethodsSearch.search((PyFunction)element, true); + return query.forEach(new Processor() { + public boolean process(final PyFunction pyFunction) { + return consumer.process(pyFunction); + } + }); + } + else if (element instanceof PyTargetExpression) { // PY-237 + final PsiElement parent = element.getParent(); + if (parent instanceof PyAssignmentStatement) { + return consumer.process(parent); + } + } + return true; } - return true; - } } diff --git a/python-impl/src/main/java/com/jetbrains/python/impl/psi/search/PyInitReferenceSearchExecutor.java b/python-impl/src/main/java/com/jetbrains/python/impl/psi/search/PyInitReferenceSearchExecutor.java index 11da471c..ffd3f279 100644 --- a/python-impl/src/main/java/com/jetbrains/python/impl/psi/search/PyInitReferenceSearchExecutor.java +++ b/python-impl/src/main/java/com/jetbrains/python/impl/psi/search/PyInitReferenceSearchExecutor.java @@ -38,43 +38,38 @@ * @author yole */ @ExtensionImpl -public class PyInitReferenceSearchExecutor extends QueryExecutorBase implements ReferencesSearchQueryExecutor -{ - @Override - public void processQuery(@Nonnull ReferencesSearch.SearchParameters queryParameters, @Nonnull final Processor consumer) - { - PsiElement element = queryParameters.getElementToSearch(); - if(!(element instanceof PyFunction)) - { - return; - } +public class PyInitReferenceSearchExecutor extends QueryExecutorBase implements ReferencesSearchQueryExecutor { + @Override + public void processQuery( + @Nonnull ReferencesSearch.SearchParameters queryParameters, + @Nonnull final Processor consumer + ) { + PsiElement element = queryParameters.getElementToSearch(); + if (!(element instanceof PyFunction)) { + return; + } - String className; - SearchScope searchScope; - PyFunction function; - function = (PyFunction) element; - if(!PyNames.INIT.equals(ReadAction.compute(() -> function.getName()))) - { - return; - } - final PyClass pyClass = ReadAction.compute(() -> function.getContainingClass()); - if(pyClass == null) - { - return; - } - className = ReadAction.compute(() -> pyClass.getName()); - if(className == null) - { - return; - } + String className; + SearchScope searchScope; + PyFunction function; + function = (PyFunction)element; + if (!PyNames.INIT.equals(ReadAction.compute(() -> function.getName()))) { + return; + } + final PyClass pyClass = ReadAction.compute(() -> function.getContainingClass()); + if (pyClass == null) { + return; + } + className = ReadAction.compute(() -> pyClass.getName()); + if (className == null) { + return; + } - searchScope = queryParameters.getEffectiveSearchScope(); - if(searchScope instanceof GlobalSearchScope) - { - searchScope = GlobalSearchScope.getScopeRestrictedByFileTypes((GlobalSearchScope) searchScope, PythonFileType.INSTANCE); - } + searchScope = queryParameters.getEffectiveSearchScope(); + if (searchScope instanceof GlobalSearchScope) { + searchScope = GlobalSearchScope.getScopeRestrictedByFileTypes((GlobalSearchScope)searchScope, PythonFileType.INSTANCE); + } - - queryParameters.getOptimizer().searchWord(className, searchScope, UsageSearchContext.IN_CODE, true, function); - } + queryParameters.getOptimizer().searchWord(className, searchScope, UsageSearchContext.IN_CODE, true, function); + } } diff --git a/python-impl/src/main/java/com/jetbrains/python/impl/psi/search/PyKeywordArgumentSearchExecutor.java b/python-impl/src/main/java/com/jetbrains/python/impl/psi/search/PyKeywordArgumentSearchExecutor.java index 3fdb9575..e79cf918 100644 --- a/python-impl/src/main/java/com/jetbrains/python/impl/psi/search/PyKeywordArgumentSearchExecutor.java +++ b/python-impl/src/main/java/com/jetbrains/python/impl/psi/search/PyKeywordArgumentSearchExecutor.java @@ -33,32 +33,35 @@ */ @ExtensionImpl public class PyKeywordArgumentSearchExecutor extends QueryExecutorBase implements ReferencesSearchQueryExecutor { - @Override - public void processQuery(@Nonnull ReferencesSearch.SearchParameters queryParameters, @Nonnull final Processor consumer) { - final PsiElement element = queryParameters.getElementToSearch(); - if (!(element instanceof PyNamedParameter)) { - return; - } - PyFunction owner = PsiTreeUtil.getParentOfType(element, PyFunction.class); - if (owner == null) { - return; - } - ReferencesSearch.search(owner, queryParameters.getScope()).forEach(new Processor() { - @Override - public boolean process(PsiReference reference) { - final PsiElement refElement = reference.getElement(); - final PyCallExpression call = PsiTreeUtil.getParentOfType(refElement, PyCallExpression.class); - if (call != null && PsiTreeUtil.isAncestor(call.getCallee(), refElement, false)) { - final PyArgumentList argumentList = call.getArgumentList(); - if (argumentList != null) { - final PyKeywordArgument keywordArgument = argumentList.getKeywordArgument(((PyNamedParameter)element).getName()); - if (keywordArgument != null) { - return consumer.process(keywordArgument.getReference()); - } - } + @Override + public void processQuery( + @Nonnull ReferencesSearch.SearchParameters queryParameters, + @Nonnull final Processor consumer + ) { + final PsiElement element = queryParameters.getElementToSearch(); + if (!(element instanceof PyNamedParameter)) { + return; } - return true; - } - }); - } + PyFunction owner = PsiTreeUtil.getParentOfType(element, PyFunction.class); + if (owner == null) { + return; + } + ReferencesSearch.search(owner, queryParameters.getScope()).forEach(new Processor() { + @Override + public boolean process(PsiReference reference) { + final PsiElement refElement = reference.getElement(); + final PyCallExpression call = PsiTreeUtil.getParentOfType(refElement, PyCallExpression.class); + if (call != null && PsiTreeUtil.isAncestor(call.getCallee(), refElement, false)) { + final PyArgumentList argumentList = call.getArgumentList(); + if (argumentList != null) { + final PyKeywordArgument keywordArgument = argumentList.getKeywordArgument(((PyNamedParameter)element).getName()); + if (keywordArgument != null) { + return consumer.process(keywordArgument.getReference()); + } + } + } + return true; + } + }); + } } diff --git a/python-impl/src/main/java/com/jetbrains/python/impl/psi/search/PyStringReferenceSearch.java b/python-impl/src/main/java/com/jetbrains/python/impl/psi/search/PyStringReferenceSearch.java index 1553fc79..a01db6f3 100644 --- a/python-impl/src/main/java/com/jetbrains/python/impl/psi/search/PyStringReferenceSearch.java +++ b/python-impl/src/main/java/com/jetbrains/python/impl/psi/search/PyStringReferenceSearch.java @@ -40,28 +40,30 @@ */ @ExtensionImpl public class PyStringReferenceSearch extends QueryExecutorBase implements ReferencesSearchQueryExecutor { - public void processQuery(@Nonnull final ReferencesSearch.SearchParameters params, - @Nonnull final Processor consumer) { - final PsiElement element = params.getElementToSearch(); - if (!(element instanceof PyElement) && !(element instanceof PsiDirectory)) { - return; - } + public void processQuery( + @Nonnull final ReferencesSearch.SearchParameters params, + @Nonnull final Processor consumer + ) { + final PsiElement element = params.getElementToSearch(); + if (!(element instanceof PyElement) && !(element instanceof PsiDirectory)) { + return; + } + + String name; + SearchScope searchScope = ReadAction.compute(() -> { + SearchScope s = params.getEffectiveSearchScope(); + if (s instanceof GlobalSearchScope) { + s = GlobalSearchScope.getScopeRestrictedByFileTypes((GlobalSearchScope)s, PythonFileType.INSTANCE); + } + return s; + }); - String name; - SearchScope searchScope = ReadAction.compute(() -> { - SearchScope s = params.getEffectiveSearchScope(); - if (s instanceof GlobalSearchScope) { - s = GlobalSearchScope.getScopeRestrictedByFileTypes((GlobalSearchScope)s, PythonFileType.INSTANCE); - } - return s; - }); + name = ReadAction.compute(() -> PyUtil.computeElementNameForStringSearch(element)); - name = ReadAction.compute(() -> PyUtil.computeElementNameForStringSearch(element)); + if (StringUtil.isEmpty(name)) { + return; + } - if (StringUtil.isEmpty(name)) { - return; + params.getOptimizer().searchWord(name, searchScope, UsageSearchContext.IN_STRINGS, true, element); } - - params.getOptimizer().searchWord(name, searchScope, UsageSearchContext.IN_STRINGS, true, element); - } } From 0751917c65796f5cb76977bd54b30a60c141f0a0 Mon Sep 17 00:00:00 2001 From: UNV Date: Sat, 12 Apr 2025 20:28:46 +0300 Subject: [PATCH 2/2] Refactoring of query executors. --- .../PyDotNetSuperMethodsSearchExecutor.java | 8 ++-- .../PyJavaSuperMethodsSearchExecutor.java | 11 +++-- ...efaultPyClassInheritorsSearchExecutor.java | 34 +++++++-------- ...aultPyOverridingMethodsSearchExecutor.java | 32 +++++++------- .../DefaultPySuperMethodsSearchExecutor.java | 42 +++++++++---------- .../impl/psi/search/PyDefinitionsSearch.java | 31 +++++--------- .../search/PyInitReferenceSearchExecutor.java | 26 +++++------- .../PyKeywordArgumentSearchExecutor.java | 40 +++++++++--------- .../psi/search/PyStringReferenceSearch.java | 21 +++++----- 9 files changed, 114 insertions(+), 131 deletions(-) diff --git a/iron-python/src/main/java/consulo/ironPython/psi/impl/PyDotNetSuperMethodsSearchExecutor.java b/iron-python/src/main/java/consulo/ironPython/psi/impl/PyDotNetSuperMethodsSearchExecutor.java index 3ec5ed5b..d5f0a3ff 100644 --- a/iron-python/src/main/java/consulo/ironPython/psi/impl/PyDotNetSuperMethodsSearchExecutor.java +++ b/iron-python/src/main/java/consulo/ironPython/psi/impl/PyDotNetSuperMethodsSearchExecutor.java @@ -16,15 +16,15 @@ package consulo.ironPython.psi.impl; +import com.jetbrains.python.impl.psi.search.PySuperMethodsSearch; import com.jetbrains.python.psi.PyClass; import com.jetbrains.python.psi.PyFunction; -import com.jetbrains.python.impl.psi.search.PySuperMethodsSearch; -import consulo.application.util.function.Processor; import consulo.application.util.query.QueryExecutor; import consulo.language.psi.PsiElement; - import jakarta.annotation.Nonnull; +import java.util.function.Predicate; + /** * @author yole */ @@ -32,7 +32,7 @@ public class PyDotNetSuperMethodsSearchExecutor implements QueryExecutor consumer + @Nonnull final Predicate consumer ) { PyFunction func = queryParameters.getDerivedMethod(); PyClass containingClass = func.getContainingClass(); diff --git a/jython/src/main/java/com/jetbrains/python/jython/psi/impl/PyJavaSuperMethodsSearchExecutor.java b/jython/src/main/java/com/jetbrains/python/jython/psi/impl/PyJavaSuperMethodsSearchExecutor.java index d3c198f3..13ac4782 100644 --- a/jython/src/main/java/com/jetbrains/python/jython/psi/impl/PyJavaSuperMethodsSearchExecutor.java +++ b/jython/src/main/java/com/jetbrains/python/jython/psi/impl/PyJavaSuperMethodsSearchExecutor.java @@ -30,21 +30,24 @@ import jakarta.annotation.Nonnull; +import java.util.function.Predicate; + /** * @author yole */ @ExtensionImpl public class PyJavaSuperMethodsSearchExecutor implements PySuperMethodsSearchExecutor { + @Override public boolean execute( - @Nonnull final PySuperMethodsSearch.SearchParameters queryParameters, - @Nonnull final Processor consumer + @Nonnull PySuperMethodsSearch.SearchParameters queryParameters, + @Nonnull Predicate consumer ) { PyFunction func = queryParameters.getDerivedMethod(); PyClass containingClass = func.getContainingClass(); if (containingClass != null) { for (PyClassLikeType type : containingClass.getSuperClassTypes(TypeEvalContext.codeInsightFallback(containingClass.getProject()))) { - if (type instanceof PyJavaClassType) { - final PsiClass psiClass = ((PyJavaClassType)type).getPsiClass(); + if (type instanceof PyJavaClassType javaClassType) { + PsiClass psiClass = javaClassType.getPsiClass(); PsiMethod[] methods = psiClass.findMethodsByName(func.getName(), true); // the Python method actually does override/implement all of Java super methods with the same name if (!ContainerUtil.process(methods, consumer)) { diff --git a/python-impl/src/main/java/com/jetbrains/python/impl/psi/search/DefaultPyClassInheritorsSearchExecutor.java b/python-impl/src/main/java/com/jetbrains/python/impl/psi/search/DefaultPyClassInheritorsSearchExecutor.java index bcf337a6..233bfbcf 100644 --- a/python-impl/src/main/java/com/jetbrains/python/impl/psi/search/DefaultPyClassInheritorsSearchExecutor.java +++ b/python-impl/src/main/java/com/jetbrains/python/impl/psi/search/DefaultPyClassInheritorsSearchExecutor.java @@ -18,37 +18,37 @@ import com.google.common.collect.ImmutableSet; import com.jetbrains.python.impl.psi.stubs.PySuperClassIndex; import com.jetbrains.python.psi.PyClass; +import consulo.annotation.access.RequiredReadAction; import consulo.annotation.component.ExtensionImpl; -import consulo.application.ReadAction; -import consulo.application.util.function.Processor; +import consulo.application.AccessRule; import consulo.language.psi.stub.StubIndex; import consulo.project.Project; import consulo.project.content.scope.ProjectScopes; - import jakarta.annotation.Nonnull; import java.util.Collection; import java.util.HashSet; import java.util.Set; +import java.util.function.Predicate; /** * @author yole */ @ExtensionImpl public class DefaultPyClassInheritorsSearchExecutor implements PyClassInheritorsSearchExecutor { - /** * These base classes are to general to look for inheritors list. */ protected static final ImmutableSet IGNORED_BASES = ImmutableSet.of("object", "BaseException", "Exception"); + @Override public boolean execute( - @Nonnull final PyClassInheritorsSearch.SearchParameters queryParameters, - @Nonnull final Processor consumer + @Nonnull PyClassInheritorsSearch.SearchParameters queryParameters, + @Nonnull Predicate consumer ) { Set processed = new HashSet<>(); - return ReadAction.compute(() -> processDirectInheritors( + return AccessRule.read(() -> processDirectInheritors( queryParameters.getSuperClass(), consumer, queryParameters.isCheckDeepInheritance(), @@ -56,13 +56,14 @@ public boolean execute( )); } + @RequiredReadAction private static boolean processDirectInheritors( - final PyClass superClass, - final Processor consumer, - final boolean checkDeep, - final Set processed + PyClass superClass, + Predicate consumer, + boolean checkDeep, + Set processed ) { - final String superClassName = superClass.getName(); + String superClassName = superClass.getName(); if (superClassName == null || IGNORED_BASES.contains(superClassName)) { return true; // we don't want to look for inheritors of overly general classes } @@ -71,16 +72,13 @@ private static boolean processDirectInheritors( } processed.add(superClass); Project project = superClass.getProject(); - final Collection candidates = + Collection candidates = StubIndex.getElements(PySuperClassIndex.KEY, superClassName, project, ProjectScopes.getAllScope(project), PyClass.class); for (PyClass candidate : candidates) { - final PyClass[] classes = candidate.getSuperClasses(null); + PyClass[] classes = candidate.getSuperClasses(null); for (PyClass superClassCandidate : classes) { if (superClassCandidate.isEquivalentTo(superClass)) { - if (!consumer.process(candidate)) { - return false; - } - if (checkDeep && !processDirectInheritors(candidate, consumer, checkDeep, processed)) { + if (!consumer.test(candidate) || checkDeep && !processDirectInheritors(candidate, consumer, checkDeep, processed)) { return false; } break; diff --git a/python-impl/src/main/java/com/jetbrains/python/impl/psi/search/DefaultPyOverridingMethodsSearchExecutor.java b/python-impl/src/main/java/com/jetbrains/python/impl/psi/search/DefaultPyOverridingMethodsSearchExecutor.java index 3d32a07a..8eaf7b06 100644 --- a/python-impl/src/main/java/com/jetbrains/python/impl/psi/search/DefaultPyOverridingMethodsSearchExecutor.java +++ b/python-impl/src/main/java/com/jetbrains/python/impl/psi/search/DefaultPyOverridingMethodsSearchExecutor.java @@ -18,11 +18,11 @@ import com.jetbrains.python.impl.psi.PyUtil; import com.jetbrains.python.psi.*; import consulo.annotation.component.ExtensionImpl; -import consulo.application.ReadAction; -import consulo.application.util.function.Processor; - +import consulo.application.AccessRule; import jakarta.annotation.Nonnull; +import java.util.function.Predicate; + /** * @author yole */ @@ -30,34 +30,30 @@ public class DefaultPyOverridingMethodsSearchExecutor implements PyOverridingMethodsSearchExecutor { @Override public boolean execute( - @Nonnull final PyOverridingMethodsSearch.SearchParameters queryParameters, - @Nonnull final Processor consumer + @Nonnull PyOverridingMethodsSearch.SearchParameters queryParameters, + @Nonnull Predicate consumer ) { - final PyFunction baseMethod = queryParameters.getFunction(); + PyFunction baseMethod = queryParameters.getFunction(); - final PyClass containingClass = ReadAction.compute(baseMethod::getContainingClass); + PyClass containingClass = AccessRule.read(baseMethod::getContainingClass); return PyClassInheritorsSearch.search(containingClass, queryParameters.isCheckDeep()).forEach(pyClass -> { - PyFunction overridingMethod = ReadAction.compute(() -> { + PyFunction overridingMethod = AccessRule.read(() -> { PyFunction func = pyClass.findMethodByName(baseMethod.getName(), false, null); if (func != null) { - final Property baseProperty = baseMethod.getProperty(); - final Property overridingProperty = func.getProperty(); + Property baseProperty = baseMethod.getProperty(); + Property overridingProperty = func.getProperty(); if (baseProperty != null && overridingProperty != null) { - final AccessDirection direction = PyUtil.getPropertyAccessDirection(baseMethod); - final PyCallable callable = overridingProperty.getByDirection(direction).valueOrNull(); - func = (callable instanceof PyFunction) ? (PyFunction)callable : null; + AccessDirection direction = PyUtil.getPropertyAccessDirection(baseMethod); + PyCallable callable = overridingProperty.getByDirection(direction).valueOrNull(); + func = callable instanceof PyFunction function ? function : null; } } return func; }); - //noinspection SimplifiableIfStatement - if (overridingMethod != null) { - return consumer.process(overridingMethod); - } - return true; + return overridingMethod == null || consumer.test(overridingMethod); }); } } diff --git a/python-impl/src/main/java/com/jetbrains/python/impl/psi/search/DefaultPySuperMethodsSearchExecutor.java b/python-impl/src/main/java/com/jetbrains/python/impl/psi/search/DefaultPySuperMethodsSearchExecutor.java index f6138f86..57f47c9a 100644 --- a/python-impl/src/main/java/com/jetbrains/python/impl/psi/search/DefaultPySuperMethodsSearchExecutor.java +++ b/python-impl/src/main/java/com/jetbrains/python/impl/psi/search/DefaultPySuperMethodsSearchExecutor.java @@ -16,18 +16,18 @@ package com.jetbrains.python.impl.psi.search; import com.jetbrains.python.impl.psi.PyUtil; +import com.jetbrains.python.impl.psi.types.PyTypeUtil; import com.jetbrains.python.psi.*; import com.jetbrains.python.psi.types.PyClassLikeType; -import com.jetbrains.python.impl.psi.types.PyTypeUtil; import com.jetbrains.python.psi.types.TypeEvalContext; +import consulo.annotation.access.RequiredReadAction; import consulo.annotation.component.ExtensionImpl; -import consulo.application.util.function.Processor; import consulo.language.psi.PsiElement; - import jakarta.annotation.Nonnull; import java.util.HashSet; import java.util.Set; +import java.util.function.Predicate; /** * @author yole @@ -35,15 +35,16 @@ @ExtensionImpl public class DefaultPySuperMethodsSearchExecutor implements PySuperMethodsSearchExecutor { @Override + @RequiredReadAction public boolean execute( - @Nonnull final PySuperMethodsSearch.SearchParameters queryParameters, - @Nonnull final Processor consumer + @Nonnull PySuperMethodsSearch.SearchParameters queryParameters, + @Nonnull Predicate consumer ) { - final PyFunction func = queryParameters.getDerivedMethod(); - final String name = func.getName(); - final PyClass containingClass = func.getContainingClass(); - final Set foundMethodContainingClasses = new HashSet<>(); - final TypeEvalContext context = queryParameters.getContext(); + PyFunction func = queryParameters.getDerivedMethod(); + String name = func.getName(); + PyClass containingClass = func.getContainingClass(); + Set foundMethodContainingClasses = new HashSet<>(); + TypeEvalContext context = queryParameters.getContext(); if (name != null && containingClass != null) { for (PyClass superClass : containingClass.getAncestorClasses(context)) { if (!queryParameters.isDeepSearch()) { @@ -59,31 +60,30 @@ public boolean execute( } PyFunction superMethod = superClass.findMethodByName(name, false, null); if (superMethod != null) { - final Property property = func.getProperty(); - final Property superProperty = superMethod.getProperty(); + Property property = func.getProperty(); + Property superProperty = superMethod.getProperty(); if (property != null && superProperty != null) { - final AccessDirection direction = PyUtil.getPropertyAccessDirection(func); - final PyCallable callable = superProperty.getByDirection(direction).valueOrNull(); - superMethod = (callable instanceof PyFunction) ? (PyFunction)callable : null; + AccessDirection direction = PyUtil.getPropertyAccessDirection(func); + PyCallable callable = superProperty.getByDirection(direction).valueOrNull(); + superMethod = callable instanceof PyFunction function ? function : null; } } - if (superMethod == null && context != null) { // If super method still not found and we have context, we may use it to find method - final PyClassLikeType classLikeType = PyUtil.as(context.getType(superClass), PyClassLikeType.class); + PyClassLikeType classLikeType = PyUtil.as(context.getType(superClass), PyClassLikeType.class); if (classLikeType != null) { - for (final PyFunction function : PyTypeUtil.getMembersOfType(classLikeType, PyFunction.class, true, context)) { - final String elemName = function.getName(); + for (PyFunction function : PyTypeUtil.getMembersOfType(classLikeType, PyFunction.class, true, context)) { + String elemName = function.getName(); if (elemName != null && elemName.equals(func.getName())) { - consumer.process(function); + consumer.test(function); } } } } if (superMethod != null) { foundMethodContainingClasses.add(superClass); - if (!consumer.process(superMethod)) { + if (!consumer.test(superMethod)) { return false; } } diff --git a/python-impl/src/main/java/com/jetbrains/python/impl/psi/search/PyDefinitionsSearch.java b/python-impl/src/main/java/com/jetbrains/python/impl/psi/search/PyDefinitionsSearch.java index 34c2aa3c..10505f8e 100644 --- a/python-impl/src/main/java/com/jetbrains/python/impl/psi/search/PyDefinitionsSearch.java +++ b/python-impl/src/main/java/com/jetbrains/python/impl/psi/search/PyDefinitionsSearch.java @@ -21,41 +21,32 @@ import com.jetbrains.python.psi.PyFunction; import com.jetbrains.python.psi.PyTargetExpression; import consulo.annotation.component.ExtensionImpl; -import consulo.application.util.function.Processor; -import consulo.application.util.query.Query; import consulo.language.psi.PsiElement; import consulo.language.psi.search.DefinitionsScopedSearch; import consulo.language.psi.search.DefinitionsScopedSearchExecutor; - import jakarta.annotation.Nonnull; +import java.util.function.Predicate; + /** * @author yole */ @ExtensionImpl public class PyDefinitionsSearch implements DefinitionsScopedSearchExecutor { + @Override public boolean execute( - @Nonnull final DefinitionsScopedSearch.SearchParameters parameters, - @Nonnull final Processor consumer + @Nonnull DefinitionsScopedSearch.SearchParameters parameters, + @Nonnull Predicate consumer ) { PsiElement element = parameters.getElement(); - if (element instanceof PyClass) { - final Query query = PyClassInheritorsSearch.search((PyClass)element, true); - return query.forEach(consumer::process); + if (element instanceof PyClass pyClass) { + return PyClassInheritorsSearch.search(pyClass, true).forEach(consumer::test); } - else if (element instanceof PyFunction) { - final Query query = PyOverridingMethodsSearch.search((PyFunction)element, true); - return query.forEach(new Processor() { - public boolean process(final PyFunction pyFunction) { - return consumer.process(pyFunction); - } - }); + else if (element instanceof PyFunction function) { + return PyOverridingMethodsSearch.search(function, true).forEach(consumer::test); } - else if (element instanceof PyTargetExpression) { // PY-237 - final PsiElement parent = element.getParent(); - if (parent instanceof PyAssignmentStatement) { - return consumer.process(parent); - } + else if (element instanceof PyTargetExpression && element.getParent() instanceof PyAssignmentStatement assignment) { + return consumer.test(assignment); // PY-237 } return true; } diff --git a/python-impl/src/main/java/com/jetbrains/python/impl/psi/search/PyInitReferenceSearchExecutor.java b/python-impl/src/main/java/com/jetbrains/python/impl/psi/search/PyInitReferenceSearchExecutor.java index ffd3f279..a0221a6d 100644 --- a/python-impl/src/main/java/com/jetbrains/python/impl/psi/search/PyInitReferenceSearchExecutor.java +++ b/python-impl/src/main/java/com/jetbrains/python/impl/psi/search/PyInitReferenceSearchExecutor.java @@ -21,8 +21,7 @@ import com.jetbrains.python.psi.PyClass; import com.jetbrains.python.psi.PyFunction; import consulo.annotation.component.ExtensionImpl; -import consulo.application.ReadAction; -import consulo.application.util.function.Processor; +import consulo.application.AccessRule; import consulo.content.scope.SearchScope; import consulo.language.psi.PsiElement; import consulo.language.psi.PsiReference; @@ -31,9 +30,10 @@ import consulo.language.psi.search.ReferencesSearchQueryExecutor; import consulo.language.psi.search.UsageSearchContext; import consulo.project.util.query.QueryExecutorBase; - import jakarta.annotation.Nonnull; +import java.util.function.Predicate; + /** * @author yole */ @@ -42,32 +42,28 @@ public class PyInitReferenceSearchExecutor extends QueryExecutorBase consumer + @Nonnull Predicate consumer ) { PsiElement element = queryParameters.getElementToSearch(); - if (!(element instanceof PyFunction)) { + if (!(element instanceof PyFunction function)) { return; } - String className; - SearchScope searchScope; - PyFunction function; - function = (PyFunction)element; - if (!PyNames.INIT.equals(ReadAction.compute(() -> function.getName()))) { + if (!PyNames.INIT.equals(AccessRule.read(function::getName))) { return; } - final PyClass pyClass = ReadAction.compute(() -> function.getContainingClass()); + PyClass pyClass = AccessRule.read(function::getContainingClass); if (pyClass == null) { return; } - className = ReadAction.compute(() -> pyClass.getName()); + String className = AccessRule.read(pyClass::getName); if (className == null) { return; } - searchScope = queryParameters.getEffectiveSearchScope(); - if (searchScope instanceof GlobalSearchScope) { - searchScope = GlobalSearchScope.getScopeRestrictedByFileTypes((GlobalSearchScope)searchScope, PythonFileType.INSTANCE); + SearchScope searchScope = queryParameters.getEffectiveSearchScope(); + if (searchScope instanceof GlobalSearchScope globalSearchScope) { + searchScope = GlobalSearchScope.getScopeRestrictedByFileTypes(globalSearchScope, PythonFileType.INSTANCE); } queryParameters.getOptimizer().searchWord(className, searchScope, UsageSearchContext.IN_CODE, true, function); diff --git a/python-impl/src/main/java/com/jetbrains/python/impl/psi/search/PyKeywordArgumentSearchExecutor.java b/python-impl/src/main/java/com/jetbrains/python/impl/psi/search/PyKeywordArgumentSearchExecutor.java index e79cf918..6268455d 100644 --- a/python-impl/src/main/java/com/jetbrains/python/impl/psi/search/PyKeywordArgumentSearchExecutor.java +++ b/python-impl/src/main/java/com/jetbrains/python/impl/psi/search/PyKeywordArgumentSearchExecutor.java @@ -16,29 +16,30 @@ package com.jetbrains.python.impl.psi.search; +import com.jetbrains.python.psi.*; import consulo.annotation.component.ExtensionImpl; -import consulo.language.psi.search.ReferencesSearchQueryExecutor; -import consulo.project.util.query.QueryExecutorBase; import consulo.language.psi.PsiElement; import consulo.language.psi.PsiReference; import consulo.language.psi.search.ReferencesSearch; +import consulo.language.psi.search.ReferencesSearchQueryExecutor; import consulo.language.psi.util.PsiTreeUtil; -import consulo.application.util.function.Processor; -import com.jetbrains.python.psi.*; - +import consulo.project.util.query.QueryExecutorBase; import jakarta.annotation.Nonnull; +import java.util.function.Predicate; + /** * @author yole */ @ExtensionImpl -public class PyKeywordArgumentSearchExecutor extends QueryExecutorBase implements ReferencesSearchQueryExecutor { +public class PyKeywordArgumentSearchExecutor extends QueryExecutorBase + implements ReferencesSearchQueryExecutor { @Override public void processQuery( @Nonnull ReferencesSearch.SearchParameters queryParameters, - @Nonnull final Processor consumer + @Nonnull Predicate consumer ) { - final PsiElement element = queryParameters.getElementToSearch(); + PsiElement element = queryParameters.getElementToSearch(); if (!(element instanceof PyNamedParameter)) { return; } @@ -46,22 +47,19 @@ public void processQuery( if (owner == null) { return; } - ReferencesSearch.search(owner, queryParameters.getScope()).forEach(new Processor() { - @Override - public boolean process(PsiReference reference) { - final PsiElement refElement = reference.getElement(); - final PyCallExpression call = PsiTreeUtil.getParentOfType(refElement, PyCallExpression.class); - if (call != null && PsiTreeUtil.isAncestor(call.getCallee(), refElement, false)) { - final PyArgumentList argumentList = call.getArgumentList(); - if (argumentList != null) { - final PyKeywordArgument keywordArgument = argumentList.getKeywordArgument(((PyNamedParameter)element).getName()); - if (keywordArgument != null) { - return consumer.process(keywordArgument.getReference()); - } + ReferencesSearch.search(owner, queryParameters.getScope()).forEach(reference -> { + PsiElement refElement = reference.getElement(); + PyCallExpression call = PsiTreeUtil.getParentOfType(refElement, PyCallExpression.class); + if (call != null && PsiTreeUtil.isAncestor(call.getCallee(), refElement, false)) { + PyArgumentList argumentList = call.getArgumentList(); + if (argumentList != null) { + PyKeywordArgument keywordArgument = argumentList.getKeywordArgument(((PyNamedParameter)element).getName()); + if (keywordArgument != null) { + return consumer.test(keywordArgument.getReference()); } } - return true; } + return true; }); } } diff --git a/python-impl/src/main/java/com/jetbrains/python/impl/psi/search/PyStringReferenceSearch.java b/python-impl/src/main/java/com/jetbrains/python/impl/psi/search/PyStringReferenceSearch.java index a01db6f3..a0e672b0 100644 --- a/python-impl/src/main/java/com/jetbrains/python/impl/psi/search/PyStringReferenceSearch.java +++ b/python-impl/src/main/java/com/jetbrains/python/impl/psi/search/PyStringReferenceSearch.java @@ -20,8 +20,7 @@ import com.jetbrains.python.impl.psi.PyUtil; import com.jetbrains.python.psi.PyElement; import consulo.annotation.component.ExtensionImpl; -import consulo.application.ReadAction; -import consulo.application.util.function.Processor; +import consulo.application.AccessRule; import consulo.content.scope.SearchScope; import consulo.language.psi.PsiDirectory; import consulo.language.psi.PsiElement; @@ -32,33 +31,35 @@ import consulo.language.psi.search.UsageSearchContext; import consulo.project.util.query.QueryExecutorBase; import consulo.util.lang.StringUtil; - import jakarta.annotation.Nonnull; +import java.util.function.Predicate; + /** * @author traff */ @ExtensionImpl public class PyStringReferenceSearch extends QueryExecutorBase implements ReferencesSearchQueryExecutor { + @Override public void processQuery( - @Nonnull final ReferencesSearch.SearchParameters params, - @Nonnull final Processor consumer + @Nonnull ReferencesSearch.SearchParameters params, + @Nonnull Predicate consumer ) { - final PsiElement element = params.getElementToSearch(); + PsiElement element = params.getElementToSearch(); if (!(element instanceof PyElement) && !(element instanceof PsiDirectory)) { return; } String name; - SearchScope searchScope = ReadAction.compute(() -> { + SearchScope searchScope = AccessRule.read(() -> { SearchScope s = params.getEffectiveSearchScope(); - if (s instanceof GlobalSearchScope) { - s = GlobalSearchScope.getScopeRestrictedByFileTypes((GlobalSearchScope)s, PythonFileType.INSTANCE); + if (s instanceof GlobalSearchScope globalSearchScope) { + s = GlobalSearchScope.getScopeRestrictedByFileTypes(globalSearchScope, PythonFileType.INSTANCE); } return s; }); - name = ReadAction.compute(() -> PyUtil.computeElementNameForStringSearch(element)); + name = AccessRule.read(() -> PyUtil.computeElementNameForStringSearch(element)); if (StringUtil.isEmpty(name)) { return;