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
@@ -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)
@@ -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.checkers.declaration.isEnumEntryInitializer
 import org.jetbrains.kotlin.fir.analysis.checkers.getContainingClassSymbol
@@ -13,7 +13,8 @@ import org.jetbrains.kotlin.fir.analysis.checkers.outerClassSymbol
 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.FirAnonymousFunction
+import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.declarations.utils.isCompanion
 import org.jetbrains.kotlin.fir.declarations.utils.isEnumClass
 import org.jetbrains.kotlin.fir.expressions.*
@@ -71,7 +72,7 @@ object FirUninitializedEnumChecker : FirQualifiedAccessExpressionChecker() {
    // https://youtrack.jetbrains.com/issue/KT-11769
    override fun check(expression: FirQualifiedAccessExpression, context: CheckerContext, reporter: DiagnosticReporter) {
        val source = expression.source ?: return
-        if (source.kind is FirFakeSourceElementKind) return
+        if (source.kind is KtFakeSourceElementKind) return

        val reference = expression.calleeReference as? FirResolvedNamedReference ?: return
        val calleeSymbol = reference.resolvedSymbol
@@ -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.references.FirSuperReference

-fun FirSuperReference.hadExplicitTypeInSource(): Boolean = superTypeRef.source?.kind != FirFakeSourceElementKind.SuperCallImplicitType
+fun FirSuperReference.hadExplicitTypeInSource(): Boolean = superTypeRef.source?.kind != KtFakeSourceElementKind.SuperCallImplicitType
@@ -7,17 +7,21 @@ package org.jetbrains.kotlin.fir.analysis.checkers.extended

 import com.intellij.lang.LighterASTNode
 import com.intellij.psi.tree.IElementType
+import org.jetbrains.kotlin.KtFakeSourceElementKind
+import org.jetbrains.kotlin.KtLightSourceElement
+import org.jetbrains.kotlin.KtPsiSourceElement
 import org.jetbrains.kotlin.KtNodeTypes
-import org.jetbrains.kotlin.fir.*
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.checkers.expression.FirVariableAssignmentChecker
 import org.jetbrains.kotlin.fir.analysis.checkers.getChildren
 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.dispatchReceiverTypeOrNull
 import org.jetbrains.kotlin.fir.expressions.FirFunctionCall
 import org.jetbrains.kotlin.fir.expressions.FirVariableAssignment
 import org.jetbrains.kotlin.fir.expressions.toResolvedCallableSymbol
+import org.jetbrains.kotlin.fir.psi
 import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
 import org.jetbrains.kotlin.fir.types.coneType
 import org.jetbrains.kotlin.fir.types.isPrimitive
@@ -29,10 +33,10 @@ object CanBeReplacedWithOperatorAssignmentChecker : FirVariableAssignmentChecker
    override fun check(expression: FirVariableAssignment, context: CheckerContext, reporter: DiagnosticReporter) {
        val lValue = expression.lValue
        if (lValue !is FirResolvedNamedReference) return
-        if (expression.source?.kind is FirFakeSourceElementKind) return
+        if (expression.source?.kind is KtFakeSourceElementKind) return

        val rValue = expression.rValue as? FirFunctionCall ?: return
-        if (rValue.source?.kind is FirFakeSourceElementKind) return
+        if (rValue.source?.kind is KtFakeSourceElementKind) return

        if (rValue.explicitReceiver?.typeRef?.coneType?.isPrimitive != true) return
        val rValueResolvedSymbol = rValue.toResolvedCallableSymbol() ?: return
@@ -41,14 +45,14 @@ object CanBeReplacedWithOperatorAssignmentChecker : FirVariableAssignmentChecker
        var needToReport = false
        val assignmentSource = expression.source

-        if (assignmentSource is FirPsiSourceElement) {
+        if (assignmentSource is KtPsiSourceElement) {
            val lValuePsi = lValue.psi as? KtNameReferenceExpression ?: return
            val rValuePsi = rValue.psi as? KtBinaryExpression ?: return

            if (rValuePsi.matcher(lValuePsi)) {
                needToReport = true
            }
-        } else if (assignmentSource is FirLightSourceElement) {
+        } else if (assignmentSource is KtLightSourceElement) {
            val lValueLightTree = lValue.source!!.lighterASTNode
            val rValueLightTree = rValue.source!!.lighterASTNode
            if (lightTreeMatcher(lValueLightTree, rValueLightTree, assignmentSource)) {
@@ -65,7 +69,7 @@ object CanBeReplacedWithOperatorAssignmentChecker : FirVariableAssignmentChecker
    fun lightTreeMatcher(
        variable: LighterASTNode,
        expression: LighterASTNode,
-        source: FirLightSourceElement,
+        source: KtLightSourceElement,
        prevOperator: LighterASTNode? = null
    ): Boolean {
        val tree = source.treeStructure
@@ -5,10 +5,10 @@

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

+import org.jetbrains.kotlin.KtFakeSourceElementKind
+import org.jetbrains.kotlin.KtSourceElement
 import org.jetbrains.kotlin.KtNodeTypes
 import org.jetbrains.kotlin.contracts.description.EventOccurrencesRange
-import org.jetbrains.kotlin.fir.FirFakeSourceElementKind
-import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.analysis.cfa.AbstractFirPropertyInitializationChecker
 import org.jetbrains.kotlin.fir.analysis.cfa.util.PathAwarePropertyInitializationInfo
 import org.jetbrains.kotlin.fir.analysis.cfa.util.TraverseDirection
@@ -40,12 +40,12 @@ object CanBeValChecker : AbstractFirPropertyInitializationChecker() {

        for (property in unprocessedProperties) {
            val source = property.source
-            if (source?.kind is FirFakeSourceElementKind) continue
+            if (source?.kind is KtFakeSourceElementKind) continue
            if (source?.elementType == KtNodeTypes.DESTRUCTURING_DECLARATION) continue
            propertiesCharacteristics[property] = EventOccurrencesRange.ZERO
        }

-        var lastDestructuringSource: FirSourceElement? = null
+        var lastDestructuringSource: KtSourceElement? = null
        var destructuringCanBeVal = false
        var lastDestructuredVariables = 0

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

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

-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.expression.FirFunctionCallChecker
 import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
@@ -17,7 +17,7 @@ import org.jetbrains.kotlin.fir.scopes.impl.FirIntegerOperatorCall

 object EmptyRangeChecker : FirFunctionCallChecker() {
    override fun check(expression: FirFunctionCall, context: CheckerContext, reporter: DiagnosticReporter) {
-        if (expression.source?.kind is FirFakeSourceElementKind) return
+        if (expression.source?.kind is KtFakeSourceElementKind) return
        val left = expression.rangeLeft ?: return
        val right = expression.rangeRight ?: return

@@ -5,8 +5,8 @@

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

+import org.jetbrains.kotlin.KtFakeSourceElementKind
 import org.jetbrains.kotlin.KtNodeTypes
-import org.jetbrains.kotlin.fir.FirFakeSourceElementKind
 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
@@ -28,7 +28,7 @@ object RedundantExplicitTypeChecker : FirPropertyChecker() {
        val initializer = declaration.initializer ?: return
        val typeReference = declaration.returnTypeRef

-        if (typeReference.source?.kind is FirFakeSourceElementKind) return
+        if (typeReference.source?.kind is KtFakeSourceElementKind) return

        val type = declaration.returnTypeRef.coneType

@@ -5,10 +5,10 @@

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

+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.fir.FirFakeSourceElementKind
-import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.checkers.implicitModality
 import org.jetbrains.kotlin.fir.analysis.checkers.syntax.FirDeclarationSyntaxChecker
@@ -24,12 +24,12 @@ import org.jetbrains.kotlin.psi.KtDeclaration

 object RedundantModalityModifierSyntaxChecker : FirDeclarationSyntaxChecker<FirDeclaration, KtDeclaration>() {

-    override fun isApplicable(element: FirDeclaration, source: FirSourceElement): Boolean =
-        source.kind !is FirFakeSourceElementKind && element is FirMemberDeclaration
+    override fun isApplicable(element: FirDeclaration, source: KtSourceElement): Boolean =
+        source.kind !is KtFakeSourceElementKind && element is FirMemberDeclaration

    override fun checkPsiOrLightTree(
        element: FirDeclaration,
-        source: FirSourceElement,
+        source: KtSourceElement,
        context: CheckerContext,
        reporter: DiagnosticReporter
    ) {
@@ -5,7 +5,7 @@

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

-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.declaration.FirSimpleFunctionChecker
 import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
@@ -20,7 +20,7 @@ object RedundantReturnUnitType : FirSimpleFunctionChecker() {
        if (declaration.body is FirSingleExpressionBlock) return
        val returnType = declaration.returnTypeRef
        if (returnType.source == null) return
-        if (declaration.source?.kind is FirFakeSourceElementKind) return
+        if (declaration.source?.kind is KtFakeSourceElementKind) return
        if (returnType.annotations.isNotEmpty()) return

        if (returnType.isUnit) {
@@ -5,7 +5,7 @@

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

-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.declaration.FirPropertyChecker
 import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
@@ -22,7 +22,7 @@ object RedundantSetterParameterTypeChecker : FirPropertyChecker() {
        val propertyTypeSource = declaration.returnTypeRef.source
        val setterParameterTypeSource = valueParameter.returnTypeRef.source ?: return

-        if (setterParameterTypeSource.kind !is FirFakeSourceElementKind && setterParameterTypeSource != propertyTypeSource) {
+        if (setterParameterTypeSource.kind !is KtFakeSourceElementKind && setterParameterTypeSource != propertyTypeSource) {
            reporter.reportOn(setterParameterTypeSource, REDUNDANT_SETTER_PARAMETER_TYPE, context)
        }
    }
@@ -8,9 +8,9 @@ package org.jetbrains.kotlin.fir.analysis.checkers.extended
 import com.intellij.lang.LighterASTNode
 import com.intellij.lang.PsiBuilder
 import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.KtLightSourceElement
+import org.jetbrains.kotlin.KtPsiSourceElement
 import org.jetbrains.kotlin.KtNodeTypes
-import org.jetbrains.kotlin.fir.FirLightSourceElement
-import org.jetbrains.kotlin.fir.FirPsiSourceElement
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.checkers.expression.FirStringConcatenationCallChecker
 import org.jetbrains.kotlin.fir.analysis.checkers.getChildren
@@ -38,8 +38,8 @@ object RedundantSingleExpressionStringTemplateChecker : FirStringConcatenationCa

    private fun FirStatement.stringParentChildrenCount(): Int? {
        return when (val source = source) {
-            is FirPsiSourceElement -> source.psi.stringParentChildrenCount()
-            is FirLightSourceElement -> source.lighterASTNode.stringParentChildrenCount(source)
+            is KtPsiSourceElement -> source.psi.stringParentChildrenCount()
+            is KtLightSourceElement -> source.lighterASTNode.stringParentChildrenCount(source)
            null -> null
        }
    }
@@ -49,7 +49,7 @@ object RedundantSingleExpressionStringTemplateChecker : FirStringConcatenationCa
        return parent.stringParentChildrenCount()
    }

-    private fun LighterASTNode.stringParentChildrenCount(source: FirLightSourceElement): Int? {
+    private fun LighterASTNode.stringParentChildrenCount(source: KtLightSourceElement): Int? {
        val parent = source.treeStructure.getParent(this)
        return if (parent != null && parent.tokenType == KtNodeTypes.STRING_TEMPLATE) {
            val childrenOfParent = parent.getChildren(source.treeStructure)
@@ -5,10 +5,11 @@

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

+import org.jetbrains.kotlin.KtFakeSourceElement
+import org.jetbrains.kotlin.KtFakeSourceElementKind
+import org.jetbrains.kotlin.KtSourceElement
 import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.descriptors.Visibility
-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.context.findClosest
 import org.jetbrains.kotlin.fir.analysis.checkers.findClosestClassOrObject
@@ -35,12 +36,12 @@ object RedundantVisibilityModifierSyntaxChecker : FirDeclarationSyntaxChecker<Fi

    override fun checkPsiOrLightTree(
        element: FirDeclaration,
-        source: FirSourceElement,
+        source: KtSourceElement,
        context: CheckerContext,
        reporter: DiagnosticReporter
    ) {
-        if (element is FirConstructor && source.kind is FirFakeSourceElementKind) return
-        if (source.kind is FirFakeSourceElementKind) return
+        if (element is FirConstructor && source.kind is KtFakeSourceElementKind) return
+        if (source.kind is KtFakeSourceElementKind) return
        if (
            element !is FirMemberDeclaration
            && !(element is FirPropertyAccessor && element.visibility == context.containingPropertyVisibility)
@@ -5,8 +5,8 @@

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

+import org.jetbrains.kotlin.KtFakeSourceElementKind
 import org.jetbrains.kotlin.fir.FirElement
-import org.jetbrains.kotlin.fir.FirFakeSourceElementKind
 import org.jetbrains.kotlin.fir.analysis.checkers.cfa.FirControlFlowChecker
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
@@ -40,8 +40,8 @@ object UnreachableCodeChecker : FirControlFlowChecker() {
    }

    private val sourceKindsToSkip = setOf(
-        FirFakeSourceElementKind.ImplicitReturn,
-        FirFakeSourceElementKind.DesugaredForLoop
+        KtFakeSourceElementKind.ImplicitReturn,
+        KtFakeSourceElementKind.DesugaredForLoop
    )

    private fun CFGNode<*>.skipNode(): Boolean {
@@ -7,9 +7,9 @@ package org.jetbrains.kotlin.fir.analysis.checkers.extended

 import kotlinx.collections.immutable.PersistentMap
 import kotlinx.collections.immutable.persistentMapOf
+import org.jetbrains.kotlin.KtFakeSourceElementKind
 import org.jetbrains.kotlin.KtNodeTypes
 import org.jetbrains.kotlin.fir.FirAnnotationContainer
-import org.jetbrains.kotlin.fir.FirFakeSourceElementKind
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.analysis.cfa.util.*
 import org.jetbrains.kotlin.fir.analysis.checkers.cfa.FirControlFlowChecker
@@ -185,7 +185,7 @@ object UnusedChecker : FirControlFlowChecker() {
            data: Collection<Pair<EdgeLabel, PathAwareVariableStatusInfo>>
        ): PathAwareVariableStatusInfo {
            val dataForNode = visitNode(node, data)
-            if (node.fir.source?.kind is FirFakeSourceElementKind) return dataForNode
+            if (node.fir.source?.kind is KtFakeSourceElementKind) return dataForNode
            val symbol = node.fir.symbol
            return update(dataForNode, symbol) { prev ->
                when (prev) {
@@ -322,6 +322,6 @@ object UnusedChecker : FirControlFlowChecker() {
    private val FirPropertySymbol.isLoopIterator: Boolean
        get() {
            @OptIn(SymbolInternals::class)
-            return fir.initializer?.source?.kind == FirFakeSourceElementKind.DesugaredForLoop
+            return fir.initializer?.source?.kind == KtFakeSourceElementKind.DesugaredForLoop
        }
 }
@@ -5,8 +5,8 @@

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

-import org.jetbrains.kotlin.fir.FirLightSourceElement
-import org.jetbrains.kotlin.fir.FirPsiSourceElement
+import org.jetbrains.kotlin.KtPsiSourceElement
+import org.jetbrains.kotlin.KtLightSourceElement
 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.psi.KtFunction
 object FirAnonymousFunctionSyntaxChecker : FirDeclarationSyntaxChecker<FirAnonymousFunction, KtFunction>() {
    override fun checkPsi(
        element: FirAnonymousFunction,
-        source: FirPsiSourceElement,
+        source: KtPsiSourceElement,
        psi: KtFunction,
        context: CheckerContext,
        reporter: DiagnosticReporter
@@ -34,7 +34,7 @@ object FirAnonymousFunctionSyntaxChecker : FirDeclarationSyntaxChecker<FirAnonym

    override fun checkLightTree(
        element: FirAnonymousFunction,
-        source: FirLightSourceElement,
+        source: KtLightSourceElement,
        context: CheckerContext,
        reporter: DiagnosticReporter
    ) {
@@ -6,8 +6,8 @@
 package org.jetbrains.kotlin.fir.analysis.checkers.syntax

 import com.intellij.psi.PsiElement
+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
@@ -19,13 +19,13 @@ import org.jetbrains.kotlin.fir.expressions.impl.FirElseIfTrueCondition
 import org.jetbrains.kotlin.lexer.KtTokens

 object FirCommaInWhenConditionChecker : FirExpressionSyntaxChecker<FirWhenExpression, PsiElement>() {
-    override fun isApplicable(element: FirWhenExpression, source: FirSourceElement): Boolean {
+    override fun isApplicable(element: FirWhenExpression, source: KtSourceElement): Boolean {
        return element.subject == null
    }

    override fun checkPsiOrLightTree(
        element: FirWhenExpression,
-        source: FirSourceElement,
+        source: KtSourceElement,
        context: CheckerContext,
        reporter: DiagnosticReporter
    ) {
@@ -10,17 +10,16 @@ import com.intellij.psi.PsiElement
 import com.intellij.psi.tree.TokenSet
 import com.intellij.util.diff.FlyweightCapableTreeStructure
 import org.jetbrains.kotlin.ElementTypeUtils.getOperationSymbol
+import org.jetbrains.kotlin.ElementTypeUtils.isExpression
+import org.jetbrains.kotlin.KtLightSourceElement
 import org.jetbrains.kotlin.KtNodeTypes.*
-import org.jetbrains.kotlin.fir.FirLightSourceElement
-import org.jetbrains.kotlin.fir.FirPsiSourceElement
-import org.jetbrains.kotlin.fir.FirRealPsiSourceElement
-import org.jetbrains.kotlin.fir.FirSourceElement
+import org.jetbrains.kotlin.KtPsiSourceElement
+import org.jetbrains.kotlin.KtRealPsiSourceElement
+import org.jetbrains.kotlin.diagnostics.DiagnosticReporter
+import org.jetbrains.kotlin.diagnostics.reportOn
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.checkers.getChildren
-import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
-import org.jetbrains.kotlin.fir.analysis.diagnostics.isExpression
-import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn
 import org.jetbrains.kotlin.fir.expressions.FirWhenExpression
 import org.jetbrains.kotlin.lexer.KtTokens.*
 import org.jetbrains.kotlin.psi.*
@@ -35,7 +34,7 @@ object FirConfusingWhenBranchSyntaxChecker : FirExpressionSyntaxChecker<FirWhenE

    override fun checkLightTree(
        element: FirWhenExpression,
-        source: FirLightSourceElement,
+        source: KtLightSourceElement,
        context: CheckerContext,
        reporter: DiagnosticReporter
    ) {
@@ -48,7 +47,7 @@ object FirConfusingWhenBranchSyntaxChecker : FirExpressionSyntaxChecker<FirWhenE
                val expression = when (node.tokenType) {
                    WHEN_CONDITION_EXPRESSION -> node.getChildren(tree).firstOrNull { it.isExpression() }
                    WHEN_CONDITION_IN_RANGE -> node.getChildren(tree)
-                        .firstOrNull { it.tokenType != OPERATION_REFERENCE && it.isExpression()}
+                        .firstOrNull { it.tokenType != OPERATION_REFERENCE && it.isExpression() }
                    else -> null
                } ?: continue
                checkConditionExpression(offset, expression, tree, context, reporter)
@@ -73,14 +72,15 @@ object FirConfusingWhenBranchSyntaxChecker : FirExpressionSyntaxChecker<FirWhenE
            else -> false
        }
        if (shouldReport) {
-            val source = FirLightSourceElement(expression, offset + expression.startOffset, offset + expression.endOffset, tree)
+            val source =
+                KtLightSourceElement(expression, offset + expression.startOffset, offset + expression.endOffset, tree)
            reporter.reportOn(source, FirErrors.CONFUSING_BRANCH_CONDITION, context)
        }
    }

    override fun checkPsi(
        element: FirWhenExpression,
-        source: FirPsiSourceElement,
+        source: KtPsiSourceElement,
        psi: PsiElement,
        context: CheckerContext,
        reporter: DiagnosticReporter
@@ -111,7 +111,7 @@ object FirConfusingWhenBranchSyntaxChecker : FirExpressionSyntaxChecker<FirWhenE
            else -> false
        }
        if (shouldReport) {
-            val source = FirRealPsiSourceElement(rawExpression)
+            val source = KtRealPsiSourceElement(rawExpression)
            reporter.reportOn(source, FirErrors.CONFUSING_BRANCH_CONDITION, context)
        }
    }
@@ -5,27 +5,27 @@

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

+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.FirLightSourceElement
-import org.jetbrains.kotlin.fir.FirPsiSourceElement
-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
 import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn
 import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 import org.jetbrains.kotlin.fir.declarations.utils.isInterface
-import org.jetbrains.kotlin.fir.psi
+import org.jetbrains.kotlin.psi
 import org.jetbrains.kotlin.psi.KtClass
 import org.jetbrains.kotlin.psi.KtDelegatedSuperTypeEntry

 object FirDelegationInInterfaceSyntaxChecker : FirDeclarationSyntaxChecker<FirRegularClass, KtClass>() {

-    override fun isApplicable(element: FirRegularClass, source: FirSourceElement): Boolean = element.isInterface
+    override fun isApplicable(element: FirRegularClass, source: KtSourceElement): Boolean = element.isInterface

    override fun checkPsi(
        element: FirRegularClass,
-        source: FirPsiSourceElement,
+        source: KtPsiSourceElement,
        psi: KtClass,
        context: CheckerContext,
        reporter: DiagnosticReporter
@@ -40,7 +40,7 @@ object FirDelegationInInterfaceSyntaxChecker : FirDeclarationSyntaxChecker<FirRe

    override fun checkLightTree(
        element: FirRegularClass,
-        source: FirLightSourceElement,
+        source: KtLightSourceElement,
        context: CheckerContext,
        reporter: DiagnosticReporter
    ) {
@@ -5,10 +5,10 @@

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

-import org.jetbrains.kotlin.fir.FirFakeSourceElementKind
-import org.jetbrains.kotlin.fir.FirLightSourceElement
-import org.jetbrains.kotlin.fir.FirPsiSourceElement
-import org.jetbrains.kotlin.fir.FirSourceElement
+import org.jetbrains.kotlin.KtFakeSourceElementKind
+import org.jetbrains.kotlin.KtLightSourceElement
+import org.jetbrains.kotlin.KtPsiSourceElement
+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.declarations.FirSimpleFunction
@@ -16,12 +16,12 @@ import org.jetbrains.kotlin.psi.KtFunction
 import org.jetbrains.kotlin.psi.psiUtil.startOffset

 object FirFunctionTypeParametersSyntaxChecker : FirDeclarationSyntaxChecker<FirSimpleFunction, KtFunction>() {
-    override fun isApplicable(element: FirSimpleFunction, source: FirSourceElement): Boolean =
-        source.kind !is FirFakeSourceElementKind
+    override fun isApplicable(element: FirSimpleFunction, source: KtSourceElement): Boolean =
+        source.kind !is KtFakeSourceElementKind

    override fun checkPsi(
        element: FirSimpleFunction,
-        source: FirPsiSourceElement,
+        source: KtPsiSourceElement,
        psi: KtFunction,
        context: CheckerContext,
        reporter: DiagnosticReporter
@@ -40,7 +40,7 @@ object FirFunctionTypeParametersSyntaxChecker : FirDeclarationSyntaxChecker<FirS

    override fun checkLightTree(
        element: FirSimpleFunction,
-        source: FirLightSourceElement,
+        source: KtLightSourceElement,
        context: CheckerContext,
        reporter: DiagnosticReporter
    ) {
@@ -5,8 +5,10 @@

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

+import org.jetbrains.kotlin.KtFakeSourceElementKind
+import org.jetbrains.kotlin.KtPsiSourceElement
+import org.jetbrains.kotlin.KtSourceElement
 import org.jetbrains.kotlin.config.LanguageFeature
-import org.jetbrains.kotlin.fir.*
 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,12 +20,12 @@ import org.jetbrains.kotlin.psi.KtProperty

 // KtExpression is the appropriate PsiElement type; local variables are used in increments/decrements of dot-qualified expressions.
 object FirLocalVariableTypeParametersSyntaxChecker : FirDeclarationSyntaxChecker<FirProperty, KtExpression>() {
-    override fun isApplicable(element: FirProperty, source: FirSourceElement): Boolean =
-        source.kind !is FirFakeSourceElementKind && element.isLocal
+    override fun isApplicable(element: FirProperty, source: KtSourceElement): Boolean =
+        source.kind !is KtFakeSourceElementKind && element.isLocal

    override fun checkPsi(
        element: FirProperty,
-        source: FirPsiSourceElement,
+        source: KtPsiSourceElement,
        psi: KtExpression,
        context: CheckerContext,
        reporter: DiagnosticReporter
@@ -38,7 +40,7 @@ object FirLocalVariableTypeParametersSyntaxChecker : FirDeclarationSyntaxChecker

    override fun checkLightTree(
        element: FirProperty,
-        source: FirLightSourceElement,
+        source: KtLightSourceElement,
        context: CheckerContext,
        reporter: DiagnosticReporter
    ) {
@@ -6,10 +6,10 @@
 package org.jetbrains.kotlin.fir.analysis.checkers.syntax

 import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.KtLightSourceElement
+import org.jetbrains.kotlin.KtPsiSourceElement
+import org.jetbrains.kotlin.KtSourceElement
 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.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirDeclarationChecker
 import org.jetbrains.kotlin.fir.analysis.checkers.expression.FirExpressionChecker
@@ -30,25 +30,25 @@ interface FirSyntaxChecker<in D : FirElement, P : PsiElement> {
        if (!isApplicable(element, source)) return
        @Suppress("UNCHECKED_CAST")
        when (source) {
-            is FirPsiSourceElement -> checkPsi(element, source, source.psi as P, context, reporter)
-            is FirLightSourceElement -> checkLightTree(element, source, context, reporter)
+            is KtPsiSourceElement -> checkPsi(element, source, source.psi as P, context, reporter)
+            is KtLightSourceElement -> checkLightTree(element, source, context, reporter)
        }
    }

-    fun isApplicable(element: D, source: FirSourceElement): Boolean = true
+    fun isApplicable(element: D, source: KtSourceElement): Boolean = true

-    fun checkPsi(element: D, source: FirPsiSourceElement, psi: P, context: CheckerContext, reporter: DiagnosticReporter) {
+    fun checkPsi(element: D, source: KtPsiSourceElement, psi: P, context: CheckerContext, reporter: DiagnosticReporter) {
        checkPsiOrLightTree(element, source, context, reporter)
    }

-    fun checkLightTree(element: D, source: FirLightSourceElement, context: CheckerContext, reporter: DiagnosticReporter) {
+    fun checkLightTree(element: D, source: KtLightSourceElement, context: CheckerContext, reporter: DiagnosticReporter) {
        checkPsiOrLightTree(element, source, context, reporter)
    }

    /**
     *  By default psi tree should be equivalent to light tree and can be processed the same way.
     */
-    fun checkPsiOrLightTree(element: D, source: FirSourceElement, context: CheckerContext, reporter: DiagnosticReporter) {}
+    fun checkPsiOrLightTree(element: D, source: KtSourceElement, context: CheckerContext, reporter: DiagnosticReporter) {}
 }

 abstract class FirDeclarationSyntaxChecker<in D : FirDeclaration, P : PsiElement> :
@@ -5,8 +5,8 @@

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

-import org.jetbrains.kotlin.fir.FirPsiSourceElement
-import org.jetbrains.kotlin.fir.FirSourceElement
+import org.jetbrains.kotlin.KtPsiSourceElement
+import org.jetbrains.kotlin.KtSourceElement
 import org.jetbrains.kotlin.fir.analysis.checkers.SourceNavigator.Companion.withNavigator
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
@@ -19,12 +19,12 @@ import org.jetbrains.kotlin.psi.KtTypeParameter

 object FirTypeParameterSyntaxChecker : FirDeclarationSyntaxChecker<FirTypeParameter, KtTypeParameter>() {

-    override fun isApplicable(element: FirTypeParameter, source: FirSourceElement): Boolean =
+    override fun isApplicable(element: FirTypeParameter, source: KtSourceElement): Boolean =
        element.bounds.size >= 2

    override fun checkPsi(
        element: FirTypeParameter,
-        source: FirPsiSourceElement,
+        source: KtPsiSourceElement,
        psi: KtTypeParameter,
        context: CheckerContext,
        reporter: DiagnosticReporter
@@ -37,7 +37,7 @@ object FirTypeParameterSyntaxChecker : FirDeclarationSyntaxChecker<FirTypeParame

    override fun checkPsiOrLightTree(
        element: FirTypeParameter,
-        source: FirSourceElement,
+        source: KtSourceElement,
        context: CheckerContext,
        reporter: DiagnosticReporter
    ) {
@@ -5,12 +5,10 @@

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

-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.context.findClosest
 import org.jetbrains.kotlin.fir.analysis.checkers.expression.FirDeprecationChecker
 import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
-import org.jetbrains.kotlin.fir.declarations.FirPropertyAccessor
 import org.jetbrains.kotlin.fir.resolve.toSymbol
 import org.jetbrains.kotlin.fir.types.ConeClassLikeType
 import org.jetbrains.kotlin.fir.types.FirTypeRef
@@ -19,7 +17,7 @@ import org.jetbrains.kotlin.fir.types.coneTypeSafe
 object FirDeprecatedTypeChecker : FirTypeRefChecker() {
    override fun check(typeRef: FirTypeRef, context: CheckerContext, reporter: DiagnosticReporter) {
        val source = typeRef.source ?: return
-        if (source.kind is FirFakeSourceElementKind) return
+        if (source.kind is KtFakeSourceElementKind) return
        val resolved = typeRef.coneTypeSafe<ConeClassLikeType>() ?: return
        val symbol = resolved.lookupTag.toSymbol(context.session) ?: return

@@ -6,7 +6,7 @@
 package org.jetbrains.kotlin.fir.analysis.checkers.type

 import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
-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.FirOptInUsageBaseChecker
 import org.jetbrains.kotlin.fir.analysis.checkers.getAnnotationClassForOptInMarker
@@ -32,7 +32,7 @@ object FirOptInUsageTypeRefChecker : FirTypeRefChecker() {
    @OptIn(SymbolInternals::class)
    override fun check(typeRef: FirTypeRef, context: CheckerContext, reporter: DiagnosticReporter) {
        val source = typeRef.source
-        if (source?.kind !is FirRealSourceElementKind) return
+        if (source?.kind !is KtRealSourceElementKind) return
        // coneTypeSafe filters out all delegatedTypeRefs from here
        val coneType = typeRef.coneTypeSafe<ConeClassLikeType>() ?: return

@@ -5,9 +5,9 @@

 package org.jetbrains.kotlin.fir.analysis.collectors

+import org.jetbrains.kotlin.KtFakeSourceElementKind
 import org.jetbrains.kotlin.fir.FirAnnotationContainer
 import org.jetbrains.kotlin.fir.FirElement
-import org.jetbrains.kotlin.fir.FirFakeSourceElementKind
 import org.jetbrains.kotlin.fir.PrivateForInline
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.declarations.*
@@ -160,7 +160,7 @@ abstract class AbstractDiagnosticCollectorVisitor(
    }

    override fun visitTypeRef(typeRef: FirTypeRef, data: Nothing?) {
-        if (typeRef.source != null && typeRef.source?.kind !is FirFakeSourceElementKind) {
+        if (typeRef.source != null && typeRef.source?.kind !is KtFakeSourceElementKind) {
            withAnnotationContainer(typeRef) {
                checkElement(typeRef)
                visitNestedElements(typeRef)
@@ -179,7 +179,7 @@ abstract class AbstractDiagnosticCollectorVisitor(
        if (resolvedTypeRef.type is ConeClassErrorType) {
            super.visitResolvedTypeRef(resolvedTypeRef, data)
        }
-        if (resolvedTypeRef.source?.kind is FirFakeSourceElementKind) return
+        if (resolvedTypeRef.source?.kind is KtFakeSourceElementKind) return

        //the note about is just wrong
        //if we don't visit resolved type we can't make any diagnostics on them
@@ -5,10 +5,10 @@

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

+import org.jetbrains.kotlin.KtFakeSourceElementKind
+import org.jetbrains.kotlin.KtSourceElement
 import org.jetbrains.kotlin.KtNodeTypes
-import org.jetbrains.kotlin.fir.FirFakeSourceElementKind
 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.toFirDiagnostics
@@ -59,7 +59,7 @@ class ErrorNodeDiagnosticCollectorComponent(
        // Don't report duplicated unresolved reference on annotation entry (already reported on its type)
        if (source.elementType == KtNodeTypes.ANNOTATION_ENTRY && errorNamedReference.diagnostic is ConeUnresolvedNameError) return
        // Already reported in FirConventionFunctionCallChecker
-        if (source.kind == FirFakeSourceElementKind.ArrayAccessNameReference &&
+        if (source.kind == KtFakeSourceElementKind.ArrayAccessNameReference &&
            errorNamedReference.diagnostic is ConeUnresolvedNameError
        ) return

@@ -106,10 +106,10 @@ class ErrorNodeDiagnosticCollectorComponent(

    private fun reportFirDiagnostic(
        diagnostic: ConeDiagnostic,
-        source: FirSourceElement,
+        source: KtSourceElement,
        reporter: DiagnosticReporter,
        context: CheckerContext,
-        qualifiedAccessSource: FirSourceElement? = null
+        qualifiedAccessSource: KtSourceElement? = null
    ) {
        // Will be handled by [FirDestructuringDeclarationChecker]
        if (source.elementType == KtNodeTypes.DESTRUCTURING_DECLARATION_ENTRY) {
@@ -117,13 +117,13 @@ class ErrorNodeDiagnosticCollectorComponent(
        }

        // Will be handled by [FirDelegatedPropertyChecker]
-        if (source.kind == FirFakeSourceElementKind.DelegatedPropertyAccessor &&
+        if (source.kind == KtFakeSourceElementKind.DelegatedPropertyAccessor &&
            (diagnostic is ConeUnresolvedNameError || diagnostic is ConeAmbiguityError || diagnostic is ConeInapplicableWrongReceiver || diagnostic is ConeInapplicableCandidateError)
        ) {
            return
        }

-        if (source.kind == FirFakeSourceElementKind.ImplicitConstructor || source.kind == FirFakeSourceElementKind.DesugaredForLoop) {
+        if (source.kind == KtFakeSourceElementKind.ImplicitConstructor || source.kind == KtFakeSourceElementKind.DesugaredForLoop) {
            // See FirForLoopChecker
            return
        }
@@ -5,9 +5,8 @@

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

+import org.jetbrains.kotlin.KtSourceElement
 import org.jetbrains.kotlin.fir.FirAnnotationContainer
-import org.jetbrains.kotlin.fir.FirElement
-import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.collectors.AbstractDiagnosticCollector
 import org.jetbrains.kotlin.fir.languageVersionSettings
@@ -18,7 +17,7 @@ abstract class DiagnosticReporter {

@OptIn(InternalDiagnosticFactoryMethod::class)
 fun DiagnosticReporter.reportOn(
-    source: FirSourceElement?,
+    source: KtSourceElement?,
    factory: FirDiagnosticFactory0,
    context: CheckerContext,
    positioningStrategy: SourceElementPositioningStrategy? = null
@@ -28,7 +27,7 @@ fun DiagnosticReporter.reportOn(

@OptIn(InternalDiagnosticFactoryMethod::class)
 fun <A : Any> DiagnosticReporter.reportOn(
-    source: FirSourceElement?,
+    source: KtSourceElement?,
    factory: FirDiagnosticFactory1<A>,
    a: A,
    context: CheckerContext,
@@ -39,7 +38,7 @@ fun <A : Any> DiagnosticReporter.reportOn(

@OptIn(InternalDiagnosticFactoryMethod::class)
 fun <A : Any, B : Any> DiagnosticReporter.reportOn(
-    source: FirSourceElement?,
+    source: KtSourceElement?,
    factory: FirDiagnosticFactory2<A, B>,
    a: A,
    b: B,
@@ -51,7 +50,7 @@ fun <A : Any, B : Any> DiagnosticReporter.reportOn(

@OptIn(InternalDiagnosticFactoryMethod::class)
 fun <A : Any, B : Any, C : Any> DiagnosticReporter.reportOn(
-    source: FirSourceElement?,
+    source: KtSourceElement?,
    factory: FirDiagnosticFactory3<A, B, C>,
    a: A,
    b: B,
@@ -64,7 +63,7 @@ fun <A : Any, B : Any, C : Any> DiagnosticReporter.reportOn(

@OptIn(InternalDiagnosticFactoryMethod::class)
 fun <A : Any, B : Any, C : Any, D : Any> DiagnosticReporter.reportOn(
-    source: FirSourceElement?,
+    source: KtSourceElement?,
    factory: FirDiagnosticFactory4<A, B, C, D>,
    a: A,
    b: B,
@@ -78,7 +77,7 @@ fun <A : Any, B : Any, C : Any, D : Any> DiagnosticReporter.reportOn(

@OptIn(InternalDiagnosticFactoryMethod::class)
 fun DiagnosticReporter.reportOn(
-    source: FirSourceElement?,
+    source: KtSourceElement?,
    factory: FirDiagnosticFactoryForDeprecation0,
    context: CheckerContext,
    positioningStrategy: SourceElementPositioningStrategy? = null
@@ -88,7 +87,7 @@ fun DiagnosticReporter.reportOn(

@OptIn(InternalDiagnosticFactoryMethod::class)
 fun <A : Any> DiagnosticReporter.reportOn(
-    source: FirSourceElement?,
+    source: KtSourceElement?,
    factory: FirDiagnosticFactoryForDeprecation1<A>,
    a: A,
    context: CheckerContext,
@@ -99,7 +98,7 @@ fun <A : Any> DiagnosticReporter.reportOn(

@OptIn(InternalDiagnosticFactoryMethod::class)
 fun <A : Any, B : Any> DiagnosticReporter.reportOn(
-    source: FirSourceElement?,
+    source: KtSourceElement?,
    factory: FirDiagnosticFactoryForDeprecation2<A, B>,
    a: A,
    b: B,
@@ -111,7 +110,7 @@ fun <A : Any, B : Any> DiagnosticReporter.reportOn(

@OptIn(InternalDiagnosticFactoryMethod::class)
 fun <A : Any, B : Any, C : Any> DiagnosticReporter.reportOn(
-    source: FirSourceElement?,
+    source: KtSourceElement?,
    factory: FirDiagnosticFactoryForDeprecation3<A, B, C>,
    a: A,
    b: B,
@@ -124,7 +123,7 @@ fun <A : Any, B : Any, C : Any> DiagnosticReporter.reportOn(

@OptIn(InternalDiagnosticFactoryMethod::class)
 fun <A : Any, B : Any, C : Any, D : Any> DiagnosticReporter.reportOn(
-    source: FirSourceElement?,
+    source: KtSourceElement?,
    factory: FirDiagnosticFactoryForDeprecation4<A, B, C, D>,
    a: A,
    b: B,
@@ -8,15 +8,15 @@ package org.jetbrains.kotlin.fir.analysis.diagnostics
 import com.intellij.openapi.util.TextRange
 import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiFile
+import org.jetbrains.kotlin.KtLightSourceElement
+import org.jetbrains.kotlin.KtPsiSourceElement
+import org.jetbrains.kotlin.KtSourceElement
 import org.jetbrains.kotlin.diagnostics.*
-import org.jetbrains.kotlin.fir.FirLightSourceElement
-import org.jetbrains.kotlin.fir.FirPsiSourceElement
-import org.jetbrains.kotlin.fir.FirSourceElement

 // ------------------------------ diagnostics ------------------------------

 sealed class FirDiagnostic : DiagnosticMarker {
-    abstract val element: FirSourceElement
+    abstract val element: KtSourceElement
    abstract val severity: Severity
    abstract val factory: AbstractFirDiagnosticFactory
    abstract val positioningStrategy: SourceElementPositioningStrategy
@@ -65,7 +65,7 @@ sealed class FirDiagnosticWithParameters4<A, B, C, D> : FirDiagnostic(), Diagnos

 interface FirPsiDiagnostic : DiagnosticMarker {
    val factory: AbstractFirDiagnosticFactory
-    val element: FirPsiSourceElement
+    val element: KtPsiSourceElement
    val textRanges: List<TextRange>
    val severity: Severity

@@ -87,7 +87,7 @@ private fun FirPsiDiagnostic.checkPsiTypeConsistency() {
 }

 data class FirPsiSimpleDiagnostic(
-    override val element: FirPsiSourceElement,
+    override val element: KtPsiSourceElement,
    override val severity: Severity,
    override val factory: FirDiagnosticFactory0,
    override val positioningStrategy: SourceElementPositioningStrategy
@@ -98,7 +98,7 @@ data class FirPsiSimpleDiagnostic(
 }

 data class FirPsiDiagnosticWithParameters1<A>(
-    override val element: FirPsiSourceElement,
+    override val element: KtPsiSourceElement,
    override val a: A,
    override val severity: Severity,
    override val factory: FirDiagnosticFactory1<A>,
@@ -111,7 +111,7 @@ data class FirPsiDiagnosticWithParameters1<A>(


 data class FirPsiDiagnosticWithParameters2<A, B>(
-    override val element: FirPsiSourceElement,
+    override val element: KtPsiSourceElement,
    override val a: A,
    override val b: B,
    override val severity: Severity,
@@ -124,7 +124,7 @@ data class FirPsiDiagnosticWithParameters2<A, B>(
 }

 data class FirPsiDiagnosticWithParameters3<A, B, C>(
-    override val element: FirPsiSourceElement,
+    override val element: KtPsiSourceElement,
    override val a: A,
    override val b: B,
    override val c: C,
@@ -138,7 +138,7 @@ data class FirPsiDiagnosticWithParameters3<A, B, C>(
 }

 data class FirPsiDiagnosticWithParameters4<A, B, C, D>(
-    override val element: FirPsiSourceElement,
+    override val element: KtPsiSourceElement,
    override val a: A,
    override val b: B,
    override val c: C,
@@ -155,7 +155,7 @@ data class FirPsiDiagnosticWithParameters4<A, B, C, D>(
 // ------------------------------ light tree diagnostics ------------------------------

 interface FirLightDiagnostic : DiagnosticMarker {
-    val element: FirLightSourceElement
+    val element: KtLightSourceElement

    @Deprecated("Should not be called", level = DeprecationLevel.HIDDEN)
    override val psiElement: PsiElement
@@ -163,14 +163,14 @@ interface FirLightDiagnostic : DiagnosticMarker {
 }

 data class FirLightSimpleDiagnostic(
-    override val element: FirLightSourceElement,
+    override val element: KtLightSourceElement,
    override val severity: Severity,
    override val factory: FirDiagnosticFactory0,
    override val positioningStrategy: SourceElementPositioningStrategy
 ) : FirSimpleDiagnostic(), FirLightDiagnostic

 data class FirLightDiagnosticWithParameters1<A>(
-    override val element: FirLightSourceElement,
+    override val element: KtLightSourceElement,
    override val a: A,
    override val severity: Severity,
    override val factory: FirDiagnosticFactory1<A>,
@@ -178,7 +178,7 @@ data class FirLightDiagnosticWithParameters1<A>(
 ) : FirDiagnosticWithParameters1<A>(), FirLightDiagnostic

 data class FirLightDiagnosticWithParameters2<A, B>(
-    override val element: FirLightSourceElement,
+    override val element: KtLightSourceElement,
    override val a: A,
    override val b: B,
    override val severity: Severity,
@@ -187,7 +187,7 @@ data class FirLightDiagnosticWithParameters2<A, B>(
 ) : FirDiagnosticWithParameters2<A, B>(), FirLightDiagnostic

 data class FirLightDiagnosticWithParameters3<A, B, C>(
-    override val element: FirLightSourceElement,
+    override val element: KtLightSourceElement,
    override val a: A,
    override val b: B,
    override val c: C,
@@ -197,7 +197,7 @@ data class FirLightDiagnosticWithParameters3<A, B, C>(
 ) : FirDiagnosticWithParameters3<A, B, C>(), FirLightDiagnostic

 data class FirLightDiagnosticWithParameters4<A, B, C, D>(
-    override val element: FirLightSourceElement,
+    override val element: KtLightSourceElement,
    override val a: A,
    override val b: B,
    override val c: C,
@@ -2,11 +2,11 @@

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

+import org.jetbrains.kotlin.KtLightSourceElement
+import org.jetbrains.kotlin.KtPsiSourceElement
+import org.jetbrains.kotlin.KtSourceElement
 import org.jetbrains.kotlin.config.LanguageFeature
 import org.jetbrains.kotlin.diagnostics.Severity
-import org.jetbrains.kotlin.fir.FirLightSourceElement
-import org.jetbrains.kotlin.fir.FirPsiSourceElement
-import org.jetbrains.kotlin.fir.FirSourceElement
 import kotlin.reflect.KClass

@RequiresOptIn("Please use DiagnosticReporter.reportOn method if possible")
@@ -35,14 +35,14 @@ class FirDiagnosticFactory0(

    @InternalDiagnosticFactoryMethod
    fun on(
-        element: FirSourceElement,
+        element: KtSourceElement,
        positioningStrategy: SourceElementPositioningStrategy?
    ): FirSimpleDiagnostic {
        return when (element) {
-            is FirPsiSourceElement -> FirPsiSimpleDiagnostic(
+            is KtPsiSourceElement -> FirPsiSimpleDiagnostic(
                element, severity, this, positioningStrategy ?: defaultPositioningStrategy
            )
-            is FirLightSourceElement -> FirLightSimpleDiagnostic(element, severity, this, positioningStrategy ?: defaultPositioningStrategy)
+            is KtLightSourceElement -> FirLightSimpleDiagnostic(element, severity, this, positioningStrategy ?: defaultPositioningStrategy)
            else -> incorrectElement(element)
        }
    }
@@ -61,15 +61,15 @@ class FirDiagnosticFactory1<A>(

    @InternalDiagnosticFactoryMethod
    fun on(
-        element: FirSourceElement,
+        element: KtSourceElement,
        a: A,
        positioningStrategy: SourceElementPositioningStrategy?
    ): FirDiagnosticWithParameters1<A> {
        return when (element) {
-            is FirPsiSourceElement -> FirPsiDiagnosticWithParameters1(
+            is KtPsiSourceElement -> FirPsiDiagnosticWithParameters1(
                element, a, severity, this, positioningStrategy ?: defaultPositioningStrategy
            )
-            is FirLightSourceElement -> FirLightDiagnosticWithParameters1(
+            is KtLightSourceElement -> FirLightDiagnosticWithParameters1(
                element,
                a,
                severity,
@@ -95,16 +95,16 @@ class FirDiagnosticFactory2<A, B>(

    @InternalDiagnosticFactoryMethod
    fun on(
-        element: FirSourceElement,
+        element: KtSourceElement,
        a: A,
        b: B,
        positioningStrategy: SourceElementPositioningStrategy?
    ): FirDiagnosticWithParameters2<A, B> {
        return when (element) {
-            is FirPsiSourceElement -> FirPsiDiagnosticWithParameters2(
+            is KtPsiSourceElement -> FirPsiDiagnosticWithParameters2(
                element, a, b, severity, this, positioningStrategy ?: defaultPositioningStrategy
            )
-            is FirLightSourceElement -> FirLightDiagnosticWithParameters2(
+            is KtLightSourceElement -> FirLightDiagnosticWithParameters2(
                element,
                a,
                b,
@@ -132,17 +132,17 @@ class FirDiagnosticFactory3<A, B, C>(

    @InternalDiagnosticFactoryMethod
    fun on(
-        element: FirSourceElement,
+        element: KtSourceElement,
        a: A,
        b: B,
        c: C,
        positioningStrategy: SourceElementPositioningStrategy?
    ): FirDiagnosticWithParameters3<A, B, C> {
        return when (element) {
-            is FirPsiSourceElement -> FirPsiDiagnosticWithParameters3(
+            is KtPsiSourceElement -> FirPsiDiagnosticWithParameters3(
                element, a, b, c, severity, this, positioningStrategy ?: defaultPositioningStrategy
            )
-            is FirLightSourceElement -> FirLightDiagnosticWithParameters3(
+            is KtLightSourceElement -> FirLightDiagnosticWithParameters3(
                element,
                a,
                b,
@@ -172,7 +172,7 @@ class FirDiagnosticFactory4<A, B, C, D>(

    @InternalDiagnosticFactoryMethod
    fun on(
-        element: FirSourceElement,
+        element: KtSourceElement,
        a: A,
        b: B,
        c: C,
@@ -180,10 +180,10 @@ class FirDiagnosticFactory4<A, B, C, D>(
        positioningStrategy: SourceElementPositioningStrategy?
    ): FirDiagnosticWithParameters4<A, B, C, D> {
        return when (element) {
-            is FirPsiSourceElement -> FirPsiDiagnosticWithParameters4(
+            is KtPsiSourceElement -> FirPsiDiagnosticWithParameters4(
                element, a, b, c, d, severity, this, positioningStrategy ?: defaultPositioningStrategy
            )
-            is FirLightSourceElement -> FirLightDiagnosticWithParameters4(
+            is KtLightSourceElement -> FirLightDiagnosticWithParameters4(
                element,
                a,
                b,
@@ -198,7 +198,7 @@ class FirDiagnosticFactory4<A, B, C, D>(
    }
 }

-private fun incorrectElement(element: FirSourceElement): Nothing {
+private fun incorrectElement(element: KtSourceElement): Nothing {
    throw IllegalArgumentException("Unknown element type: ${element::class}")
 }

@@ -7,12 +7,12 @@ package org.jetbrains.kotlin.fir.analysis.diagnostics

 import com.intellij.openapi.util.TextRange
 import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.KtPsiSourceElement
+import org.jetbrains.kotlin.KtSourceElement
 import org.jetbrains.kotlin.cfg.UnreachableCode
 import org.jetbrains.kotlin.diagnostics.DiagnosticMarker
 import org.jetbrains.kotlin.diagnostics.PositioningStrategy
-import org.jetbrains.kotlin.fir.FirPsiSourceElement
-import org.jetbrains.kotlin.fir.FirSourceElement
-import org.jetbrains.kotlin.fir.psi
+import org.jetbrains.kotlin.psi
 import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.psi.KtNamedDeclaration

@@ -22,8 +22,8 @@ object FirPsiPositioningStrategies {
        override fun markDiagnostic(diagnostic: DiagnosticMarker): List<TextRange> {
            //todo it is better to implement arguments extraction in FirDiagnosticFactory, but kotlin struggle with checking types in it atm
            @Suppress("UNCHECKED_CAST")
-            val typed = diagnostic as FirDiagnosticWithParameters2<Set<FirSourceElement>, Set<FirSourceElement>>
-            val source = diagnostic.element as FirPsiSourceElement
+            val typed = diagnostic as FirDiagnosticWithParameters2<Set<KtSourceElement>, Set<KtSourceElement>>
+            val source = diagnostic.element as KtPsiSourceElement
            return UnreachableCode.getUnreachableTextRanges(
                source.psi as KtElement,
                typed.a.mapNotNull { it.psi as? KtElement }.toSet(),
@@ -11,10 +11,10 @@ import com.intellij.openapi.util.TextRange
 import com.intellij.psi.tree.IElementType
 import com.intellij.psi.tree.TokenSet
 import com.intellij.util.diff.FlyweightCapableTreeStructure
+import org.jetbrains.kotlin.KtSourceElement
 import org.jetbrains.kotlin.KtNodeType
 import org.jetbrains.kotlin.KtNodeTypes
 import org.jetbrains.kotlin.diagnostics.PositioningStrategies
-import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.lexer.KtTokens.MODALITY_MODIFIERS
 import org.jetbrains.kotlin.lexer.KtTokens.VISIBILITY_MODIFIERS
@@ -968,9 +968,9 @@ object LightTreePositioningStrategies {
    }

    val UNREACHABLE_CODE: LightTreePositioningStrategy = object : LightTreePositioningStrategy() {
-        override fun markFirDiagnostic(element: FirSourceElement, diagnostic: FirDiagnostic): List<TextRange> {
+        override fun markFirDiagnostic(element: KtSourceElement, diagnostic: FirDiagnostic): List<TextRange> {
            @Suppress("UNCHECKED_CAST")
-            val typed = diagnostic as FirDiagnosticWithParameters2<Set<FirSourceElement>, Set<FirSourceElement>>
+            val typed = diagnostic as FirDiagnosticWithParameters2<Set<KtSourceElement>, Set<KtSourceElement>>
            with(UnreachableCodeLightTreeHelper(element.treeStructure)) {
                val reachable = typed.a.map { it.lighterASTNode }.toSet()
                val unreachable = typed.b.map { it.lighterASTNode }.toSet()
@@ -1055,13 +1055,13 @@ object LightTreePositioningStrategies {
    )
 }

-fun FirSourceElement.hasValOrVar(): Boolean =
+fun KtSourceElement.hasValOrVar(): Boolean =
    treeStructure.valOrVarKeyword(lighterASTNode) != null

-fun FirSourceElement.hasVar(): Boolean =
+fun KtSourceElement.hasVar(): Boolean =
    treeStructure.findChildByType(lighterASTNode, KtTokens.VAR_KEYWORD) != null

-fun FirSourceElement.hasPrimaryConstructor(): Boolean =
+fun KtSourceElement.hasPrimaryConstructor(): Boolean =
    treeStructure.primaryConstructor(lighterASTNode) != null

 private fun FlyweightCapableTreeStructure<LighterASTNode>.companionKeyword(node: LighterASTNode): LighterASTNode? =
--- a/Show More
+++ b/Show More