From 76ece48d63836479d133cb693bb48bed3d48c14b Mon Sep 17 00:00:00 2001
From: Anna Kozlova <anna.kozlova@jetbrains.com>
Date: Mon, 10 Oct 2022 08:39:45 +0200
Subject: [PATCH] [kotlin] direct function overrides search

wrap search parameters to forbid kotlin class inheritance search from java overriding methods search, cause kotlin method overrides should be found separately and without LC

GitOrigin-RevId: 33bbefa169bc8ad4e6440e09d036e3b7ce11238e
---
 .../searches/ClassInheritorsSearch.java       |  7 +++++-
 .../searches/DirectClassInheritorsSearch.java |  8 ++++++-
 .../search/JavaClassInheritorsSearcher.java   |  7 +++++-
 .../search/JavaOverridingMethodsSearcher.java | 22 ++++++++++++++++---
 .../KotlinDirectInheritorsSearcher.kt         | 17 ++++++++++++--
 .../kotlin/kotlin.search/kotlin.search.iml    |  1 +
 .../DirectKotlinOverridingMethodSearch.kt     | 22 +++----------------
 7 files changed, 57 insertions(+), 27 deletions(-)
 rename plugins/kotlin/{idea => base/analysis}/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinDirectInheritorsSearcher.kt (78%)

diff --git a/java/java-indexing-api/src/com/intellij/psi/search/searches/ClassInheritorsSearch.java b/java/java-indexing-api/src/com/intellij/psi/search/searches/ClassInheritorsSearch.java
index 2b0f931985a2..c048903b885a 100644
--- a/java/java-indexing-api/src/com/intellij/psi/search/searches/ClassInheritorsSearch.java
+++ b/java/java-indexing-api/src/com/intellij/psi/search/searches/ClassInheritorsSearch.java
@@ -1,4 +1,4 @@
-// Copyright 2000-2020 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
+// Copyright 2000-2022 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
 package com.intellij.psi.search.searches;
 
 import com.intellij.lang.Language;
@@ -154,6 +154,11 @@ public final class ClassInheritorsSearch extends ExtensibleQueryFactory<PsiClass
           public boolean shouldSearchInLanguage(@NotNull Language language) {
             return parameters.shouldSearchInLanguage(language);
           }
