Move Fir*SourceElement to frontend.common, rename to Kt* (complete)

2021-09-17 12:05:37 +02:00
parent c50c8ad270
commit a65beb2dc5
580 changed files with 2031 additions and 1950 deletions
@@ -6,15 +6,18 @@
 package org.jetbrains.kotlin.analysis.api.fir.generator

 import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.KtSourceElement
+import org.jetbrains.kotlin.analysis.api.symbols.*
+import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.config.LanguageFeature
 import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.contracts.description.EventOccurrencesRange
+import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.descriptors.EffectiveVisibility
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.diagnostics.Severity
 import org.jetbrains.kotlin.diagnostics.WhenMissingCase
 import org.jetbrains.kotlin.fir.FirModuleData
-import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.checkers.generator.diagnostics.model.*
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.expressions.FirExpression
@@ -23,9 +26,6 @@ import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.fir.types.ConeKotlinType
 import org.jetbrains.kotlin.fir.types.FirTypeRef
-import org.jetbrains.kotlin.analysis.api.symbols.*
-import org.jetbrains.kotlin.analysis.api.types.KtType
-import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.lexer.KtKeywordToken
 import org.jetbrains.kotlin.lexer.KtModifierKeywordToken
 import org.jetbrains.kotlin.name.ClassId
@@ -312,12 +312,12 @@ private object FirToKtConversionCreator {
            KtFunctionLikeSymbol::class.createType(),
            importsToAdd = listOf("org.jetbrains.kotlin.fir.declarations.FirSimpleFunction")
        ),
-        FirSourceElement::class to HLFunctionCallConversion(
+        KtSourceElement::class to HLFunctionCallConversion(
            "({0} as FirPsiSourceElement).psi",
            PsiElement::class.createType(),
            importsToAdd = listOf(
                "org.jetbrains.kotlin.fir.psi",
-                "org.jetbrains.kotlin.fir.FirPsiSourceElement"
+                "org.jetbrains.kotlin.FirPsiSourceElement"
            )
        )
    )
@@ -8,11 +8,14 @@ package org.jetbrains.kotlin.analysis.api.fir
 import com.intellij.openapi.project.Project
 import com.intellij.psi.PsiElement
 import com.intellij.psi.search.GlobalSearchScope
