Fix warnings in idea-frontend-fir

idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/file/structure/FileStructureElement.kt

@@ -94,7 +94,7 @@ internal sealed class ReanalyzableStructureElement<KT : KtDeclaration, S : FirBa
     override val diagnostics = FileStructureElementDiagnostics(
         firFile,
         lockProvider,
-        SingleNonLocalDeclarationDiagnosticRetriever(firSymbol.fir as FirDeclaration)
+        SingleNonLocalDeclarationDiagnosticRetriever(firSymbol.fir)
     )
 
     companion object {

idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/providers/FirIdeProvider.kt

@@ -29,14 +29,14 @@ import org.jetbrains.kotlin.name.Name
 
 @ThreadSafeMutableState
 internal class FirIdeProvider(
-    project: Project,
+    @Suppress("UNUSED_PARAMETER") project: Project,
     val session: FirSession,
-    moduleInfo: ModuleSourceInfoBase,
+    @Suppress("UNUSED_PARAMETER") moduleInfo: ModuleSourceInfoBase,
     val kotlinScopeProvider: FirKotlinScopeProvider,
     firFileBuilder: FirFileBuilder,
     val cache: ModuleFileCache,
     private val declarationProvider: DeclarationProvider,
-    private val packageExistenceChecker: KtPackageProvider,
+    packageExistenceChecker: KtPackageProvider,
 ) : FirProvider() {
     override val symbolProvider: FirSymbolProvider = SymbolProvider()
 
@@ -54,7 +54,7 @@ internal class FirIdeProvider(
 
     override fun getFirClassifierContainerFile(fqName: ClassId): FirFile {
         return getFirClassifierContainerFileIfAny(fqName)
-            ?: error("Couldn't find container for ${fqName}")
+            ?: error("Couldn't find container for $fqName")
     }
 
     override fun getFirClassifierContainerFileIfAny(fqName: ClassId): FirFile? {

idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/sessions/LibrariesCache.kt

@@ -8,7 +8,8 @@ package org.jetbrains.kotlin.idea.fir.low.level.api.sessions
 import org.jetbrains.kotlin.analyzer.ModuleSourceInfoBase
 import java.util.concurrent.ConcurrentHashMap
 
-internal inline class LibrariesCache(private val cache: ConcurrentHashMap<ModuleSourceInfoBase, FirIdeLibrariesSession> = ConcurrentHashMap()) {
+@JvmInline
+internal value class LibrariesCache(private val cache: ConcurrentHashMap<ModuleSourceInfoBase, FirIdeLibrariesSession> = ConcurrentHashMap()) {
     fun cached(moduleSourceInfo: ModuleSourceInfoBase, create: (ModuleSourceInfoBase) -> FirIdeLibrariesSession): FirIdeLibrariesSession =
         cache.computeIfAbsent(moduleSourceInfo, create)
-}
+}

idea/idea-frontend-fir/idea-fir-low-level-api/tests/org/jetbrains/kotlin/idea/fir/low/level/api/compiler/based/AbstractCompilerBasedTest.kt

@@ -25,7 +25,6 @@ import org.jetbrains.kotlin.fir.DependencyListForCliModule
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.SealedClassInheritorsProvider
 import org.jetbrains.kotlin.fir.deserialization.ModuleDataProvider
-import org.jetbrains.kotlin.fir.java.FirJavaElementFinder
 import org.jetbrains.kotlin.fir.session.FirModuleInfoBasedModuleData
 import org.jetbrains.kotlin.idea.asJava.IDEKotlinAsJavaFirSupport
 import org.jetbrains.kotlin.idea.fir.low.level.api.*
@@ -51,7 +50,8 @@ import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder
 import org.jetbrains.kotlin.test.builders.testConfiguration
 import org.jetbrains.kotlin.test.directives.FirDiagnosticsDirectives
 import org.jetbrains.kotlin.test.directives.model.DirectivesContainer
-import org.jetbrains.kotlin.test.frontend.fir.*
+import org.jetbrains.kotlin.test.frontend.fir.FirOutputArtifact
+import org.jetbrains.kotlin.test.frontend.fir.getAnalyzerServices
 import org.jetbrains.kotlin.test.model.*
 import org.jetbrains.kotlin.test.runners.AbstractKotlinCompilerTest
 import org.jetbrains.kotlin.test.services.*
@@ -328,5 +328,6 @@ private fun reRegisterJavaElementFinder(project: Project) {
             IDEKotlinAsJavaFirSupport(project)
         )
     }
+    @Suppress("DEPRECATION")
     PsiElementFinder.EP.getPoint(project).registerExtension(JavaElementFinder(project))
 }

idea/idea-frontend-fir/idea-fir-low-level-api/tests/org/jetbrains/kotlin/idea/fir/low/level/api/compiler/based/IdeTestIgnoreHandler.kt

@@ -24,7 +24,6 @@ class IdeTestIgnoreHandler(testServices: TestServices) : AfterAnalysisChecker(te
     override fun check(failedAssertions: List<WrappedException>) {
         if (!isFirIdeIgnoreDirectivePresent()) return
         if (failedAssertions.isNotEmpty()) return
-        val moduleStructure = testServices.moduleStructure
         val testDataFile = testServices.moduleStructure.originalTestDataFiles.first()
 
         if (!isTeamCityBuild) {

idea/idea-frontend-fir/idea-fir-low-level-api/tests/org/jetbrains/kotlin/idea/fir/low/level/api/test/base/AbstractLowLevelApiTest.kt

@@ -5,16 +5,14 @@
 
 package org.jetbrains.kotlin.idea.fir.low.level.api.test.base
 
-import com.intellij.DynamicBundle
-import com.intellij.core.CoreApplicationEnvironment
 import com.intellij.mock.MockApplication
 import com.intellij.mock.MockProject
-import com.intellij.openapi.Disposable
 import com.intellij.openapi.application.ApplicationManager
 import com.intellij.openapi.util.Disposer
-import com.intellij.psi.impl.source.tree.TreeCopyHandler
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
-import org.jetbrains.kotlin.idea.fir.low.level.api.compiler.based.*
+import org.jetbrains.kotlin.idea.fir.low.level.api.compiler.based.ModuleRegistrarPreAnalysisHandler
+import org.jetbrains.kotlin.idea.fir.low.level.api.compiler.based.TestModuleInfoProvider
+import org.jetbrains.kotlin.idea.fir.low.level.api.compiler.based.moduleInfoProvider
 import org.jetbrains.kotlin.platform.jvm.JvmPlatforms
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.test.TestInfrastructureInternals
@@ -57,7 +55,7 @@ abstract class AbstractLowLevelApiTest : TestWithDisposable() {
         useDirectives(JvmEnvironmentConfigurationDirectives)
 
         useSourcePreprocessor(::ExpressionMarkersSourceFilePreprocessor)
-        useAdditionalService(::ExpressionMarkerProvider)
+        useAdditionalService { ExpressionMarkerProvider() }
         useAdditionalService(::TestModuleInfoProvider)
         usePreAnalysisHandlers(::ModuleRegistrarPreAnalysisHandler.bind(disposable))
         configureTest(this)
@@ -133,9 +131,5 @@ abstract class AbstractLowLevelApiTest : TestWithDisposable() {
     }
 }
 
-
 fun String.indexOfOrNull(substring: String) =
     indexOf(substring).takeIf { it >= 0 }
-
-private fun String.indexOfOrNull(substring: String, startingIndex: Int) =
-    indexOf(substring, startingIndex).takeIf { it >= 0 }

idea/idea-frontend-fir/idea-fir-low-level-api/tests/org/jetbrains/kotlin/idea/fir/low/level/api/test/base/ExpressionMarkersSourceFilePreprocessor.kt

@@ -55,7 +55,7 @@ internal class ExpressionMarkersSourceFilePreprocessor(testServices: TestService
     }
 }
 
-class ExpressionMarkerProvider(testServices: TestServices) : TestService {
+class ExpressionMarkerProvider : TestService {
     private val selected = mutableMapOf<String, TextRange>()
 
     @PrivateForInline

idea/idea-frontend-fir/idea-frontend-fir-generator/src/org/jetbrains/kotlin/idea/frontend/api/fir/generator/HLDiagnosticConverter.kt

@@ -109,7 +109,7 @@ private object FirToKtConversionCreator {
         val nullable = type.isMarkedNullable
         val kClass = type.classifier as KClass<*>
         return tryMapAllowedType(kClass)
-            ?: tryMapPsiElementType(type, kClass)
+            ?: tryMapPsiElementType(kClass)
             ?: tryMapFirTypeToKtType(kClass, nullable)
             ?: tryMapPlatformType(type, kClass)
             ?: error("Unsupported type $type, consider add corresponding mapping")
@@ -165,7 +165,7 @@ private object FirToKtConversionCreator {
         return null
     }
 
-    private fun tryMapPsiElementType(type: KType, kClass: KClass<*>): HLParameterConversion? {
+    private fun tryMapPsiElementType(kClass: KClass<*>): HLParameterConversion? {
         if (kClass.isSubclassOf(PsiElement::class)) {
             return HLIdParameterConversion
         }

idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/FirLightClassForClassOrObjectSymbol.kt

@@ -5,7 +5,6 @@
 
 package org.jetbrains.kotlin.idea.asJava
 
-import com.intellij.openapi.util.Comparing
 import com.intellij.psi.*
 import com.intellij.psi.impl.InheritanceImplUtil
 import com.intellij.psi.impl.PsiClassImplUtil
@@ -13,16 +12,18 @@ import com.intellij.psi.search.SearchScope
 import com.intellij.psi.stubs.IStubElementType
 import com.intellij.psi.stubs.StubElement
 import org.jetbrains.annotations.NonNls
-import org.jetbrains.kotlin.asJava.classes.*
+import org.jetbrains.kotlin.asJava.classes.KtLightClass
+import org.jetbrains.kotlin.asJava.classes.LightClassInheritanceHelper
+import org.jetbrains.kotlin.asJava.classes.getOutermostClassOrObject
+import org.jetbrains.kotlin.asJava.classes.lazyPub
 import org.jetbrains.kotlin.asJava.elements.FirLightIdentifier
 import org.jetbrains.kotlin.asJava.elements.KtLightField
 import org.jetbrains.kotlin.idea.asJava.classes.checkIsInheritor
 import org.jetbrains.kotlin.idea.asJava.classes.getOrCreateFirLightClass
 import org.jetbrains.kotlin.idea.asJava.elements.FirLightTypeParameterListForSymbol
-import org.jetbrains.kotlin.idea.frontend.api.symbols.*
+import org.jetbrains.kotlin.idea.frontend.api.symbols.KtNamedClassOrObjectSymbol
 import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolKind
 import org.jetbrains.kotlin.load.java.structure.LightClassOriginKind
-import org.jetbrains.kotlin.psi.KtBlockExpression
 import org.jetbrains.kotlin.psi.KtClassBody
 import org.jetbrains.kotlin.psi.KtClassOrObject
 import org.jetbrains.kotlin.psi.debugText.getDebugText
@@ -111,7 +112,7 @@ internal abstract class FirLightClassForClassOrObjectSymbol(
 
     override fun isEquivalentTo(another: PsiElement?): Boolean =
         basicIsEquivalentTo(this, another) ||
-                another is PsiClass && qualifiedName != null && Comparing.equal(another.qualifiedName, qualifiedName)
+                another is PsiClass && qualifiedName != null && another.qualifiedName == qualifiedName
 
     abstract override fun equals(other: Any?): Boolean
 

idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/FirLightClassForFacade.kt

@@ -5,7 +5,6 @@
 
 package org.jetbrains.kotlin.idea.asJava
 
-import com.intellij.openapi.util.Comparing
 import com.intellij.openapi.util.TextRange
 import com.intellij.psi.*
 import com.intellij.psi.impl.light.LightEmptyImplementsList
@@ -13,7 +12,9 @@ import com.intellij.psi.impl.light.LightModifierList
 import org.jetbrains.annotations.NonNls
 import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacade
 import org.jetbrains.kotlin.asJava.classes.lazyPub
-import org.jetbrains.kotlin.asJava.elements.*
+import org.jetbrains.kotlin.asJava.elements.FakeFileForLightClass
+import org.jetbrains.kotlin.asJava.elements.KtLightField
+import org.jetbrains.kotlin.asJava.elements.KtLightMethod
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
 import org.jetbrains.kotlin.fileClasses.javaFileFacadeFqName
 import org.jetbrains.kotlin.idea.KotlinLanguage
@@ -23,8 +24,8 @@ import org.jetbrains.kotlin.idea.asJava.classes.createMethods
 import org.jetbrains.kotlin.idea.frontend.api.fir.analyzeWithSymbolAsContext
 import org.jetbrains.kotlin.idea.frontend.api.scopes.KtDeclarationScope
 import org.jetbrains.kotlin.idea.frontend.api.symbols.KtCallableSymbol
-import org.jetbrains.kotlin.idea.frontend.api.symbols.KtKotlinPropertySymbol
 import org.jetbrains.kotlin.idea.frontend.api.symbols.KtFunctionSymbol
+import org.jetbrains.kotlin.idea.frontend.api.symbols.KtKotlinPropertySymbol
 import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolWithDeclarations
 import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolWithVisibility
 import org.jetbrains.kotlin.load.java.structure.LightClassOriginKind
@@ -225,7 +226,7 @@ class FirLightClassForFacade(
     override fun getNavigationElement() = firstFileInFacade
 
     override fun isEquivalentTo(another: PsiElement?): Boolean =
-        equals(another) || another is FirLightClassForFacade && Comparing.equal(another.qualifiedName, qualifiedName)
+        equals(another) || another is FirLightClassForFacade && another.qualifiedName == qualifiedName
 
     override fun isInheritor(baseClass: PsiClass, checkDeep: Boolean): Boolean {
         return baseClass.qualifiedName == CommonClassNames.JAVA_LANG_OBJECT

idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/firLightUtils.kt

@@ -20,7 +20,10 @@ import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.backend.jvm.jvmTypeMapper
-import org.jetbrains.kotlin.fir.declarations.*
+import org.jetbrains.kotlin.fir.declarations.FirClass
+import org.jetbrains.kotlin.fir.declarations.FirConstructor
+import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration
+import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.declarations.utils.modality
 import org.jetbrains.kotlin.fir.declarations.utils.superConeTypes
 import org.jetbrains.kotlin.fir.isPrimitiveType
@@ -36,7 +39,10 @@ import org.jetbrains.kotlin.idea.frontend.api.fir.analyzeWithSymbolAsContext
 import org.jetbrains.kotlin.idea.frontend.api.fir.symbols.KtFirSymbol
 import org.jetbrains.kotlin.idea.frontend.api.fir.types.KtFirType
 import org.jetbrains.kotlin.idea.frontend.api.symbols.*
-import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.*
+import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSimpleConstantValue
+import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolWithModality
+import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolWithVisibility
+import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtTypeAndAnnotations
 import org.jetbrains.kotlin.idea.frontend.api.types.KtNonErrorClassType
 import org.jetbrains.kotlin.idea.frontend.api.types.KtType
 import org.jetbrains.kotlin.idea.frontend.api.types.KtTypeNullability
@@ -162,12 +168,11 @@ private fun mapSupertype(
 internal fun KtTypeAndAnnotations.mapSupertype(
     psiContext: PsiElement,
     kotlinCollectionAsIs: Boolean = false
-): PsiClassType? = type.mapSupertype(psiContext, kotlinCollectionAsIs, emptyList())
+): PsiClassType? = type.mapSupertype(psiContext, kotlinCollectionAsIs)
 
 internal fun KtType.mapSupertype(
     psiContext: PsiElement,
     kotlinCollectionAsIs: Boolean = false,
-    annotations: List<KtAnnotationCall>
 ): PsiClassType? {
     if (this !is KtNonErrorClassType) return null
     require(this is KtFirType)

idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/parameters/FirLightTypeParameter.kt

@@ -18,15 +18,14 @@ import org.jetbrains.kotlin.asJava.classes.cannotModify
 import org.jetbrains.kotlin.asJava.classes.lazyPub
 import org.jetbrains.kotlin.asJava.elements.KtLightAbstractAnnotation
 import org.jetbrains.kotlin.asJava.elements.KtLightDeclaration
-import org.jetbrains.kotlin.name.StandardClassIds
 import org.jetbrains.kotlin.idea.KotlinLanguage
 import org.jetbrains.kotlin.idea.asJava.basicIsEquivalentTo
 import org.jetbrains.kotlin.idea.asJava.invalidAccess
 import org.jetbrains.kotlin.idea.asJava.mapSupertype
 import org.jetbrains.kotlin.idea.frontend.api.isValid
 import org.jetbrains.kotlin.idea.frontend.api.symbols.KtTypeParameterSymbol
-import org.jetbrains.kotlin.idea.frontend.api.types.KtClassType
 import org.jetbrains.kotlin.idea.frontend.api.types.KtNonErrorClassType
+import org.jetbrains.kotlin.name.StandardClassIds
 import org.jetbrains.kotlin.psi.KtTypeParameter
 import org.jetbrains.kotlin.psi.psiUtil.startOffset
 
@@ -70,7 +69,6 @@ internal class FirLightTypeParameter(
                 it.mapSupertype(
                     psiContext = this,
                     kotlinCollectionAsIs = true,
-                    annotations = emptyList()
                 )
             }
             .forEach { listBuilder.addReference(it) }

idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/fir/FirUtils.kt

@@ -5,7 +5,6 @@
 
 package org.jetbrains.kotlin.idea.fir
 
-import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.expressions.FirFunctionCall
 import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessExpression
 import org.jetbrains.kotlin.fir.references.FirErrorNamedReference
@@ -19,7 +18,6 @@ import org.jetbrains.kotlin.idea.frontend.api.fir.KtSymbolByFirBuilder
 import org.jetbrains.kotlin.idea.frontend.api.symbols.KtSymbol
 import org.jetbrains.kotlin.util.OperatorNameConventions
 
-
 fun FirFunctionCall.isImplicitFunctionCall(): Boolean {
     if (dispatchReceiver !is FirQualifiedAccessExpression) return false
     return calleeReference.getCandidateSymbols().any(FirBasedSymbol<*>::isInvokeFunction)
@@ -35,9 +33,7 @@ fun FirReference.getResolvedSymbolOfNameReference(): FirBasedSymbol<*>? =
     (this as? FirResolvedNamedReference)?.resolvedSymbol
 
 internal fun FirReference.getResolvedKtSymbolOfNameReference(builder: KtSymbolByFirBuilder): KtSymbol? =
-    (getResolvedSymbolOfNameReference()?.fir as? FirDeclaration)?.let { firDeclaration ->
+    getResolvedSymbolOfNameReference()?.fir?.let(builder::buildSymbol)
-        builder.buildSymbol(firDeclaration)
-    }
 
 internal fun FirErrorNamedReference.getCandidateSymbols(): Collection<FirBasedSymbol<*>> =
     when (val diagnostic = diagnostic) {

idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirCompletionCandidateChecker.kt

@@ -6,7 +6,6 @@
 package org.jetbrains.kotlin.idea.frontend.api.fir.components
 
 import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration
-import org.jetbrains.kotlin.fir.declarations.FirFile
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.declarations.FirVariable
 import org.jetbrains.kotlin.fir.expressions.FirExpression
@@ -62,7 +61,7 @@ internal class KtFirCompletionCandidateChecker(
         val file = originalFile.getOrBuildFirFile(firResolveState)
         val explicitReceiverExpression = possibleExplicitReceiver?.getOrBuildFirOfType<FirExpression>(firResolveState)
         val resolver = SingleCandidateResolver(firResolveState.rootModuleSession, file)
-        val implicitReceivers = getImplicitReceivers(originalFile, file, nameExpression)
+        val implicitReceivers = getImplicitReceivers(nameExpression)
         for (implicitReceiverValue in implicitReceivers) {
             val resolutionParameters = ResolutionParameters(
                 singleCandidateResolutionMode = SingleCandidateResolutionMode.CHECK_EXTENSION_FOR_COMPLETION,
@@ -84,11 +83,7 @@ internal class KtFirCompletionCandidateChecker(
         return KtExtensionApplicabilityResult.NonApplicable
     }
 
-    private fun getImplicitReceivers(
+    private fun getImplicitReceivers(fakeNameExpression: KtSimpleNameExpression): Sequence<ImplicitReceiverValue<*>?> {
-        originalFile: KtFile,
-        firFile: FirFile,
-        fakeNameExpression: KtSimpleNameExpression
-    ): Sequence<ImplicitReceiverValue<*>?> {
         val towerDataContext = analysisSession.firResolveState.getTowerContextProvider()
             .getClosestAvailableParentContext(fakeNameExpression)
             ?: error("Cannot find enclosing declaration for ${fakeNameExpression.getElementTextInContext()}")

idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirScopeProvider.kt

@@ -8,7 +8,6 @@ package org.jetbrains.kotlin.idea.frontend.api.fir.components
 import com.intellij.openapi.project.Project
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirClass
-import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.expressions.FirAnonymousObjectExpression
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
@@ -169,7 +168,7 @@ internal class KtFirScopeProvider(
             KtImplicitReceiver(
                 token,
                 builder.typeBuilder.buildKtType(receiver.type),
-                builder.buildSymbol(receiver.boundSymbol.fir as FirDeclaration),
+                builder.buildSymbol(receiver.boundSymbol.fir),
             )
         }
 

idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirTypeAndAnnotations.kt

@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.idea.frontend.api.types.KtType
 
 internal class KtFirTypeAndAnnotations<T : FirDeclaration>(
     private val containingDeclaration: FirRefWithValidityCheck<T>,
-    typeResolvePhase: FirResolvePhase,
+    @Suppress("UNUSED_PARAMETER") typeResolvePhase: FirResolvePhase,
     _builder: KtSymbolByFirBuilder,
     private val typeRef: (T) -> FirTypeRef,
 ) : KtTypeAndAnnotations() {

idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/pointers/KtFirBackingFieldSymbolPointer.kt

@@ -17,6 +17,7 @@ internal class KtFirBackingFieldSymbolPointer(
 ) : KtSymbolPointer<KtBackingFieldSymbol>() {
     override fun restoreSymbol(analysisSession: KtAnalysisSession): KtBackingFieldSymbol? {
         require(analysisSession is KtFirAnalysisSession)
+        @Suppress("DEPRECATION")
         val propertySymbol = propertySymbolPointer.restoreSymbol(analysisSession) ?: return null
         check(propertySymbol is KtFirKotlinPropertySymbol)
         return propertySymbol.firRef.withFir { firProperty ->

idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/types/PublicTypeApproximator.kt

@@ -16,7 +16,7 @@ internal object PublicTypeApproximator {
         session: FirSession,
     ): ConeKotlinType? {
         val approximator = session.inferenceComponents.approximator
-        return approximator.approximateToSuperType(type, PublicApproximatorConfiguration) as ConeKotlinType?
+        return approximator.approximateToSuperType(type, PublicApproximatorConfiguration)
     }
 
     private object PublicApproximatorConfiguration : TypeApproximatorConfiguration.AllFlexibleSameValue() {
@@ -27,4 +27,4 @@ internal object PublicTypeApproximator {
         override val intersectionTypesInContravariantPositions: Boolean get() = true
         override val localTypes: Boolean get() = true
     }
-}
+}

idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/utils/KtAnalysisSessionFe10BindingHolder.kt

@@ -48,6 +48,7 @@ class KtAnalysisSessionFe10BindingHolder private constructor(
     companion object {
         @InvalidWayOfUsingAnalysisSession
         fun create(firResolveState: FirModuleResolveState, token: ValidityToken, ktElement: KtElement): KtAnalysisSessionFe10BindingHolder {
+            @Suppress("DEPRECATION")
             val firAnalysisSession = KtFirAnalysisSession.createAnalysisSessionByResolveState(firResolveState, token, ktElement)
             return KtAnalysisSessionFe10BindingHolder(firAnalysisSession)
         }

idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/utils/LazyOnlyWeakRef.kt

@@ -11,7 +11,7 @@ import java.lang.ref.WeakReference
 import kotlin.reflect.KProperty
 
 class ReadOnlyWeakRef<V : Any>
-@Deprecated("Consider suing ValidityTokenOwner.weakRef instead")
+@Deprecated("Consider using ValidityTokenOwner.weakRef instead")
 constructor(value: V, val token: ValidityToken) {
     val weakRef = WeakReference(value)
 
@@ -24,7 +24,8 @@ constructor(value: V, val token: ValidityToken) {
         }
 }
 
-@Suppress("NOTHING_TO_INLINE")
+@Suppress("NOTHING_TO_INLINE", "DEPRECATION")
 internal inline fun <V : Any> ValidityTokenOwner.weakRef(value: V) = ReadOnlyWeakRef(value, token)
 
-internal inline fun <V : Any> ValidityTokenOwner.weakRef(value: () -> V) = ReadOnlyWeakRef(value(), token)
+@Suppress("DEPRECATION")
+internal inline fun <V : Any> ValidityTokenOwner.weakRef(value: () -> V) = ReadOnlyWeakRef(value(), token)