LL API: remove old resolve api

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirPsiTypeProvider.kt

@@ -19,8 +19,6 @@ import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.types.KtTypeMappingMode
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.withFirDeclaration
 import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacade
 import org.jetbrains.kotlin.asJava.elements.KtLightElement
 import org.jetbrains.kotlin.codegen.signature.BothSignatureWriter
@@ -31,9 +29,6 @@ import org.jetbrains.kotlin.descriptors.java.JavaVisibilities
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.analysis.checkers.toRegularClassSymbol
 import org.jetbrains.kotlin.fir.backend.jvm.jvmTypeMapper
-import org.jetbrains.kotlin.fir.declarations.FirClass
-import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
-import org.jetbrains.kotlin.fir.declarations.utils.superConeTypes
 import org.jetbrains.kotlin.fir.resolve.fullyExpandedType
 import org.jetbrains.kotlin.fir.resolve.substitution.AbstractConeSubstitutor
 import org.jetbrains.kotlin.fir.resolve.toSymbol
@@ -61,7 +56,6 @@ internal class KtFirPsiTypeProvider(
     ): PsiType? = withValidityAssertion {
         type.coneType.asPsiType(
             rootModuleSession,
-            analysisSession.firResolveState,
             mode.toTypeMappingMode(type, isAnnotationMethod),
             useSitePosition
         )
@@ -85,10 +79,9 @@ internal class KtFirPsiTypeProvider(
 
 private fun ConeKotlinType.simplifyType(
     session: FirSession,
-    state: FirModuleResolveState,
     useSitePosition: PsiElement,
 ): ConeKotlinType {
-    val substitutor = AnonymousTypesSubstitutor(session, state)
+    val substitutor = AnonymousTypesSubstitutor(session)
     val visibilityForApproximation = useSitePosition.visibilityForApproximation
     // TODO: See if the given [useSitePosition] is an `inline` method
     val isInlineFunction = false
@@ -181,11 +174,10 @@ private fun ConeKotlinType.isLocalButAvailableAtPosition(
 
 internal fun ConeKotlinType.asPsiType(
     session: FirSession,
-    state: FirModuleResolveState,
     mode: TypeMappingMode,
     useSitePosition: PsiElement,
 ): PsiType? {
-    val correctedType = simplifyType(session, state, useSitePosition)
+    val correctedType = simplifyType(session, useSitePosition)
 
     if (correctedType is ConeClassErrorType || correctedType !is SimpleTypeMarker) return null
 
@@ -213,7 +205,6 @@ internal fun ConeKotlinType.asPsiType(
 
 private class AnonymousTypesSubstitutor(
     private val session: FirSession,
-    private val state: FirModuleResolveState,
 ) : AbstractConeSubstitutor(session.typeContext) {
     override fun substituteType(type: ConeKotlinType): ConeKotlinType? {
         if (type !is ConeClassLikeType) return null
@@ -222,18 +213,14 @@ private class AnonymousTypesSubstitutor(
         if (!isAnonymous) return null
 
         fun ConeClassLikeType.isNotInterface(): Boolean {
-            val firClassNode = lookupTag.toSymbol(session)?.fir as? FirClass ?: return false
-            return firClassNode.withFirDeclaration(state) { firSuperClass ->
-                firSuperClass.classKind != ClassKind.INTERFACE
-            }
+            val firClassNode = lookupTag.toSymbol(session) as? FirClassSymbol<*> ?: return false
+            return firClassNode.classKind != ClassKind.INTERFACE
         }
 
-        val firClassNode = (type.lookupTag.toSymbol(session) as? FirClassSymbol)?.fir
+        val firClassNode = type.lookupTag.toSymbol(session) as? FirClassSymbol
         if (firClassNode != null) {
-            val superTypesCones = firClassNode.withFirDeclaration(state, FirResolvePhase.SUPER_TYPES) {
-                (it as? FirClass)?.superConeTypes
-            }
-            val superClass = superTypesCones?.firstOrNull { it.isNotInterface() }
+            val superTypesCones = firClassNode.resolvedSuperTypes
+            val superClass = superTypesCones.firstOrNull { (it as? ConeClassLikeType)?.isNotInterface() == true }
             if (superClass != null) return superClass
         }
 

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirSymbolProvider.kt

@@ -15,7 +15,7 @@ import org.jetbrains.kotlin.analysis.api.withValidityAssertion
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getOrBuildFirFile
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getOrBuildFirOfType
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.withFirSymbolOfType
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.resolveToFirSymbolOfType
 import org.jetbrains.kotlin.fir.declarations.FirDeclarationOrigin
 import org.jetbrains.kotlin.fir.renderWithType
 import org.jetbrains.kotlin.fir.resolve.providers.FirSymbolProvider
@@ -40,12 +40,14 @@ internal class KtFirSymbolProvider(
                 "Creating KtValueParameterSymbol for function type parameter is not possible. Please see the KDoc of getParameterSymbol"
             )
 
-            psi.isLoopParameter -> psi.withFirSymbolOfType<FirPropertySymbol, KtLocalVariableSymbol>(resolveState) {
-                firSymbolBuilder.variableLikeBuilder.buildLocalVariableSymbol(it)
+            psi.isLoopParameter -> {
+                firSymbolBuilder.variableLikeBuilder.buildLocalVariableSymbol(psi.resolveToFirSymbolOfType<FirPropertySymbol>(resolveState))
             }
 
-            else -> psi.withFirSymbolOfType<FirValueParameterSymbol, KtValueParameterSymbol>(resolveState) {
-                firSymbolBuilder.variableLikeBuilder.buildValueParameterSymbol(it)
+            else -> {
+                firSymbolBuilder.variableLikeBuilder.buildValueParameterSymbol(
+                    psi.resolveToFirSymbolOfType<FirValueParameterSymbol>(resolveState)
+                )
             }
         }
     }
@@ -55,95 +57,76 @@ internal class KtFirSymbolProvider(
     }
 
     override fun getFunctionLikeSymbol(psi: KtNamedFunction): KtFunctionLikeSymbol = withValidityAssertion {
-        psi.withFirSymbolOfType<FirFunctionSymbol<*>, KtFunctionLikeSymbol>(resolveState) { fir ->
-            when (fir) {
-                is FirNamedFunctionSymbol -> {
-                    if (fir.origin == FirDeclarationOrigin.SamConstructor) {
-                        firSymbolBuilder.functionLikeBuilder.buildSamConstructorSymbol(fir)
-                    } else {
-                        firSymbolBuilder.functionLikeBuilder.buildFunctionSymbol(fir)
-                    }
+        when (val firSymbol = psi.resolveToFirSymbolOfType<FirFunctionSymbol<*>>(resolveState)) {
+            is FirNamedFunctionSymbol -> {
+                if (firSymbol.origin == FirDeclarationOrigin.SamConstructor) {
+                    firSymbolBuilder.functionLikeBuilder.buildSamConstructorSymbol(firSymbol)
+                } else {
+                    firSymbolBuilder.functionLikeBuilder.buildFunctionSymbol(firSymbol)
                 }
-                is FirAnonymousFunctionSymbol -> firSymbolBuilder.functionLikeBuilder.buildAnonymousFunctionSymbol(fir)
-                else -> error("Unexpected ${fir.fir.renderWithType()}")
             }
+            is FirAnonymousFunctionSymbol -> firSymbolBuilder.functionLikeBuilder.buildAnonymousFunctionSymbol(firSymbol)
+            else -> error("Unexpected ${firSymbol.fir.renderWithType()}")
         }
     }
 
     override fun getConstructorSymbol(psi: KtConstructor<*>): KtConstructorSymbol = withValidityAssertion {
-        psi.withFirSymbolOfType<FirConstructorSymbol, KtConstructorSymbol>(resolveState) {
-            firSymbolBuilder.functionLikeBuilder.buildConstructorSymbol(it)
-        }
+
+        firSymbolBuilder.functionLikeBuilder.buildConstructorSymbol(psi.resolveToFirSymbolOfType<FirConstructorSymbol>(resolveState))
+
     }
 
     override fun getTypeParameterSymbol(psi: KtTypeParameter): KtTypeParameterSymbol = withValidityAssertion {
-        psi.withFirSymbolOfType<FirTypeParameterSymbol, KtTypeParameterSymbol>(resolveState) {
-            firSymbolBuilder.classifierBuilder.buildTypeParameterSymbol(it)
-        }
+        firSymbolBuilder.classifierBuilder.buildTypeParameterSymbol(psi.resolveToFirSymbolOfType<FirTypeParameterSymbol>(resolveState))
     }
 
     override fun getTypeAliasSymbol(psi: KtTypeAlias): KtTypeAliasSymbol = withValidityAssertion {
-        psi.withFirSymbolOfType<FirTypeAliasSymbol, KtTypeAliasSymbol>(resolveState) {
-            firSymbolBuilder.classifierBuilder.buildTypeAliasSymbol(it)
-        }
+        firSymbolBuilder.classifierBuilder.buildTypeAliasSymbol(psi.resolveToFirSymbolOfType<FirTypeAliasSymbol>(resolveState))
     }
 
     override fun getEnumEntrySymbol(psi: KtEnumEntry): KtEnumEntrySymbol = withValidityAssertion {
-        psi.withFirSymbolOfType<FirEnumEntrySymbol, KtEnumEntrySymbol>(resolveState) {
-            firSymbolBuilder.buildEnumEntrySymbol(it)
-        }
+        firSymbolBuilder.buildEnumEntrySymbol(psi.resolveToFirSymbolOfType<FirEnumEntrySymbol>(resolveState))
     }
 
     override fun getAnonymousFunctionSymbol(psi: KtNamedFunction): KtAnonymousFunctionSymbol = withValidityAssertion {
-        psi.withFirSymbolOfType<FirNamedFunctionSymbol, KtFunctionSymbol>(resolveState) {
-            firSymbolBuilder.functionLikeBuilder.buildFunctionSymbol(it)
-        }
         firSymbolBuilder.functionLikeBuilder.buildAnonymousFunctionSymbol(psi.getOrBuildFirOfType(resolveState))
     }
 
     override fun getAnonymousFunctionSymbol(psi: KtFunctionLiteral): KtAnonymousFunctionSymbol = withValidityAssertion {
-        psi.withFirSymbolOfType<FirAnonymousFunctionSymbol, KtAnonymousFunctionSymbol>(resolveState) {
-            firSymbolBuilder.functionLikeBuilder.buildAnonymousFunctionSymbol(it)
-        }
+        firSymbolBuilder.functionLikeBuilder.buildAnonymousFunctionSymbol(
+            psi.resolveToFirSymbolOfType<FirAnonymousFunctionSymbol>(resolveState)
+        )
     }
 
     override fun getVariableSymbol(psi: KtProperty): KtVariableSymbol = withValidityAssertion {
-        psi.withFirSymbolOfType<FirPropertySymbol, KtVariableSymbol>(resolveState) {
-            firSymbolBuilder.variableLikeBuilder.buildVariableSymbol(it)
-        }
+        firSymbolBuilder.variableLikeBuilder.buildVariableSymbol(psi.resolveToFirSymbolOfType<FirPropertySymbol>(resolveState))
     }
 
     override fun getAnonymousObjectSymbol(psi: KtObjectLiteralExpression): KtAnonymousObjectSymbol = withValidityAssertion {
-        psi.objectDeclaration.withFirSymbolOfType<FirAnonymousObjectSymbol, KtAnonymousObjectSymbol>(resolveState) {
-            firSymbolBuilder.classifierBuilder.buildAnonymousObjectSymbol(it)
-        }
+        firSymbolBuilder.classifierBuilder.buildAnonymousObjectSymbol(
+            psi.objectDeclaration.resolveToFirSymbolOfType<FirAnonymousObjectSymbol>(resolveState)
+        )
     }
 
     override fun getClassOrObjectSymbol(psi: KtClassOrObject): KtClassOrObjectSymbol = withValidityAssertion {
-        psi.withFirSymbolOfType<FirClassSymbol<*>, KtClassOrObjectSymbol>(resolveState) {
-            firSymbolBuilder.classifierBuilder.buildClassOrObjectSymbol(it)
-        }
+        firSymbolBuilder.classifierBuilder.buildClassOrObjectSymbol(psi.resolveToFirSymbolOfType<FirClassSymbol<*>>(resolveState))
     }
 
     override fun getNamedClassOrObjectSymbol(psi: KtClassOrObject): KtNamedClassOrObjectSymbol? = withValidityAssertion {
         require(psi !is KtObjectDeclaration || psi.parent !is KtObjectLiteralExpression)
         // A KtClassOrObject may also map to an FirEnumEntry. Hence, we need to return null in this case.
         if (psi is KtEnumEntry) return null
-        psi.withFirSymbolOfType<FirRegularClassSymbol, KtNamedClassOrObjectSymbol>(resolveState) {
-            firSymbolBuilder.classifierBuilder.buildNamedClassOrObjectSymbol(it)
-        }
+        firSymbolBuilder.classifierBuilder.buildNamedClassOrObjectSymbol(psi.resolveToFirSymbolOfType<FirRegularClassSymbol>(resolveState))
     }
 
     override fun getPropertyAccessorSymbol(psi: KtPropertyAccessor): KtPropertyAccessorSymbol = withValidityAssertion {
-        psi.withFirSymbolOfType<FirPropertyAccessorSymbol, KtPropertyAccessorSymbol>(resolveState) {
-            firSymbolBuilder.callableBuilder.buildPropertyAccessorSymbol(it)
-        }
+        firSymbolBuilder.callableBuilder.buildPropertyAccessorSymbol(psi.resolveToFirSymbolOfType<FirPropertyAccessorSymbol>(resolveState))
     }
 
     override fun getClassInitializerSymbol(psi: KtClassInitializer): KtClassInitializerSymbol = withValidityAssertion {
-        psi.withFirSymbolOfType<FirAnonymousInitializerSymbol, KtClassInitializerSymbol>(resolveState) {
-            firSymbolBuilder.anonymousInitializerBuilder.buildClassInitializer(it)
-        }
+        firSymbolBuilder.anonymousInitializerBuilder.buildClassInitializer(
+            psi.resolveToFirSymbolOfType<FirAnonymousInitializerSymbol>(resolveState)
+        )
     }
 
     override fun getClassOrObjectSymbolByClassId(classId: ClassId): KtClassOrObjectSymbol? = withValidityAssertion {

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/utils/firUtils.kt

@@ -11,8 +11,6 @@ import org.jetbrains.kotlin.analysis.api.KtNonConstantInitializerValue
 import org.jetbrains.kotlin.analysis.api.fir.evaluate.FirCompileTimeConstantEvaluator
 import org.jetbrains.kotlin.analysis.api.fir.getCandidateSymbols
 import org.jetbrains.kotlin.analysis.api.types.KtTypeNullability
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.withFirDeclaration
 import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.analysis.checkers.classKind