+import org.jetbrains.kotlin.KtFakeSourceElement
+import org.jetbrains.kotlin.KtFakeSourceElementKind
+import org.jetbrains.kotlin.KtRealPsiSourceElement
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.KtDeclarationAndFirDeclarationEqualityChecker
+import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.FirIdeSession
 import org.jetbrains.kotlin.analysis.providers.createDeclarationProvider
 import org.jetbrains.kotlin.fir.*
 import org.jetbrains.kotlin.fir.declarations.*
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.KtDeclarationAndFirDeclarationEqualityChecker
-import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.FirIdeSession
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
@@ -137,17 +140,17 @@ object FirIdeDeserializedDeclarationSourceProvider {
 private fun KtElement.isCompiled(): Boolean = containingKtFile.isCompiled

 private val allowedFakeElementKinds = setOf(
-    FirFakeSourceElementKind.FromUseSiteTarget,
-    FirFakeSourceElementKind.PropertyFromParameter,
-    FirFakeSourceElementKind.ItLambdaParameter,
-    FirFakeSourceElementKind.DataClassGeneratedMembers,
-    FirFakeSourceElementKind.ImplicitConstructor,
+    KtFakeSourceElementKind.FromUseSiteTarget,
+    KtFakeSourceElementKind.PropertyFromParameter,
+    KtFakeSourceElementKind.ItLambdaParameter,
+    KtFakeSourceElementKind.DataClassGeneratedMembers,
+    KtFakeSourceElementKind.ImplicitConstructor,
 )

 private fun FirElement.getAllowedPsi() = when (val source = source) {
    null -> null
-    is FirRealPsiSourceElement -> source.psi
-    is FirFakeSourceElement -> if (source.kind in allowedFakeElementKinds) psi else null
+    is KtRealPsiSourceElement -> source.psi
+    is KtFakeSourceElement -> if (source.kind in allowedFakeElementKinds) psi else null
    else -> null
 }

@@ -5,6 +5,7 @@

 package org.jetbrains.kotlin.analysis.api.fir.components

+import org.jetbrains.kotlin.KtSourceElement
 import org.jetbrains.kotlin.analysis.api.KtStarProjectionTypeArgument
 import org.jetbrains.kotlin.analysis.api.KtTypeArgument
 import org.jetbrains.kotlin.analysis.api.KtTypeArgumentWithVariance
@@ -15,7 +16,6 @@ import org.jetbrains.kotlin.analysis.api.fir.types.KtFirType
 import org.jetbrains.kotlin.analysis.api.types.KtSubstitutor
 import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnostic
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirPsiDiagnostic
 import org.jetbrains.kotlin.fir.analysis.diagnostics.toFirDiagnostics
@@ -45,8 +45,8 @@ internal interface KtFirAnalysisSessionComponent {
        KT_DIAGNOSTIC_CONVERTER.convert(analysisSession, this as FirDiagnostic)

    fun ConeDiagnostic.asKtDiagnostic(
-        source: FirSourceElement,
-        qualifiedAccessSource: FirSourceElement?,
+        source: KtSourceElement,
+        qualifiedAccessSource: KtSourceElement?,
        diagnosticCache: MutableList<FirDiagnostic>
    ): KtDiagnosticWithPsi<*>? {
        val firDiagnostic = toFirDiagnostics(analysisSession.rootModuleSession, source, qualifiedAccessSource).firstOrNull() ?: return null
@@ -5,6 +5,7 @@

 package org.jetbrains.kotlin.analysis.api.fir.components

+import org.jetbrains.kotlin.KtSourceElement
 import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
 import org.jetbrains.kotlin.analysis.api.calls.*
 import org.jetbrains.kotlin.analysis.api.diagnostics.KtNonBoundToPsiErrorDiagnostic
@@ -23,7 +24,6 @@ import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.types.KtSubstitutor
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getOrBuildFir
-import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnostic
 import org.jetbrains.kotlin.fir.declarations.FirConstructor
 import org.jetbrains.kotlin.fir.expressions.*
@@ -322,13 +322,13 @@ internal class KtFirCallResolver(
        return ktArgumentMapping
    }

-    private fun FirErrorNamedReference.createErrorCallTarget(qualifiedAccessSource: FirSourceElement?): KtErrorCallTarget =
+    private fun FirErrorNamedReference.createErrorCallTarget(qualifiedAccessSource: KtSourceElement?): KtErrorCallTarget =
        KtErrorCallTarget(
            getCandidateSymbols().mapNotNull { it.fir.buildSymbol(firSymbolBuilder) as? KtFunctionLikeSymbol },
            source?.let { diagnostic.asKtDiagnostic(it, qualifiedAccessSource, diagnosticCache) }
                ?: KtNonBoundToPsiErrorDiagnostic(factoryName = null, diagnostic.reason, token), token)

-    private fun FirErrorReferenceWithCandidate.createErrorCallTarget(qualifiedAccessSource: FirSourceElement?): KtErrorCallTarget =
+    private fun FirErrorReferenceWithCandidate.createErrorCallTarget(qualifiedAccessSource: KtSourceElement?): KtErrorCallTarget =
        KtErrorCallTarget(
            getCandidateSymbols().mapNotNull { it.fir.buildSymbol(firSymbolBuilder) as? KtFunctionLikeSymbol },
            source?.let { diagnostic.asKtDiagnostic(it, qualifiedAccessSource, diagnosticCache) }
@@ -337,7 +337,7 @@ internal class KtFirCallResolver(
    private fun FirResolvedNamedReference.getKtFunctionOrConstructorSymbol(): KtFunctionLikeSymbol? =
        resolvedSymbol.fir.buildSymbol(firSymbolBuilder) as? KtFunctionLikeSymbol

-    private fun FirSuperReference.createCallTarget(qualifiedAccessSource: FirSourceElement?): KtCallTarget? =
+    private fun FirSuperReference.createCallTarget(qualifiedAccessSource: KtSourceElement?): KtCallTarget? =
        when (val type = superTypeRef.coneType) {
            is ConeKotlinErrorType ->
                KtErrorCallTarget(
@@ -23,7 +23,6 @@ import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.utils.isSuspend
 import org.jetbrains.kotlin.fir.declarations.utils.superConeTypes
 import org.jetbrains.kotlin.fir.expressions.*
-import org.jetbrains.kotlin.fir.psi
 import org.jetbrains.kotlin.fir.references.FirNamedReference
 import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
 import org.jetbrains.kotlin.fir.references.FirSuperReference
@@ -31,6 +30,7 @@ import org.jetbrains.kotlin.fir.resolve.constructFunctionalType
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.lexer.KtTokens
+import org.jetbrains.kotlin.psi
 import org.jetbrains.kotlin.psi.*

 internal class KtFirExpressionTypeProvider(
@@ -5,13 +5,19 @@

 package org.jetbrains.kotlin.analysis.api.fir.components

+import org.jetbrains.kotlin.analysis.api.assertIsValidAndAccessible
+import org.jetbrains.kotlin.analysis.api.components.KtImportOptimizer
+import org.jetbrains.kotlin.analysis.api.components.KtImportOptimizerResult
+import org.jetbrains.kotlin.analysis.api.fir.getCandidateSymbols
+import org.jetbrains.kotlin.analysis.api.fir.utils.computeImportableName
+import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
+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.fir.FirElement
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirFile
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.expressions.*
-import org.jetbrains.kotlin.fir.psi
-import org.jetbrains.kotlin.fir.realPsi
 import org.jetbrains.kotlin.fir.references.FirNamedReference
 import org.jetbrains.kotlin.fir.symbols.ensureResolved
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
@@ -20,22 +26,16 @@ import org.jetbrains.kotlin.fir.types.FirErrorTypeRef
 import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
 import org.jetbrains.kotlin.fir.types.classId
 import org.jetbrains.kotlin.fir.visitors.FirVisitorVoid
-import org.jetbrains.kotlin.analysis.api.fir.getCandidateSymbols
-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.api.assertIsValidAndAccessible
-import org.jetbrains.kotlin.analysis.api.components.KtImportOptimizer
-import org.jetbrains.kotlin.analysis.api.components.KtImportOptimizerResult
-import org.jetbrains.kotlin.analysis.api.fir.utils.computeImportableName
-import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.name.parentOrNull
+import org.jetbrains.kotlin.psi
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.getCallNameExpression
 import org.jetbrains.kotlin.psi.psiUtil.getPossiblyQualifiedCallExpression
 import org.jetbrains.kotlin.psi.psiUtil.unwrapNullability
+import org.jetbrains.kotlin.realPsi
 import org.jetbrains.kotlin.resolve.ImportPath
 import org.jetbrains.kotlin.util.OperatorNameConventions

@@ -6,6 +6,8 @@
 package org.jetbrains.kotlin.analysis.api.fir.components

 import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.KtFakeSourceElementKind
+import org.jetbrains.kotlin.KtRealSourceElementKind
 import org.jetbrains.kotlin.analysis.api.components.KtSymbolContainingDeclarationProvider
 import org.jetbrains.kotlin.analysis.api.fir.KtFirAnalysisSession
 import org.jetbrains.kotlin.analysis.api.fir.symbols.KtFirReceiverParameterSymbol
@@ -16,10 +18,8 @@ import org.jetbrains.kotlin.analysis.api.symbols.*
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolKind
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolWithKind
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
-import org.jetbrains.kotlin.fir.FirFakeSourceElementKind
-import org.jetbrains.kotlin.fir.FirRealSourceElementKind
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
-import org.jetbrains.kotlin.fir.psi
+import org.jetbrains.kotlin.psi
 import org.jetbrains.kotlin.psi.KtDeclaration
 import org.jetbrains.kotlin.psi.KtDestructuringDeclaration
 import org.jetbrains.kotlin.psi.KtPrimaryConstructor
@@ -89,11 +89,11 @@ internal class KtFirSymbolContainingDeclarationProvider(
        val source = symbol.firRef.withFir(action = FirDeclaration::source)
        val thisSource = when (source?.kind) {
            null -> error("PSI should present for declaration built by Kotlin code")
-            FirFakeSourceElementKind.ImplicitConstructor ->
+            KtFakeSourceElementKind.ImplicitConstructor ->
                return source.psi as KtDeclaration
-            FirFakeSourceElementKind.PropertyFromParameter -> return source.psi?.parentOfType<KtPrimaryConstructor>()!!
-            FirFakeSourceElementKind.DefaultAccessor -> return source.psi as KtProperty
-            FirRealSourceElementKind -> source.psi!!
+            KtFakeSourceElementKind.PropertyFromParameter -> return source.psi?.parentOfType<KtPrimaryConstructor>()!!
+            KtFakeSourceElementKind.DefaultAccessor -> return source.psi as KtProperty
+            KtRealSourceElementKind -> source.psi!!
            else -> error("Unexpected FirSourceElement: kind=${source.kind} element=${source.psi!!::class.simpleName}")
        }

@@ -5,38 +5,12 @@

 package org.jetbrains.kotlin.analysis.api.fir.diagnostics

-import com.intellij.psi.PsiElement
-import com.intellij.psi.impl.source.tree.LeafPsiElement
-import org.jetbrains.kotlin.fir.FirPsiSourceElement
+import org.jetbrains.kotlin.KtPsiSourceElement
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirPsiDiagnostic
 import org.jetbrains.kotlin.fir.analysis.diagnostics.jvm.FirJvmErrors
-import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirClass
-import org.jetbrains.kotlin.fir.declarations.FirDeclaration
-import org.jetbrains.kotlin.fir.declarations.FirProperty
-import org.jetbrains.kotlin.fir.declarations.FirRegularClass
-import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
-import org.jetbrains.kotlin.fir.declarations.FirTypeParameter
-import org.jetbrains.kotlin.fir.declarations.FirVariable
-import org.jetbrains.kotlin.fir.psi
-import org.jetbrains.kotlin.psi.KtAnnotationEntry
-import org.jetbrains.kotlin.psi.KtAnonymousInitializer
-import org.jetbrains.kotlin.psi.KtArrayAccessExpression
-import org.jetbrains.kotlin.psi.KtBackingField
-import org.jetbrains.kotlin.psi.KtBinaryExpression
-import org.jetbrains.kotlin.psi.KtBinaryExpressionWithTypeRHS
-import org.jetbrains.kotlin.psi.KtCallExpression
-import org.jetbrains.kotlin.psi.KtClass
-import org.jetbrains.kotlin.psi.KtClassOrObject
-import org.jetbrains.kotlin.psi.KtConstructor
-import org.jetbrains.kotlin.psi.KtConstructorDelegationCall
-import org.jetbrains.kotlin.psi.KtDeclaration
-import org.jetbrains.kotlin.psi.KtDeclarationWithBody
-import org.jetbrains.kotlin.psi.KtDelegatedSuperTypeEntry
-import org.jetbrains.kotlin.psi.KtDestructuringDeclaration
-import org.jetbrains.kotlin.psi.KtElement
-import org.jetbrains.kotlin.psi.KtEnumEntry
+import org.jetbrains.kotlin.psi
 import org.jetbrains.kotlin.psi.KtExpression
 import org.jetbrains.kotlin.psi.KtExpressionWithLabel
 import org.jetbrains.kotlin.psi.KtFunction
@@ -253,7 +227,7 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert
            firSymbolBuilder.variableLikeBuilder.buildVariableSymbol(firDiagnostic.a.fir),
            firDiagnostic.b,
            firDiagnostic.c,
-            firDiagnostic as FirPsiDiagnostic,
+            firDiagnostic as KtPsiDiagnostic,
            token,
        )
    }
@@ -369,26 +343,26 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert
    }
    add(FirErrors.SUPER_IS_NOT_AN_EXPRESSION) { firDiagnostic ->
        SuperIsNotAnExpressionImpl(
-            firDiagnostic as FirPsiDiagnostic,
+            firDiagnostic as KtPsiDiagnostic,
            token,
        )
    }
    add(FirErrors.SUPER_NOT_AVAILABLE) { firDiagnostic ->
        SuperNotAvailableImpl(
-            firDiagnostic as FirPsiDiagnostic,
+            firDiagnostic as KtPsiDiagnostic,
            token,
        )
    }
    add(FirErrors.ABSTRACT_SUPER_CALL) { firDiagnostic ->
        AbstractSuperCallImpl(
-            firDiagnostic as FirPsiDiagnostic,
+            firDiagnostic as KtPsiDiagnostic,
            token,
        )
    }
    add(FirErrors.INSTANCE_ACCESS_BEFORE_SUPER_CALL) { firDiagnostic ->
        InstanceAccessBeforeSuperCallImpl(
            firDiagnostic.a,
-            firDiagnostic as FirPsiDiagnostic,
+            firDiagnostic as KtPsiDiagnostic,
            token,
        )
    }
@@ -993,19 +967,19 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert
    add(FirErrors.OPT_IN_MARKER_ON_WRONG_TARGET) { firDiagnostic ->
        OptInMarkerOnWrongTargetImpl(
            firDiagnostic.a,
-            firDiagnostic as FirPsiDiagnostic,
+            firDiagnostic as KtPsiDiagnostic,
            token,
        )
    }
    add(FirErrors.OPT_IN_MARKER_ON_OVERRIDE) { firDiagnostic ->
        OptInMarkerOnOverrideImpl(
-            firDiagnostic as FirPsiDiagnostic,
+            firDiagnostic as KtPsiDiagnostic,
            token,
        )
    }
    add(FirErrors.OPT_IN_MARKER_ON_OVERRIDE_WARNING) { firDiagnostic ->
        OptInMarkerOnOverrideWarningImpl(
-            firDiagnostic as FirPsiDiagnostic,
+            firDiagnostic as KtPsiDiagnostic,
            token,
        )
    }
@@ -2982,10 +2956,10 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert
    add(FirErrors.UNREACHABLE_CODE) { firDiagnostic ->
        UnreachableCodeImpl(
            firDiagnostic.a.map { firSourceElement ->
-                (firSourceElement as FirPsiSourceElement).psi
+                (firSourceElement as KtPsiSourceElement).psi
            },
            firDiagnostic.b.map { firSourceElement ->
-                (firSourceElement as FirPsiSourceElement).psi
+                (firSourceElement as KtPsiSourceElement).psi
            },
            firDiagnostic as FirPsiDiagnostic,
            token,
@@ -3178,13 +3152,13 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert
    }
    add(FirErrors.CONFUSING_BRANCH_CONDITION.errorFactory) { firDiagnostic ->
        ConfusingBranchConditionErrorImpl(
-            firDiagnostic as FirPsiDiagnostic,
+            firDiagnostic as KtPsiDiagnostic,
            token,
        )
    }
    add(FirErrors.CONFUSING_BRANCH_CONDITION.warningFactory) { firDiagnostic ->
        ConfusingBranchConditionWarningImpl(
-            firDiagnostic as FirPsiDiagnostic,
+            firDiagnostic as KtPsiDiagnostic,
            token,
        )
    }
@@ -3390,7 +3364,7 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert
    add(FirErrors.DSL_SCOPE_VIOLATION) { firDiagnostic ->
        DslScopeViolationImpl(
            firSymbolBuilder.buildSymbol(firDiagnostic.a.fir),
-            firDiagnostic as FirPsiDiagnostic,
+            firDiagnostic as KtPsiDiagnostic,
            token,
        )
    }
@@ -3517,7 +3491,7 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert
    }
    add(FirErrors.NOT_A_FUNCTION_LABEL) { firDiagnostic ->
        NotAFunctionLabelImpl(
-            firDiagnostic as FirPsiDiagnostic,
+            firDiagnostic as KtPsiDiagnostic,
            token,
        )
    }
@@ -239,7 +239,7 @@ internal class InvisibleSetterImpl(
    override val property: KtVariableSymbol,
    override val visibility: Visibility,
    override val callableId: CallableId,
-    override val firDiagnostic: FirPsiDiagnostic,
+    override val firDiagnostic: KtPsiDiagnostic,
    override val token: ValidityToken,
 ) : KtFirDiagnostic.InvisibleSetter(), KtAbstractFirDiagnostic<PsiElement>

@@ -336,23 +336,23 @@ internal class ResolutionToClassifierImpl(
 ) : KtFirDiagnostic.ResolutionToClassifier(), KtAbstractFirDiagnostic<PsiElement>

 internal class SuperIsNotAnExpressionImpl(
-    override val firDiagnostic: FirPsiDiagnostic,
+    override val firDiagnostic: KtPsiDiagnostic,
    override val token: ValidityToken,
 ) : KtFirDiagnostic.SuperIsNotAnExpression(), KtAbstractFirDiagnostic<PsiElement>

 internal class SuperNotAvailableImpl(
-    override val firDiagnostic: FirPsiDiagnostic,
+    override val firDiagnostic: KtPsiDiagnostic,
    override val token: ValidityToken,
 ) : KtFirDiagnostic.SuperNotAvailable(), KtAbstractFirDiagnostic<PsiElement>

 internal class AbstractSuperCallImpl(
-    override val firDiagnostic: FirPsiDiagnostic,
+    override val firDiagnostic: KtPsiDiagnostic,
    override val token: ValidityToken,
 ) : KtFirDiagnostic.AbstractSuperCall(), KtAbstractFirDiagnostic<PsiElement>

 internal class InstanceAccessBeforeSuperCallImpl(
    override val target: String,
-    override val firDiagnostic: FirPsiDiagnostic,
+    override val firDiagnostic: KtPsiDiagnostic,
    override val token: ValidityToken,
 ) : KtFirDiagnostic.InstanceAccessBeforeSuperCall(), KtAbstractFirDiagnostic<PsiElement>

@@ -857,17 +857,17 @@ internal class OptInMarkerWithWrongRetentionImpl(

 internal class OptInMarkerOnWrongTargetImpl(
    override val target: String,
-    override val firDiagnostic: FirPsiDiagnostic,
+    override val firDiagnostic: KtPsiDiagnostic,
    override val token: ValidityToken,
 ) : KtFirDiagnostic.OptInMarkerOnWrongTarget(), KtAbstractFirDiagnostic<KtAnnotationEntry>

 internal class OptInMarkerOnOverrideImpl(
-    override val firDiagnostic: FirPsiDiagnostic,
+    override val firDiagnostic: KtPsiDiagnostic,
    override val token: ValidityToken,
 ) : KtFirDiagnostic.OptInMarkerOnOverride(), KtAbstractFirDiagnostic<KtAnnotationEntry>

 internal class OptInMarkerOnOverrideWarningImpl(
-    override val firDiagnostic: FirPsiDiagnostic,
+    override val firDiagnostic: KtPsiDiagnostic,
    override val token: ValidityToken,
 ) : KtFirDiagnostic.OptInMarkerOnOverrideWarning(), KtAbstractFirDiagnostic<KtAnnotationEntry>

@@ -2674,12 +2674,12 @@ internal class DuplicateLabelInWhenImpl(
 ) : KtFirDiagnostic.DuplicateLabelInWhen(), KtAbstractFirDiagnostic<KtElement>

 internal class ConfusingBranchConditionErrorImpl(
-    override val firDiagnostic: FirPsiDiagnostic,
+    override val firDiagnostic: KtPsiDiagnostic,
    override val token: ValidityToken,
 ) : KtFirDiagnostic.ConfusingBranchConditionError(), KtAbstractFirDiagnostic<PsiElement>

 internal class ConfusingBranchConditionWarningImpl(
-    override val firDiagnostic: FirPsiDiagnostic,
+    override val firDiagnostic: KtPsiDiagnostic,
    override val token: ValidityToken,
 ) : KtFirDiagnostic.ConfusingBranchConditionWarning(), KtAbstractFirDiagnostic<PsiElement>

@@ -2849,7 +2849,7 @@ internal class PropertyAsOperatorImpl(

 internal class DslScopeViolationImpl(
    override val calleeSymbol: KtSymbol,
-    override val firDiagnostic: FirPsiDiagnostic,
+    override val firDiagnostic: KtPsiDiagnostic,
    override val token: ValidityToken,
 ) : KtFirDiagnostic.DslScopeViolation(), KtAbstractFirDiagnostic<PsiElement>

@@ -2955,7 +2955,7 @@ internal class ReturnNotAllowedImpl(
 ) : KtFirDiagnostic.ReturnNotAllowed(), KtAbstractFirDiagnostic<KtReturnExpression>

 internal class NotAFunctionLabelImpl(
-    override val firDiagnostic: FirPsiDiagnostic,
+    override val firDiagnostic: KtPsiDiagnostic,
    override val token: ValidityToken,
 ) : KtFirDiagnostic.NotAFunctionLabel(), KtAbstractFirDiagnostic<KtReturnExpression>

@@ -5,7 +5,7 @@

 package org.jetbrains.kotlin.analysis.api.fir.evaluate

-import org.jetbrains.kotlin.fir.FirSourceElement
+import org.jetbrains.kotlin.KtSourceElement
 import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
 import org.jetbrains.kotlin.fir.expressions.FirConstExpression
@@ -201,7 +201,7 @@ internal object FirCompileTimeConstantEvaluator {
        }
    }

-    private fun <T> ConstantValueKind<T>?.toConstExpression(source: FirSourceElement?, value: Any): FirConstExpression<T>? =
+    private fun <T> ConstantValueKind<T>?.toConstExpression(source: KtSourceElement?, value: Any): FirConstExpression<T>? =
        if (this == null) null else
            @Suppress("UNCHECKED_CAST")
            buildConstExpression(source, this, value as T)
@@ -6,6 +6,7 @@
 package org.jetbrains.kotlin.idea.references

 import com.intellij.psi.tree.TokenSet
+import org.jetbrains.kotlin.KtFakeSourceElementKind
 import org.jetbrains.kotlin.analysis.api.fir.*
 import org.jetbrains.kotlin.analysis.api.fir.symbols.KtFirPackageSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol
@@ -20,6 +21,7 @@ import org.jetbrains.kotlin.fir.declarations.utils.isCompanion
 import org.jetbrains.kotlin.fir.declarations.utils.isLocal
 import org.jetbrains.kotlin.fir.declarations.utils.isStatic
 import org.jetbrains.kotlin.fir.expressions.*
+import org.jetbrains.kotlin.fir.psi
 import org.jetbrains.kotlin.fir.references.*
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeUnmatchedTypeArgumentsError
@@ -39,6 +41,7 @@ import org.jetbrains.kotlin.fir.symbols.impl.FirSyntheticPropertySymbol
 import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.psi
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.collectDescendantsOfType
 import org.jetbrains.kotlin.psi.psiUtil.getQualifiedExpressionForSelector
@@ -60,7 +63,7 @@ internal object FirReferenceResolveHelper {
    }

    private fun FirResolvedTypeRef.getDeclaredType() =
-        if (this.delegatedTypeRef?.source?.kind == FirFakeSourceElementKind.ArrayTypeFromVarargParameter) type.arrayElementType()
+        if (this.delegatedTypeRef?.source?.kind == KtFakeSourceElementKind.ArrayTypeFromVarargParameter) type.arrayElementType()
        else type

    private fun ClassId.toTargetPsi(
@@ -6,17 +6,9 @@
 package org.jetbrains.kotlin.analysis.api.fir.symbols

 import com.intellij.psi.PsiElement
-import org.jetbrains.kotlin.descriptors.Modality
-import org.jetbrains.kotlin.descriptors.Visibility
-import org.jetbrains.kotlin.fir.FirFakeSourceElementKind
-import org.jetbrains.kotlin.fir.containingClass
-import org.jetbrains.kotlin.fir.declarations.FirProperty
-import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
-import org.jetbrains.kotlin.fir.declarations.synthetic.FirSyntheticProperty
-import org.jetbrains.kotlin.fir.declarations.utils.*
-import org.jetbrains.kotlin.analysis.api.fir.findPsi
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
+import org.jetbrains.kotlin.KtFakeSourceElementKind
 import org.jetbrains.kotlin.analysis.api.fir.KtSymbolByFirBuilder
+import org.jetbrains.kotlin.analysis.api.fir.findPsi
 import org.jetbrains.kotlin.analysis.api.fir.evaluate.KtFirConstantValueConverter
 import org.jetbrains.kotlin.analysis.api.fir.symbols.annotations.containsAnnotation
 import org.jetbrains.kotlin.analysis.api.fir.symbols.annotations.getAnnotationClassIds
@@ -33,9 +25,20 @@ import org.jetbrains.kotlin.analysis.api.symbols.markers.KtAnnotationCall
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtConstantValue
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolKind
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
-import org.jetbrains.kotlin.analysis.api.symbols.pointers.*
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.CanNotCreateSymbolPointerForLocalLibraryDeclarationException
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.WrongSymbolForSamConstructor
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.types.KtType
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
+import org.jetbrains.kotlin.descriptors.Modality
+import org.jetbrains.kotlin.descriptors.Visibility
+import org.jetbrains.kotlin.fir.containingClass
+import org.jetbrains.kotlin.fir.declarations.FirProperty
+import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
+import org.jetbrains.kotlin.fir.declarations.synthetic.FirSyntheticProperty
+import org.jetbrains.kotlin.fir.declarations.utils.*
 import org.jetbrains.kotlin.name.CallableId
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.Name
@@ -109,7 +112,7 @@ internal class KtFirKotlinPropertySymbol(

    override val isFromPrimaryConstructor: Boolean
        get() = firRef.withFir {
-            it.fromPrimaryConstructor == true || it.source?.kind == FirFakeSourceElementKind.PropertyFromParameter
+            it.fromPrimaryConstructor == true || it.source?.kind == KtFakeSourceElementKind.PropertyFromParameter
        }
    override val isOverride: Boolean get() = firRef.withFir { it.isOverride }
    override val isStatic: Boolean get() = firRef.withFir { it.isStatic }
@@ -5,7 +5,11 @@

 package org.jetbrains.kotlin.analysis.api.fir.symbols

-import org.jetbrains.kotlin.fir.FirFakeSourceElementKind
+import org.jetbrains.kotlin.KtFakeSourceElementKind
+import org.jetbrains.kotlin.analysis.api.ValidityTokenOwner
+import org.jetbrains.kotlin.analysis.api.fir.utils.FirRefWithValidityCheck
+import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtSymbolOrigin
 import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirDeclarationOrigin
@@ -13,10 +17,6 @@ import org.jetbrains.kotlin.fir.declarations.synthetic.FirSyntheticProperty
 import org.jetbrains.kotlin.fir.originalIfFakeOverride
 import org.jetbrains.kotlin.fir.render
 import org.jetbrains.kotlin.fir.scopes.impl.importedFromObjectData
-import org.jetbrains.kotlin.analysis.api.ValidityTokenOwner
-import org.jetbrains.kotlin.analysis.api.fir.utils.FirRefWithValidityCheck
-import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol
-import org.jetbrains.kotlin.analysis.api.symbols.KtSymbolOrigin

 internal interface KtFirSymbol<out F : FirDeclaration> : KtSymbol, ValidityTokenOwner {
    val firRef: FirRefWithValidityCheck<F>
@@ -35,10 +35,10 @@ internal fun KtFirSymbol<*>.symbolHashCode(): Int = firRef.hashCode() * 31 + tok
 internal tailrec fun FirDeclaration.ktSymbolOrigin(): KtSymbolOrigin = when (origin) {
    FirDeclarationOrigin.Source -> {
        when (source?.kind) {
-            FirFakeSourceElementKind.ImplicitConstructor,
-            FirFakeSourceElementKind.DataClassGeneratedMembers,
-            FirFakeSourceElementKind.EnumGeneratedDeclaration,
-            FirFakeSourceElementKind.ItLambdaParameter -> KtSymbolOrigin.SOURCE_MEMBER_GENERATED
+            KtFakeSourceElementKind.ImplicitConstructor,
+            KtFakeSourceElementKind.DataClassGeneratedMembers,
+            KtFakeSourceElementKind.EnumGeneratedDeclaration,
+            KtFakeSourceElementKind.ItLambdaParameter -> KtSymbolOrigin.SOURCE_MEMBER_GENERATED

            else -> KtSymbolOrigin.SOURCE
        }
@@ -9,16 +9,6 @@ import com.intellij.psi.util.PsiTreeUtil
 import org.jetbrains.kotlin.analysis.api.impl.barebone.parentOfType
 import org.jetbrains.kotlin.analysis.api.impl.barebone.parentsOfType
 import org.jetbrains.kotlin.analysis.low.level.api.fir.DeclarationCopyBuilder.withBodyFrom
-import org.jetbrains.kotlin.fir.FirElement
-import org.jetbrains.kotlin.fir.declarations.*
-import org.jetbrains.kotlin.fir.expressions.FirAnnotation
-import org.jetbrains.kotlin.fir.realPsi
-import org.jetbrains.kotlin.fir.resolve.ScopeSession
-import org.jetbrains.kotlin.fir.resolve.transformers.FirTypeResolveTransformer
-import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirTowerDataContextCollector
-import org.jetbrains.kotlin.fir.scopes.createImportingScopes
-import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
-import org.jetbrains.kotlin.fir.visitors.FirVisitorVoid
 import org.jetbrains.kotlin.analysis.low.level.api.fir.FirModuleResolveStateDepended
 import org.jetbrains.kotlin.analysis.low.level.api.fir.FirModuleResolveStateImpl
 import org.jetbrains.kotlin.analysis.low.level.api.fir.element.builder.FileTowerProvider
@@ -33,9 +23,19 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.FirIdeSourcesSes
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.getElementTextInContext
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.originalDeclaration
 import org.jetbrains.kotlin.analysis.project.structure.getKtModule
+import org.jetbrains.kotlin.fir.FirElement
+import org.jetbrains.kotlin.fir.declarations.*
+import org.jetbrains.kotlin.fir.expressions.FirAnnotation
+import org.jetbrains.kotlin.fir.resolve.ScopeSession
+import org.jetbrains.kotlin.fir.resolve.transformers.FirTypeResolveTransformer
+import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirTowerDataContextCollector
+import org.jetbrains.kotlin.fir.scopes.createImportingScopes
+import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
+import org.jetbrains.kotlin.fir.visitors.FirVisitorVoid
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.containingClassOrObject
 import org.jetbrains.kotlin.psi.psiUtil.isAncestor
+import org.jetbrains.kotlin.realPsi

 object LowLevelFirApiFacadeForResolveOnAir {

@@ -5,15 +5,15 @@

 package org.jetbrains.kotlin.analysis.low.level.api.fir.diagnostics

+import org.jetbrains.kotlin.KtFakeSourceElementKind
+import org.jetbrains.kotlin.analysis.low.level.api.fir.diagnostics.fir.PersistenceContextCollector
+import org.jetbrains.kotlin.analysis.low.level.api.fir.diagnostics.fir.PersistentCheckerContextFactory
+import org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder.LockProvider
 import org.jetbrains.kotlin.fir.FirElement
-import org.jetbrains.kotlin.fir.FirFakeSourceElementKind
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.collectors.components.AbstractDiagnosticCollectorComponent
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.resolve.SessionHolderImpl
-import org.jetbrains.kotlin.analysis.low.level.api.fir.diagnostics.fir.PersistenceContextCollector
-import org.jetbrains.kotlin.analysis.low.level.api.fir.diagnostics.fir.PersistentCheckerContextFactory
-import org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder.LockProvider

 internal abstract class FileStructureElementDiagnosticRetriever {
    abstract fun retrieve(
@@ -84,8 +84,8 @@ internal class SingleNonLocalDeclarationDiagnosticRetriever(

    companion object {
        fun shouldDiagnosticsAlwaysBeCheckedOn(firElement: FirElement) = when (firElement.source?.kind) {
-            FirFakeSourceElementKind.PropertyFromParameter -> true
-            FirFakeSourceElementKind.ImplicitConstructor -> true
+            KtFakeSourceElementKind.PropertyFromParameter -> true
+            KtFakeSourceElementKind.ImplicitConstructor -> true
            else -> false
        }
    }
@@ -27,7 +27,7 @@ internal class FirIdeDiagnosticReporter : DiagnosticReporter() {
 }

 private fun FirLightDiagnostic.toPsiDiagnostic(): FirPsiDiagnostic {
-    val psiSourceElement = element.unwrapToFirPsiSourceElement()
+    val psiSourceElement = element.unwrapToKtPsiSourceElement()
        ?: error("Diagnostic should be created from PSI in IDE")
    @Suppress("UNCHECKED_CAST")
    return when (this) {
@@ -11,8 +11,8 @@ import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirFile
 import org.jetbrains.kotlin.fir.declarations.FirTowerDataContext
 import org.jetbrains.kotlin.fir.expressions.FirStatement
-import org.jetbrains.kotlin.fir.psi
 import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirTowerDataContextCollector
+import org.jetbrains.kotlin.psi
 import org.jetbrains.kotlin.psi.*

 interface FirTowerContextProvider {
@@ -11,11 +11,10 @@ import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirClassLikeDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirFile
-import org.jetbrains.kotlin.fir.psi
-import org.jetbrains.kotlin.fir.render
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 import org.jetbrains.kotlin.name.CallableId
 import org.jetbrains.kotlin.name.ClassId
+import org.jetbrains.kotlin.psi
 import org.jetbrains.kotlin.psi.KtFile
 import java.util.*
 import java.util.concurrent.ConcurrentHashMap
@@ -6,13 +6,6 @@
 package org.jetbrains.kotlin.analysis.low.level.api.fir.file.structure

 import com.intellij.psi.PsiElement
-import org.jetbrains.kotlin.fir.FirElement
-import org.jetbrains.kotlin.fir.declarations.*
-import org.jetbrains.kotlin.fir.psi
-import org.jetbrains.kotlin.fir.resolve.ScopeSession
-import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LowLevelFirApiFacadeForResolveOnAir
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.collectDesignation
@@ -26,6 +19,13 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.RawFirNonLoc
 import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.declarationCanBeLazilyResolved
 import org.jetbrains.kotlin.analysis.low.level.api.fir.providers.FirIdeProvider
 import org.jetbrains.kotlin.analysis.low.level.api.fir.providers.firIdeProvider
+import org.jetbrains.kotlin.fir.FirElement
+import org.jetbrains.kotlin.fir.declarations.*
+import org.jetbrains.kotlin.fir.resolve.ScopeSession
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol
+import org.jetbrains.kotlin.psi
 import org.jetbrains.kotlin.psi.*
 import java.util.concurrent.ConcurrentHashMap

@@ -5,11 +5,12 @@

 package org.jetbrains.kotlin.analysis.low.level.api.fir.file.structure

+import org.jetbrains.kotlin.KtFakeSourceElementKind
+import org.jetbrains.kotlin.KtRealPsiSourceElement
+import org.jetbrains.kotlin.analysis.low.level.api.fir.element.builder.DuplicatedFirSourceElementsException
+import org.jetbrains.kotlin.analysis.low.level.api.fir.util.isErrorElement
 import org.jetbrains.kotlin.fir.FirElement
-import org.jetbrains.kotlin.fir.FirFakeSourceElementKind
-import org.jetbrains.kotlin.fir.FirRealPsiSourceElement
 import org.jetbrains.kotlin.fir.expressions.FirVariableAssignment
-import org.jetbrains.kotlin.fir.psi
 import org.jetbrains.kotlin.fir.references.*
 import org.jetbrains.kotlin.fir.types.FirErrorTypeRef
 import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
@@ -17,8 +18,7 @@ import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.types.FirUserTypeRef
 import org.jetbrains.kotlin.fir.types.impl.FirResolvedTypeRefImpl
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
-import org.jetbrains.kotlin.analysis.low.level.api.fir.element.builder.DuplicatedFirSourceElementsException
-import org.jetbrains.kotlin.analysis.low.level.api.fir.util.isErrorElement
+import org.jetbrains.kotlin.psi
 import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.psi.KtTypeReference

@@ -93,9 +93,9 @@ internal open class FirElementsRecorder : FirVisitor<Unit, MutableMap<KtElement,
    private fun cacheElement(element: FirElement, cache: MutableMap<KtElement, FirElement>) {
        val psi = element.source
            ?.takeIf {
-                it is FirRealPsiSourceElement ||
-                        it.kind == FirFakeSourceElementKind.ReferenceInAtomicQualifiedAccess ||
-                        it.kind == FirFakeSourceElementKind.FromUseSiteTarget
+                it is KtRealPsiSourceElement ||
+                        it.kind == KtFakeSourceElementKind.ReferenceInAtomicQualifiedAccess ||
+                        it.kind == KtFakeSourceElementKind.FromUseSiteTarget
            }.psi as? KtElement
            ?: return
        cache(psi, element, cache)
@@ -5,6 +5,8 @@

 package org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve

+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDeclarationDesignation
+import org.jetbrains.kotlin.analysis.low.level.api.fir.providers.firIdeProvider
 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.utils.getExplicitBackingField
@@ -12,11 +14,9 @@ import org.jetbrains.kotlin.fir.expressions.FirFunctionCall
 import org.jetbrains.kotlin.fir.expressions.FirWrappedDelegateExpression
 import org.jetbrains.kotlin.fir.expressions.impl.FirLazyBlock
 import org.jetbrains.kotlin.fir.expressions.impl.FirLazyExpression
-import org.jetbrains.kotlin.fir.psi
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
 import org.jetbrains.kotlin.fir.visitors.transformSingle
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDeclarationDesignation
-import org.jetbrains.kotlin.analysis.low.level.api.fir.providers.firIdeProvider
+import org.jetbrains.kotlin.psi
 import org.jetbrains.kotlin.psi.KtNamedFunction
 import org.jetbrains.kotlin.psi.KtProperty
 import org.jetbrains.kotlin.psi.KtSecondaryConstructor
@@ -24,11 +24,11 @@ import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.synthetic.FirSyntheticProperty
 import org.jetbrains.kotlin.fir.declarations.synthetic.FirSyntheticPropertyAccessor
 import org.jetbrains.kotlin.fir.expressions.FirAnnotation
-import org.jetbrains.kotlin.fir.realPsi
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.providers.firProvider
 import org.jetbrains.kotlin.fir.resolve.transformers.FirImportResolveTransformer
 import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirTowerDataContextCollector
+import org.jetbrains.kotlin.realPsi

 internal class FirLazyDeclarationResolver(private val firFileBuilder: FirFileBuilder) {
    /**
@@ -5,11 +5,11 @@

 package org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve

+import org.jetbrains.kotlin.KtFakeSourceElement
+import org.jetbrains.kotlin.KtFakeSourceElementKind
 import org.jetbrains.kotlin.analysis.api.impl.barebone.parentOfType
-import org.jetbrains.kotlin.fir.FirFakeSourceElement
-import org.jetbrains.kotlin.fir.FirFakeSourceElementKind
 import org.jetbrains.kotlin.fir.declarations.*
-import org.jetbrains.kotlin.fir.psi
+import org.jetbrains.kotlin.psi
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.containingClassOrObject
 import org.jetbrains.kotlin.psi.psiUtil.getParentOfType
@@ -18,7 +18,7 @@ internal fun FirDeclaration.getKtDeclarationForFirElement(): KtDeclaration {
    require(this !is FirFile)

    val ktDeclaration = (psi as? KtDeclaration) ?: run {
-        (source as? FirFakeSourceElement).psi?.parentOfType()
+        (source as? KtFakeSourceElement).psi?.parentOfType()
    }
    check(ktDeclaration is KtDeclaration) {
        "FirDeclaration should have a PSI of type KtDeclaration"
@@ -34,7 +34,7 @@ internal fun FirDeclaration.getKtDeclarationForFirElement(): KtDeclaration {
                    if (containingDeclaration !is KtPropertyAccessor) containingDeclaration else containingDeclaration.property
                }
                is KtCallExpression -> {
-                    check(this.source?.kind == FirFakeSourceElementKind.DefaultAccessor)
+                    check(this.source?.kind == KtFakeSourceElementKind.DefaultAccessor)
                    ((ktDeclaration as? KtCallExpression)?.parent as? KtPropertyDelegate)?.parent as? KtProperty
                }
                else -> ktDeclaration
@@ -6,17 +6,17 @@
 package org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve

 import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDeclarationDesignation
 import org.jetbrains.kotlin.fir.*
-import org.jetbrains.kotlin.fir.builder.RawFirBuilder
 import org.jetbrains.kotlin.fir.builder.BodyBuildingMode
 import org.jetbrains.kotlin.fir.builder.PsiHandlingMode
+import org.jetbrains.kotlin.fir.builder.RawFirBuilder
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.utils.isInner
 import org.jetbrains.kotlin.fir.scopes.FirScopeProvider
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
 import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
 import org.jetbrains.kotlin.fir.types.FirTypeRef
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDeclarationDesignation
 import org.jetbrains.kotlin.fir.expressions.FirAnnotation
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.hasExpectModifier
@@ -7,8 +7,8 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.util

 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.declarations.FirFile
-import org.jetbrains.kotlin.fir.psi
 import org.jetbrains.kotlin.fir.visitors.FirVisitorVoid
+import org.jetbrains.kotlin.psi
 import org.jetbrains.kotlin.psi.KtElement

 object FirElementFinder {
@@ -5,19 +5,19 @@

 package org.jetbrains.kotlin.analysis.low.level.api.fir.util

-import org.jetbrains.kotlin.fir.declarations.FirClassLikeDeclaration
-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.psi
-import org.jetbrains.kotlin.fir.realPsi
-import org.jetbrains.kotlin.fir.resolve.providers.FirSymbolProvider
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.throwUnexpectedFirElementError
 import org.jetbrains.kotlin.analysis.low.level.api.fir.element.builder.getNonLocalContainingOrThisDeclaration
 import org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder.FirFileBuilder
 import org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder.ModuleFileCache
+import org.jetbrains.kotlin.fir.declarations.FirClassLikeDeclaration
+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.resolve.providers.FirSymbolProvider
+import org.jetbrains.kotlin.psi
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.containingClassOrObject
+import org.jetbrains.kotlin.realPsi

 /**
 * 'Non-local' stands for not local classes/functions/etc.
@@ -18,8 +18,8 @@ import org.jetbrains.kotlin.cfg.containingDeclarationForPseudocode
 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.diagnostics.FirDiagnosticHolder
-import org.jetbrains.kotlin.fir.psi
 import org.jetbrains.kotlin.fir.render
+import org.jetbrains.kotlin.psi
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.isObjectLiteral
 import java.util.concurrent.TimeUnit
@@ -5,17 +5,17 @@

 package org.jetbrains.kotlin.analysis.low.level.api.fir

-import org.jetbrains.kotlin.fir.FirElement
-import org.jetbrains.kotlin.fir.FirRenderer
-import org.jetbrains.kotlin.fir.declarations.*
-import org.jetbrains.kotlin.fir.realPsi
-import org.jetbrains.kotlin.fir.render
-import org.jetbrains.kotlin.fir.visitors.FirVisitorVoid
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.withFirDeclaration
 import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.ResolveType
 import org.jetbrains.kotlin.analysis.low.level.api.fir.test.base.AbstractLowLevelApiSingleFileTest
+import org.jetbrains.kotlin.fir.FirElement
+import org.jetbrains.kotlin.fir.FirRenderer
+import org.jetbrains.kotlin.fir.declarations.*
+import org.jetbrains.kotlin.fir.render
+import org.jetbrains.kotlin.fir.visitors.FirVisitorVoid
 import org.jetbrains.kotlin.psi.KtDeclaration
 import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.realPsi
 import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder
 import org.jetbrains.kotlin.test.directives.JvmEnvironmentConfigurationDirectives
 import org.jetbrains.kotlin.test.services.TestModuleStructure
@@ -5,21 +5,20 @@

 package org.jetbrains.kotlin.analysis.low.level.api.fir.compiler.based

+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.DiagnosticCheckerFilter
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.collectDiagnosticsForFile
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.resolvedFirToPhase
 import org.jetbrains.kotlin.fir.analysis.AbstractFirAnalyzerFacade
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnostic
 import org.jetbrains.kotlin.fir.backend.Fir2IrResult
 import org.jetbrains.kotlin.fir.declarations.FirFile
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
-import org.jetbrains.kotlin.fir.psi
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.transformers.FirSealedClassInheritorsProcessor
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.DiagnosticCheckerFilter
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.collectDiagnosticsForFile
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.resolvedFirToPhase
+import org.jetbrains.kotlin.psi
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi2ir.generators.GeneratorExtensions
-import org.jetbrains.kotlin.test.directives.FirDiagnosticsDirectives
 import org.jetbrains.kotlin.test.model.TestFile

 class LowLevelFirAnalyzerFacade(
@@ -5,8 +5,17 @@

 package org.jetbrains.kotlin.analysis.low.level.api.fir.diagnostic

+import org.jetbrains.kotlin.KtRealSourceElementKind
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.DiagnosticCheckerFilter
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.collectDiagnosticsForFile
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getOrBuildFirOfType
+import org.jetbrains.kotlin.analysis.low.level.api.fir.diagnostics.BeforeElementDiagnosticCollectionHandler
+import org.jetbrains.kotlin.analysis.low.level.api.fir.diagnostics.SingleNonLocalDeclarationDiagnosticRetriever
+import org.jetbrains.kotlin.analysis.low.level.api.fir.diagnostics.fir.PersistentCheckerContextFactory
+import org.jetbrains.kotlin.analysis.low.level.api.fir.renderWithClassName
+import org.jetbrains.kotlin.analysis.low.level.api.fir.resolveWithClearCaches
+import org.jetbrains.kotlin.analysis.low.level.api.fir.test.base.AbstractLowLevelApiSingleFileTest
 import org.jetbrains.kotlin.fir.FirElement
-import org.jetbrains.kotlin.fir.FirRealSourceElementKind
 import org.jetbrains.kotlin.fir.SessionConfiguration
 import org.jetbrains.kotlin.fir.analysis.collectors.AbstractDiagnosticCollectorVisitor
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
@@ -15,16 +24,6 @@ import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.SessionHolderImpl
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.visitors.FirVisitorVoid
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.DiagnosticCheckerFilter
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.collectDiagnosticsForFile
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getOrBuildFir
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getOrBuildFirOfType
-import org.jetbrains.kotlin.analysis.low.level.api.fir.diagnostics.BeforeElementDiagnosticCollectionHandler
-import org.jetbrains.kotlin.analysis.low.level.api.fir.diagnostics.SingleNonLocalDeclarationDiagnosticRetriever
-import org.jetbrains.kotlin.analysis.low.level.api.fir.diagnostics.fir.PersistentCheckerContextFactory
-import org.jetbrains.kotlin.analysis.low.level.api.fir.renderWithClassName
-import org.jetbrains.kotlin.analysis.low.level.api.fir.resolveWithClearCaches
-import org.jetbrains.kotlin.analysis.low.level.api.fir.test.base.AbstractLowLevelApiSingleFileTest
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.test.services.TestModuleStructure
 import org.jetbrains.kotlin.test.services.TestServices
@@ -82,11 +81,11 @@ abstract class AbstractDiagnosticTraversalCounterTest  : AbstractLowLevelApiSing
        val errorElements = mutableListOf<Pair<FirElement, Int>>()
        val nonDuplicatingElements = findNonDuplicatingFirElements(firFile).filter { element ->
            when {
-                element is FirTypeRef && element.source?.kind != FirRealSourceElementKind -> {
+                element is FirTypeRef && element.source?.kind != KtRealSourceElementKind -> {
                    // AbstractDiagnosticCollectorVisitor do not visit such elements
                    false
                }
-                element.source?.kind == FirRealSourceElementKind -> true
+                element.source?.kind == KtRealSourceElementKind -> true
                SingleNonLocalDeclarationDiagnosticRetriever.shouldDiagnosticsAlwaysBeCheckedOn(element) -> true
                else -> false
            }
@@ -5,14 +5,14 @@

 package org.jetbrains.kotlin.cli.common.fir

+import org.jetbrains.kotlin.KtLightSourceElement
+import org.jetbrains.kotlin.KtPsiSourceElement
 import org.jetbrains.kotlin.cli.common.messages.AnalyzerWithCompilerReport
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSourceLocation
 import org.jetbrains.kotlin.cli.common.messages.MessageCollector
 import org.jetbrains.kotlin.cli.common.messages.MessageUtil
 import org.jetbrains.kotlin.diagnostics.DiagnosticUtils
 import org.jetbrains.kotlin.diagnostics.Severity
-import org.jetbrains.kotlin.fir.FirLightSourceElement
-import org.jetbrains.kotlin.fir.FirPsiSourceElement
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDefaultErrorMessages
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnostic

@@ -49,17 +49,17 @@ object FirDiagnosticsCompilerResultsReporter {
    }

    private fun FirDiagnostic.location(): CompilerMessageSourceLocation? = when (val element = element) {
-        is FirPsiSourceElement -> element.location(this)
-        is FirLightSourceElement -> element.location(this)
+        is KtPsiSourceElement -> element.location(this)
+        is KtLightSourceElement -> element.location(this)
    }

-    private fun FirPsiSourceElement.location(diagnostic: FirDiagnostic): CompilerMessageSourceLocation? {
+    private fun KtPsiSourceElement.location(diagnostic: FirDiagnostic): CompilerMessageSourceLocation? {
        val file = psi.containingFile
        return MessageUtil.psiFileToMessageLocation(file, file.name, DiagnosticUtils.getLineAndColumnRange(file, diagnostic.textRanges))
    }

    @Suppress("UNUSED_PARAMETER")
-    private fun FirLightSourceElement.location(diagnostic: FirDiagnostic): CompilerMessageSourceLocation? {
+    private fun KtLightSourceElement.location(diagnostic: FirDiagnostic): CompilerMessageSourceLocation? {
        // TODO: support light tree
        return null
    }
@@ -69,7 +69,7 @@ object FirDiagnosticsCompilerResultsReporter {
            val element1 = o1.element
            val element2 = o1.element
            // TODO: support light tree
-            if (element1 !is FirPsiSourceElement || element2 !is FirPsiSourceElement) return 0
+            if (element1 !is KtPsiSourceElement || element2 !is KtPsiSourceElement) return 0

            val file1 = element1.psi.containingFile
            val file2 = element2.psi.containingFile
@@ -7,6 +7,7 @@ package org.jetbrains.kotlin.fir.checkers.generator.diagnostics

 import com.intellij.psi.PsiElement
 import com.intellij.psi.impl.source.tree.LeafPsiElement
+import org.jetbrains.kotlin.KtSourceElement
 import org.jetbrains.kotlin.config.LanguageFeature
 import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.contracts.description.EventOccurrencesRange
@@ -15,7 +16,6 @@ import org.jetbrains.kotlin.descriptors.EffectiveVisibility
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.diagnostics.WhenMissingCase
 import org.jetbrains.kotlin.fir.FirModuleData
-import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.PrivateForInline
 import org.jetbrains.kotlin.fir.checkers.generator.diagnostics.model.*
 import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
@@ -1054,8 +1054,8 @@ object DIAGNOSTICS_LIST : DiagnosticList("FirErrors") {
            parameter<Symbol>("property")
        }
        val UNREACHABLE_CODE by warning<KtElement>(PositioningStrategy.UNREACHABLE_CODE) {
-            parameter<Set<FirSourceElement>>("reachable")
-            parameter<Set<FirSourceElement>>("unreachable")
+            parameter<Set<KtSourceElement>>("reachable")
+            parameter<Set<KtSourceElement>>("unreachable")
        }
        val SENSELESS_COMPARISON by warning<KtExpression> {
            parameter<FirExpression>("expression")
@@ -5,9 +5,9 @@

 package org.jetbrains.kotlin.fir.analysis.jvm.checkers.declaration

+import org.jetbrains.kotlin.KtFakeSourceElementKind
+import org.jetbrains.kotlin.KtSourceElement
 import org.jetbrains.kotlin.descriptors.Modality
-import org.jetbrains.kotlin.fir.FirFakeSourceElementKind
-import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirBasicDeclarationChecker
 import org.jetbrains.kotlin.fir.analysis.checkers.getModifier
@@ -32,7 +32,7 @@ object FirJvmExternalDeclarationChecker : FirBasicDeclarationChecker() {

    private fun checkInternal(
        declaration: FirDeclaration,
-        reportSource: FirSourceElement?,
+        reportSource: KtSourceElement?,
        modality: Modality?,
        context: CheckerContext,
        reporter: DiagnosticReporter
@@ -47,7 +47,7 @@ object FirJvmExternalDeclarationChecker : FirBasicDeclarationChecker() {

        if (!declaration.isExternal) return
        val source = declaration.source ?: return
-        if (source.kind is FirFakeSourceElementKind) return
+        if (source.kind is KtFakeSourceElementKind) return

        // WRONG_MODIFIER_TARGET on external constructor is intentionally NOT covered in this checker.
        if (declaration !is FirFunction) {
@@ -5,14 +5,12 @@

 package org.jetbrains.kotlin.fir.analysis.jvm.checkers.declaration

+import org.jetbrains.kotlin.KtFakeSourceElementKind
 import org.jetbrains.kotlin.JvmFieldApplicabilityProblem.*
-import org.jetbrains.kotlin.name.JvmNames.JVM_MULTIFILE_CLASS_SHORT
-import org.jetbrains.kotlin.builtins.StandardNames
 import org.jetbrains.kotlin.config.LanguageFeature
 import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibilities
-import org.jetbrains.kotlin.fir.FirFakeSourceElementKind
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.analysis.checkers.classKind
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
@@ -29,7 +27,6 @@ import org.jetbrains.kotlin.fir.declarations.FirProperty
 import org.jetbrains.kotlin.fir.declarations.getAnnotationByClassId
 import org.jetbrains.kotlin.fir.declarations.utils.*
 import org.jetbrains.kotlin.fir.languageVersionSettings
-import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
 import org.jetbrains.kotlin.fir.resolve.toFirRegularClassSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
@@ -98,8 +95,8 @@ object FirJvmFieldApplicabilityChecker : FirPropertyChecker() {
    }

    private fun FirProperty.hasCustomAccessor(): Boolean {
-        return (getter != null && getter?.source?.kind !is FirFakeSourceElementKind) ||
-                (setter != null && setter?.source?.kind !is FirFakeSourceElementKind)
+        return (getter != null && getter?.source?.kind !is KtFakeSourceElementKind) ||
+                (setter != null && setter?.source?.kind !is KtFakeSourceElementKind)
    }

    private fun FirRegularClassSymbol.isInsideCompanionObjectOfInterface(session: FirSession): Boolean {
@@ -5,10 +5,10 @@

 package org.jetbrains.kotlin.fir.analysis.jvm.checkers.declaration

+import org.jetbrains.kotlin.KtFakeSourceElementKind
+import org.jetbrains.kotlin.KtRealSourceElementKind
 import org.jetbrains.kotlin.config.LanguageFeature
 import org.jetbrains.kotlin.descriptors.ClassKind
-import org.jetbrains.kotlin.fir.FirFakeSourceElementKind
-import org.jetbrains.kotlin.fir.FirRealSourceElementKind
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirRegularClassChecker
 import org.jetbrains.kotlin.fir.analysis.checkers.toRegularClassSymbol
@@ -89,7 +89,7 @@ object FirJvmRecordChecker : FirRegularClassChecker() {

        declaration.declarations.forEach { decl ->
            if (decl is FirProperty) {
-                val fromConstructor = decl.source?.kind == FirFakeSourceElementKind.PropertyFromParameter
+                val fromConstructor = decl.source?.kind == KtFakeSourceElementKind.PropertyFromParameter
                if (decl.isVar && fromConstructor) {
                    reporter.reportOn(decl.source, FirJvmErrors.JVM_RECORD_NOT_VAL_PARAMETER, context)
                } else if (!fromConstructor && (decl.hasBackingField || decl.delegateFieldSymbol != null)) {
@@ -101,7 +101,7 @@ object FirJvmRecordChecker : FirRegularClassChecker() {
        }

        declaration.superTypeRefs.firstOrNull()?.let { typeRef ->
-            if (typeRef.source?.kind != FirRealSourceElementKind) return@let
+            if (typeRef.source?.kind != KtRealSourceElementKind) return@let
            if (typeRef.toRegularClassSymbol(context.session)?.classKind == ClassKind.CLASS) {
                reporter.reportOn(declaration.source, FirJvmErrors.JVM_RECORD_EXTENDS_CLASS, typeRef.coneType, context)
            }
@@ -5,12 +5,12 @@

 package org.jetbrains.kotlin.fir.analysis.jvm.checkers.declaration

+import org.jetbrains.kotlin.KtSourceElement
 import org.jetbrains.kotlin.config.LanguageFeature
 import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.descriptors.isInterface
-import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.analysis.checkers.classKind
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirAnnotatedDeclarationChecker
@@ -66,7 +66,7 @@ object FirJvmStaticChecker : FirAnnotatedDeclarationChecker() {
        declaration: FirAnnotatedDeclaration,
        context: CheckerContext,
        reporter: DiagnosticReporter,
-        targetSource: FirSourceElement?,
+        targetSource: KtSourceElement?,
        outerProperty: FirProperty? = null,
    ) {
        if (declaration !is FirMemberDeclaration) {
@@ -101,7 +101,7 @@ object FirJvmStaticChecker : FirAnnotatedDeclarationChecker() {
        context: CheckerContext,
        reporter: DiagnosticReporter,
        supportsJvmStaticInInterface: Boolean,
-        targetSource: FirSourceElement?,
+        targetSource: KtSourceElement?,
    ) {
        val properDiagnostic = if (supportsJvmStaticInInterface) {
            FirJvmErrors.JVM_STATIC_NOT_IN_OBJECT_OR_COMPANION
@@ -116,7 +116,7 @@ object FirJvmStaticChecker : FirAnnotatedDeclarationChecker() {
        declaration: FirAnnotatedDeclaration,
        context: CheckerContext,
        reporter: DiagnosticReporter,
-        targetSource: FirSourceElement?,
+        targetSource: KtSourceElement?,
    ) {
        if (declaration !is FirCallableDeclaration) {
            return
@@ -182,7 +182,7 @@ object FirJvmStaticChecker : FirAnnotatedDeclarationChecker() {
        declaration: FirMemberDeclaration,
        context: CheckerContext,
        reporter: DiagnosticReporter,
-        targetSource: FirSourceElement?,
+        targetSource: KtSourceElement?,
        outerProperty: FirProperty? = null,
    ) {
        val isOverride = outerProperty?.isOverride ?: declaration.isOverride
@@ -198,7 +198,7 @@ object FirJvmStaticChecker : FirAnnotatedDeclarationChecker() {
        declaration: FirAnnotatedDeclaration,
        context: CheckerContext,
        reporter: DiagnosticReporter,
-        targetSource: FirSourceElement?,
+        targetSource: KtSourceElement?,
    ) {
        if (
            declaration is FirProperty && declaration.isConst ||
@@ -6,10 +6,10 @@
 package org.jetbrains.kotlin.fir.analysis.jvm.checkers.declaration

 //import org.jetbrains.kotlin.builtins.StandardNames
+import org.jetbrains.kotlin.KtSourceElement
 import org.jetbrains.kotlin.config.LanguageFeature
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
 import org.jetbrains.kotlin.descriptors.annotations.KotlinTarget
-import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.analysis.checkers.containsRepeatableAnnotation
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirAnnotatedDeclarationChecker
@@ -148,7 +148,7 @@ object FirRepeatableAnnotationChecker : FirAnnotatedDeclarationChecker() {
    private fun checkRepeatableAnnotationContainer(
        annotationClass: FirRegularClass,
        containerClass: FirRegularClassSymbol,
-        annotationSource: FirSourceElement?,
+        annotationSource: KtSourceElement?,
        context: CheckerContext,
        reporter: DiagnosticReporter
    ) {
@@ -160,7 +160,7 @@ object FirRepeatableAnnotationChecker : FirAnnotatedDeclarationChecker() {
    private fun checkContainerParameters(
        containerClass: FirRegularClassSymbol,
        annotationClass: FirRegularClass,
-        annotationSource: FirSourceElement?,
+        annotationSource: KtSourceElement?,
        context: CheckerContext,
        reporter: DiagnosticReporter
    ) {
@@ -200,7 +200,7 @@ object FirRepeatableAnnotationChecker : FirAnnotatedDeclarationChecker() {
    private fun checkContainerRetention(
        containerClass: FirRegularClassSymbol,
        annotationClass: FirRegularClass,
-        annotationSource: FirSourceElement?,
+        annotationSource: KtSourceElement?,
        context: CheckerContext,
        reporter: DiagnosticReporter
    ) {
@@ -222,7 +222,7 @@ object FirRepeatableAnnotationChecker : FirAnnotatedDeclarationChecker() {
    private fun checkContainerTarget(
        containerClass: FirRegularClassSymbol,
        annotationClass: FirRegularClass,
-        annotationSource: FirSourceElement?,
+        annotationSource: KtSourceElement?,
        context: CheckerContext,
        reporter: DiagnosticReporter
    ) {
@@ -5,7 +5,7 @@

 package org.jetbrains.kotlin.fir.analysis.jvm.checkers.declaration

-import org.jetbrains.kotlin.fir.FirRealSourceElementKind
+import org.jetbrains.kotlin.KtRealSourceElementKind
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirPropertyChecker
 import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
@@ -17,7 +17,7 @@ import org.jetbrains.kotlin.name.JvmNames.VOLATILE_ANNOTATION_CLASS_ID

 object FirVolatileAnnotationChecker : FirPropertyChecker() {
    override fun check(declaration: FirProperty, context: CheckerContext, reporter: DiagnosticReporter) {
-        if (declaration.source?.kind != FirRealSourceElementKind) return
+        if (declaration.source?.kind != KtRealSourceElementKind) return

        val fieldAnnotation = declaration.getAnnotationByClassId(VOLATILE_ANNOTATION_CLASS_ID)
        if (fieldAnnotation != null && !declaration.isVar) {
@@ -5,7 +5,7 @@

 package org.jetbrains.kotlin.fir.analysis.jvm.checkers.expression

-import org.jetbrains.kotlin.fir.FirRealSourceElementKind
+import org.jetbrains.kotlin.KtRealSourceElementKind
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.checkers.expression.FirAnnotationChecker
 import org.jetbrains.kotlin.fir.analysis.checkers.toRegularClassSymbol
@@ -33,7 +33,7 @@ object FirJavaAnnotationsChecker : FirAnnotationChecker() {
        )

    override fun check(expression: FirAnnotation, context: CheckerContext, reporter: DiagnosticReporter) {
-        if (context.containingDeclarations.lastOrNull()?.source?.kind != FirRealSourceElementKind) return
+        if (context.containingDeclarations.lastOrNull()?.source?.kind != KtRealSourceElementKind) return
        val callableSymbol = expression.annotationTypeRef.toRegularClassSymbol(context.session)
        if (callableSymbol?.origin != FirDeclarationOrigin.Java) return

@@ -5,7 +5,7 @@

 package org.jetbrains.kotlin.fir.analysis.jvm.checkers.expression

-import org.jetbrains.kotlin.fir.FirSourceElement
+import org.jetbrains.kotlin.KtSourceElement
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.checkers.expression.FirFunctionCallChecker
 import org.jetbrains.kotlin.fir.analysis.checkers.overriddenFunctions
@@ -45,7 +45,7 @@ object FirJvmInconsistentOperatorFromJavaCallChecker : FirFunctionCallChecker()
        callableSymbol.check(expression.calleeReference.source, context, reporter)
    }

-    fun FirNamedFunctionSymbol.check(source: FirSourceElement?, context: CheckerContext, reporter: DiagnosticReporter): Boolean {
+    fun FirNamedFunctionSymbol.check(source: KtSourceElement?, context: CheckerContext, reporter: DiagnosticReporter): Boolean {
        if (callableId == CONCURRENT_HASH_MAP_CALLABLE_ID) {
            reporter.reportOn(source, FirJvmErrors.CONCURRENT_HASH_MAP_CONTAINS_OPERATOR, context)
            return true
@@ -7,6 +7,7 @@ package org.jetbrains.kotlin.fir.analysis.diagnostics

 import com.intellij.psi.PsiElement
 import com.intellij.psi.impl.source.tree.LeafPsiElement
+import org.jetbrains.kotlin.KtSourceElement
 import org.jetbrains.kotlin.config.LanguageFeature
 import org.jetbrains.kotlin.config.LanguageFeature.ForbidExposingTypesInPrimaryConstructorProperties
 import org.jetbrains.kotlin.config.LanguageFeature.ProhibitAssigningSingleElementsToVarargsInNamedForm
@@ -23,7 +24,6 @@ import org.jetbrains.kotlin.descriptors.EffectiveVisibility
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.diagnostics.WhenMissingCase
 import org.jetbrains.kotlin.fir.FirModuleData
-import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.analysis.diagnostics.SourceElementPositioningStrategies
 import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
 import org.jetbrains.kotlin.fir.expressions.FirExpression
@@ -568,7 +568,7 @@ object FirErrors {
    val WRONG_IMPLIES_CONDITION by warning0<PsiElement>()
    val VARIABLE_WITH_NO_TYPE_NO_INITIALIZER by error0<KtVariableDeclaration>(SourceElementPositioningStrategies.DECLARATION_NAME)
    val INITIALIZATION_BEFORE_DECLARATION by error1<KtExpression, FirBasedSymbol<*>>()
-    val UNREACHABLE_CODE by warning2<KtElement, Set<FirSourceElement>, Set<FirSourceElement>>(SourceElementPositioningStrategies.UNREACHABLE_CODE)
+    val UNREACHABLE_CODE by warning2<KtElement, Set<KtSourceElement>, Set<KtSourceElement>>(SourceElementPositioningStrategies.UNREACHABLE_CODE)
    val SENSELESS_COMPARISON by warning2<KtExpression, FirExpression, Boolean>()
    val SENSELESS_NULL_IN_WHEN by warning0<KtElement>()

@@ -8,34 +8,34 @@ package org.jetbrains.kotlin.fir.analysis
 import com.intellij.lang.LighterASTNode
 import com.intellij.psi.tree.IElementType
 import com.intellij.psi.tree.TokenSet
-import org.jetbrains.kotlin.fir.*
+import org.jetbrains.kotlin.*

-fun FirSourceElement.getChild(type: IElementType, index: Int = 0, depth: Int = -1): FirSourceElement? {
+fun KtSourceElement.getChild(type: IElementType, index: Int = 0, depth: Int = -1): KtSourceElement? {
    return getChild(setOf(type), index, depth)
 }

-fun FirSourceElement.getChild(types: TokenSet, index: Int = 0, depth: Int = -1): FirSourceElement? {
+fun KtSourceElement.getChild(types: TokenSet, index: Int = 0, depth: Int = -1): KtSourceElement? {
    return getChild(types.types.toSet(), index, depth)
 }

-fun FirSourceElement.getChild(types: Set<IElementType>, index: Int = 0, depth: Int = -1): FirSourceElement? {
+fun KtSourceElement.getChild(types: Set<IElementType>, index: Int = 0, depth: Int = -1): KtSourceElement? {
    return when (this) {
-        is FirPsiSourceElement -> {
+        is KtPsiSourceElement -> {
            getChild(types, index, depth)
        }
-        is FirLightSourceElement -> {
+        is KtLightSourceElement -> {
            getChild(types, index, depth)
        }
        else -> null
    }
 }

-private fun FirPsiSourceElement.getChild(types: Set<IElementType>, index: Int, depth: Int): FirSourceElement? {
+private fun KtPsiSourceElement.getChild(types: Set<IElementType>, index: Int, depth: Int): KtSourceElement? {
    val visitor = PsiElementFinderByType(types, index, depth)
-    return visitor.find(psi)?.toFirPsiSourceElement()
+    return visitor.find(psi)?.toKtPsiSourceElement()
 }

-private fun FirLightSourceElement.getChild(types: Set<IElementType>, index: Int, depth: Int): FirSourceElement? {
+private fun KtLightSourceElement.getChild(types: Set<IElementType>, index: Int, depth: Int): KtSourceElement? {
    val visitor = LighterTreeElementFinderByType(treeStructure, types, index, depth)
    val childNode = visitor.find(lighterASTNode) ?: return null
    return buildChildSourceElement(childNode)
@@ -44,9 +44,9 @@ private fun FirLightSourceElement.getChild(types: Set<IElementType>, index: Int,
 /**
 * Keeps 'padding' of parent node in child node
 */
-internal fun FirLightSourceElement.buildChildSourceElement(childNode: LighterASTNode): FirLightSourceElement {
+internal fun KtLightSourceElement.buildChildSourceElement(childNode: LighterASTNode): KtLightSourceElement {
    val offsetDelta = startOffset - lighterASTNode.startOffset
-    return childNode.toFirLightSourceElement(
+    return childNode.toKtLightSourceElement(
        treeStructure,
        startOffset = childNode.startOffset + offsetDelta,
        endOffset = childNode.endOffset + offsetDelta
@@ -7,9 +7,9 @@ package org.jetbrains.kotlin.fir.analysis.cfa

 import kotlinx.collections.immutable.PersistentMap
 import kotlinx.collections.immutable.persistentMapOf
+import org.jetbrains.kotlin.KtSourceElement
 import org.jetbrains.kotlin.contracts.description.EventOccurrencesRange
 import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.analysis.cfa.util.*
 import org.jetbrains.kotlin.fir.analysis.checkers.cfa.FirControlFlowChecker
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
@@ -66,7 +66,7 @@ object FirCallsEffectAnalyzer : FirControlFlowChecker() {

        if (functionalTypeEffects.isEmpty()) return

-        val leakedSymbols = mutableMapOf<FirBasedSymbol<*>, MutableList<FirSourceElement>>()
+        val leakedSymbols = mutableMapOf<FirBasedSymbol<*>, MutableList<KtSourceElement>>()
        graph.traverse(
            TraverseDirection.Forward,
            CapturedLambdaFinder(function),
@@ -125,7 +125,7 @@ object FirCallsEffectAnalyzer : FirControlFlowChecker() {

    private class IllegalScopeContext(
        private val functionalTypeSymbols: Set<FirBasedSymbol<*>>,
-        private val leakedSymbols: MutableMap<FirBasedSymbol<*>, MutableList<FirSourceElement>>,
+        private val leakedSymbols: MutableMap<FirBasedSymbol<*>, MutableList<KtSourceElement>>,
    ) {
        private var scopeDepth: Int = 0
        private var illegalScopeDepth: Int? = null
@@ -144,7 +144,7 @@ object FirCallsEffectAnalyzer : FirControlFlowChecker() {

        inline fun checkExpressionForLeakedSymbols(
            fir: FirExpression?,
-            source: FirSourceElement? = fir?.source,
+            source: KtSourceElement? = fir?.source,
            illegalUsage: () -> Boolean = { false }
        ) {
            val symbol = referenceToSymbol(fir.toQualifiedReference())
@@ -5,6 +5,7 @@

 package org.jetbrains.kotlin.fir.analysis.checkers

+import org.jetbrains.kotlin.KtFakeSourceElementKind
 import org.jetbrains.kotlin.config.LanguageFeature
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
 import org.jetbrains.kotlin.descriptors.annotations.KotlinTarget
@@ -5,8 +5,8 @@

 package org.jetbrains.kotlin.fir.analysis.checkers

+import org.jetbrains.kotlin.KtFakeSourceElementKind
 import org.jetbrains.kotlin.fir.FirElement
-import org.jetbrains.kotlin.fir.FirFakeSourceElementKind
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.utils.isOperator
 import org.jetbrains.kotlin.fir.types.*
@@ -221,7 +221,7 @@ private val NO_NAME_PROVIDED = Name.special("<no name provided>")
 // - see tests with `fun () {}`.
 // you can't redeclare something that has no name.
 private fun FirDeclaration.isCollectable() = when (this) {
-    is FirSimpleFunction -> source?.kind !is FirFakeSourceElementKind && name != NO_NAME_PROVIDED
+    is FirSimpleFunction -> source?.kind !is KtFakeSourceElementKind && name != NO_NAME_PROVIDED
    is FirRegularClass -> name != NO_NAME_PROVIDED
    else -> true
 }
@@ -6,6 +6,8 @@
 package org.jetbrains.kotlin.fir.analysis.checkers

 import org.jetbrains.kotlin.builtins.StandardNames.HASHCODE_NAME
+import org.jetbrains.kotlin.KtFakeSourceElementKind
+import org.jetbrains.kotlin.KtSourceElement
 import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibilities
@@ -534,13 +536,13 @@ fun checkTypeMismatch(
    assignment: FirVariableAssignment?,
    rValue: FirExpression,
    context: CheckerContext,
-    source: FirSourceElement,
+    source: KtSourceElement,
    reporter: DiagnosticReporter,
    isInitializer: Boolean
 ) {
    var lValueType = lValueOriginalType
    var rValueType = rValue.typeRef.coneType
-    if (source.kind is FirFakeSourceElementKind.DesugaredIncrementOrDecrement) {
+    if (source.kind is KtFakeSourceElementKind.DesugaredIncrementOrDecrement) {
        if (!lValueType.isNullable && rValueType.isNullable) {
            val tempType = rValueType
            rValueType = lValueType
@@ -584,7 +586,7 @@ fun checkTypeMismatch(
                    context
                )
            }
-            source.kind is FirFakeSourceElementKind.DesugaredIncrementOrDecrement -> {
+            source.kind is KtFakeSourceElementKind.DesugaredIncrementOrDecrement -> {
                if (!lValueType.isNullable && rValueType.isNullable) {
                    val tempType = rValueType
                    rValueType = lValueType
@@ -660,7 +662,7 @@ fun extractArgumentTypeRefAndSource(typeRef: FirTypeRef?, index: Int): FirTypeRe
    return null
 }

-data class FirTypeRefSource(val typeRef: FirTypeRef?, val source: FirSourceElement?)
+data class FirTypeRefSource(val typeRef: FirTypeRef?, val source: KtSourceElement?)

 fun FirRegularClassSymbol.collectEnumEntries(): Collection<FirEnumEntrySymbol> {
    assert(classKind == ClassKind.ENUM_CLASS)
@@ -718,13 +720,13 @@ fun getActualTargetList(annotated: FirDeclaration): AnnotationTargetList {
        is FirProperty -> {
            when {
                annotated.isLocal ->
-                    if (annotated.source?.kind == FirFakeSourceElementKind.DesugaredComponentFunctionCall) {
+                    if (annotated.source?.kind == KtFakeSourceElementKind.DesugaredComponentFunctionCall) {
                        TargetLists.T_DESTRUCTURING_DECLARATION
                    } else {
                        TargetLists.T_LOCAL_VARIABLE
                    }
                annotated.symbol.callableId.isMember() ->
-                    if (annotated.source?.kind == FirFakeSourceElementKind.PropertyFromParameter) {
+                    if (annotated.source?.kind == KtFakeSourceElementKind.PropertyFromParameter) {
                        TargetLists.T_VALUE_PARAMETER_WITH_VAL
                    } else {
                        TargetLists.T_MEMBER_PROPERTY(annotated.hasBackingField, annotated.delegate != null)
@@ -757,7 +759,7 @@ fun getActualTargetList(annotated: FirDeclaration): AnnotationTargetList {
        is FirTypeParameter -> TargetLists.T_TYPE_PARAMETER
        is FirAnonymousInitializer -> TargetLists.T_INITIALIZER
        is FirAnonymousObject ->
-            if (annotated.source?.kind == FirFakeSourceElementKind.EnumInitializer) {
+            if (annotated.source?.kind == KtFakeSourceElementKind.EnumInitializer) {
                AnnotationTargetList(
                    KotlinTarget.classActualTargets(
                        ClassKind.ENUM_ENTRY,
@@ -5,7 +5,7 @@

 package org.jetbrains.kotlin.fir.analysis.checkers

-import org.jetbrains.kotlin.fir.FirSourceElement
+import org.jetbrains.kotlin.KtSourceElement
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
@@ -22,7 +22,7 @@ fun checkInconsistentTypeParameters(
    firTypeRefClasses: List<Pair<FirTypeRef?, FirRegularClassSymbol>>,
    context: CheckerContext,
    reporter: DiagnosticReporter,
-    source: FirSourceElement?,
+    source: KtSourceElement?,
    isValues: Boolean
 ) {
    val result = buildDeepSubstitutionMultimap(firTypeRefClasses, context)
@@ -9,8 +9,8 @@ import com.intellij.lang.ASTNode
 import com.intellij.lang.LighterASTNode
 import com.intellij.psi.tree.TokenSet
 import com.intellij.util.diff.FlyweightCapableTreeStructure
-import org.jetbrains.kotlin.KtNodeTypes
-import org.jetbrains.kotlin.fir.*
+import org.jetbrains.kotlin.*
+import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.analysis.diagnostics.valOrVarKeyword
 import org.jetbrains.kotlin.lexer.KtKeywordToken
 import org.jetbrains.kotlin.lexer.KtModifierKeywordToken
@@ -60,8 +60,8 @@ sealed class FirModifier<Node : Any>(val node: Node, val token: KtModifierKeywor
        node: ASTNode,
        token: KtModifierKeywordToken
    ) : FirModifier<ASTNode>(node, token) {
-        override val source: FirSourceElement
-            get() = node.psi.toFirPsiSourceElement()
+        override val source: KtSourceElement
+            get() = node.psi.toKtPsiSourceElement()
    }

    class FirLightModifier(
@@ -70,22 +70,22 @@ sealed class FirModifier<Node : Any>(val node: Node, val token: KtModifierKeywor
        val tree: FlyweightCapableTreeStructure<LighterASTNode>,
        private val offsetDelta: Int
    ) : FirModifier<LighterASTNode>(node, token) {
-        override val source: FirSourceElement
-            get() = node.toFirLightSourceElement(
+        override val source: KtSourceElement
+            get() = node.toKtLightSourceElement(
                tree,
                startOffset = node.startOffset + offsetDelta,
                endOffset = node.endOffset + offsetDelta
            )
    }

-    abstract val source: FirSourceElement
+    abstract val source: KtSourceElement
 }

-fun FirSourceElement?.getModifierList(): FirModifierList? {
+fun KtSourceElement?.getModifierList(): FirModifierList? {
    return when (this) {
        null -> null
-        is FirPsiSourceElement -> (psi as? KtModifierListOwner)?.modifierList?.let { FirModifierList.FirPsiModifierList(it) }
-        is FirLightSourceElement -> {
+        is KtPsiSourceElement -> (psi as? KtModifierListOwner)?.modifierList?.let { FirModifierList.FirPsiModifierList(it) }
+        is KtLightSourceElement -> {
            val modifierListNode = lighterASTNode.getChildren(treeStructure).find { it.tokenType == KtNodeTypes.MODIFIER_LIST }
                ?: return null
            val offsetDelta = startOffset - lighterASTNode.startOffset
@@ -100,9 +100,9 @@ fun FirElement.getModifier(token: KtModifierKeywordToken): FirModifier<*>? = sou

 fun FirElement.hasModifier(token: KtModifierKeywordToken): Boolean = token in source.getModifierList()

-internal val FirSourceElement?.valOrVarKeyword: KtKeywordToken?
+internal val KtSourceElement?.valOrVarKeyword: KtKeywordToken?
    get() = when (this) {
        null -> null
-        is FirPsiSourceElement -> (psi as? KtValVarKeywordOwner)?.valOrVarKeyword?.let { it.node?.elementType as? KtKeywordToken }
-        is FirLightSourceElement -> treeStructure.valOrVarKeyword(lighterASTNode)?.tokenType as? KtKeywordToken
+        is KtPsiSourceElement -> (psi as? KtValVarKeywordOwner)?.valOrVarKeyword?.let { it.node?.elementType as? KtKeywordToken }
+        is KtLightSourceElement -> treeStructure.valOrVarKeyword(lighterASTNode)?.tokenType as? KtKeywordToken
    }
@@ -5,21 +5,21 @@

 package org.jetbrains.kotlin.fir.analysis.checkers

-import org.jetbrains.kotlin.fir.FirFakeSourceElementKind
-import org.jetbrains.kotlin.fir.FirRealSourceElementKind
-import org.jetbrains.kotlin.fir.FirSourceElement
+import org.jetbrains.kotlin.KtFakeSourceElementKind
+import org.jetbrains.kotlin.KtRealSourceElementKind
+import org.jetbrains.kotlin.KtSourceElement
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
 import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn

 fun checkUnderscoreDiagnostics(
-    source: FirSourceElement?,
+    source: KtSourceElement?,
    context: CheckerContext,
    reporter: DiagnosticReporter,
    isExpression: Boolean
 ) {
-    if (source != null && (source.kind is FirRealSourceElementKind || source.kind is FirFakeSourceElementKind.ReferenceInAtomicQualifiedAccess)) {
+    if (source != null && (source.kind is KtRealSourceElementKind || source.kind is KtFakeSourceElementKind.ReferenceInAtomicQualifiedAccess)) {
        with(SourceNavigator.forSource(source)) {
            if (source.getRawIdentifier()?.isUnderscore == true) {
                reporter.reportOn(
@@ -5,7 +5,7 @@

 package org.jetbrains.kotlin.fir.analysis.checkers

-import org.jetbrains.kotlin.fir.FirSourceElement
+import org.jetbrains.kotlin.KtSourceElement
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
@@ -99,7 +99,7 @@ fun checkUpperBoundViolated(
    for (index in 0 until count) {
        var typeArgument: ConeKotlinType? = null
        var typeArgumentTypeRef: FirTypeRef? = null
-        var typeArgumentSource: FirSourceElement? = null
+        var typeArgumentSource: KtSourceElement? = null

        if (typeArguments != null) {
            val localTypeArgument = typeArguments[index]
@@ -9,11 +9,11 @@ import com.intellij.lang.LighterASTNode
 import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiNameIdentifierOwner
 import com.intellij.psi.impl.source.tree.LeafPsiElement
+import org.jetbrains.kotlin.KtLightSourceElement
+import org.jetbrains.kotlin.KtPsiSourceElement
+import org.jetbrains.kotlin.KtSourceElement
 import org.jetbrains.kotlin.KtNodeTypes
 import org.jetbrains.kotlin.fir.FirElement
-import org.jetbrains.kotlin.fir.FirLightSourceElement
-import org.jetbrains.kotlin.fir.FirPsiSourceElement
-import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.analysis.diagnostics.getAncestors
 import org.jetbrains.kotlin.fir.analysis.diagnostics.nameIdentifier
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
@@ -34,7 +34,7 @@ interface SourceNavigator {

    fun FirTypeRef.isInTypeConstraint(): Boolean

-    fun FirSourceElement.getRawIdentifier(): String?
+    fun KtSourceElement.getRawIdentifier(): String?

    fun FirDeclaration.getRawName(): String?

@@ -46,21 +46,21 @@ interface SourceNavigator {

        fun forElement(e: FirElement): SourceNavigator = forSource(e.source)

-        fun forSource(e: FirSourceElement?): SourceNavigator = when (e) {
-            is FirLightSourceElement -> lightTreeInstance
-            is FirPsiSourceElement -> PsiSourceNavigator
+        fun forSource(e: KtSourceElement?): SourceNavigator = when (e) {
+            is KtLightSourceElement -> lightTreeInstance
+            is KtPsiSourceElement -> PsiSourceNavigator
            null -> lightTreeInstance //shouldn't matter
        }

        inline fun <R> FirElement.withNavigator(block: SourceNavigator.() -> R): R = with(forSource(this.source), block)

-        inline fun <R> FirSourceElement.withNavigator(block: SourceNavigator.() -> R): R = with(forSource(this), block)
+        inline fun <R> KtSourceElement.withNavigator(block: SourceNavigator.() -> R): R = with(forSource(this), block)
    }
 }

 open class LightTreeSourceNavigator : SourceNavigator {

-    private fun <T> FirElement.withSource(f: (FirSourceElement) -> T): T? =
+    private fun <T> FirElement.withSource(f: (KtSourceElement) -> T): T? =
        source?.let { f(it) }

    override fun FirTypeRef.isInConstructorCallee(): Boolean = withSource { source ->
@@ -74,7 +74,7 @@ open class LightTreeSourceNavigator : SourceNavigator {
            ?.tokenType == KtNodeTypes.TYPE_CONSTRAINT
    }

-    override fun FirSourceElement.getRawIdentifier(): String? {
+    override fun KtSourceElement.getRawIdentifier(): String? {
        return when (elementType) {
            is KtNameReferenceExpressionElementType, KtTokens.IDENTIFIER -> lighterASTNode.toString()
            is KtTypeProjectionElementType -> lighterASTNode.getChildren(treeStructure).last().toString()
@@ -90,7 +90,7 @@ open class LightTreeSourceNavigator : SourceNavigator {
        return source?.getParentOfParent()?.tokenType == KtNodeTypes.CATCH
    }

-    private fun FirSourceElement?.getParentOfParent(): LighterASTNode? {
+    private fun KtSourceElement?.getParentOfParent(): LighterASTNode? {
        val source = this ?: return null
        var parent = source.treeStructure.getParent(source.lighterASTNode)
        parent?.let { parent = source.treeStructure.getParent(it) }
@@ -104,14 +104,14 @@ object PsiSourceNavigator : LightTreeSourceNavigator() {
    //Swallows incorrect casts!!!
    private inline fun <reified P : PsiElement> FirElement.psi(): P? = source?.psi()

-    private inline fun <reified P : PsiElement> FirSourceElement.psi(): P? {
-        val psi = (this as? FirPsiSourceElement)?.psi
+    private inline fun <reified P : PsiElement> KtSourceElement.psi(): P? {
+        val psi = (this as? KtPsiSourceElement)?.psi
        return psi as? P
    }

    override fun FirTypeRef.isInConstructorCallee(): Boolean = psi<KtTypeReference>()?.parent is KtConstructorCalleeExpression

-    override fun FirSourceElement.getRawIdentifier(): String? {
+    override fun KtSourceElement.getRawIdentifier(): String? {
        val psi = psi<PsiElement>()
        return if (psi is KtNameReferenceExpression) {
            psi.getReferencedNameElement().node.text
@@ -5,11 +5,11 @@

 package org.jetbrains.kotlin.fir.analysis.checkers.declaration

+import org.jetbrains.kotlin.KtFakeSourceElementKind
 import org.jetbrains.kotlin.config.LanguageFeature
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
 import org.jetbrains.kotlin.descriptors.annotations.KotlinTarget
 import org.jetbrains.kotlin.fir.FirAnnotationContainer
-import org.jetbrains.kotlin.fir.FirFakeSourceElementKind
 import org.jetbrains.kotlin.fir.analysis.checkers.*
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.checkers.context.findClosest
@@ -63,7 +63,7 @@ object FirAnnotationChecker : FirAnnotatedDeclarationChecker() {
        if (declaration is FirProperty) {
            checkRepeatedAnnotationsInProperty(declaration, context, reporter)
        } else if (declaration is FirCallableDeclaration) {
-            if (declaration.source?.kind !is FirFakeSourceElementKind) {
+            if (declaration.source?.kind !is KtFakeSourceElementKind) {
                checkRepeatedAnnotations(declaration.returnTypeRef.coneTypeSafe(), context, reporter)
            }
        } else if (declaration is FirTypeAlias) {
@@ -110,7 +110,7 @@ object FirAnnotationChecker : FirAnnotatedDeclarationChecker() {
                context
            )
        } else {
-            if (declaration is FirProperty && declaration.source?.kind == FirFakeSourceElementKind.PropertyFromParameter) return
+            if (declaration is FirProperty && declaration.source?.kind == KtFakeSourceElementKind.PropertyFromParameter) return
            reporter.reportOn(
                annotation.source,
                FirErrors.WRONG_ANNOTATION_TARGET,
@@ -127,7 +127,7 @@ object FirAnnotationChecker : FirAnnotatedDeclarationChecker() {
        context: CheckerContext,
        reporter: DiagnosticReporter
    ) {
-        if (annotation.source?.kind == FirFakeSourceElementKind.FromUseSiteTarget) return
+        if (annotation.source?.kind == KtFakeSourceElementKind.FromUseSiteTarget) return
        when (target) {
            AnnotationUseSiteTarget.PROPERTY,
            AnnotationUseSiteTarget.PROPERTY_GETTER -> {
@@ -161,7 +161,7 @@ object FirAnnotationChecker : FirAnnotatedDeclarationChecker() {
                        reporter.reportOn(annotation.source, FirErrors.INAPPLICABLE_PARAM_TARGET, context)
                    }
                }
-                annotated is FirProperty && annotated.source?.kind == FirFakeSourceElementKind.PropertyFromParameter -> {
+                annotated is FirProperty && annotated.source?.kind == KtFakeSourceElementKind.PropertyFromParameter -> {
                }
                else -> reporter.reportOn(annotation.source, FirErrors.INAPPLICABLE_PARAM_TARGET, context)
            }
@@ -259,7 +259,7 @@ object FirAnnotationChecker : FirAnnotatedDeclarationChecker() {

            if (annotation.annotationTypeRef.coneType in existingAnnotations && !annotation.isRepeatable(context.session)) {
                val factory = if (isError) FirErrors.REPEATED_ANNOTATION else FirErrors.REPEATED_ANNOTATION_WARNING
-                if (annotation.source?.kind !is FirFakeSourceElementKind) {
+                if (annotation.source?.kind !is KtFakeSourceElementKind) {
                    reporter.reportOn(annotation.source, factory, context)
                }
            }
@@ -5,9 +5,9 @@

 package org.jetbrains.kotlin.fir.analysis.checkers.declaration

+import org.jetbrains.kotlin.KtFakeSourceElementKind
+import org.jetbrains.kotlin.KtSourceElement
 import org.jetbrains.kotlin.descriptors.Visibilities
-import org.jetbrains.kotlin.fir.FirFakeSourceElementKind
-import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.checkers.extractArgumentTypeRefAndSource
 import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
@@ -53,7 +53,7 @@ object FirClassVarianceChecker : FirClassChecker() {
    ) {
        val memberSource = member.source
        if (member is FirSimpleFunction) {
-            if (memberSource != null && memberSource.kind !is FirFakeSourceElementKind) {
+            if (memberSource != null && memberSource.kind !is KtFakeSourceElementKind) {
                for (param in member.valueParameters) {
                    checkVarianceConflict(param.returnTypeRef, Variance.IN_VARIANCE, context, reporter)
                }
@@ -65,7 +65,7 @@ object FirClassVarianceChecker : FirClassChecker() {

        var returnSource = member.returnTypeRef.source
        if (returnSource != null && memberSource != null) {
-            if (returnSource.kind is FirFakeSourceElementKind && memberSource.kind !is FirFakeSourceElementKind) {
+            if (returnSource.kind is KtFakeSourceElementKind && memberSource.kind !is KtFakeSourceElementKind) {
                returnSource = memberSource
            }
        }
@@ -94,7 +94,7 @@ object FirClassVarianceChecker : FirClassChecker() {
    private fun checkVarianceConflict(
        type: FirTypeRef, variance: Variance,
        context: CheckerContext, reporter: DiagnosticReporter,
-        source: FirSourceElement? = null
+        source: KtSourceElement? = null
    ) {
        checkVarianceConflict(type.coneType, variance, type, type.coneType, context, reporter, source)
    }
@@ -106,7 +106,7 @@ object FirClassVarianceChecker : FirClassChecker() {
        containingType: ConeKotlinType,
        context: CheckerContext,
        reporter: DiagnosticReporter,
-        source: FirSourceElement? = null,
+        source: KtSourceElement? = null,
        isInAbbreviation: Boolean = false
    ) {
        if (type is ConeTypeParameterType) {
@@ -5,7 +5,7 @@

 package org.jetbrains.kotlin.fir.analysis.checkers.declaration

-import org.jetbrains.kotlin.fir.FirFakeSourceElementKind
+import org.jetbrains.kotlin.KtFakeSourceElementKind
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
@@ -62,7 +62,7 @@ object FirCommonConstructorDelegationIssuesChecker : FirRegularClassChecker() {
                // couldn't find proper super() constructor implicitly
                if (
                    callee is FirErrorNamedReference && callee.diagnostic is ConeAmbiguityError &&
-                    it.delegatedConstructor?.source?.kind is FirFakeSourceElementKind
+                    it.delegatedConstructor?.source?.kind is KtFakeSourceElementKind
                ) {
                    reporter.reportOn(it.source, FirErrors.EXPLICIT_DELEGATION_CALL_REQUIRED, context)
                }
@@ -5,6 +5,7 @@

 package org.jetbrains.kotlin.fir.analysis.checkers.declaration

+import org.jetbrains.kotlin.KtFakeSourceElementKind
 import org.jetbrains.kotlin.fir.*
 import org.jetbrains.kotlin.fir.analysis.checkers.FirDeclarationInspector
 import org.jetbrains.kotlin.fir.analysis.checkers.FirDeclarationPresenter
@@ -244,7 +245,7 @@ object FirConflictsChecker : FirBasicDeclarationChecker() {
            }
        }

-        if (declaration.source?.kind !is FirFakeSourceElementKind) {
+        if (declaration.source?.kind !is KtFakeSourceElementKind) {
            when (declaration) {
                is FirMemberDeclaration -> {
                    if (declaration is FirFunction) {
@@ -5,8 +5,8 @@

 package org.jetbrains.kotlin.fir.analysis.checkers.declaration

+import org.jetbrains.kotlin.KtFakeSourceElementKind
 import org.jetbrains.kotlin.descriptors.ClassKind
-import org.jetbrains.kotlin.fir.FirFakeSourceElementKind
 import org.jetbrains.kotlin.fir.analysis.checkers.canBeUsedForConstVal
 import org.jetbrains.kotlin.fir.analysis.checkers.checkConstantArguments
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
@@ -40,7 +40,7 @@ object FirConstPropertyChecker : FirPropertyChecker() {
        }

        val source = declaration.getter?.source
-        if (source != null && source.kind !is FirFakeSourceElementKind) {
+        if (source != null && source.kind !is KtFakeSourceElementKind) {
            reporter.reportOn(source, FirErrors.CONST_VAL_WITH_GETTER, context)
            return
        }
@@ -5,7 +5,7 @@

 package org.jetbrains.kotlin.fir.analysis.checkers.declaration

-import org.jetbrains.kotlin.fir.FirFakeSourceElementKind
+import org.jetbrains.kotlin.KtFakeSourceElementKind
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
@@ -27,7 +27,7 @@ object FirContractChecker : FirFunctionChecker() {

        // Any statements that [ConeEffectExtractor] cannot extract effects will be in `unresolvedEffects`.
        for (statement in (declaration.contractDescription as FirResolvedContractDescription).unresolvedEffects) {
-            if (statement.source == null || statement.source!!.kind is FirFakeSourceElementKind) continue
+            if (statement.source == null || statement.source!!.kind is KtFakeSourceElementKind) continue

            // TODO: report on fine-grained locations, e.g., ... implies unresolved => report on unresolved, not the entire statement.
            //  but, sometimes, it's just reported on `contract`...
@@ -5,8 +5,8 @@

 package org.jetbrains.kotlin.fir.analysis.checkers.declaration

+import org.jetbrains.kotlin.KtFakeSourceElementKind
 import org.jetbrains.kotlin.descriptors.ClassKind
-import org.jetbrains.kotlin.fir.FirFakeSourceElementKind
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
@@ -24,7 +24,7 @@ object FirDataClassPrimaryConstructorChecker : FirRegularClassChecker() {

        val primaryConstructor = declaration.primaryConstructorIfAny(context.session)

-        if (primaryConstructor == null || primaryConstructor.source.let { it == null || it.kind is FirFakeSourceElementKind }) {
+        if (primaryConstructor == null || primaryConstructor.source.let { it == null || it.kind is KtFakeSourceElementKind }) {
            reporter.reportOn(declaration.source, FirErrors.PRIMARY_CONSTRUCTOR_REQUIRED_FOR_DATA_CLASS, context)
            return
        }
@@ -5,8 +5,8 @@

 package org.jetbrains.kotlin.fir.analysis.checkers.declaration

+import org.jetbrains.kotlin.KtFakeSourceElementKind
 import org.jetbrains.kotlin.fir.FirElement
-import org.jetbrains.kotlin.fir.FirFakeSourceElementKind
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
@@ -70,7 +70,7 @@ object FirDelegatedPropertyChecker : FirPropertyChecker() {
             */
            private fun checkFunctionReferenceErrors(functionCall: FirFunctionCall): Boolean {
                val errorNamedReference = functionCall.calleeReference as? FirErrorNamedReference ?: return false
-                if (errorNamedReference.source?.kind != FirFakeSourceElementKind.DelegatedPropertyAccessor) return false
+                if (errorNamedReference.source?.kind != KtFakeSourceElementKind.DelegatedPropertyAccessor) return false
                val expectedFunctionSignature =
                    (if (isGet) "getValue" else "setValue") + "(${functionCall.arguments.joinToString(", ") { it.typeRef.coneType.render() }})"
                val delegateDescription = if (isGet) "delegate" else "delegate for var (read-write property)"
@@ -5,7 +5,7 @@

 package org.jetbrains.kotlin.fir.analysis.checkers.declaration

-import org.jetbrains.kotlin.fir.FirFakeSourceElementKind
+import org.jetbrains.kotlin.KtFakeSourceElementKind
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
@@ -24,7 +24,7 @@ object FirDelegationSuperCallInEnumConstructorChecker : FirRegularClassChecker()
            if (
                it is FirConstructor && !it.isPrimary &&
                it.delegatedConstructor?.isThis == false &&
-                it.delegatedConstructor?.source?.kind !is FirFakeSourceElementKind
+                it.delegatedConstructor?.source?.kind !is KtFakeSourceElementKind
            ) {
                reporter.reportOn(it.delegatedConstructor?.source, FirErrors.DELEGATION_SUPER_CALL_IN_ENUM_CONSTRUCTOR, context)
            }
@@ -5,8 +5,8 @@

 package org.jetbrains.kotlin.fir.analysis.checkers.declaration

+import org.jetbrains.kotlin.KtSourceElement
 import org.jetbrains.kotlin.KtNodeTypes
-import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
@@ -89,7 +89,7 @@ object FirDestructuringDeclarationChecker : FirPropertyChecker() {
    }

    private fun checkInitializer(
-        source: FirSourceElement,
+        source: KtSourceElement,
        initializer: FirExpression?,
        reporter: DiagnosticReporter,
        context: CheckerContext
@@ -106,7 +106,7 @@ object FirDestructuringDeclarationChecker : FirPropertyChecker() {
    }

    private fun checkComponentCall(
-        source: FirSourceElement,
+        source: KtSourceElement,
        destructuringDeclarationType: ConeKotlinType,
        reference: FirErrorNamedReference,
        property: FirProperty,
@@ -5,10 +5,10 @@

 package org.jetbrains.kotlin.fir.analysis.checkers.declaration

+import org.jetbrains.kotlin.KtSourceElement
 import org.jetbrains.kotlin.config.LanguageFeature
 import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
@@ -118,7 +118,7 @@ object FirExpectActualDeclarationChecker : FirBasicDeclarationChecker() {

    @Suppress("UNUSED_PARAMETER")
    private fun checkAnnotationConstructors(
-        source: FirSourceElement?,
+        source: KtSourceElement?,
        expected: FirConstructorSymbol,
        actual: FirConstructorSymbol,
        context: CheckerContext,
@@ -5,7 +5,7 @@

 package org.jetbrains.kotlin.fir.analysis.checkers.declaration

-import org.jetbrains.kotlin.fir.FirFakeSourceElementKind
+import org.jetbrains.kotlin.KtFakeSourceElementKind
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
@@ -18,7 +18,7 @@ import org.jetbrains.kotlin.name.SpecialNames
 object FirFunctionNameChecker : FirSimpleFunctionChecker() {
    override fun check(declaration: FirSimpleFunction, context: CheckerContext, reporter: DiagnosticReporter) {
        val source = declaration.source
-        if (source == null || source.kind is FirFakeSourceElementKind) return
+        if (source == null || source.kind is KtFakeSourceElementKind) return
        val containingDeclaration = context.containingDeclarations.lastOrNull()
        val isNonLocal = containingDeclaration is FirFile || containingDeclaration is FirClass
        if (declaration.name == SpecialNames.NO_NAME_PROVIDED && isNonLocal) {
@@ -5,9 +5,9 @@

 package org.jetbrains.kotlin.fir.analysis.checkers.declaration

+import org.jetbrains.kotlin.KtFakeSourceElementKind
+import org.jetbrains.kotlin.KtRealSourceElementKind
 import org.jetbrains.kotlin.fir.FirElement
-import org.jetbrains.kotlin.fir.FirFakeSourceElementKind
-import org.jetbrains.kotlin.fir.FirRealSourceElementKind
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.checkers.isInlineClass
 import org.jetbrains.kotlin.fir.analysis.checkers.valOrVarKeyword
@@ -43,7 +43,7 @@ object FirFunctionParameterChecker : FirFunctionChecker() {
            val returnTypeRef = valueParameter.returnTypeRef
            if (returnTypeRef !is FirErrorTypeRef) continue
            // type problems on real source are already reported by ConeDiagnostic.toFirDiagnostics
-            if (returnTypeRef.source?.kind == FirRealSourceElementKind) continue
+            if (returnTypeRef.source?.kind == KtRealSourceElementKind) continue

            val diagnostic = returnTypeRef.diagnostic
            if (diagnostic is ConeSimpleDiagnostic && diagnostic.kind == DiagnosticKind.ValueParameterWithNoTypeAnnotation) {
@@ -125,7 +125,7 @@ object FirFunctionParameterChecker : FirFunctionChecker() {

        for (valueParameter in function.valueParameters) {
            val source = valueParameter.source
-            if (source?.kind is FirFakeSourceElementKind) continue
+            if (source?.kind is KtFakeSourceElementKind) continue
            source.valOrVarKeyword?.let {
                if (function is FirConstructor) {
                    reporter.reportOn(source, FirErrors.VAL_OR_VAR_ON_SECONDARY_CONSTRUCTOR_PARAMETER, it, context)
@@ -5,8 +5,8 @@

 package org.jetbrains.kotlin.fir.analysis.checkers.declaration

+import org.jetbrains.kotlin.KtFakeSourceElementKind
 import org.jetbrains.kotlin.descriptors.ClassKind
-import org.jetbrains.kotlin.fir.FirFakeSourceElementKind
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.checkers.unsubstitutedScope
 import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
@@ -41,7 +41,7 @@ object FirImplementationMismatchChecker : FirClassChecker() {
    override fun check(declaration: FirClass, context: CheckerContext, reporter: DiagnosticReporter) {
        val source = declaration.source ?: return
        val sourceKind = source.kind
-        if (sourceKind is FirFakeSourceElementKind && sourceKind != FirFakeSourceElementKind.EnumInitializer) return
+        if (sourceKind is KtFakeSourceElementKind && sourceKind != KtFakeSourceElementKind.EnumInitializer) return
        if (declaration is FirRegularClass && declaration.isExpect) return
        val classKind = declaration.classKind
        if (classKind == ClassKind.ANNOTATION_CLASS || classKind == ClassKind.ENUM_CLASS) return
@@ -5,7 +5,7 @@

 package org.jetbrains.kotlin.fir.analysis.checkers.declaration

-import org.jetbrains.kotlin.fir.FirSourceElement
+import org.jetbrains.kotlin.KtSourceElement
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
@@ -15,7 +15,10 @@ import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyGetter
 import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertySetter
 import org.jetbrains.kotlin.fir.declarations.utils.hasExplicitBackingField
 import org.jetbrains.kotlin.fir.declarations.utils.isLateInit
-import org.jetbrains.kotlin.fir.types.*
+import org.jetbrains.kotlin.fir.types.ConeTypeParameterType
+import org.jetbrains.kotlin.fir.types.coneType
+import org.jetbrains.kotlin.fir.types.isNullable
+import org.jetbrains.kotlin.fir.types.isPrimitiveOrNullablePrimitive

 object FirInapplicableLateinitChecker : FirPropertyChecker() {
    override fun check(declaration: FirProperty, context: CheckerContext, reporter: DiagnosticReporter) {
@@ -61,7 +64,7 @@ object FirInapplicableLateinitChecker : FirPropertyChecker() {
    private fun FirProperty.hasGetter() = getter != null && getter !is FirDefaultPropertyGetter
    private fun FirProperty.hasSetter() = setter != null && setter !is FirDefaultPropertySetter

-    private fun DiagnosticReporter.reportError(source: FirSourceElement?, target: String, context: CheckerContext) {
+    private fun DiagnosticReporter.reportError(source: KtSourceElement?, target: String, context: CheckerContext) {
        reportOn(source, FirErrors.INAPPLICABLE_LATEINIT_MODIFIER, target, context)
    }
 }
@@ -5,8 +5,8 @@

 package org.jetbrains.kotlin.fir.analysis.checkers.declaration

+import org.jetbrains.kotlin.KtRealSourceElementKind
 import org.jetbrains.kotlin.KtNodeTypes
-import org.jetbrains.kotlin.fir.FirRealSourceElementKind
 import org.jetbrains.kotlin.fir.analysis.checkers.checkTypeMismatch
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
@@ -20,7 +20,7 @@ object FirInitializerTypeMismatchChecker : FirPropertyChecker() {
        val source = declaration.source ?: return
        if (source.elementType == KtNodeTypes.DESTRUCTURING_DECLARATION) return
        if (initializer is FirComponentCall) return
-        if (declaration.returnTypeRef.source?.kind != FirRealSourceElementKind) return
+        if (declaration.returnTypeRef.source?.kind != KtRealSourceElementKind) return
        val propertyType = declaration.returnTypeRef.coneType

        checkTypeMismatch(propertyType, null, initializer, context, source, reporter, true)
@@ -5,16 +5,14 @@

 package org.jetbrains.kotlin.fir.analysis.checkers.declaration

+import org.jetbrains.kotlin.KtFakeSourceElementKind
+import org.jetbrains.kotlin.KtRealSourceElementKind
 import org.jetbrains.kotlin.descriptors.Modality
-import org.jetbrains.kotlin.fir.*
+import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.checkers.hasModifier
 import org.jetbrains.kotlin.fir.analysis.checkers.toRegularClassSymbol
-import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
-import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
-import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn
-import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOnWithSuppression
-import org.jetbrains.kotlin.fir.analysis.diagnostics.withSuppressedDiagnostics
+import org.jetbrains.kotlin.fir.analysis.diagnostics.*
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.utils.*
 import org.jetbrains.kotlin.fir.resolve.fullyExpandedType
@@ -120,7 +118,7 @@ object FirInlineClassDeclarationChecker : FirRegularClassChecker() {
                                }

                            innerDeclaration.hasBackingField &&
-                                    innerDeclaration.source?.kind !is FirFakeSourceElementKind ->
+                                    innerDeclaration.source?.kind !is KtFakeSourceElementKind ->
                                reporter.reportOnWithSuppression(
                                    innerDeclaration,
                                    FirErrors.PROPERTY_WITH_BACKING_FIELD_INSIDE_INLINE_CLASS,
@@ -133,7 +131,7 @@ object FirInlineClassDeclarationChecker : FirRegularClassChecker() {
            }
        }

-        if (primaryConstructor?.source?.kind !is FirRealSourceElementKind) {
+        if (primaryConstructor?.source?.kind !is KtRealSourceElementKind) {
            reporter.reportOn(declaration.source, FirErrors.ABSENCE_OF_PRIMARY_CONSTRUCTOR_FOR_INLINE_CLASS, context)
            return
        }
@@ -173,7 +171,7 @@ object FirInlineClassDeclarationChecker : FirRegularClassChecker() {
    }

    private fun FirProperty.isRelatedToParameter(parameter: FirValueParameter?) =
-        name == parameter?.name && source?.kind is FirFakeSourceElementKind
+        name == parameter?.name && source?.kind is KtFakeSourceElementKind

    private fun FirValueParameter.isNotFinalReadOnly(primaryConstructorProperty: FirProperty?): Boolean {
        if (primaryConstructorProperty == null) return true
@@ -5,11 +5,13 @@

 package org.jetbrains.kotlin.fir.analysis.checkers.declaration

+import org.jetbrains.kotlin.KtSourceElement
 import org.jetbrains.kotlin.builtins.StandardNames.BACKING_FIELD
 import org.jetbrains.kotlin.config.LanguageFeature
 import org.jetbrains.kotlin.descriptors.EffectiveVisibility
 import org.jetbrains.kotlin.descriptors.Visibilities
-import org.jetbrains.kotlin.fir.*
+import org.jetbrains.kotlin.fir.FirElement
+import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.checkers.isInlineOnly
 import org.jetbrains.kotlin.fir.analysis.checkers.unsubstitutedScope
@@ -18,9 +20,11 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
 import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn
 import org.jetbrains.kotlin.fir.analysis.diagnostics.withSuppressedDiagnostics
+import org.jetbrains.kotlin.fir.containingClass
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.utils.*
 import org.jetbrains.kotlin.fir.expressions.*
+import org.jetbrains.kotlin.fir.languageVersionSettings
 import org.jetbrains.kotlin.fir.references.FirSuperReference
 import org.jetbrains.kotlin.fir.types.isBuiltinFunctionalType
 import org.jetbrains.kotlin.fir.types.isFunctionalType
@@ -229,7 +233,7 @@ object FirInlineDeclarationChecker : FirFunctionChecker() {
        private fun checkVisibilityAndAccess(
            accessExpression: FirQualifiedAccess,
            calledDeclaration: FirCallableSymbol<*>?,
-            source: FirSourceElement,
+            source: KtSourceElement,
            context: CheckerContext
        ) {
            if (
@@ -283,7 +287,7 @@ object FirInlineDeclarationChecker : FirFunctionChecker() {

        private fun checkPrivateClassMemberAccess(
            calledDeclaration: FirCallableSymbol<*>,
-            source: FirSourceElement,
+            source: KtSourceElement,
            context: CheckerContext
        ) {
            if (!isEffectivelyPrivateApiFunction) {
@@ -331,7 +335,7 @@ object FirInlineDeclarationChecker : FirFunctionChecker() {

        private fun checkRecursion(
            targetSymbol: FirBasedSymbol<*>,
-            source: FirSourceElement,
+            source: KtSourceElement,
            context: CheckerContext
        ) {
            if (targetSymbol == inlineFunction.symbol) {
@@ -5,8 +5,8 @@

 package org.jetbrains.kotlin.fir.analysis.checkers.declaration

-import org.jetbrains.kotlin.fir.FirFakeSourceElementKind
-import org.jetbrains.kotlin.fir.FirSourceElement
+import org.jetbrains.kotlin.KtFakeSourceElementKind
+import org.jetbrains.kotlin.KtSourceElement
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
@@ -34,9 +34,9 @@ object FirInvalidAndDangerousCharactersChecker : FirBasicDeclarationChecker() {
        }
    }

-    private fun checkNameAndReport(name: Name, source: FirSourceElement?, context: CheckerContext, reporter: DiagnosticReporter) {
+    private fun checkNameAndReport(name: Name, source: KtSourceElement?, context: CheckerContext, reporter: DiagnosticReporter) {
        if (source != null &&
-            source.kind !is FirFakeSourceElementKind &&
+            source.kind !is KtFakeSourceElementKind &&
            !name.isSpecial
        ) {
            val nameString = name.asString()
@@ -5,7 +5,7 @@

 package org.jetbrains.kotlin.fir.analysis.checkers.declaration

-import org.jetbrains.kotlin.fir.FirFakeSourceElementKind
+import org.jetbrains.kotlin.KtFakeSourceElementKind
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
@@ -37,7 +37,7 @@ object FirKClassWithIncorrectTypeArgumentChecker : FirFileChecker() {
        reporter: DiagnosticReporter
    ) {
        val source = declaration.source ?: return
-        if (source.kind is FirFakeSourceElementKind) return
+        if (source.kind is KtFakeSourceElementKind) return

        val returnType = declaration.returnTypeRef.coneType
        if (!returnType.isKClassTypeWithErrorOrNullableArgument(context.session.typeContext)) return
@@ -5,15 +5,17 @@

 package org.jetbrains.kotlin.fir.analysis.checkers.declaration

+import org.jetbrains.kotlin.KtFakeSourceElementKind
 import org.jetbrains.kotlin.descriptors.Visibilities
-import org.jetbrains.kotlin.fir.FirFakeSourceElementKind
 import org.jetbrains.kotlin.fir.analysis.checkers.contains
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.checkers.getModifierList
 import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
 import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn
-import org.jetbrains.kotlin.fir.declarations.*
+import org.jetbrains.kotlin.fir.declarations.FirClass
+import org.jetbrains.kotlin.fir.declarations.FirRegularClass
+import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
 import org.jetbrains.kotlin.fir.declarations.utils.*
 import org.jetbrains.kotlin.lexer.KtTokens

@@ -34,7 +36,7 @@ object FirMemberFunctionsChecker : FirClassChecker() {
        reporter: DiagnosticReporter
    ) {
        val source = function.source ?: return
-        if (source.kind is FirFakeSourceElementKind) return
+        if (source.kind is KtFakeSourceElementKind) return
        val functionSymbol = function.symbol
        // If multiple (potentially conflicting) modality modifiers are specified, not all modifiers are recorded at `status`.
        // So, our source of truth should be the full modifier list retrieved from the source.
@@ -5,11 +5,11 @@

 package org.jetbrains.kotlin.fir.analysis.checkers.declaration

+import org.jetbrains.kotlin.KtFakeSourceElementKind
 import org.jetbrains.kotlin.contracts.description.EventOccurrencesRange
 import org.jetbrains.kotlin.contracts.description.isDefinitelyVisited
 import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.fir.FirElement
-import org.jetbrains.kotlin.fir.FirFakeSourceElementKind
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.analysis.cfa.util.PropertyInitializationInfo
 import org.jetbrains.kotlin.fir.analysis.cfa.util.PropertyInitializationInfoCollector
@@ -164,7 +164,7 @@ object FirMemberPropertiesChecker : FirClassChecker() {
        reachable: Boolean
    ) {
        val source = property.source ?: return
-        if (source.kind is FirFakeSourceElementKind) return
+        if (source.kind is KtFakeSourceElementKind) return
        // If multiple (potentially conflicting) modality modifiers are specified, not all modifiers are recorded at `status`.
        // So, our source of truth should be the full modifier list retrieved from the source.
        val modifierList = property.source.getModifierList()
@@ -5,13 +5,16 @@

 package org.jetbrains.kotlin.fir.analysis.checkers.declaration

+import org.jetbrains.kotlin.KtFakeSourceElementKind
+import org.jetbrains.kotlin.KtSourceElement
 import org.jetbrains.kotlin.descriptors.annotations.KotlinTarget
 import org.jetbrains.kotlin.descriptors.annotations.KotlinTarget.Companion.classActualTargets
-import org.jetbrains.kotlin.fir.FirFakeSourceElementKind
-import org.jetbrains.kotlin.fir.FirSourceElement
-import org.jetbrains.kotlin.fir.analysis.checkers.*
+import org.jetbrains.kotlin.fir.analysis.checkers.FirModifier
+import org.jetbrains.kotlin.fir.analysis.checkers.FirModifierList
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.checkers.context.findClosest
+import org.jetbrains.kotlin.fir.analysis.checkers.getActualTargetList
+import org.jetbrains.kotlin.fir.analysis.checkers.getModifierList
 import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnosticFactory2
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
@@ -31,7 +34,7 @@ object FirModifierChecker : FirBasicDeclarationChecker() {
        if (declaration is FirFile) return

        val source = declaration.source ?: return
-        if (source.kind is FirFakeSourceElementKind) return
+        if (source.kind is KtFakeSourceElementKind) return

        source.getModifierList()?.let { checkModifiers(it, declaration, context, reporter) }
    }
@@ -53,7 +56,7 @@ object FirModifierChecker : FirBasicDeclarationChecker() {
        val parent = context.findClosest<FirDeclaration> {
            it !is FirPrimaryConstructor &&
                    it !is FirProperty &&
-                    it.source?.kind !is FirFakeSourceElementKind
+                    it.source?.kind !is KtFakeSourceElementKind
        }

        val actualParents = when (parent) {
@@ -164,7 +167,7 @@ object FirModifierChecker : FirBasicDeclarationChecker() {
    }

    private fun checkTarget(
-        modifierSource: FirSourceElement,
+        modifierSource: KtSourceElement,
        modifierToken: KtModifierKeywordToken,
        actualTargets: List<KotlinTarget>,
        parent: FirDeclaration?,
@@ -224,7 +227,7 @@ object FirModifierChecker : FirBasicDeclarationChecker() {
    }

    private fun checkParent(
-        modifierSource: FirSourceElement,
+        modifierSource: KtSourceElement,
        modifierToken: KtModifierKeywordToken,
        actualParents: List<KotlinTarget>,
        context: CheckerContext,
@@ -5,9 +5,9 @@

 package org.jetbrains.kotlin.fir.analysis.checkers.declaration

+import org.jetbrains.kotlin.KtFakeSourceElementKind
 import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.descriptors.Modality
-import org.jetbrains.kotlin.fir.FirFakeSourceElementKind
 import org.jetbrains.kotlin.fir.analysis.checkers.*
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
@@ -38,7 +38,7 @@ object FirNotImplementedOverrideChecker : FirClassChecker() {
    override fun check(declaration: FirClass, context: CheckerContext, reporter: DiagnosticReporter) {
        val source = declaration.source ?: return
        val sourceKind = source.kind
-        if (sourceKind is FirFakeSourceElementKind && sourceKind != FirFakeSourceElementKind.EnumInitializer) return
+        if (sourceKind is KtFakeSourceElementKind && sourceKind != KtFakeSourceElementKind.EnumInitializer) return
        val modality = declaration.modality()
        val canHaveAbstractDeclarations = modality == Modality.ABSTRACT || modality == Modality.SEALED
        if (declaration is FirRegularClass && declaration.isExpect) return
@@ -5,10 +5,10 @@

 package org.jetbrains.kotlin.fir.analysis.checkers.declaration

+import org.jetbrains.kotlin.KtFakeSourceElementKind
+import org.jetbrains.kotlin.KtRealSourceElementKind
+import org.jetbrains.kotlin.KtSourceElement
 import org.jetbrains.kotlin.descriptors.ClassKind
-import org.jetbrains.kotlin.fir.FirFakeSourceElementKind
-import org.jetbrains.kotlin.fir.FirRealSourceElementKind
-import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.checkers.hasModifier
 import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
@@ -39,10 +39,10 @@ object FirOpenMemberChecker : FirClassChecker() {
        }
    }

-    private val FirSourceElement.shouldReportOpenFromSource: Boolean
+    private val KtSourceElement.shouldReportOpenFromSource: Boolean
        get() = when (kind) {
-            FirRealSourceElementKind,
-            FirFakeSourceElementKind.PropertyFromParameter -> true
+            KtRealSourceElementKind,
+            KtFakeSourceElementKind.PropertyFromParameter -> true
            else -> false
        }
 }
@@ -6,6 +6,8 @@
 package org.jetbrains.kotlin.fir.analysis.checkers.declaration

 import org.jetbrains.kotlin.config.LanguageFeature
+import org.jetbrains.kotlin.KtFakeSourceElementKind
+import org.jetbrains.kotlin.KtRealSourceElementKind
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
@@ -21,11 +23,13 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
 import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn
 import org.jetbrains.kotlin.fir.analysis.diagnostics.withSuppressedDiagnostics
 import org.jetbrains.kotlin.fir.analysis.overridesBackwardCompatibilityHelper
+import org.jetbrains.kotlin.fir.containingClass
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.utils.isFinal
 import org.jetbrains.kotlin.fir.declarations.utils.isOverride
 import org.jetbrains.kotlin.fir.declarations.utils.modality
 import org.jetbrains.kotlin.fir.declarations.utils.visibility
+import org.jetbrains.kotlin.fir.originalOrSelf
 import org.jetbrains.kotlin.fir.resolve.substitution.substitutorByMap
 import org.jetbrains.kotlin.fir.resolve.toFirRegularClassSymbol
 import org.jetbrains.kotlin.fir.resolve.toSymbol
@@ -254,7 +258,7 @@ object FirOverrideChecker : FirClassChecker() {
            val kind = member.source?.kind
            // Only report if the current member has real source or it's a member property declared inside the primary constructor.

-            if (kind is FirFakeSourceElementKind.DataClassGeneratedMembers) {
+            if (kind is KtFakeSourceElementKind.DataClassGeneratedMembers) {
                overriddenMemberSymbols.find { it.isFinal }?.let { base ->
                    reporter.reportOn(
                        containingClass.source,
@@ -267,7 +271,7 @@ object FirOverrideChecker : FirClassChecker() {
                return
            }

-            if (kind !is FirRealSourceElementKind && kind !is FirFakeSourceElementKind.PropertyFromParameter) return
+            if (kind !is KtRealSourceElementKind && kind !is KtFakeSourceElementKind.PropertyFromParameter) return

            val overridden = overriddenMemberSymbols.first().originalOrSelf()
            val originalContainingClassSymbol = overridden.containingClass()?.toSymbol(context.session) as? FirRegularClassSymbol ?: return
@@ -5,8 +5,8 @@

 package org.jetbrains.kotlin.fir.analysis.checkers.declaration

+import org.jetbrains.kotlin.KtFakeSourceElementKind
 import org.jetbrains.kotlin.KtNodeTypes
-import org.jetbrains.kotlin.fir.FirFakeSourceElementKind
 import org.jetbrains.kotlin.fir.analysis.checkers.SourceNavigator
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.checkers.toRegularClassSymbol
@@ -17,9 +17,9 @@ import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 import org.jetbrains.kotlin.fir.declarations.utils.isInterface
 import org.jetbrains.kotlin.fir.declarations.primaryConstructorIfAny
 import org.jetbrains.kotlin.fir.symbols.impl.FirConstructorSymbol
-import org.jetbrains.kotlin.name.StandardClassIds
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.fir.types.impl.FirImplicitAnyTypeRef
+import org.jetbrains.kotlin.name.StandardClassIds
 import org.jetbrains.kotlin.utils.addToStdlib.lastIsInstanceOrNull

 /** Checker on super type declarations in the primary constructor of a class declaration. */
@@ -74,7 +74,7 @@ object FirPrimaryConstructorSuperTypeChecker : FirRegularClassChecker() {
            return
        }
        val delegatedCallSource = delegatedConstructorCall.source ?: return
-        if (delegatedCallSource.kind !is FirFakeSourceElementKind) return
+        if (delegatedCallSource.kind !is KtFakeSourceElementKind) return
        if (superClassSymbol.classId == StandardClassIds.Enum) return
        if (delegatedCallSource.elementType != KtNodeTypes.SUPER_TYPE_CALL_ENTRY) {
            reporter.reportOn(constructedTypeRef.source, FirErrors.SUPERTYPE_NOT_INITIALIZED, context)
@@ -5,7 +5,7 @@

 package org.jetbrains.kotlin.fir.analysis.checkers.declaration

-import org.jetbrains.kotlin.fir.FirFakeSourceElementKind
+import org.jetbrains.kotlin.KtFakeSourceElementKind
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.checkers.extractArgumentTypeRefAndSource
 import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
@@ -74,7 +74,7 @@ object FirProjectionRelationChecker : FirBasicDeclarationChecker() {

            val argTypeRefSource = extractArgumentTypeRefAndSource(typeRef, it) ?: continue

-            if (projectionRelation != ProjectionRelation.None && typeRef.source?.kind !is FirFakeSourceElementKind) {
+            if (projectionRelation != ProjectionRelation.None && typeRef.source?.kind !is KtFakeSourceElementKind) {
                reporter.reportOn(
                    argTypeRefSource.source ?: argTypeRefSource.typeRef?.source,
                    if (projectionRelation == ProjectionRelation.Conflicting)
@@ -5,15 +5,17 @@

 package org.jetbrains.kotlin.fir.analysis.checkers.declaration

+import org.jetbrains.kotlin.KtFakeSourceElementKind
 import org.jetbrains.kotlin.descriptors.Visibilities
-import org.jetbrains.kotlin.fir.FirFakeSourceElementKind
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.checkers.findClosestClassOrObject
 import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
 import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn
 import org.jetbrains.kotlin.fir.analysis.diagnostics.withSuppressedDiagnostics
-import org.jetbrains.kotlin.fir.declarations.*
+import org.jetbrains.kotlin.fir.declarations.FirProperty
+import org.jetbrains.kotlin.fir.declarations.FirPropertyAccessor
+import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 import org.jetbrains.kotlin.fir.declarations.utils.canHaveAbstractDeclaration
 import org.jetbrains.kotlin.fir.declarations.utils.isAbstract
 import org.jetbrains.kotlin.fir.declarations.utils.isOpen
@@ -43,7 +45,7 @@ object FirPropertyAccessorsTypesChecker : FirPropertyChecker() {
                }
            }
            val getterReturnTypeRef = getter.returnTypeRef
-            if (getterReturnTypeRef.source?.kind is FirFakeSourceElementKind) {
+            if (getterReturnTypeRef.source?.kind is KtFakeSourceElementKind) {
                return
            }
            val getterReturnType = getterReturnTypeRef.coneType
@@ -122,7 +124,7 @@ object FirPropertyAccessorsTypesChecker : FirPropertyChecker() {
        reporter: DiagnosticReporter
    ) {
        if (property.delegateFieldSymbol != null && accessor.body != null &&
-            accessor.source?.kind != FirFakeSourceElementKind.DelegatedPropertyAccessor
+            accessor.source?.kind != KtFakeSourceElementKind.DelegatedPropertyAccessor
        ) {
            reporter.reportOn(accessor.source, FirErrors.ACCESSOR_FOR_DELEGATED_PROPERTY, context)
        }
@@ -5,7 +5,7 @@

 package org.jetbrains.kotlin.fir.analysis.checkers.declaration

-import org.jetbrains.kotlin.fir.FirFakeSourceElementKind
+import org.jetbrains.kotlin.KtFakeSourceElementKind
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
@@ -15,7 +15,7 @@ import org.jetbrains.kotlin.fir.declarations.utils.isAbstract

 object FirPropertyFromParameterChecker : FirPropertyChecker() {
    override fun check(declaration: FirProperty, context: CheckerContext, reporter: DiagnosticReporter) {
-        if (declaration.source?.kind != FirFakeSourceElementKind.PropertyFromParameter) return
+        if (declaration.source?.kind != KtFakeSourceElementKind.PropertyFromParameter) return
        if (declaration.isAbstract) {
            reporter.reportOn(
                declaration.source,
@@ -5,7 +5,7 @@

 package org.jetbrains.kotlin.fir.analysis.checkers.declaration

-import org.jetbrains.kotlin.fir.FirFakeSourceElementKind
+import org.jetbrains.kotlin.KtFakeSourceElementKind
 import org.jetbrains.kotlin.fir.analysis.checkers.SourceNavigator
 import org.jetbrains.kotlin.fir.analysis.checkers.checkUnderscoreDiagnostics
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
@@ -54,7 +54,7 @@ object FirReservedUnderscoreDeclarationChecker : FirBasicDeclarationChecker() {
        isSingleUnderscoreAllowed: Boolean = false
    ) {
        val declarationSource = declaration.source
-        if (declarationSource != null && declarationSource.kind !is FirFakeSourceElementKind) {
+        if (declarationSource != null && declarationSource.kind !is KtFakeSourceElementKind) {
            with(SourceNavigator.forElement(declaration)) {
                val rawName = declaration.getRawName()
                if (rawName?.isUnderscore == true && !(isSingleUnderscoreAllowed && rawName == "_")) {
@@ -5,13 +5,14 @@

 package org.jetbrains.kotlin.fir.analysis.checkers.declaration

-import org.jetbrains.kotlin.fir.FirFakeSourceElementKind
+import org.jetbrains.kotlin.KtFakeSourceElementKind
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.checkers.hasModifier
 import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
 import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn
-import org.jetbrains.kotlin.fir.declarations.*
+import org.jetbrains.kotlin.fir.declarations.FirFile
+import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
 import org.jetbrains.kotlin.fir.declarations.utils.hasBody
 import org.jetbrains.kotlin.fir.declarations.utils.isExpect
 import org.jetbrains.kotlin.fir.declarations.utils.isExternal
@@ -29,7 +30,7 @@ object FirTopLevelFunctionsChecker : FirFileChecker() {

    private fun checkFunction(function: FirSimpleFunction, reporter: DiagnosticReporter, context: CheckerContext) {
        val source = function.source ?: return
-        if (source.kind is FirFakeSourceElementKind) return
+        if (source.kind is KtFakeSourceElementKind) return
        // If multiple (potentially conflicting) modality modifiers are specified, not all modifiers are recorded at `status`.
        // So, our source of truth should be the full modifier list retrieved from the source.
        if (function.hasModifier(KtTokens.ABSTRACT_KEYWORD)) return
@@ -5,9 +5,9 @@

 package org.jetbrains.kotlin.fir.analysis.checkers.declaration

+import org.jetbrains.kotlin.KtFakeSourceElementKind
+import org.jetbrains.kotlin.KtSourceElement
 import org.jetbrains.kotlin.descriptors.Visibilities
-import org.jetbrains.kotlin.fir.FirFakeSourceElementKind
-import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.analysis.checkers.FirModifierList
 import org.jetbrains.kotlin.fir.analysis.checkers.contains
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
@@ -35,7 +35,7 @@ object FirTopLevelPropertiesChecker : FirFileChecker() {

    private fun checkProperty(property: FirProperty, reporter: DiagnosticReporter, context: CheckerContext) {
        val source = property.source ?: return
-        if (source.kind is FirFakeSourceElementKind) return
+        if (source.kind is KtFakeSourceElementKind) return
        // If multiple (potentially conflicting) modality modifiers are specified, not all modifiers are recorded at `status`.
        // So, our source of truth should be the full modifier list retrieved from the source.
        val modifierList = source.getModifierList()
@@ -57,7 +57,7 @@ object FirTopLevelPropertiesChecker : FirFileChecker() {
 // TODO: check class too
 internal fun checkExpectDeclarationVisibilityAndBody(
    declaration: FirMemberDeclaration,
-    source: FirSourceElement,
+    source: KtSourceElement,
    reporter: DiagnosticReporter,
    context: CheckerContext
 ) {
@@ -5,8 +5,8 @@

 package org.jetbrains.kotlin.fir.analysis.checkers.declaration

+import org.jetbrains.kotlin.KtRealSourceElementKind
 import org.jetbrains.kotlin.descriptors.ClassKind
-import org.jetbrains.kotlin.fir.FirRealSourceElementKind
 import org.jetbrains.kotlin.fir.analysis.checkers.*
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
@@ -77,7 +77,7 @@ object FirTypeParameterBoundsChecker : FirTypeParameterChecker() {
        reporter: DiagnosticReporter
    ) {
        if (containingDeclaration is FirTypeAlias) {
-            declaration.bounds.filter { it.source?.kind == FirRealSourceElementKind }.forEach { bound ->
+            declaration.bounds.filter { it.source?.kind == KtRealSourceElementKind }.forEach { bound ->
                reporter.reportOn(bound.source, FirErrors.BOUND_ON_TYPE_ALIAS_PARAMETER_NOT_ALLOWED, context)
            }
        }
@@ -5,7 +5,7 @@

 package org.jetbrains.kotlin.fir.analysis.checkers.declaration

-import org.jetbrains.kotlin.fir.FirFakeSourceElementKind
+import org.jetbrains.kotlin.KtFakeSourceElementKind
 import org.jetbrains.kotlin.fir.analysis.checkers.checkUpperBoundViolated
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
@@ -28,7 +28,7 @@ object FirUpperBoundViolatedDeclarationChecker : FirBasicDeclarationChecker() {
        } else if (declaration is FirTypeAlias) {
            checkUpperBoundViolated(declaration.expandedTypeRef, context, reporter, isIgnoreTypeParameters = true)
        } else if (declaration is FirCallableDeclaration) {
-            if (declaration.returnTypeRef.source?.kind !is FirFakeSourceElementKind) {
+            if (declaration.returnTypeRef.source?.kind !is KtFakeSourceElementKind) {
                checkUpperBoundViolated(
                    declaration.returnTypeRef, context, reporter,
                    isIgnoreTypeParameters = context.containingDeclarations.lastOrNull() is FirTypeAlias
@@ -5,9 +5,9 @@

 package org.jetbrains.kotlin.fir.analysis.checkers.expression

+import org.jetbrains.kotlin.KtSourceElement
 import org.jetbrains.kotlin.config.ApiVersion
 import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.analysis.checkers.ConstantArgumentKind
 import org.jetbrains.kotlin.fir.analysis.checkers.checkConstantArguments
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
@@ -145,7 +145,7 @@ object FirAnnotationArgumentChecker : FirAnnotationCallChecker() {
    }

    private fun checkDeprecatedSinceKotlin(
-        source: FirSourceElement?,
+        source: KtSourceElement?,
        fqName: FqName?,
        argumentMapping: Map<Name, FirExpression>,
        context: CheckerContext,
@@ -5,8 +5,8 @@

 package org.jetbrains.kotlin.fir.analysis.checkers.expression

+import org.jetbrains.kotlin.KtFakeSourceElementKind
 import org.jetbrains.kotlin.descriptors.ClassKind
-import org.jetbrains.kotlin.fir.FirFakeSourceElementKind
 import org.jetbrains.kotlin.fir.analysis.checkers.classKind
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.checkers.declaration.isExtensionMember
@@ -15,12 +15,11 @@ import org.jetbrains.kotlin.fir.analysis.checkers.getContainingClassSymbol
 import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
 import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn
-import org.jetbrains.kotlin.fir.declarations.FirProperty
-import org.jetbrains.kotlin.fir.declarations.FirValueParameter
 import org.jetbrains.kotlin.fir.expressions.FirCallableReferenceAccess
 import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessExpression
 import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
-import org.jetbrains.kotlin.fir.symbols.impl.*
+import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirConstructorSymbol

 object FirCallableReferenceChecker : FirQualifiedAccessExpressionChecker() {
    override fun check(expression: FirQualifiedAccessExpression, context: CheckerContext, reporter: DiagnosticReporter) {
@@ -39,7 +38,7 @@ object FirCallableReferenceChecker : FirQualifiedAccessExpressionChecker() {
        val reference = callableReferenceAccess.calleeReference as? FirResolvedNamedReference ?: return

        val source = reference.source ?: return
-        if (source.kind is FirFakeSourceElementKind) return
+        if (source.kind is KtFakeSourceElementKind) return

        val referredSymbol = reference.resolvedSymbol
        if (referredSymbol is FirConstructorSymbol && referredSymbol.getContainingClassSymbol(context.session)?.classKind == ClassKind.ANNOTATION_CLASS) {
@@ -5,7 +5,7 @@

 package org.jetbrains.kotlin.fir.analysis.checkers.expression

-import org.jetbrains.kotlin.fir.FirFakeSourceElementKind
+import org.jetbrains.kotlin.KtFakeSourceElementKind
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
@@ -27,7 +27,7 @@ import org.jetbrains.kotlin.resolve.checkers.OptInNames
 object FirClassLiteralChecker : FirGetClassCallChecker() {
    override fun check(expression: FirGetClassCall, context: CheckerContext, reporter: DiagnosticReporter) {
        val source = expression.source ?: return
-        if (source.kind is FirFakeSourceElementKind) return
+        if (source.kind is KtFakeSourceElementKind) return
        val argument = expression.argument
        if (argument is FirResolvedQualifier) {
            val classId = argument.classId
@@ -5,8 +5,8 @@

 package org.jetbrains.kotlin.fir.analysis.checkers.expression

-import org.jetbrains.kotlin.fir.FirFakeSourceElementKind
-import org.jetbrains.kotlin.fir.FirRealSourceElementKind
+import org.jetbrains.kotlin.KtFakeSourceElementKind
+import org.jetbrains.kotlin.KtRealSourceElementKind
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
@@ -29,7 +29,7 @@ object FirConventionFunctionCallChecker : FirFunctionCallChecker() {
        val calleeReference = expression.calleeReference as? FirErrorNamedReference ?: return
        val diagnostic = calleeReference.diagnostic as? ConeUnresolvedNameError ?: return

-        if (expression.calleeReference.source?.kind == FirFakeSourceElementKind.ArrayAccessNameReference) {
+        if (expression.calleeReference.source?.kind == KtFakeSourceElementKind.ArrayAccessNameReference) {
            when (diagnostic.name) {
                OperatorNameConventions.GET -> reporter.reportOn(calleeReference.source, FirErrors.NO_GET_METHOD, context)
                OperatorNameConventions.SET -> reporter.reportOn(calleeReference.source, FirErrors.NO_SET_METHOD, context)
@@ -44,9 +44,9 @@ object FirConventionFunctionCallChecker : FirFunctionCallChecker() {
        reporter: DiagnosticReporter
    ) {
        val sourceKind = callExpression.source?.kind
-        if (sourceKind !is FirRealSourceElementKind &&
-            sourceKind !is FirFakeSourceElementKind.GeneratedComparisonExpression &&
-            sourceKind !is FirFakeSourceElementKind.DesugaredCompoundAssignment
+        if (sourceKind !is KtRealSourceElementKind &&
+            sourceKind !is KtFakeSourceElementKind.GeneratedComparisonExpression &&
+            sourceKind !is KtFakeSourceElementKind.DesugaredCompoundAssignment
        ) return
        val unwrapped = when (receiver) {
            is FirExpressionWithSmartcast -> receiver.originalExpression
@@ -5,29 +5,32 @@

 package org.jetbrains.kotlin.fir.analysis.checkers.expression

-import org.jetbrains.kotlin.resolve.deprecation.DeprecationInfo
-import org.jetbrains.kotlin.resolve.deprecation.DeprecationLevelValue
+import org.jetbrains.kotlin.KtFakeSourceElementKind
+import org.jetbrains.kotlin.KtRealSourceElementKind
+import org.jetbrains.kotlin.KtSourceElement
 import org.jetbrains.kotlin.fir.FirElement
-import org.jetbrains.kotlin.fir.FirFakeSourceElementKind
-import org.jetbrains.kotlin.fir.FirRealSourceElementKind
-import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.checkers.toRegularClassSymbol
 import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
 import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn
 import org.jetbrains.kotlin.fir.declarations.getDeprecation
-import org.jetbrains.kotlin.fir.expressions.*
+import org.jetbrains.kotlin.fir.expressions.FirAnnotation
+import org.jetbrains.kotlin.fir.expressions.FirDelegatedConstructorCall
+import org.jetbrains.kotlin.fir.expressions.FirResolvable
+import org.jetbrains.kotlin.fir.expressions.FirStatement
 import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
 import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirConstructorSymbol
+import org.jetbrains.kotlin.resolve.deprecation.DeprecationInfo
+import org.jetbrains.kotlin.resolve.deprecation.DeprecationLevelValue
 import org.jetbrains.kotlin.utils.addToStdlib.safeAs

 object FirDeprecationChecker : FirBasicExpressionChecker() {

    private val allowedSourceKinds = setOf(
-        FirRealSourceElementKind,
-        FirFakeSourceElementKind.DesugaredIncrementOrDecrement
+        KtRealSourceElementKind,
+        KtFakeSourceElementKind.DesugaredIncrementOrDecrement
    )

    override fun check(expression: FirStatement, context: CheckerContext, reporter: DiagnosticReporter) {
@@ -41,7 +44,7 @@ object FirDeprecationChecker : FirBasicExpressionChecker() {
    }

    internal fun reportDeprecationIfNeeded(
-        source: FirSourceElement?,
+        source: KtSourceElement?,
        referencedSymbol: FirBasedSymbol<*>,
        callSite: FirElement?,
        context: CheckerContext,
@@ -52,7 +55,7 @@ object FirDeprecationChecker : FirBasicExpressionChecker() {
    }

    internal fun reportDeprecation(
-        source: FirSourceElement?,
+        source: KtSourceElement?,
        referencedSymbol: FirBasedSymbol<*>,
        deprecationInfo: DeprecationInfo,
        reporter: DiagnosticReporter,
@@ -5,8 +5,8 @@

 package org.jetbrains.kotlin.fir.analysis.checkers.expression

+import org.jetbrains.kotlin.KtRealSourceElementKind
 import org.jetbrains.kotlin.KtNodeTypes
-import org.jetbrains.kotlin.fir.FirRealSourceElementKind
 import org.jetbrains.kotlin.fir.analysis.checkers.ConeTypeCompatibilityChecker
 import org.jetbrains.kotlin.fir.analysis.checkers.ConeTypeCompatibilityChecker.isCompatible
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
@@ -55,7 +55,7 @@ object FirEqualityCompatibilityChecker : FirEqualityOperatorCallChecker() {
        }
        if (compatibility != ConeTypeCompatibilityChecker.Compatibility.COMPATIBLE) {
            when (expression.source?.kind) {
-                FirRealSourceElementKind -> {
+                KtRealSourceElementKind -> {
                    // Note: FE1.0 reports INCOMPATIBLE_ENUM_COMPARISON_ERROR only when TypeIntersector.isIntersectionEmpty() thinks the
                    // given types are compatible. Exactly mimicking the behavior of FE1.0 is difficult and does not seem to provide any
                    // value. So instead, we deterministically output INCOMPATIBLE_ENUM_COMPARISON_ERROR if at least one of the value is an
@@ -5,12 +5,12 @@

 package org.jetbrains.kotlin.fir.analysis.checkers.expression

+import org.jetbrains.kotlin.KtSourceElement
 import org.jetbrains.kotlin.KtNodeTypes
 import org.jetbrains.kotlin.config.LanguageFeature
 import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.diagnostics.WhenMissingCase
-import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.checkers.toRegularClassSymbol
 import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
@@ -85,9 +85,9 @@ object FirExhaustiveWhenChecker : FirWhenExpressionChecker() {
        }
    }

-    private val FirSourceElement.isIfExpression: Boolean
+    private val KtSourceElement.isIfExpression: Boolean
        get() = elementType == KtNodeTypes.IF

-    private val FirSourceElement.isWhenExpression: Boolean
+    private val KtSourceElement.isWhenExpression: Boolean
        get() = elementType == KtNodeTypes.WHEN
 }
@@ -5,9 +5,9 @@

 package org.jetbrains.kotlin.fir.analysis.checkers.expression

+import org.jetbrains.kotlin.KtFakeSourceElementKind
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
 import org.jetbrains.kotlin.descriptors.annotations.KotlinTarget
-import org.jetbrains.kotlin.fir.FirFakeSourceElementKind
 import org.jetbrains.kotlin.fir.analysis.checkers.checkRepeatedAnnotation
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.checkers.getAllowedAnnotationTargets
@@ -29,7 +29,7 @@ object FirExpressionAnnotationChecker : FirBasicExpressionChecker() {
        // See KT-33658 about annotations on non-expression statements
        if (expression is FirDeclaration ||
            expression !is FirExpression ||
-            expression is FirBlock && expression.source?.kind == FirFakeSourceElementKind.DesugaredForLoop
+            expression is FirBlock && expression.source?.kind == KtFakeSourceElementKind.DesugaredForLoop
        ) return

        val annotationsMap = hashMapOf<ConeKotlinType, MutableList<AnnotationUseSiteTarget?>>()
@@ -5,8 +5,8 @@

 package org.jetbrains.kotlin.fir.analysis.checkers.expression

-import org.jetbrains.kotlin.fir.FirFakeSourceElementKind
-import org.jetbrains.kotlin.fir.FirSourceElement
+import org.jetbrains.kotlin.KtFakeSourceElementKind
+import org.jetbrains.kotlin.KtSourceElement
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.checkers.valOrVarKeyword
 import org.jetbrains.kotlin.fir.analysis.diagnostics.*
@@ -37,12 +37,12 @@ import org.jetbrains.kotlin.resolve.calls.tower.isSuccess

 object FirForLoopChecker : FirBlockChecker() {
    override fun check(expression: FirBlock, context: CheckerContext, reporter: DiagnosticReporter) {
-        if (expression.source?.kind != FirFakeSourceElementKind.DesugaredForLoop) return
+        if (expression.source?.kind != KtFakeSourceElementKind.DesugaredForLoop) return

        val statements = expression.statements
        val iteratorDeclaration = statements[0] as? FirProperty ?: return
        val whileLoop = statements[1] as? FirWhileLoop ?: return
-        if (iteratorDeclaration.source?.kind != FirFakeSourceElementKind.DesugaredForLoop) return
+        if (iteratorDeclaration.source?.kind != KtFakeSourceElementKind.DesugaredForLoop) return
        val iteratorCall = iteratorDeclaration.initializer as FirFunctionCall
        val source = iteratorCall.explicitReceiver?.source ?: iteratorCall.source
        if (checkSpecialFunctionCall(
@@ -70,7 +70,7 @@ object FirForLoopChecker : FirBlockChecker() {
        )

        val loopParameter = whileLoop.block.statements.firstOrNull() as? FirProperty ?: return
-        if (loopParameter.initializer?.source?.kind != FirFakeSourceElementKind.DesugaredForLoop) return
+        if (loopParameter.initializer?.source?.kind != KtFakeSourceElementKind.DesugaredForLoop) return
        val nextCall = loopParameter.initializer as FirFunctionCall
        checkSpecialFunctionCall(
            nextCall,
@@ -91,7 +91,7 @@ object FirForLoopChecker : FirBlockChecker() {
    private fun checkSpecialFunctionCall(
        call: FirFunctionCall,
        reporter: DiagnosticReporter,
-        reportSource: FirSourceElement?,
+        reportSource: KtSourceElement?,
        context: CheckerContext,
        ambiguityFactory: FirDiagnosticFactory1<Collection<FirBasedSymbol<*>>>,
        missingFactory: FirDiagnosticFactory0,
@@ -5,9 +5,9 @@

 package org.jetbrains.kotlin.fir.analysis.checkers.expression

+import org.jetbrains.kotlin.KtSourceElement
 import org.jetbrains.kotlin.config.AnalysisFlags
 import org.jetbrains.kotlin.config.LanguageFeature
-import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.checkers.extractClassesFromArgument
 import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
@@ -53,7 +53,7 @@ object FirOptInAnnotationCallChecker : FirAnnotationCallChecker() {
    }

    private fun checkOptInIsEnabled(
-        element: FirSourceElement?,
+        element: KtSourceElement?,
        context: CheckerContext,
        reporter: DiagnosticReporter
    ) {
@@ -5,7 +5,7 @@

 package org.jetbrains.kotlin.fir.analysis.checkers.expression

-import org.jetbrains.kotlin.fir.FirFakeSourceElementKind
+import org.jetbrains.kotlin.KtFakeSourceElementKind
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccess
@@ -19,8 +19,8 @@ import org.jetbrains.kotlin.fir.types.coneType
 object FirOptInUsageAccessChecker : FirQualifiedAccessChecker() {
    override fun check(expression: FirQualifiedAccess, context: CheckerContext, reporter: DiagnosticReporter) {
        val sourceKind = expression.source?.kind
-        if (sourceKind is FirFakeSourceElementKind.DataClassGeneratedMembers ||
-            sourceKind is FirFakeSourceElementKind.PropertyFromParameter
+        if (sourceKind is KtFakeSourceElementKind.DataClassGeneratedMembers ||
+            sourceKind is KtFakeSourceElementKind.PropertyFromParameter
        ) return
        val reference = expression.calleeReference as? FirResolvedNamedReference ?: return
        val resolvedSymbol = reference.resolvedSymbol
@@ -5,7 +5,7 @@

 package org.jetbrains.kotlin.fir.analysis.checkers.expression

-import org.jetbrains.kotlin.fir.FirSourceElement
+import org.jetbrains.kotlin.KtSourceElement
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.diagnostics.*
 import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessExpression
@@ -42,7 +42,7 @@ object FirReifiedChecker : FirQualifiedAccessExpressionChecker() {

    private fun checkArgumentAndReport(
        typeArgument: ConeKotlinType?,
-        source: FirSourceElement,
+        source: KtSourceElement,
        isArray: Boolean,
        context: CheckerContext,
        reporter: DiagnosticReporter
@@ -5,8 +5,8 @@

 package org.jetbrains.kotlin.fir.analysis.checkers.expression

-import org.jetbrains.kotlin.fir.FirFakeSourceElementKind
-import org.jetbrains.kotlin.fir.FirRealSourceElementKind
+import org.jetbrains.kotlin.KtFakeSourceElementKind
+import org.jetbrains.kotlin.KtRealSourceElementKind
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
@@ -24,7 +24,7 @@ import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
 object FirReturnSyntaxAndLabelChecker : FirReturnExpressionChecker() {
    override fun check(expression: FirReturnExpression, context: CheckerContext, reporter: DiagnosticReporter) {
        val source = expression.source
-        if (source?.kind == FirFakeSourceElementKind.ImplicitReturn) return
+        if (source?.kind == KtFakeSourceElementKind.ImplicitReturn) return

        val labeledElement = expression.target.labeledElement
        val targetSymbol = labeledElement.symbol
@@ -36,7 +36,7 @@ object FirReturnSyntaxAndLabelChecker : FirReturnExpressionChecker() {

        if (targetSymbol is FirAnonymousFunctionSymbol) {
            val label = targetSymbol.label
-            if (label?.source?.kind !is FirRealSourceElementKind) {
+            if (label?.source?.kind !is KtRealSourceElementKind) {
                val functionCall = context.qualifiedAccessOrAnnotationCalls.asReversed().find {
                    it is FirFunctionCall &&
                            ((it.calleeReference as? FirResolvedNamedReference)?.resolvedSymbol as? FirNamedFunctionSymbol)?.callableId ==
@@ -5,7 +5,7 @@

 package org.jetbrains.kotlin.fir.analysis.checkers.expression

-import org.jetbrains.kotlin.fir.FirSourceElement
+import org.jetbrains.kotlin.KtSourceElement
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
@@ -20,7 +20,7 @@ import org.jetbrains.kotlin.fir.types.coneType

 object FirSpreadOfNullableChecker : FirFunctionCallChecker() {
    override fun check(expression: FirFunctionCall, context: CheckerContext, reporter: DiagnosticReporter) {
-        fun checkAndReport(argument: FirExpression, source: FirSourceElement?) {
+        fun checkAndReport(argument: FirExpression, source: KtSourceElement?) {
            val argumentTypeRef = argument.typeRef
            if (argument is FirSpreadArgumentExpression && argumentTypeRef.coneType !is ConeFlexibleType && argumentTypeRef.canBeNull) {
                reporter.reportOn(source, FirErrors.SPREAD_OF_NULLABLE, context)
--- a/Show More
+++ b/Show More