+
+          @Override
+          public ClassInheritorsSearch.SearchParameters getOriginalParameters() {
+            return parameters;
+          }
         });
       if (parameters.getNameCondition() != Conditions.<String>alwaysTrue()) {
         directQuery = new FilteredQuery<>(directQuery, psiClass -> parameters.getNameCondition()
diff --git a/java/java-indexing-api/src/com/intellij/psi/search/searches/DirectClassInheritorsSearch.java b/java/java-indexing-api/src/com/intellij/psi/search/searches/DirectClassInheritorsSearch.java
index 0b30d6f5867d..8c0821ec5476 100644
--- a/java/java-indexing-api/src/com/intellij/psi/search/searches/DirectClassInheritorsSearch.java
+++ b/java/java-indexing-api/src/com/intellij/psi/search/searches/DirectClassInheritorsSearch.java
@@ -1,4 +1,4 @@
-// Copyright 2000-2020 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
+// Copyright 2000-2022 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
 package com.intellij.psi.search.searches;
 
 import com.intellij.lang.Language;
@@ -11,6 +11,7 @@ import com.intellij.util.Query;
 import com.intellij.util.QueryExecutor;
 import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 
 public final class DirectClassInheritorsSearch extends ExtensibleQueryFactory<PsiClass, DirectClassInheritorsSearch.SearchParameters> {
   public static final ExtensionPointName<QueryExecutor<PsiClass, DirectClassInheritorsSearch.SearchParameters>> EP_NAME = ExtensionPointName.create("com.intellij.directClassInheritorsSearch");
@@ -55,6 +56,11 @@ public final class DirectClassInheritorsSearch extends ExtensibleQueryFactory<Ps
       return myIncludeAnonymous;
     }
 
+    @Nullable
+    public ClassInheritorsSearch.SearchParameters getOriginalParameters() {
+      return null;
+    }
+
     @ApiStatus.Experimental
     public boolean shouldSearchInLanguage(@NotNull Language language) {
       return true;
diff --git a/java/java-indexing-impl/src/com/intellij/psi/impl/search/JavaClassInheritorsSearcher.java b/java/java-indexing-impl/src/com/intellij/psi/impl/search/JavaClassInheritorsSearcher.java
index 63da3eed7204..39e41761b168 100644
--- a/java/java-indexing-impl/src/com/intellij/psi/impl/search/JavaClassInheritorsSearcher.java
+++ b/java/java-indexing-impl/src/com/intellij/psi/impl/search/JavaClassInheritorsSearcher.java
@@ -1,4 +1,4 @@
-// Copyright 2000-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
+// Copyright 2000-2022 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
 package com.intellij.psi.impl.search;
 
 import com.intellij.java.indexing.JavaIndexingBundle;
@@ -119,6 +119,11 @@ public class JavaClassInheritorsSearcher extends QueryExecutorBase<PsiClass, Cla
             public boolean shouldSearchInLanguage(@NotNull Language language) {
               return parameters.shouldSearchInLanguage(language);
             }
+
+            @Override
+            public ClassInheritorsSearch.SearchParameters getOriginalParameters() {
+              return parameters;
+            }
           })
           .allowParallelProcessing().forEach(subClass -> {
             ProgressManager.checkCanceled();
diff --git a/java/java-indexing-impl/src/com/intellij/psi/impl/search/JavaOverridingMethodsSearcher.java b/java/java-indexing-impl/src/com/intellij/psi/impl/search/JavaOverridingMethodsSearcher.java
index 864bca93af31..8d6547f3d624 100644
--- a/java/java-indexing-impl/src/com/intellij/psi/impl/search/JavaOverridingMethodsSearcher.java
+++ b/java/java-indexing-impl/src/com/intellij/psi/impl/search/JavaOverridingMethodsSearcher.java
@@ -44,7 +44,7 @@ public class JavaOverridingMethodsSearcher implements QueryExecutor<PsiMethod, O
 
     Iterable<PsiMethod> cached = HighlightingCaches.getInstance(project).OVERRIDING_METHODS.get(method);
     if (cached == null) {
-      cached = compute(method, project);
+      cached = compute(method, parameters, project);
       // for non-physical elements ignore the cache completely because non-physical elements created so often/unpredictably so I can't figure out when to clear caches in this case
       if (ReadAction.compute(method::isPhysical)) {
         HighlightingCaches.getInstance(project).OVERRIDING_METHODS.put(method, cached);
@@ -108,7 +108,7 @@ public class JavaOverridingMethodsSearcher implements QueryExecutor<PsiMethod, O
   }
 
   @NotNull
-  private static Iterable<PsiMethod> compute(@NotNull PsiMethod method, @NotNull Project project) {
+  private static Iterable<PsiMethod> compute(@NotNull PsiMethod method, OverridingMethodsSearch.SearchParameters parameters, @NotNull Project project) {
     final PsiClass containingClass = ReadAction.compute(method::getContainingClass);
     assert containingClass != null;
     Collection<PsiMethod> result = new HashSet<>();
@@ -124,11 +124,27 @@ public class JavaOverridingMethodsSearcher implements QueryExecutor<PsiMethod, O
 
     // use wider scope to handle public method defined in package-private class which is subclassed by public class in the same package which is subclassed by public class from another package with redefined method
     SearchScope allScope = GlobalSearchScope.allScope(project);
-    boolean success = ClassInheritorsSearch.search(containingClass, allScope, true).allowParallelProcessing().forEach(inheritorsProcessor);
+    boolean success = ClassInheritorsSearch.search(new ClassInheritanceSearchFromJavaOverridingMethodsParameters(containingClass, allScope, parameters))
+      .allowParallelProcessing().forEach(inheritorsProcessor);
     assert success;
     return result;
   }
 
+  public static class ClassInheritanceSearchFromJavaOverridingMethodsParameters extends ClassInheritorsSearch.SearchParameters {
+    private final OverridingMethodsSearch.SearchParameters myOriginalParameters;
+
+    public ClassInheritanceSearchFromJavaOverridingMethodsParameters(@NotNull PsiClass aClass,
+                                                                     @NotNull SearchScope scope,
+                                                                     OverridingMethodsSearch.SearchParameters parameters) {
+      super(aClass, scope, true, true, true);
+      myOriginalParameters = parameters;
+    }
+
+    public OverridingMethodsSearch.SearchParameters getOriginalParameters() {
+      return myOriginalParameters;
+    }
+  }
+  
   @Nullable
   public static PsiMethod findOverridingMethod(@NotNull PsiClass inheritor,
                                                @NotNull PsiMethod method,
diff --git a/plugins/kotlin/idea/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinDirectInheritorsSearcher.kt b/plugins/kotlin/base/analysis/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinDirectInheritorsSearcher.kt
similarity index 78%
rename from plugins/kotlin/idea/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinDirectInheritorsSearcher.kt
rename to plugins/kotlin/base/analysis/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinDirectInheritorsSearcher.kt
index ac5722e85cb2..a3764441f02d 100644
--- a/plugins/kotlin/idea/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinDirectInheritorsSearcher.kt
+++ b/plugins/kotlin/base/analysis/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinDirectInheritorsSearcher.kt
@@ -1,23 +1,36 @@
-// Copyright 2000-2022 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
+// Copyright 2000-2022 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
 
 package org.jetbrains.kotlin.idea.search.ideaExtensions
 
 import com.intellij.openapi.application.QueryExecutorBase
 import com.intellij.openapi.progress.ProgressManager
 import com.intellij.psi.PsiClass
+import com.intellij.psi.PsiMethod
+import com.intellij.psi.impl.search.JavaOverridingMethodsSearcher.ClassInheritanceSearchFromJavaOverridingMethodsParameters
 import com.intellij.psi.search.GlobalSearchScope
+import com.intellij.psi.search.SearchScope
 import com.intellij.psi.search.searches.DirectClassInheritorsSearch
+import com.intellij.psi.search.searches.OverridingMethodsSearch
 import com.intellij.util.Processor
-import org.jetbrains.kotlin.asJava.toLightClassWithBuiltinMapping
 import org.jetbrains.kotlin.asJava.classes.KtFakeLightClass
 import org.jetbrains.kotlin.asJava.toFakeLightClass
+import org.jetbrains.kotlin.asJava.toLightClassWithBuiltinMapping
 import org.jetbrains.kotlin.idea.base.projectStructure.scope.KotlinSourceFilterScope
 import org.jetbrains.kotlin.idea.base.util.fileScope
 import org.jetbrains.kotlin.idea.stubindex.KotlinSuperClassIndex
 import org.jetbrains.kotlin.idea.stubindex.KotlinTypeAliasByExpansionShortNameIndex
 
+class JavaOverridingMethodsSearcherFromKotlinParameters(method: PsiMethod, scope: SearchScope, checkDeep: Boolean) 
+    : OverridingMethodsSearch.SearchParameters(method, scope, checkDeep)
+
+
 open class KotlinDirectInheritorsSearcher : QueryExecutorBase<PsiClass, DirectClassInheritorsSearch.SearchParameters>(true) {
     override fun processQuery(queryParameters: DirectClassInheritorsSearch.SearchParameters, consumer: Processor<in PsiClass>) {
+        val originalParameters = queryParameters.originalParameters
+        if (originalParameters is ClassInheritanceSearchFromJavaOverridingMethodsParameters && 
+            originalParameters.originalParameters is JavaOverridingMethodsSearcherFromKotlinParameters) {
+            return
+        }
         val baseClass = queryParameters.classToProcess
 
         val baseClassName = baseClass.name ?: return
diff --git a/plugins/kotlin/kotlin.search/kotlin.search.iml b/plugins/kotlin/kotlin.search/kotlin.search.iml
index fbab445a74a1..2494c7867ab7 100644
--- a/plugins/kotlin/kotlin.search/kotlin.search.iml
+++ b/plugins/kotlin/kotlin.search/kotlin.search.iml
@@ -18,5 +18,6 @@
     <orderEntry type="module" module-name="kotlin.base.project-structure" />
     <orderEntry type="module" module-name="intellij.java.psi.impl" />
     <orderEntry type="module" module-name="intellij.java.indexing.impl" />
+    <orderEntry type="module" module-name="kotlin.base.analysis" />
   </component>
 </module>
\ No newline at end of file
diff --git a/plugins/kotlin/kotlin.search/src/org/jetbrains/kotlin/idea/inheritorsSearch/DirectKotlinOverridingMethodSearch.kt b/plugins/kotlin/kotlin.search/src/org/jetbrains/kotlin/idea/inheritorsSearch/DirectKotlinOverridingMethodSearch.kt
index e410e8b7b780..23f7e0e52e3c 100644
--- a/plugins/kotlin/kotlin.search/src/org/jetbrains/kotlin/idea/inheritorsSearch/DirectKotlinOverridingMethodSearch.kt
+++ b/plugins/kotlin/kotlin.search/src/org/jetbrains/kotlin/idea/inheritorsSearch/DirectKotlinOverridingMethodSearch.kt
@@ -4,10 +4,8 @@ package org.jetbrains.kotlin.idea.inheritorsSearch
 import com.intellij.model.search.SearchService
 import com.intellij.model.search.Searcher
 import com.intellij.openapi.project.Project
-import com.intellij.psi.PsiClass
 import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiMethod
-import com.intellij.psi.impl.search.JavaOverridingMethodsSearcher.findOverridingMethod
 import com.intellij.psi.search.SearchScope
 import com.intellij.psi.search.searches.OverridingMethodsSearch
 import com.intellij.util.*
@@ -16,6 +14,7 @@ import org.jetbrains.kotlin.analysis.api.analyze
 import org.jetbrains.kotlin.analysis.api.symbols.KtClassOrObjectSymbol
 import org.jetbrains.kotlin.asJava.toLightMethods
 import org.jetbrains.kotlin.idea.inheritorsSearch.DirectKotlinOverridingMethodSearch.SearchParameters
+import org.jetbrains.kotlin.idea.search.ideaExtensions.JavaOverridingMethodsSearcherFromKotlinParameters
 import org.jetbrains.kotlin.psi.KtCallableDeclaration
 import org.jetbrains.kotlin.psi.KtClass
 import org.jetbrains.kotlin.psi.KtClassOrObject
@@ -59,20 +58,6 @@ class DirectKotlinOverridingMethodSearcher : Searcher<SearchParameters, PsiEleme
         
         return DirectKotlinClassInheritorsSearch.search(klass, parameters.searchScope)
             .flatMapping { ktClassOrObject ->
-                if (ktClassOrObject is PsiClass) {
-                    val javaOverridingMethods = parameters.ktFunction.toLightMethods().mapNotNull {
-                        val containingClass = it.containingClass ?: return@mapNotNull null
-                        return@mapNotNull findOverridingMethod(ktClassOrObject, it, containingClass)
-                    }.toList()
-                    return@flatMapping object : AbstractQuery<PsiElement>() {
-                        override fun processResults(consumer: Processor<in PsiElement>): Boolean {
-                            for (method in javaOverridingMethods) {
-                                if (!consumer.process(method)) return false
-                            }
-                            return true
-                        }
-                    }
-                }
                 if (ktClassOrObject !is KtClassOrObject) return@flatMapping EmptyQuery.getEmptyQuery()
                 return@flatMapping object : AbstractQuery<PsiElement>() {
                     override fun processResults(consumer: Processor<in PsiElement>): Boolean {
@@ -100,8 +85,7 @@ class DirectKotlinOverridingMethodSearcher : Searcher<SearchParameters, PsiEleme
 
 private val oldSearchers = setOf(
     "org.jetbrains.kotlin.idea.search.ideaExtensions.KotlinOverridingMethodsWithFlexibleTypesSearcher",
-    "org.jetbrains.kotlin.idea.search.ideaExtensions.KotlinOverridingMethodsWithGenericsSearcher",
-    "com.intellij.psi.impl.search.JavaOverridingMethodsSearcher"
+    "org.jetbrains.kotlin.idea.search.ideaExtensions.KotlinOverridingMethodsWithGenericsSearcher"
 )
 private val EVERYTHING_BUT_KOTLIN = object : QueryFactory<PsiMethod, OverridingMethodsSearch.SearchParameters>() {
     init {
@@ -118,7 +102,7 @@ internal class DirectKotlinOverridingMethodDelegatedSearcher : Searcher<SearchPa
         val methods = baseFunction.toLightMethods()
 
         val queries = methods.map { it ->
-            EVERYTHING_BUT_KOTLIN.createQuery(OverridingMethodsSearch.SearchParameters(it, parameters.searchScope, false))
+            EVERYTHING_BUT_KOTLIN.createQuery(JavaOverridingMethodsSearcherFromKotlinParameters(it, parameters.searchScope, false))
         }
 
         return object : AbstractQuery<PsiElement>() {