[LL FIR] merge LLFirResolveTargetWithDedicatedElement into LLFirResolveTarget

^KT-61296

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/api/targets/LLFirClassWithAllCallablesResolveTarget.kt

@@ -17,14 +17,14 @@ class LLFirClassWithAllCallablesResolveTarget(
     firFile: FirFile,
     classPath: List<FirRegularClass>,
     target: FirRegularClass,
-) : LLFirResolveTargetWithDedicatedElement<FirRegularClass>(firFile, classPath, target) {
+) : LLFirResolveTarget(firFile, classPath, target) {
     override fun forEachTarget(action: (FirElementWithResolveState) -> Unit) {
         action(target)
         forEachCallable(action)
     }
 
     inline fun forEachCallable(action: (FirCallableDeclaration) -> Unit) {
-        for (member in target.declarations) {
+        for (member in (target as FirRegularClass).declarations) {
             if (member is FirCallableDeclaration) {
                 action(member)
             }

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/api/targets/LLFirClassWithAllMembersResolveTarget.kt

@@ -17,13 +17,13 @@ class LLFirClassWithAllMembersResolveTarget(
     firFile: FirFile,
     classPath: List<FirRegularClass>,
     target: FirRegularClass,
-) : LLFirResolveTargetWithDedicatedElement<FirRegularClass>(firFile, classPath, target) {
+) : LLFirResolveTarget(firFile, classPath, target) {
     override fun forEachTarget(action: (FirElementWithResolveState) -> Unit) {
         action(target)
         forEachMember(action)
     }
 
     inline fun forEachMember(action: (FirDeclaration) -> Unit) {
-        target.declarations.forEach(action)
+        (target as FirRegularClass).declarations.forEach(action)
     }
 }

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/api/targets/LLFirClassWithSpecificMembersResolveTarget.kt

@@ -15,7 +15,7 @@ class LLFirClassWithSpecificMembersResolveTarget(
     classPath: List<FirRegularClass>,
     target: FirRegularClass,
     val members: List<FirDeclaration>,
-) : LLFirResolveTargetWithDedicatedElement<FirRegularClass>(firFile, classPath, target) {
+) : LLFirResolveTarget(firFile, classPath, target) {
     override fun forEachTarget(action: (FirElementWithResolveState) -> Unit) {
         action(target)
         forEachMember(action)

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/api/targets/LLFirResolveTarget.kt

@@ -5,23 +5,23 @@
 
 package org.jetbrains.kotlin.analysis.low.level.api.fir.api.targets
 
-import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.llFirResolvableSession
-import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.llFirSession
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.errorWithFirSpecificEntries
 import org.jetbrains.kotlin.fir.FirElementWithResolveState
+import org.jetbrains.kotlin.fir.FirFileAnnotationsContainer
+import org.jetbrains.kotlin.fir.declarations.FirAnonymousInitializer
+import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration
+import org.jetbrains.kotlin.fir.declarations.FirClassLikeDeclaration
+import org.jetbrains.kotlin.fir.declarations.FirConstructor
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirFile
 import org.jetbrains.kotlin.fir.declarations.FirRegularClass
-import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.declarations.FirScript
-import org.jetbrains.kotlin.utils.exceptions.errorWithAttachment
-
 
 /**
- * Target to be lazily resolved by LL FIR lazy resolver.
+ * [target] element and optionally its subgraph to be lazily resolved by LL FIR lazy resolver.
  *
- * Specifies the path to the resolve targets and resolve targets themselves.
+ * Specifies the path to resolve targets and resolve targets themselves.
- * Those targets are going to be resolved by [org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.LLFirModuleLazyDeclarationResolver]
+ * Those targets are going to be resolved by [LLFirModuleLazyDeclarationResolver][org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.LLFirModuleLazyDeclarationResolver].
  */
 sealed class LLFirResolveTarget(
     /**
@@ -29,13 +29,23 @@ sealed class LLFirResolveTarget(
      */
     val firFile: FirFile,
 
+    /**
+     * The list of [FirRegularClass] which are the required to go from file to target declarations in the top-down order.
+     */
+    classPath: List<FirRegularClass>,
+
+    /**
+     * A dedicated main element.
+     */
+    val target: FirElementWithResolveState,
+) {
     /**
      * The list of [FirScript] and [FirRegularClass] which are the required to go from file to target declarations in the top-down order.
      *
-     * If resolve target is [FirRegularClass] or [FirScript] itself, it's not included into the [path]
+     * If resolve target is [FirRegularClass] or [FirScript] itself, it's not included into the [path].
      */
-    val path: List<FirDeclaration>,
+    val path: List<FirDeclaration> = pathWithScript(firFile, classPath, target)
-) {
+
     /**
      * Executions the [action] for each target that this [LLFirResolveTarget] represents.
      */
@@ -59,5 +69,19 @@ sealed class LLFirResolveTarget(
         append(")")
     }
 
-    protected abstract fun toStringForTarget(): String
+    protected open fun toStringForTarget(): String = when (target) {
+        is FirConstructor -> "constructor"
+        is FirClassLikeDeclaration -> target.symbol.name.asString()
+        is FirCallableDeclaration -> target.symbol.name.asString()
+        is FirAnonymousInitializer -> ("<init-block>")
+        is FirFileAnnotationsContainer -> "<file annotations>"
+        is FirScript -> target.name.asString()
+        else -> "???"
+    }
+}
+
+private fun pathWithScript(firFile: FirFile, path: List<FirRegularClass>, target: FirElementWithResolveState): List<FirDeclaration> {
+    if (target is FirFile || target is FirFileAnnotationsContainer || target is FirScript) return path
+    val firScript = firFile.declarations.singleOrNull() as? FirScript ?: return path
+    return listOf(firScript) + path
 }

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/api/targets/LLFirResolveTargetWithDedicatedElement.kt

@@ -1,46 +0,0 @@
-/*
- * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-
-package org.jetbrains.kotlin.analysis.low.level.api.fir.api.targets
-
-import org.jetbrains.kotlin.fir.FirElementWithResolveState
-import org.jetbrains.kotlin.fir.FirFileAnnotationsContainer
-import org.jetbrains.kotlin.fir.declarations.FirAnonymousInitializer
-import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration
-import org.jetbrains.kotlin.fir.declarations.FirClassLikeDeclaration
-import org.jetbrains.kotlin.fir.declarations.FirConstructor
-import org.jetbrains.kotlin.fir.declarations.FirDeclaration
-import org.jetbrains.kotlin.fir.declarations.FirFile
-import org.jetbrains.kotlin.fir.declarations.FirRegularClass
-import org.jetbrains.kotlin.fir.declarations.FirScript
-
-/**
- * [LLFirResolveTarget] representing a target with a dedicated main element.
- * Such resolved is supposed to resolve [target] element and/or its declaration subgraph.
- */
-sealed class LLFirResolveTargetWithDedicatedElement<T : FirElementWithResolveState>(
-    firFile: FirFile,
-    classPath: List<FirRegularClass>,
-    val target: T,
-) : LLFirResolveTarget(
-    firFile = firFile,
-    path = pathWithScript(firFile, classPath, target),
-) {
-    override fun toStringForTarget(): String = when (target) {
-        is FirConstructor -> "constructor"
-        is FirClassLikeDeclaration -> target.symbol.name.asString()
-        is FirCallableDeclaration -> target.symbol.name.asString()
-        is FirAnonymousInitializer -> ("<init-block>")
-        is FirFileAnnotationsContainer -> "<file annotations>"
-        is FirScript -> target.name.asString()
-        else -> "???"
-    }
-}
-
-private fun pathWithScript(firFile: FirFile, path: List<FirRegularClass>, target: FirElementWithResolveState): List<FirDeclaration> {
-    if (target is FirFile || target is FirFileAnnotationsContainer || target is FirScript) return path
-    val firScript = firFile.declarations.singleOrNull() as? FirScript ?: return path
-    return listOf(firScript) + path
-}

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/api/targets/LLFirSingleResolveTarget.kt

@@ -15,7 +15,7 @@ class LLFirSingleResolveTarget(
     firFile: FirFile,
     classPath: List<FirRegularClass>,
     target: FirElementWithResolveState,
-) : LLFirResolveTargetWithDedicatedElement<FirElementWithResolveState>(firFile, classPath, target) {
+) : LLFirResolveTarget(firFile, classPath, target) {
     override fun forEachTarget(action: (FirElementWithResolveState) -> Unit) {
         action(target)
     }

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/api/targets/LLFirWholeClassResolveTarget.kt

@@ -17,7 +17,7 @@ class LLFirWholeClassResolveTarget(
     firFile: FirFile,
     classPath: List<FirRegularClass>,
     target: FirRegularClass,
-) : LLFirResolveTargetWithDedicatedElement<FirRegularClass>(firFile, classPath, target) {
+) : LLFirResolveTarget(firFile, classPath, target) {
     override fun forEachTarget(action: (FirElementWithResolveState) -> Unit) {
         action(target)
 
@@ -32,7 +32,7 @@ class LLFirWholeClassResolveTarget(
     }
 
     inline fun forEachDeclaration(action: (FirElementWithResolveState) -> Unit) {
-        for (member in target.declarations) {
+        for (member in (target as FirRegularClass).declarations) {
             action(member)
         }
     }

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/api/targets/LLFirWholeFileResolveTarget.kt

@@ -14,7 +14,7 @@ import org.jetbrains.kotlin.fir.declarations.FirFile
 /**
  * [LLFirResolveTarget] representing all declarations in file. All of them are going to be resolved.
  */
-class LLFirWholeFileResolveTarget(firFile: FirFile) : LLFirResolveTarget(firFile, emptyList()) {
+class LLFirWholeFileResolveTarget(firFile: FirFile) : LLFirResolveTarget(firFile, emptyList(), firFile) {
     override fun forEachTarget(action: (FirElementWithResolveState) -> Unit) {
         fun goInside(target: FirElementWithResolveState) {
             action(target)

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirTargetResolver.kt

@@ -96,19 +96,19 @@ internal abstract class LLFirTargetResolver(
             when (resolveTarget) {
                 is LLFirClassWithSpecificMembersResolveTarget -> {
                     performResolve(resolveTarget.target)
-                    withRegularClass(resolveTarget.target) {
+                    withRegularClass(resolveTarget.target as FirRegularClass) {
                         resolveTarget.forEachMember(::performResolve)
                     }
                 }
                 is LLFirClassWithAllMembersResolveTarget -> {
                     performResolve(resolveTarget.target)
-                    withRegularClass(resolveTarget.target) {
+                    withRegularClass(resolveTarget.target as FirRegularClass) {
                         resolveTarget.forEachMember(::performResolve)
                     }
                 }
                 is LLFirClassWithAllCallablesResolveTarget -> {
                     performResolve(resolveTarget.target)
-                    withRegularClass(resolveTarget.target) {
+                    withRegularClass(resolveTarget.target as FirRegularClass) {
                         resolveTarget.forEachCallable(::performResolve)
                     }
                 }
@@ -120,7 +120,7 @@ internal abstract class LLFirTargetResolver(
                 }
                 is LLFirWholeClassResolveTarget -> {
                     performResolve(resolveTarget.target)
-                    withRegularClass(resolveTarget.target) {
+                    withRegularClass(resolveTarget.target as FirRegularClass) {
                         resolveTarget.forEachDeclaration(::resolveTargetWithNestedDeclarations)
                     }
                 }