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..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,35 +16,36 @@ 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 */ -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 Predicate 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..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,32 +30,32 @@ import jakarta.annotation.Nonnull; +import java.util.function.Predicate; + /** * @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 { + @Override + public boolean execute( + @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 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)) { + 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..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,68 +18,73 @@ 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"); - /** - * 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<>(); - - return ReadAction.compute(() -> processDirectInheritors(queryParameters.getSuperClass(), - consumer, - queryParameters.isCheckDeepInheritance(), - processed)); - } + @Override + public boolean execute( + @Nonnull PyClassInheritorsSearch.SearchParameters queryParameters, + @Nonnull Predicate 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 + return AccessRule.read(() -> processDirectInheritors( + queryParameters.getSuperClass(), + consumer, + queryParameters.isCheckDeepInheritance(), + processed + )); } - 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; + + @RequiredReadAction + private static boolean processDirectInheritors( + PyClass superClass, + Predicate consumer, + boolean checkDeep, + Set processed + ) { + 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(); + Collection candidates = + StubIndex.getElements(PySuperClassIndex.KEY, superClassName, project, ProjectScopes.getAllScope(project), PyClass.class); + for (PyClass candidate : candidates) { + PyClass[] classes = candidate.getSuperClasses(null); + for (PyClass superClassCandidate : classes) { + if (superClassCandidate.isEquivalentTo(superClass)) { + if (!consumer.test(candidate) || 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..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,44 +18,42 @@ 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 */ @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 PyOverridingMethodsSearch.SearchParameters queryParameters, + @Nonnull Predicate consumer + ) { + 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 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 = AccessRule.read(() -> { + PyFunction func = pyClass.findMethodByName(baseMethod.getName(), false, null); + if (func != null) { + Property baseProperty = baseMethod.getProperty(); + Property overridingProperty = func.getProperty(); + if (baseProperty != null && overridingProperty != null) { + AccessDirection direction = PyUtil.getPropertyAccessDirection(baseMethod); + PyCallable callable = overridingProperty.getByDirection(direction).valueOrNull(); + func = callable instanceof PyFunction function ? function : null; + } + } - return func; - }); + 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 90d6fd57..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,76 +16,79 @@ 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 */ @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 + @RequiredReadAction + public boolean execute( + @Nonnull PySuperMethodsSearch.SearchParameters queryParameters, + @Nonnull Predicate consumer + ) { + 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()) { + 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) { + Property property = func.getProperty(); + Property superProperty = superMethod.getProperty(); + if (property != null && superProperty != 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); - 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 + PyClassLikeType classLikeType = PyUtil.as(context.getType(superClass), PyClassLikeType.class); + if (classLikeType != null) { + for (PyFunction function : PyTypeUtil.getMembersOfType(classLikeType, PyFunction.class, true, context)) { + String elemName = function.getName(); + if (elemName != null && elemName.equals(func.getName())) { + consumer.test(function); + } + } + } + } + if (superMethod != null) { + foundMethodContainingClasses.add(superClass); + if (!consumer.test(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..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,40 +21,33 @@ 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 { - 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); + @Override + public boolean execute( + @Nonnull DefinitionsScopedSearch.SearchParameters parameters, + @Nonnull Predicate consumer + ) { + PsiElement element = parameters.getElement(); + if (element instanceof PyClass pyClass) { + return PyClassInheritorsSearch.search(pyClass, 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 PyFunction function) { + return PyOverridingMethodsSearch.search(function, true).forEach(consumer::test); + } + else if (element instanceof PyTargetExpression && element.getParent() instanceof PyAssignmentStatement assignment) { + return consumer.test(assignment); // PY-237 + } + 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..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,50 +30,42 @@ 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 */ @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; - } - - 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; - } +public class PyInitReferenceSearchExecutor extends QueryExecutorBase implements ReferencesSearchQueryExecutor { + @Override + public void processQuery( + @Nonnull ReferencesSearch.SearchParameters queryParameters, + @Nonnull Predicate consumer + ) { + PsiElement element = queryParameters.getElementToSearch(); + if (!(element instanceof PyFunction function)) { + return; + } - searchScope = queryParameters.getEffectiveSearchScope(); - if(searchScope instanceof GlobalSearchScope) - { - searchScope = GlobalSearchScope.getScopeRestrictedByFileTypes((GlobalSearchScope) searchScope, PythonFileType.INSTANCE); - } + if (!PyNames.INIT.equals(AccessRule.read(function::getName))) { + return; + } + PyClass pyClass = AccessRule.read(function::getContainingClass); + if (pyClass == null) { + return; + } + String className = AccessRule.read(pyClass::getName); + if (className == null) { + return; + } + 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); - } + 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..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,49 +16,50 @@ 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 { - @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()); - } - } +public class PyKeywordArgumentSearchExecutor extends QueryExecutorBase + implements ReferencesSearchQueryExecutor { + @Override + public void processQuery( + @Nonnull ReferencesSearch.SearchParameters queryParameters, + @Nonnull Predicate consumer + ) { + 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(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; + }); + } } 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..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,36 +31,40 @@ 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 { - 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; - } + @Override + public void processQuery( + @Nonnull ReferencesSearch.SearchParameters params, + @Nonnull Predicate consumer + ) { + PsiElement element = params.getElementToSearch(); + if (!(element instanceof PyElement) && !(element instanceof PsiDirectory)) { + return; + } + + String name; + SearchScope searchScope = AccessRule.read(() -> { + SearchScope s = params.getEffectiveSearchScope(); + if (s instanceof GlobalSearchScope globalSearchScope) { + s = GlobalSearchScope.getScopeRestrictedByFileTypes(globalSearchScope, 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 = AccessRule.read(() -> 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); - } }