[AA] KT-74867 Move filtering local declarations from KotlinAnnotationsResolver into LLFirIdePredicateBasedProvider

The problem described in the KT-74867
is caused by the fact that the IDE
implementation of `KotlinAnnotationsResolver`
(see `IdeKotlinAnnotationsResolver`) does not
filter local classes by itself.

Since `LookupPredicate`s should never match
local declarations, this resulted in exceptions in the IDE
from lazy resolution because resolving local declarations
requires resolving bodies,
and that's too early for compiler plugins.

It seems like moving this logic for filtering local declarations
from the `KotlinAnnotationsResolver` implementations
into the `LLFirIdePredicateBasedProvider` is more consistent,
because this class interacts directly with `LookupPredicate`
and should obey the contract.

^KT-74867 Fixed

Author: fedochet

analysis/analysis-api-standalone/analysis-api-standalone-base/src/org/jetbrains/kotlin/analysis/api/standalone/base/declarations/KotlinStandaloneAnnotationsResolver.kt

@@ -38,17 +38,8 @@ private class KotlinStandaloneAnnotationsResolver(
     private val allDeclarations: List<KtDeclaration> by lazy {
         val result = mutableListOf<KtDeclaration>()
 
-        val visitor = declarationRecursiveVisitor visit@{
-            val isLocal = when (it) {
-                is KtClassOrObject -> it.isLocal
-                is KtFunction -> it.isLocal
-                is KtProperty -> it.isLocal
-                else -> return@visit
-            }
-
-            if (!isLocal) {
-                result += it
-            }
+        val visitor = declarationRecursiveVisitor {
+            result += it
         }
 
         filesInScope.forEach { it.accept(visitor) }

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/providers/LLFirIdePredicateBasedProvider.kt

@@ -60,13 +60,13 @@ internal class LLFirIdePredicateBasedProvider(
 
         return annotatedDeclarations
             .asSequence()
-            .mapNotNull { it.findFirDeclaration() }
+            .mapNotNull { it.findFirDeclarationForLookupPredicate() }
             .filter { matches(predicate, it) }
             .map { it.symbol }
             .toList()
     }
 
-    private fun KtElement.findFirDeclaration(): FirDeclaration? {
+    private fun KtElement.findFirDeclarationForLookupPredicate(): FirDeclaration? {
         if (this !is KtDeclaration) return null
 
         if (this !is KtClassLikeDeclaration &&
@@ -75,6 +75,9 @@ internal class LLFirIdePredicateBasedProvider(
             this !is KtProperty
         ) return null
 
+        // LookupPredicates should never match local declarations, so we filter them early
+        if (KtPsiUtil.isLocal(this)) return null
+
         val moduleForFile = projectStructureProvider.getModule(this, session.ktModule)
         val resolutionFacadeForFile = moduleForFile.getResolutionFacade(project)
         return this.resolveToFirSymbol(resolutionFacadeForFile).fir