[FIR] Introduce FirSourceElement instead of FirElement as source in fir nodes

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/ConversionUtils.kt

@@ -8,6 +8,7 @@ package org.jetbrains.kotlin.fir.backend
 import com.intellij.psi.PsiCompiledElement
 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.psi
 import org.jetbrains.kotlin.fir.references.FirReference
 import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
 import org.jetbrains.kotlin.fir.references.FirThisReference

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrConverter.kt

@@ -9,6 +9,7 @@ import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirFile
 import org.jetbrains.kotlin.fir.descriptors.FirModuleDescriptor
+import org.jetbrains.kotlin.fir.psi
 import org.jetbrains.kotlin.ir.declarations.IrFile
 import org.jetbrains.kotlin.ir.declarations.IrModuleFragment
 import org.jetbrains.kotlin.ir.declarations.impl.IrModuleFragmentImpl

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrDeclarationStorage.kt

@@ -15,8 +15,11 @@ import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyGetter
 import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertySetter
 import org.jetbrains.kotlin.fir.descriptors.FirModuleDescriptor
 import org.jetbrains.kotlin.fir.descriptors.FirPackageFragmentDescriptor
+import org.jetbrains.kotlin.fir.psi
 import org.jetbrains.kotlin.fir.render
-import org.jetbrains.kotlin.fir.resolve.*
+import org.jetbrains.kotlin.fir.resolve.firProvider
+import org.jetbrains.kotlin.fir.resolve.firSymbolProvider
+import org.jetbrains.kotlin.fir.resolve.getOrPut
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrVisitor.kt

@@ -7,8 +7,7 @@ package org.jetbrains.kotlin.fir.backend
 
 import org.jetbrains.kotlin.backend.common.descriptors.WrappedValueParameterDescriptor
 import org.jetbrains.kotlin.descriptors.*
-import org.jetbrains.kotlin.fir.FirElement
-import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.*
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyGetter
 import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertySetter
@@ -20,7 +19,6 @@ import org.jetbrains.kotlin.fir.expressions.impl.FirUnitExpression
 import org.jetbrains.kotlin.fir.references.FirReference
 import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
 import org.jetbrains.kotlin.fir.references.impl.FirPropertyFromParameterResolvedNamedReference
-import org.jetbrains.kotlin.fir.render
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.buildUseSiteMemberScope
 import org.jetbrains.kotlin.fir.resolve.calls.SyntheticPropertySymbol
@@ -29,7 +27,6 @@ import org.jetbrains.kotlin.fir.resolve.toSymbol
 import org.jetbrains.kotlin.fir.scopes.ProcessorAction
 import org.jetbrains.kotlin.fir.scopes.impl.FirClassSubstitutionScope
 import org.jetbrains.kotlin.fir.symbols.impl.*
-import org.jetbrains.kotlin.fir.typeContext
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.fir.visitors.FirDefaultVisitor
 import org.jetbrains.kotlin.ir.IrElement

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/FirJavaElementFinder.kt

@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.*
-import org.jetbrains.kotlin.fir.resolve.FirProvider
+import org.jetbrains.kotlin.fir.psi
 import org.jetbrains.kotlin.fir.resolve.directExpansionType
 import org.jetbrains.kotlin.fir.resolve.firProvider
 import org.jetbrains.kotlin.fir.resolve.toSymbol

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/FirJavaElementFinder.kt.183

@@ -23,6 +23,7 @@ import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.*
+import org.jetbrains.kotlin.fir.psi
 import org.jetbrains.kotlin.fir.resolve.FirProvider
 import org.jetbrains.kotlin.fir.resolve.directExpansionType
 import org.jetbrains.kotlin.fir.resolve.firProvider

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaSymbolProvider.kt

@@ -28,6 +28,7 @@ import org.jetbrains.kotlin.fir.scopes.impl.FirSuperTypeScope
 import org.jetbrains.kotlin.fir.scopes.impl.declaredMemberScope
 import org.jetbrains.kotlin.fir.symbols.CallableId
 import org.jetbrains.kotlin.fir.symbols.impl.*
+import org.jetbrains.kotlin.fir.toFirSourceElement
 import org.jetbrains.kotlin.fir.types.ConeClassErrorType
 import org.jetbrains.kotlin.fir.types.impl.ConeTypeParameterTypeImpl
 import org.jetbrains.kotlin.fir.types.impl.FirResolvedTypeRefImpl
@@ -175,7 +176,7 @@ class JavaSymbolProvider(
                     }
                 }
                 FirJavaClass(
-                    (javaClass as? JavaElementImpl<*>)?.psi, session,
+                    (javaClass as? JavaElementImpl<*>)?.psi?.toFirSourceElement(), session,
                     firSymbol as FirClassSymbol, javaClass.name,
                     javaClass.visibility, javaClass.modality,
                     javaClass.classKind, isTopLevel = isTopLevel,
@@ -195,7 +196,7 @@ class JavaSymbolProvider(
                         val fieldSymbol = FirFieldSymbol(fieldId)
                         val returnType = javaField.type
                         val firJavaField = FirJavaField(
-                            (javaField as? JavaElementImpl<*>)?.psi, this@JavaSymbolProvider.session,
+                            (javaField as? JavaElementImpl<*>)?.psi?.toFirSourceElement(), this@JavaSymbolProvider.session,
                             fieldSymbol, fieldName,
                             javaField.visibility, javaField.modality,
                             returnTypeRef = returnType.toFirJavaTypeRef(this@JavaSymbolProvider.session, javaTypeParameterStack),
@@ -212,7 +213,7 @@ class JavaSymbolProvider(
                         val methodSymbol = FirNamedFunctionSymbol(methodId)
                         val returnType = javaMethod.returnType
                         val firJavaMethod = FirJavaMethod(
-                            this@JavaSymbolProvider.session, (javaMethod as? JavaElementImpl<*>)?.psi,
+                            this@JavaSymbolProvider.session, (javaMethod as? JavaElementImpl<*>)?.psi?.toFirSourceElement(),
                             methodSymbol, methodName,
                             javaMethod.visibility, javaMethod.modality,
                             returnTypeRef = returnType.toFirJavaTypeRef(this@JavaSymbolProvider.session, javaTypeParameterStack),
@@ -239,7 +240,7 @@ class JavaSymbolProvider(
                         val constructorSymbol = FirConstructorSymbol(constructorId)
                         val classTypeParameters = javaClass.typeParameters.convertTypeParameters(javaTypeParameterStack)
                         val firJavaConstructor = FirJavaConstructor(
-                            psi,
+                            psi?.toFirSourceElement(),
                             this@JavaSymbolProvider.session,
                             constructorSymbol,
                             visibility,

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaUtils.kt

@@ -29,6 +29,7 @@ import org.jetbrains.kotlin.fir.resolve.getClassDeclaredCallableSymbols
 import org.jetbrains.kotlin.fir.symbols.StandardClassIds
 import org.jetbrains.kotlin.fir.symbols.impl.ConeClassLikeLookupTagImpl
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
+import org.jetbrains.kotlin.fir.toFirSourceElement
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.fir.types.impl.ConeClassTypeImpl
 import org.jetbrains.kotlin.fir.types.impl.ConeTypeParameterTypeImpl
@@ -94,7 +95,7 @@ internal fun JavaClassifierType.toFirResolvedTypeRef(
 ): FirResolvedTypeRef {
     val coneType = this.toConeKotlinTypeWithNullability(session, javaTypeParameterStack, isNullable = false)
     return FirResolvedTypeRefImpl(
-        psi = null, type = coneType
+        source = null, type = coneType
     ).apply {
         annotations += this@toFirResolvedTypeRef.annotations.map { it.toFirAnnotationCall(session, javaTypeParameterStack) }
     }
@@ -174,9 +175,9 @@ internal fun JavaAnnotation.toFirAnnotationCall(
     session: FirSession, javaTypeParameterStack: JavaTypeParameterStack
 ): FirAnnotationCall {
     return FirAnnotationCallImpl(
-        psi = null, useSiteTarget = null,
+        source = null, useSiteTarget = null,
         annotationTypeRef = FirResolvedTypeRefImpl(
-            psi = null,
+            source = null,
             type = ConeClassTypeImpl(FirClassSymbol(classId!!).toLookupTag(), emptyArray(), isNullable = false)
         )
     ).apply {
@@ -198,7 +199,7 @@ internal fun JavaValueParameter.toFirValueParameters(
     session: FirSession, javaTypeParameterStack: JavaTypeParameterStack
 ): FirValueParameter {
     return FirJavaValueParameter(
-        session, (this as? JavaElementImpl<*>)?.psi, name ?: Name.special("<anonymous Java parameter>"),
+        session, (this as? JavaElementImpl<*>)?.psi?.toFirSourceElement(), name ?: Name.special("<anonymous Java parameter>"),
         returnTypeRef = type.toFirJavaTypeRef(session, javaTypeParameterStack),
         isVararg = isVararg
     ).apply {
@@ -312,7 +313,7 @@ private fun JavaType.toFirResolvedTypeRef(
 ): FirResolvedTypeRef {
     if (this is JavaClassifierType) return toFirResolvedTypeRef(session, javaTypeParameterStack)
     return FirResolvedTypeRefImpl(
-        psi = null, type = ConeClassErrorType("Unexpected JavaType: $this")
+        source = null, type = ConeClassErrorType("Unexpected JavaType: $this")
     )
 }
 

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/declarations/FirJavaClass.kt

@@ -5,12 +5,12 @@
 
 package org.jetbrains.kotlin.fir.java.declarations
 
-import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.fir.FirPureAbstractElement
 import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.impl.FirDeclarationStatusImpl
 import org.jetbrains.kotlin.fir.declarations.impl.FirModifiableClass
@@ -25,7 +25,7 @@ import org.jetbrains.kotlin.fir.visitors.transformSingle
 import org.jetbrains.kotlin.name.Name
 
 class FirJavaClass internal constructor(
-    override val psi: PsiElement?,
+    override val source: FirSourceElement?,
     override val session: FirSession,
     override val symbol: FirClassSymbol,
     override val name: Name,

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/declarations/FirJavaConstructor.kt

@@ -5,13 +5,12 @@
 
 package org.jetbrains.kotlin.fir.java.declarations
 
-import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.fir.CONSTRUCTOR_NAME
-import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirPureAbstractElement
 import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.impl.FirDeclarationStatusImpl
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
@@ -30,7 +29,7 @@ import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedContainerSource
 
 class FirJavaConstructor(
-    override val psi: PsiElement?,
+    override val source: FirSourceElement?,
     override val session: FirSession,
     override val symbol: FirConstructorSymbol,
     visibility: Visibility,

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/declarations/FirJavaField.kt

@@ -5,10 +5,10 @@
 
 package org.jetbrains.kotlin.fir.java.declarations
 
-import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.impl.FirDeclarationStatusImpl
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
@@ -25,7 +25,7 @@ import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedContainerSource
 
 class FirJavaField(
-    override val psi: PsiElement?,
+    override val source: FirSourceElement?,
     override val session: FirSession,
     override val symbol: FirFieldSymbol,
     override val name: Name,

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/declarations/FirJavaMethod.kt

@@ -5,10 +5,10 @@
 
 package org.jetbrains.kotlin.fir.java.declarations
 
-import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.declarations.impl.FirDeclarationStatusImpl
 import org.jetbrains.kotlin.fir.declarations.impl.FirSimpleFunctionImpl
@@ -18,7 +18,7 @@ import org.jetbrains.kotlin.name.Name
 
 class FirJavaMethod(
     session: FirSession,
-    psi: PsiElement?,
+    source: FirSourceElement?,
     symbol: FirNamedFunctionSymbol,
     name: Name,
     visibility: Visibility,
@@ -26,7 +26,7 @@ class FirJavaMethod(
     returnTypeRef: FirJavaTypeRef,
     isStatic: Boolean
 ) : FirSimpleFunctionImpl(
-    psi,
+    source,
     session,
     returnTypeRef,
     null,

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/declarations/FirJavaValueParameter.kt

@@ -5,8 +5,8 @@
 
 package org.jetbrains.kotlin.fir.java.declarations
 
-import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.declarations.impl.FirValueParameterImpl
 import org.jetbrains.kotlin.fir.java.types.FirJavaTypeRef
@@ -15,12 +15,12 @@ import org.jetbrains.kotlin.name.Name
 
 class FirJavaValueParameter(
     session: FirSession,
-    psi: PsiElement?,
+    source: FirSourceElement?,
     name: Name,
     returnTypeRef: FirJavaTypeRef,
     isVararg: Boolean
 ) : FirValueParameterImpl(
-    psi,
+    source,
     session,
     returnTypeRef,
     name,

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/javaTypeUtils.kt

@@ -10,7 +10,10 @@ import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.*
-import org.jetbrains.kotlin.fir.expressions.*
+import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
+import org.jetbrains.kotlin.fir.expressions.FirConstExpression
+import org.jetbrains.kotlin.fir.expressions.FirExpression
+import org.jetbrains.kotlin.fir.expressions.classId
 import org.jetbrains.kotlin.fir.expressions.impl.FirConstExpressionImpl
 import org.jetbrains.kotlin.fir.expressions.impl.FirQualifiedAccessExpressionImpl
 import org.jetbrains.kotlin.fir.java.JavaTypeParameterStack
@@ -24,7 +27,9 @@ import org.jetbrains.kotlin.fir.references.impl.FirSimpleNamedReference
 import org.jetbrains.kotlin.fir.resolve.constructType
 import org.jetbrains.kotlin.fir.resolve.toSymbol
 import org.jetbrains.kotlin.fir.resolve.toTypeProjection
-import org.jetbrains.kotlin.fir.symbols.*
+import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag
+import org.jetbrains.kotlin.fir.symbols.ConeClassifierLookupTag
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.ConeClassLikeLookupTagImpl
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 import org.jetbrains.kotlin.fir.typeContext
@@ -85,7 +90,7 @@ private fun JavaType?.enhancePossiblyFlexible(
             )
 
             FirResolvedTypeRefImpl(
-                psi = null,
+                source = null,
                 type = coneFlexibleOrSimpleType(session, lowerResult, upperResult)
             ).apply {
                 this.annotations += annotations
@@ -93,7 +98,7 @@ private fun JavaType?.enhancePossiblyFlexible(
         }
         else -> {
             val enhanced = type.toNotNullConeKotlinType(session, javaTypeParameterStack)
-            FirResolvedTypeRefImpl(psi = null, type = enhanced).apply {
+            FirResolvedTypeRefImpl(source = null, type = enhanced).apply {
                 this.annotations += annotations
             }
         }

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/scopes/JavaClassEnhancementScope.kt

@@ -22,7 +22,8 @@ import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.fir.scopes.ProcessorAction
 import org.jetbrains.kotlin.fir.symbols.CallableId
 import org.jetbrains.kotlin.fir.symbols.impl.*
-import org.jetbrains.kotlin.fir.types.*
+import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
+import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.ir.expressions.IrConstKind
 import org.jetbrains.kotlin.load.java.AnnotationTypeQualifierResolver
 import org.jetbrains.kotlin.load.java.descriptors.NullDefaultValue
@@ -84,7 +85,7 @@ class JavaClassEnhancementScope(
                 val symbol = FirFieldSymbol(original.callableId)
                 with(firElement) {
                     FirJavaField(
-                        firElement.psi,
+                        firElement.source,
                         this@JavaClassEnhancementScope.session,
                         symbol,
                         name,
@@ -172,7 +173,7 @@ class JavaClassEnhancementScope(
             val (newTypeRef, newDefaultValue) = newInfo
             with(valueParameter) {
                 FirValueParameterImpl(
-                    psi, this@JavaClassEnhancementScope.session,
+                    source, this@JavaClassEnhancementScope.session,
                     newTypeRef, this.name,
                     FirVariableSymbol(this.name),
                     defaultValue ?: newDefaultValue, isCrossinline, isNoinline, isVararg
@@ -192,7 +193,7 @@ class JavaClassEnhancementScope(
                 }
                 if (firMethod.isPrimary) {
                     FirPrimaryConstructorImpl(
-                        firMethod.psi,
+                        firMethod.source,
                         this@JavaClassEnhancementScope.session,
                         newReturnTypeRef,
                         null,
@@ -201,7 +202,7 @@ class JavaClassEnhancementScope(
                     )
                 } else {
                     FirConstructorImpl(
-                        firMethod.psi,
+                        firMethod.source,
                         this@JavaClassEnhancementScope.session,
                         newReturnTypeRef,
                         newReceiverTypeRef,
@@ -215,7 +216,7 @@ class JavaClassEnhancementScope(
                 }
             }
             else -> FirSimpleFunctionImpl(
-                firMethod.psi,
+                firMethod.source,
                 this@JavaClassEnhancementScope.session,
                 newReturnTypeRef,
                 newReceiverTypeRef,

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/types/FirJavaTypeRef.kt

@@ -12,7 +12,7 @@ import org.jetbrains.kotlin.load.java.structure.JavaType
 class FirJavaTypeRef(
     annotations: List<FirAnnotationCall>,
     val type: JavaType
-) : FirUserTypeRefImpl(psi = null, isMarkedNullable = false) {
+) : FirUserTypeRefImpl(source = null, isMarkedNullable = false) {
     init {
         this.annotations += annotations
     }

compiler/fir/lightTree/src/org/jetbrains/kotlin/fir/lightTree/fir/modifier/Modifier.kt

@@ -6,10 +6,10 @@
 package org.jetbrains.kotlin.fir.lightTree.fir.modifier
 
 import com.intellij.lang.LighterASTNode
-import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.descriptors.Visibility
+import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.impl.FirAbstractAnnotatedElement
 import org.jetbrains.kotlin.fir.lightTree.fir.modifier.ModifierSets.CLASS_MODIFIER
@@ -24,7 +24,7 @@ import org.jetbrains.kotlin.fir.visitors.FirTransformer
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
 class Modifier(
-    override val psi: PsiElement? = null,
+    override val source: FirSourceElement? = null,
     private val classModifiers: MutableList<ClassModifier> = mutableListOf(),
     private val memberModifiers: MutableList<MemberModifier> = mutableListOf(),
     private val visibilityModifiers: MutableList<VisibilityModifier> = mutableListOf(),

compiler/fir/lightTree/src/org/jetbrains/kotlin/fir/lightTree/fir/modifier/TypeModifier.kt

@@ -6,7 +6,7 @@
 package org.jetbrains.kotlin.fir.lightTree.fir.modifier
 
 import com.intellij.lang.LighterASTNode
-import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.impl.FirAbstractAnnotatedElement
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
@@ -14,7 +14,7 @@ import org.jetbrains.kotlin.fir.visitors.FirVisitor
 import org.jetbrains.kotlin.lexer.KtTokens
 
 class TypeModifier(
-    override val psi: PsiElement? = null,
+    override val source: FirSourceElement? = null,
     var hasSuspend: Boolean = false
 ) : FirAbstractAnnotatedElement {
     override val annotations: MutableList<FirAnnotationCall> = mutableListOf()

compiler/fir/lightTree/src/org/jetbrains/kotlin/fir/lightTree/fir/modifier/TypeParameterModifier.kt

@@ -6,7 +6,7 @@
 package org.jetbrains.kotlin.fir.lightTree.fir.modifier
 
 import com.intellij.lang.LighterASTNode
-import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.impl.FirAbstractAnnotatedElement
 import org.jetbrains.kotlin.fir.lightTree.fir.modifier.ModifierSets.REIFICATION_MODIFIER
@@ -16,7 +16,7 @@ import org.jetbrains.kotlin.fir.visitors.FirVisitor
 import org.jetbrains.kotlin.types.Variance
 
 class TypeParameterModifier(
-    override val psi: PsiElement? = null,
+    override val source: FirSourceElement? = null,
     private val varianceModifiers: MutableList<VarianceModifier> = mutableListOf(),
     private var reificationModifier: ReificationModifier? = null
 ) : FirAbstractAnnotatedElement {

compiler/fir/lightTree/src/org/jetbrains/kotlin/fir/lightTree/fir/modifier/TypeProjectionModifier.kt

@@ -6,7 +6,7 @@
 package org.jetbrains.kotlin.fir.lightTree.fir.modifier
 
 import com.intellij.lang.LighterASTNode
-import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.impl.FirAbstractAnnotatedElement
 import org.jetbrains.kotlin.fir.lightTree.fir.modifier.ModifierSets.VARIANCE_MODIFIER
@@ -15,7 +15,7 @@ import org.jetbrains.kotlin.fir.visitors.FirVisitor
 import org.jetbrains.kotlin.types.Variance
 
 class TypeProjectionModifier(
-    override val psi: PsiElement? = null,
+    override val source: FirSourceElement? = null,
     private val varianceModifiers: MutableList<VarianceModifier> = mutableListOf()
 ) : FirAbstractAnnotatedElement {
     override val annotations: MutableList<FirAnnotationCall> = mutableListOf()

compiler/fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/BaseFirBuilder.kt

@@ -8,9 +8,7 @@ package org.jetbrains.kotlin.fir.builder
 import com.intellij.psi.PsiElement
 import com.intellij.psi.tree.IElementType
 import org.jetbrains.kotlin.KtNodeTypes.*
-import org.jetbrains.kotlin.fir.FirFunctionTarget
-import org.jetbrains.kotlin.fir.FirLoopTarget
-import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.*
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.impl.FirErrorFunctionImpl
 import org.jetbrains.kotlin.fir.declarations.impl.FirTypeParameterImpl
@@ -97,9 +95,9 @@ abstract class BaseFirBuilder<T>(val session: FirSession, val context: Context =
         val KNPE = Name.identifier("KotlinNullPointerException")
     }
 
-    fun FirExpression.toReturn(basePsi: PsiElement? = psi, labelName: String? = null): FirReturnExpression {
+    fun FirExpression.toReturn(baseSource: FirSourceElement? = source, labelName: String? = null): FirReturnExpression {
         return FirReturnExpressionImpl(
-            basePsi,
+            baseSource,
             this
         ).apply {
             target = FirFunctionTarget(labelName)
@@ -110,7 +108,7 @@ abstract class BaseFirBuilder<T>(val session: FirSession, val context: Context =
                 } else {
                     target.bind(
                         FirErrorFunctionImpl(
-                            psi,
+                            source,
                             this@BaseFirBuilder.session,
                             "Cannot bind unlabeled return to a function",
                             FirErrorFunctionSymbol()
@@ -136,7 +134,7 @@ abstract class BaseFirBuilder<T>(val session: FirSession, val context: Context =
                 }
                 target.bind(
                     FirErrorFunctionImpl(
-                        psi,
+                        source,
                         this@BaseFirBuilder.session,
                         "Cannot bind label $labelName to a function",
                         FirErrorFunctionSymbol()
@@ -148,13 +146,13 @@ abstract class BaseFirBuilder<T>(val session: FirSession, val context: Context =
 
     fun KtClassOrObject?.toDelegatedSelfType(firClass: FirRegularClass): FirTypeRef {
         val typeParameters = firClass.typeParameters.map {
-            FirTypeParameterImpl(it.psi, session, it.name, FirTypeParameterSymbol(), Variance.INVARIANT, false).apply {
+            FirTypeParameterImpl(it.source, session, it.name, FirTypeParameterSymbol(), Variance.INVARIANT, false).apply {
                 this.bounds += it.bounds
                 addDefaultBoundIfNecessary()
             }
         }
         return FirResolvedTypeRefImpl(
-            this,
+            this?.toFirSourceElement(),
             ConeClassTypeImpl(
                 firClass.symbol.toLookupTag(),
                 typeParameters.map { ConeTypeParameterTypeImpl(it.symbol.toLookupTag(), false) }.toTypedArray(),
@@ -171,13 +169,14 @@ abstract class BaseFirBuilder<T>(val session: FirSession, val context: Context =
     }
 
     fun T?.bangBangToWhen(parent: KtUnaryExpression?, convert: T?.(String) -> FirExpression): FirWhenExpression {
+        val source = parent.getSourceOrNull()
         return this.convert("No operand").generateNotNullOrOther(
             session,
             FirThrowExpressionImpl(
-                parent.getPsiOrNull(), FirFunctionCallImpl(parent.getPsiOrNull()).apply {
-                    calleeReference = FirSimpleNamedReference(parent, KNPE, null)
+                source, FirFunctionCallImpl(source).apply {
+                    calleeReference = FirSimpleNamedReference(source, KNPE, null)
                 }
-            ), "bangbang", parent
+            ), "bangbang", source
         )
     }
 
@@ -197,7 +196,7 @@ abstract class BaseFirBuilder<T>(val session: FirSession, val context: Context =
             if (lastLoop != null) {
                 target.bind(lastLoop)
             } else {
-                target.bind(FirErrorLoop(expression.getPsiOrNull(), "Cannot bind unlabeled jump to a loop"))
+                target.bind(FirErrorLoop(expression.getSourceOrNull(), "Cannot bind unlabeled jump to a loop"))
             }
         } else {
             for (firLoop in context.firLoops.asReversed()) {
@@ -206,14 +205,14 @@ abstract class BaseFirBuilder<T>(val session: FirSession, val context: Context =
                     return this
                 }
             }
-            target.bind(FirErrorLoop(expression.getPsiOrNull(), "Cannot bind label $labelName to a loop"))
+            target.bind(FirErrorLoop(expression.getSourceOrNull(), "Cannot bind label $labelName to a loop"))
         }
         return this
     }
 
     /**** Conversion utils ****/
-    private fun <T> T.getPsiOrNull(): PsiElement? {
-        return if (this is PsiElement) this else null
+    private fun <T> T.getSourceOrNull(): FirSourceElement? {
+        return if (this is PsiElement) FirPsiSourceElement(this) else null
     }
 
     fun generateConstantExpressionByLiteral(expression: T): FirExpression {
@@ -231,34 +230,34 @@ abstract class BaseFirBuilder<T>(val session: FirSession, val context: Context =
                             convertedText > Int.MAX_VALUE || convertedText < Int.MIN_VALUE)
                 ) {
                     FirConstExpressionImpl(
-                        expression.getPsiOrNull(), IrConstKind.Long, convertedText, "Incorrect long: $text"
+                        expression.getSourceOrNull(), IrConstKind.Long, convertedText, "Incorrect long: $text"
                     )
                 } else if (convertedText is Number) {
                     // TODO: support byte / short
                     FirConstExpressionImpl(
-                        expression.getPsiOrNull(), IrConstKind.Int, convertedText.toInt(), "Incorrect int: $text"
+                        expression.getSourceOrNull(), IrConstKind.Int, convertedText.toInt(), "Incorrect int: $text"
                     )
                 } else {
-                    FirErrorExpressionImpl(expression.getPsiOrNull(), reason = "Incorrect constant expression: $text")
+                    FirErrorExpressionImpl(expression.getSourceOrNull(), reason = "Incorrect constant expression: $text")
                 }
             FLOAT_CONSTANT ->
                 if (convertedText is Float) {
                     FirConstExpressionImpl(
-                        expression.getPsiOrNull(), IrConstKind.Float, convertedText, "Incorrect float: $text"
+                        expression.getSourceOrNull(), IrConstKind.Float, convertedText, "Incorrect float: $text"
                     )
                 } else {
                     FirConstExpressionImpl(
-                        expression.getPsiOrNull(), IrConstKind.Double, convertedText as Double, "Incorrect double: $text"
+                        expression.getSourceOrNull(), IrConstKind.Double, convertedText as Double, "Incorrect double: $text"
                     )
                 }
             CHARACTER_CONSTANT ->
                 FirConstExpressionImpl(
-                    expression.getPsiOrNull(), IrConstKind.Char, text.parseCharacter(), "Incorrect character: $text"
+                    expression.getSourceOrNull(), IrConstKind.Char, text.parseCharacter(), "Incorrect character: $text"
                 )
             BOOLEAN_CONSTANT ->
-                FirConstExpressionImpl(expression.getPsiOrNull(), IrConstKind.Boolean, convertedText as Boolean)
+                FirConstExpressionImpl(expression.getSourceOrNull(), IrConstKind.Boolean, convertedText as Boolean)
             NULL ->
-                FirConstExpressionImpl(expression.getPsiOrNull(), IrConstKind.Null, null)
+                FirConstExpressionImpl(expression.getSourceOrNull(), IrConstKind.Null, null)
             else ->
                 throw AssertionError("Unknown literal type: $type, $text")
         }
@@ -278,11 +277,11 @@ abstract class BaseFirBuilder<T>(val session: FirSession, val context: Context =
                 OPEN_QUOTE, CLOSING_QUOTE -> continue@L
                 LITERAL_STRING_TEMPLATE_ENTRY -> {
                     sb.append(entry.asText)
-                    FirConstExpressionImpl(entry.getPsiOrNull(), IrConstKind.String, entry.asText)
+                    FirConstExpressionImpl(entry.getSourceOrNull(), IrConstKind.String, entry.asText)
                 }
                 ESCAPE_STRING_TEMPLATE_ENTRY -> {
                     sb.append(entry.unescapedValue)
-                    FirConstExpressionImpl(entry.getPsiOrNull(), IrConstKind.String, entry.unescapedValue)
+                    FirConstExpressionImpl(entry.getSourceOrNull(), IrConstKind.String, entry.unescapedValue)
                 }
                 SHORT_STRING_TEMPLATE_ENTRY, LONG_STRING_TEMPLATE_ENTRY -> {
                     hasExpressions = true
@@ -291,7 +290,7 @@ abstract class BaseFirBuilder<T>(val session: FirSession, val context: Context =
                 else -> {
                     hasExpressions = true
                     FirErrorExpressionImpl(
-                        entry.getPsiOrNull(), "Incorrect template entry: ${entry.asText}"
+                        entry.getSourceOrNull(), "Incorrect template entry: ${entry.asText}"
                     )
                 }
             }
@@ -302,14 +301,14 @@ abstract class BaseFirBuilder<T>(val session: FirSession, val context: Context =
                 }
                 else -> {
                     callCreated = true
-                    FirStringConcatenationCallImpl(base).apply {
+                    FirStringConcatenationCallImpl(base?.toFirSourceElement()).apply {
                         arguments += result!!
                         arguments += nextArgument
                     }
                 }
             }
         }
-        return if (hasExpressions) result!! else FirConstExpressionImpl(base, IrConstKind.String, sb.toString())
+        return if (hasExpressions) result!! else FirConstExpressionImpl(base?.toFirSourceElement(), IrConstKind.String, sb.toString())
     }
 
     /**
@@ -346,20 +345,21 @@ abstract class BaseFirBuilder<T>(val session: FirSession, val context: Context =
         if (argument == null) {
             return FirErrorExpressionImpl(argument, "Inc/dec without operand")
         }
-        return FirBlockImpl(baseExpression).apply {
+        val source = baseExpression?.toFirSourceElement()
+        return FirBlockImpl(source).apply {
             val tempName = Name.special("<unary>")
-            val temporaryVariable = generateTemporaryVariable(this@BaseFirBuilder.session, baseExpression, tempName, argument.convert())
+            val temporaryVariable = generateTemporaryVariable(this@BaseFirBuilder.session, source, tempName, argument.convert())
             statements += temporaryVariable
             val resultName = Name.special("<unary-result>")
-            val resultInitializer = FirFunctionCallImpl(baseExpression).apply {
-                this.calleeReference = FirSimpleNamedReference(baseExpression?.operationReference, callName, null)
-                this.explicitReceiver = generateResolvedAccessExpression(baseExpression, temporaryVariable)
+            val resultInitializer = FirFunctionCallImpl(source).apply {
+                this.calleeReference = FirSimpleNamedReference(baseExpression?.operationReference?.toFirSourceElement(), callName, null)
+                this.explicitReceiver = generateResolvedAccessExpression(source, temporaryVariable)
             }
-            val resultVar = generateTemporaryVariable(this@BaseFirBuilder.session, baseExpression, resultName, resultInitializer)
+            val resultVar = generateTemporaryVariable(this@BaseFirBuilder.session, source, resultName, resultInitializer)
             val assignment = argument.generateAssignment(
-                baseExpression,
+                source,
                 if (prefix && argument.elementType != REFERENCE_EXPRESSION)
-                    generateResolvedAccessExpression(baseExpression, resultVar)
+                    generateResolvedAccessExpression(source, resultVar)
                 else
                     resultInitializer,
                 FirOperation.ASSIGN, convert
@@ -377,14 +377,14 @@ abstract class BaseFirBuilder<T>(val session: FirSession, val context: Context =
                 if (argument.elementType != REFERENCE_EXPRESSION) {
                     statements += resultVar
                     appendAssignment()
-                    statements += generateResolvedAccessExpression(baseExpression, resultVar)
+                    statements += generateResolvedAccessExpression(source, resultVar)
                 } else {
                     appendAssignment()
-                    statements += generateAccessExpression(baseExpression, argument.getReferencedNameAsName())
+                    statements += generateAccessExpression(source, argument.getReferencedNameAsName())
                 }
             } else {
                 appendAssignment()
-                statements += generateResolvedAccessExpression(baseExpression, temporaryVariable)
+                statements += generateResolvedAccessExpression(source, temporaryVariable)
             }
         }
     }
@@ -397,10 +397,10 @@ abstract class BaseFirBuilder<T>(val session: FirSession, val context: Context =
         if (left != null) {
             when (tokenType) {
                 REFERENCE_EXPRESSION -> {
-                    return FirSimpleNamedReference(left.getPsiOrNull(), left.getReferencedNameAsName(), null)
+                    return FirSimpleNamedReference(left.getSourceOrNull(), left.getReferencedNameAsName(), null)
                 }
                 THIS_EXPRESSION -> {
-                    return FirExplicitThisReference(left.getPsiOrNull(), left.getLabelName())
+                    return FirExplicitThisReference(left.getSourceOrNull(), left.getLabelName())
                 }
                 DOT_QUALIFIED_EXPRESSION, SAFE_ACCESS_EXPRESSION -> {
                     val firMemberAccess = left.convertQualified()
@@ -410,7 +410,7 @@ abstract class BaseFirBuilder<T>(val session: FirSession, val context: Context =
                         firMemberAccess.calleeReference
                     } else {
                         FirErrorNamedReferenceImpl(
-                            left.getPsiOrNull(), "Unsupported qualified LValue: ${left.asText}"
+                            left.getSourceOrNull(), "Unsupported qualified LValue: ${left.asText}"
                         )
                     }
                 }
@@ -419,28 +419,28 @@ abstract class BaseFirBuilder<T>(val session: FirSession, val context: Context =
                 }
             }
         }
-        return FirErrorNamedReferenceImpl(left.getPsiOrNull(), "Unsupported LValue: $tokenType")
+        return FirErrorNamedReferenceImpl(left.getSourceOrNull(), "Unsupported LValue: $tokenType")
     }
 
     fun T?.generateAssignment(
-        psi: PsiElement?,
+        source: FirSourceElement?,
         value: FirExpression,
         operation: FirOperation,
         convert: T.() -> FirExpression
     ): FirStatement {
         val tokenType = this?.elementType
         if (tokenType == PARENTHESIZED) {
-            return this!!.getExpressionInParentheses().generateAssignment(psi, value, operation, convert)
+            return this!!.getExpressionInParentheses().generateAssignment(source, value, operation, convert)
         }
         if (tokenType == ARRAY_ACCESS_EXPRESSION) {
             val firArrayAccess = this!!.convert() as FirFunctionCallImpl
             val arraySet = if (operation != FirOperation.ASSIGN) {
-                FirArraySetCallImpl(psi, value, operation).apply {
+                FirArraySetCallImpl(source, value, operation).apply {
                     indexes += firArrayAccess.arguments
                 }
             } else {
                 return firArrayAccess.apply {
-                    calleeReference = FirSimpleNamedReference(psi, OperatorNameConventions.SET, null)
+                    calleeReference = FirSimpleNamedReference(source, OperatorNameConventions.SET, null)
                     arguments += value
                 }
             }
@@ -451,40 +451,40 @@ abstract class BaseFirBuilder<T>(val session: FirSession, val context: Context =
                 }
             }
             val psiArrayExpression = firArrayAccess.explicitReceiver?.psi
-            return FirBlockImpl(psiArrayExpression).apply {
+            return FirBlockImpl(psiArrayExpression?.toFirSourceElement()).apply {
                 val name = Name.special("<array-set>")
                 statements += generateTemporaryVariable(
-                    this@BaseFirBuilder.session, this@generateAssignment.getPsiOrNull(), name, firArrayAccess.explicitReceiver!!
+                    this@BaseFirBuilder.session, this@generateAssignment.getSourceOrNull(), name, firArrayAccess.explicitReceiver!!
                 )
-                statements += arraySet.apply { lValue = FirSimpleNamedReference(psiArrayExpression, name, null) }
+                statements += arraySet.apply { lValue = FirSimpleNamedReference(psiArrayExpression?.toFirSourceElement(), name, null) }
             }
         }
         if (operation != FirOperation.ASSIGN &&
             tokenType != REFERENCE_EXPRESSION && tokenType != THIS_EXPRESSION &&
             ((tokenType != DOT_QUALIFIED_EXPRESSION && tokenType != SAFE_ACCESS_EXPRESSION) || this.selectorExpression?.elementType != REFERENCE_EXPRESSION)
         ) {
-            return FirBlockImpl(this.getPsiOrNull()).apply {
+            return FirBlockImpl(this.getSourceOrNull()).apply {
                 val name = Name.special("<complex-set>")
                 statements += generateTemporaryVariable(
-                    this@BaseFirBuilder.session, this@generateAssignment.getPsiOrNull(), name,
+                    this@BaseFirBuilder.session, this@generateAssignment.getSourceOrNull(), name,
                     this@generateAssignment?.convert()
-                        ?: FirErrorExpressionImpl(this.getPsiOrNull(), "No LValue in assignment")
+                        ?: FirErrorExpressionImpl(this.getSourceOrNull(), "No LValue in assignment")
                 )
-                statements += FirVariableAssignmentImpl(psi, false, value, operation).apply {
-                    lValue = FirSimpleNamedReference(this.getPsiOrNull(), name, null)
+                statements += FirVariableAssignmentImpl(source, false, value, operation).apply {
+                    lValue = FirSimpleNamedReference(this.getSourceOrNull(), name, null)
                 }
             }
         }
 
         if (operation in FirOperation.ASSIGNMENTS && operation != FirOperation.ASSIGN) {
-            return FirOperatorCallImpl(psi, operation).apply {
+            return FirOperatorCallImpl(source, operation).apply {
                 // TODO: take good psi
-                arguments += this@generateAssignment?.convert() ?: FirErrorExpressionImpl(null, "Unsupported left value of assignment: ${psi?.text}")
+                arguments += this@generateAssignment?.convert() ?: FirErrorExpressionImpl(null, "Unsupported left value of assignment: ${source?.psi?.text}")
                 arguments += value
             }
         }
 
-        return FirVariableAssignmentImpl(psi, false, value, operation).apply {
+        return FirVariableAssignmentImpl(source, false, value, operation).apply {
             lValue = initializeLValue(this@generateAssignment) { convert() as? FirQualifiedAccess }
         }
     }

compiler/fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/ConversionUtils.kt

@@ -5,13 +5,10 @@
 
 package org.jetbrains.kotlin.fir.builder
 
-import com.intellij.psi.PsiElement
 import com.intellij.psi.tree.IElementType
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibilities
-import org.jetbrains.kotlin.fir.FirFunctionTarget
-import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.FirWhenSubject
+import org.jetbrains.kotlin.fir.*
 import org.jetbrains.kotlin.fir.declarations.FirVariable
 import org.jetbrains.kotlin.fir.declarations.impl.*
 import org.jetbrains.kotlin.fir.expressions.*
@@ -136,41 +133,41 @@ fun IElementType.toFirOperation(): FirOperation =
     }
 
 fun FirExpression.generateNotNullOrOther(
-    session: FirSession, other: FirExpression, caseId: String, basePsi: KtElement?
+    session: FirSession, other: FirExpression, caseId: String, baseSource: FirSourceElement?
 ): FirWhenExpression {
     val subjectName = Name.special("<$caseId>")
-    val subjectVariable = generateTemporaryVariable(session, basePsi, subjectName, this)
+    val subjectVariable = generateTemporaryVariable(session, baseSource, subjectName, this)
     val subject = FirWhenSubject()
-    val subjectExpression = FirWhenSubjectExpressionImpl(basePsi, subject)
+    val subjectExpression = FirWhenSubjectExpressionImpl(baseSource, subject)
     return FirWhenExpressionImpl(
-        basePsi, this, subjectVariable
+        baseSource, this, subjectVariable
     ).apply {
         subject.bind(this)
         branches += FirWhenBranchImpl(
-            basePsi,
-            FirOperatorCallImpl(basePsi, FirOperation.EQ).apply {
+            baseSource,
+            FirOperatorCallImpl(baseSource, FirOperation.EQ).apply {
                 arguments += subjectExpression
-                arguments += FirConstExpressionImpl(basePsi, IrConstKind.Null, null)
+                arguments += FirConstExpressionImpl(baseSource, IrConstKind.Null, null)
             },
             FirSingleExpressionBlock(other)
         )
         branches += FirWhenBranchImpl(
-            other.psi, FirElseIfTrueCondition(basePsi),
+            other.source, FirElseIfTrueCondition(baseSource),
             FirSingleExpressionBlock(
-                generateResolvedAccessExpression(basePsi, subjectVariable)
+                generateResolvedAccessExpression(baseSource, subjectVariable)
             )
         )
     }
 }
 
 fun FirExpression.generateLazyLogicalOperation(
-    other: FirExpression, isAnd: Boolean, basePsi: KtElement?
+    other: FirExpression, isAnd: Boolean, baseSource: FirSourceElement?
 ): FirBinaryLogicExpression {
     val kind = if (isAnd)
         LogicOperationKind.AND
     else
         LogicOperationKind.OR
-    return FirBinaryLogicExpressionImpl(basePsi, this, other, kind)
+    return FirBinaryLogicExpressionImpl(baseSource, this, other, kind)
 }
 
 internal fun KtWhenCondition.toFirWhenCondition(
@@ -178,11 +175,11 @@ internal fun KtWhenCondition.toFirWhenCondition(
     convert: KtExpression?.(String) -> FirExpression,
     toFirOrErrorTypeRef: KtTypeReference?.() -> FirTypeRef
 ): FirExpression {
-    val firSubjectExpression = FirWhenSubjectExpressionImpl(this, subject)
+    val firSubjectExpression = FirWhenSubjectExpressionImpl(this.toFirSourceElement(), subject)
     return when (this) {
         is KtWhenConditionWithExpression -> {
             FirOperatorCallImpl(
-                expression,
+                expression?.toFirSourceElement(),
                 FirOperation.EQ
             ).apply {
                 arguments += firSubjectExpression
@@ -195,20 +192,21 @@ internal fun KtWhenCondition.toFirWhenCondition(
         }
         is KtWhenConditionIsPattern -> {
             FirTypeOperatorCallImpl(
-                typeReference, if (isNegated) FirOperation.NOT_IS else FirOperation.IS,
+                typeReference?.toFirSourceElement(),
+                if (isNegated) FirOperation.NOT_IS else FirOperation.IS,
                 typeReference.toFirOrErrorTypeRef()
             ).apply {
                 arguments += firSubjectExpression
             }
         }
         else -> {
-            FirErrorExpressionImpl(this, "Unsupported when condition: ${this.javaClass}")
+            FirErrorExpressionImpl(this.toFirSourceElement(), "Unsupported when condition: ${this.javaClass}")
         }
     }
 }
 
 internal fun Array<KtWhenCondition>.toFirWhenCondition(
-    basePsi: KtElement,
+    baseSource: FirSourceElement?,
     subject: FirWhenSubject,
     convert: KtExpression?.(String) -> FirExpression,
     toFirOrErrorTypeRef: KtTypeReference?.() -> FirTypeRef
@@ -219,7 +217,7 @@ internal fun Array<KtWhenCondition>.toFirWhenCondition(
         firCondition = when (firCondition) {
             null -> firConditionElement
             else -> firCondition.generateLazyLogicalOperation(
-                firConditionElement, false, basePsi
+                firConditionElement, false, baseSource
             )
         }
     }
@@ -232,26 +230,28 @@ fun FirExpression.generateContainsOperation(
     base: KtExpression?,
     operationReference: KtOperationReferenceExpression?
 ): FirFunctionCall {
-    val containsCall = FirFunctionCallImpl(base).apply {
-        calleeReference = FirSimpleNamedReference(operationReference, OperatorNameConventions.CONTAINS, null)
+    val baseSource = base?.toFirSourceElement()
+    val operationReferenceSource = operationReference?.toFirSourceElement()
+    val containsCall = FirFunctionCallImpl(baseSource).apply {
+        calleeReference = FirSimpleNamedReference(operationReferenceSource, OperatorNameConventions.CONTAINS, null)
         explicitReceiver = this@generateContainsOperation
         arguments += argument
     }
     if (!inverted) return containsCall
-    return FirFunctionCallImpl(base).apply {
-        calleeReference = FirSimpleNamedReference(operationReference, OperatorNameConventions.NOT, null)
+    return FirFunctionCallImpl(baseSource).apply {
+        calleeReference = FirSimpleNamedReference(operationReferenceSource, OperatorNameConventions.NOT, null)
         explicitReceiver = containsCall
     }
 }
 
-fun generateAccessExpression(psi: PsiElement?, name: Name): FirQualifiedAccessExpression =
-    FirQualifiedAccessExpressionImpl(psi).apply {
-        calleeReference = FirSimpleNamedReference(psi, name, null)
+fun generateAccessExpression(source: FirSourceElement?, name: Name): FirQualifiedAccessExpression =
+    FirQualifiedAccessExpressionImpl(source).apply {
+        calleeReference = FirSimpleNamedReference(source, name, null)
     }
 
-fun generateResolvedAccessExpression(psi: PsiElement?, variable: FirVariable<*>): FirQualifiedAccessExpression =
-    FirQualifiedAccessExpressionImpl(psi).apply {
-        calleeReference = FirResolvedNamedReferenceImpl(psi, variable.name, variable.symbol)
+fun generateResolvedAccessExpression(source: FirSourceElement?, variable: FirVariable<*>): FirQualifiedAccessExpression =
+    FirQualifiedAccessExpressionImpl(source).apply {
+        calleeReference = FirResolvedNamedReferenceImpl(source, variable.name, variable.symbol)
     }
 
 internal fun generateDestructuringBlock(
@@ -262,19 +262,20 @@ internal fun generateDestructuringBlock(
     extractAnnotationsTo: KtAnnotated.(FirAbstractAnnotatedElement) -> Unit,
     toFirOrImplicitTypeRef: KtTypeReference?.() -> FirTypeRef
 ): FirExpression {
-    return FirBlockImpl(multiDeclaration).apply {
+    return FirBlockImpl(multiDeclaration.toFirSourceElement()).apply {
         if (tmpVariable) {
             statements += container
         }
         val isVar = multiDeclaration.isVar
         for ((index, entry) in multiDeclaration.entries.withIndex()) {
+            val entrySource = entry.toFirSourceElement()
             statements += FirPropertyImpl(
-                entry,
+                entrySource,
                 session,
                 entry.typeReference.toFirOrImplicitTypeRef(),
                 null,
                 entry.nameAsSafeName,
-                FirComponentCallImpl(entry, generateResolvedAccessExpression(entry, container), index + 1),
+                FirComponentCallImpl(entrySource, generateResolvedAccessExpression(entrySource, container), index + 1),
                 null,
                 isVar,
                 FirPropertySymbol(CallableId(entry.nameAsSafeName)), // TODO?
@@ -289,12 +290,12 @@ internal fun generateDestructuringBlock(
 }
 
 fun generateTemporaryVariable(
-    session: FirSession, psi: PsiElement?, name: Name, initializer: FirExpression
+    session: FirSession, source: FirSourceElement?, name: Name, initializer: FirExpression
 ): FirVariable<*> =
     FirPropertyImpl(
-        psi,
+        source,
         session,
-        FirImplicitTypeRefImpl(psi),
+        FirImplicitTypeRefImpl(source),
         null,
         name,
         initializer,
@@ -308,8 +309,8 @@ fun generateTemporaryVariable(
     }
 
 fun generateTemporaryVariable(
-    session: FirSession, psi: PsiElement?, specialName: String, initializer: FirExpression
-): FirVariable<*> = generateTemporaryVariable(session, psi, Name.special("<$specialName>"), initializer)
+    session: FirSession, source: FirSourceElement?, specialName: String, initializer: FirExpression
+): FirVariable<*> = generateTemporaryVariable(session, source, Name.special("<$specialName>"), initializer)
 
 fun FirModifiableVariable<*>.generateAccessorsByDelegate(session: FirSession, member: Boolean, stubMode: Boolean) {
     val variable = this as FirVariable<*>
@@ -385,7 +386,7 @@ fun FirModifiableVariable<*>.generateAccessorsByDelegate(session: FirSession, me
                     arguments += thisRef()
                     arguments += propertyRef()
                     arguments += FirQualifiedAccessExpressionImpl(null).apply {
-                        calleeReference = FirResolvedNamedReferenceImpl(psi, DELEGATED_SETTER_PARAM, parameter.symbol)
+                        calleeReference = FirResolvedNamedReferenceImpl(source, DELEGATED_SETTER_PARAM, parameter.symbol)
                     }
                 }
             )

compiler/fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/DataClassUtils.kt

@@ -22,6 +22,7 @@ import org.jetbrains.kotlin.fir.references.impl.FirResolvedNamedReferenceImpl
 import org.jetbrains.kotlin.fir.symbols.CallableId
 import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol
+import org.jetbrains.kotlin.fir.toFirSourceElement
 import org.jetbrains.kotlin.fir.types.impl.FirImplicitTypeRefImpl
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
@@ -49,22 +50,23 @@ fun List<Pair<KtParameter?, FirProperty>>.generateComponentFunctions(
             isExternal = false
             isSuspend = false
         }
+        val parameterSource = ktParameter?.toFirSourceElement()
         firClass.addDeclaration(
             FirSimpleFunctionImpl(
-                ktParameter, session, FirImplicitTypeRefImpl(ktParameter),
+                parameterSource, session, FirImplicitTypeRefImpl(parameterSource),
                 null, name, status, symbol
             ).apply {
                 val componentFunction = this
                 body = FirSingleExpressionBlock(
                     FirReturnExpressionImpl(
-                        ktParameter,
-                        FirQualifiedAccessExpressionImpl(ktParameter).apply {
+                        parameterSource,
+                        FirQualifiedAccessExpressionImpl(parameterSource).apply {
                             val parameterName = firProperty.name
                             dispatchReceiver = FirThisReceiverExpressionImpl(null, FirImplicitThisReference(firClass.symbol)).apply {
                                 typeRef = firPrimaryConstructor.returnTypeRef
                             }
                             calleeReference = FirResolvedNamedReferenceImpl(
-                                ktParameter,
+                                parameterSource,
                                 parameterName, firProperty.symbol
                             )
                         }
@@ -98,7 +100,7 @@ fun List<Pair<KtParameter?, FirProperty>>.generateCopyFunction(
     }
     firClass.addDeclaration(
         FirSimpleFunctionImpl(
-            classOrObject,
+            classOrObject?.toFirSourceElement(),
             session,
             firPrimaryConstructor.returnTypeRef,
             null,
@@ -108,15 +110,16 @@ fun List<Pair<KtParameter?, FirProperty>>.generateCopyFunction(
         ).apply {
             for ((ktParameter, firProperty) in this@generateCopyFunction) {
                 val name = firProperty.name
+                val parameterSource = ktParameter?.toFirSourceElement()
                 valueParameters += FirValueParameterImpl(
-                    ktParameter, session, firProperty.returnTypeRef,
+                    parameterSource, session, firProperty.returnTypeRef,
                     name,
                     FirVariableSymbol(name),
-                    FirQualifiedAccessExpressionImpl(ktParameter).apply {
+                    FirQualifiedAccessExpressionImpl(parameterSource).apply {
                         dispatchReceiver = FirThisReceiverExpressionImpl(null, FirImplicitThisReference(firClass.symbol)).apply {
                             typeRef = firPrimaryConstructor.returnTypeRef
                         }
-                        calleeReference = FirResolvedNamedReferenceImpl(ktParameter, name, firProperty.symbol)
+                        calleeReference = FirResolvedNamedReferenceImpl(parameterSource, name, firProperty.symbol)
                     },
                     isCrossinline = false, isNoinline = false, isVararg = false
                 )

compiler/fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/RawFirBuilder.kt

@@ -98,27 +98,27 @@ class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder
             this.accept(this@Visitor, Unit) as R
 
         private fun KtTypeReference?.toFirOrImplicitType(): FirTypeRef =
-            convertSafe() ?: FirImplicitTypeRefImpl(this)
+            convertSafe() ?: FirImplicitTypeRefImpl(this?.toFirSourceElement())
 
         private fun KtTypeReference?.toFirOrUnitType(): FirTypeRef =
             convertSafe() ?: implicitUnitType
 
         private fun KtTypeReference?.toFirOrErrorType(): FirTypeRef =
-            convertSafe() ?: FirErrorTypeRefImpl(this, if (this == null) "Incomplete code" else "Conversion failed")
+            convertSafe() ?: FirErrorTypeRefImpl(this?.toFirSourceElement(), if (this == null) "Incomplete code" else "Conversion failed")
 
         // Here we accept lambda as receiver to prevent expression calculation in stub mode
         private fun (() -> KtExpression?).toFirExpression(errorReason: String): FirExpression =
             if (stubMode) FirExpressionStub(null)
             else with(this()) {
-                convertSafe<FirExpression>() ?: FirErrorExpressionImpl(this, errorReason)
+                convertSafe<FirExpression>() ?: FirErrorExpressionImpl(this?.toFirSourceElement(), errorReason)
             }
 
         private fun KtExpression?.toFirExpression(errorReason: String): FirExpression =
             if (stubMode) FirExpressionStub(null)
-            else convertSafe<FirExpression>() ?: FirErrorExpressionImpl(this, errorReason)
+            else convertSafe<FirExpression>() ?: FirErrorExpressionImpl(this?.toFirSourceElement(), errorReason)
 
         private fun KtExpression.toFirStatement(errorReason: String): FirStatement =
-            convertSafe() ?: FirErrorExpressionImpl(this, errorReason)
+            convertSafe() ?: FirErrorExpressionImpl(this.toFirSourceElement(), errorReason)
 
         private fun KtExpression.toFirStatement(): FirStatement =
             convert()
@@ -129,7 +129,7 @@ class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder
             return when (this) {
                 is KtSecondaryConstructor -> toFirConstructor(
                     delegatedSuperType,
-                    delegatedSelfType ?: FirErrorTypeRefImpl(this, "Constructor in object"),
+                    delegatedSelfType ?: FirErrorTypeRefImpl(this.toFirSourceElement(), "Constructor in object"),
                     owner,
                     hasPrimaryConstructor
                 )
@@ -154,17 +154,17 @@ class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder
                 hasBlockBody() -> if (!stubMode) {
                     bodyBlockExpression?.accept(this@Visitor, Unit) as? FirBlock
                 } else {
-                    FirSingleExpressionBlock(FirExpressionStub(this).toReturn())
+                    FirSingleExpressionBlock(FirExpressionStub(this.toFirSourceElement()).toReturn())
                 }
                 else -> {
                     val result = { bodyExpression }.toFirExpression("Function has no body (but should)")
                     // basePsi is null, because 'return' is synthetic & should not be bound to some PSI
-                    FirSingleExpressionBlock(result.toReturn(basePsi = null))
+                    FirSingleExpressionBlock(result.toReturn(baseSource = null))
                 }
             }
 
         private fun ValueArgument?.toFirExpression(): FirExpression {
-            this ?: return FirErrorExpressionImpl(this as? KtElement, "No argument given")
+            this ?: return FirErrorExpressionImpl((this as? KtElement)?.toFirSourceElement(), "No argument given")
             val name = this.getArgumentName()?.asName
             val expression = this.getArgumentExpression()
             val firExpression = when (expression) {
@@ -178,8 +178,8 @@ class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder
             }
             val isSpread = getSpreadElement() != null
             return when {
-                name != null -> FirNamedArgumentExpressionImpl(expression, firExpression, isSpread, name)
-                isSpread -> FirSpreadArgumentExpressionImpl(expression, firExpression)
+                name != null -> FirNamedArgumentExpressionImpl(expression?.toFirSourceElement(), firExpression, isSpread, name)
+                isSpread -> FirSpreadArgumentExpressionImpl(expression?.toFirSourceElement(), firExpression)
                 else -> firExpression
             }
         }
@@ -190,14 +190,16 @@ class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder
             isGetter: Boolean
         ): FirPropertyAccessor {
             if (this == null) {
+                val propertySource = property.toFirSourceElement()
                 return if (isGetter) {
-                    FirDefaultPropertyGetter(property, session, propertyTypeRef, property.visibility)
+                    FirDefaultPropertyGetter(propertySource, session, propertyTypeRef, property.visibility)
                 } else {
-                    FirDefaultPropertySetter(property, session, propertyTypeRef, property.visibility)
+                    FirDefaultPropertySetter(propertySource, session, propertyTypeRef, property.visibility)
                 }
             }
+            val source = this.toFirSourceElement()
             val firAccessor = FirPropertyAccessorImpl(
-                this,
+                source,
                 session,
                 if (isGetter) {
                     returnTypeReference?.convertSafe() ?: propertyTypeRef
@@ -213,7 +215,7 @@ class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder
             extractValueParametersTo(firAccessor, propertyTypeRef)
             if (!isGetter && firAccessor.valueParameters.isEmpty()) {
                 firAccessor.valueParameters += FirDefaultSetterValueParameter(
-                    this,
+                    source,
                     session,
                     propertyTypeRef,
                     FirVariableSymbol(NAME_FOR_DEFAULT_VALUE_PARAMETER)
@@ -227,7 +229,7 @@ class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder
         private fun KtParameter.toFirValueParameter(defaultTypeRef: FirTypeRef? = null): FirValueParameter {
             val name = nameAsSafeName
             val firValueParameter = FirValueParameterImpl(
-                this,
+                this.toFirSourceElement(),
                 session,
                 when {
                     typeReference != null -> typeReference.toFirOrErrorType()
@@ -257,15 +259,17 @@ class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder
                 isConst = false
                 isLateInit = false
             }
+            val parameterSource = this.toFirSourceElement()
+            val propertySource = this@toFirProperty.toFirSourceElement()
             val firProperty = FirPropertyImpl(
-                this,
+                parameterSource,
                 session,
                 type,
                 null,
                 nameAsSafeName,
-                FirQualifiedAccessExpressionImpl(this).apply {
+                FirQualifiedAccessExpressionImpl(parameterSource).apply {
                     calleeReference = FirPropertyFromParameterResolvedNamedReference(
-                        this@toFirProperty, nameAsSafeName, firParameter.symbol
+                        propertySource, nameAsSafeName, firParameter.symbol
                     )
                 },
                 null,
@@ -274,8 +278,8 @@ class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder
                 false,
                 status
             ).apply {
-                getter = FirDefaultPropertyGetter(this@toFirProperty, this@RawFirBuilder.session, type, visibility)
-                setter = if (isMutable) FirDefaultPropertySetter(this@toFirProperty, this@RawFirBuilder.session, type, visibility) else null
+                getter = FirDefaultPropertyGetter(propertySource, this@RawFirBuilder.session, type, visibility)
+                setter = if (isMutable) FirDefaultPropertySetter(propertySource, this@RawFirBuilder.session, type, visibility) else null
             }
             extractAnnotationsTo(firProperty)
             return firProperty
@@ -306,7 +310,7 @@ class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder
             for (argument in this.valueArguments) {
                 val argumentExpression = argument.toFirExpression()
                 container.arguments += when (argument) {
-                    is KtLambdaArgument -> FirLambdaArgumentExpressionImpl(argument, argumentExpression)
+                    is KtLambdaArgument -> FirLambdaArgumentExpressionImpl(argument.toFirSourceElement(), argumentExpression)
                     else -> argumentExpression
                 }
             }
@@ -369,9 +373,10 @@ class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder
             delegatedSelfTypeRef: FirTypeRef,
             owner: KtClassOrObject
         ): FirConstructor {
-            val constructorCallee = superTypeCallEntry?.calleeExpression
+            val constructorCallee = superTypeCallEntry?.calleeExpression?.toFirSourceElement()
+            val constructorSource = (this ?: owner).toFirSourceElement()
             val firDelegatedCall = FirDelegatedConstructorCallImpl(
-                constructorCallee ?: (this ?: owner),
+                constructorCallee ?: constructorSource,
                 delegatedSuperTypeRef,
                 isThis = false
             ).apply {
@@ -393,7 +398,7 @@ class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder
                 isInner = owner.hasModifier(INNER_KEYWORD)
             }
             val firConstructor = FirPrimaryConstructorImpl(
-                this ?: owner,
+                constructorSource,
                 session,
                 delegatedSelfTypeRef,
                 null,
@@ -410,13 +415,13 @@ class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder
 
         override fun visitKtFile(file: KtFile, data: Unit): FirElement {
             context.packageFqName = file.packageFqName
-            val firFile = FirFileImpl(file, session, file.name, context.packageFqName)
+            val firFile = FirFileImpl(file.toFirSourceElement(), session, file.name, context.packageFqName)
             for (annotationEntry in file.annotationEntries) {
                 firFile.annotations += annotationEntry.convert<FirAnnotationCall>()
             }
             for (importDirective in file.importDirectives) {
                 firFile.imports += FirImportImpl(
-                    importDirective,
+                    importDirective.toFirSourceElement(),
                     importDirective.importedFqName,
                     importDirective.isAllUnder,
                     importDirective.aliasName?.let { Name.identifier(it) }
@@ -431,7 +436,7 @@ class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder
         override fun visitEnumEntry(enumEntry: KtEnumEntry, data: Unit): FirElement {
             return withChildClassName(enumEntry.nameAsSafeName) {
                 val firEnumEntry = FirEnumEntryImpl(
-                    enumEntry,
+                    enumEntry.toFirSourceElement(),
                     session,
                     enumEntry.nameAsSafeName,
                     FirClassSymbol(context.currentClassId)
@@ -476,7 +481,7 @@ class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder
                 }
                 val firClass = if (status.modality == Modality.SEALED) {
                     FirSealedClassImpl(
-                        classOrObject,
+                        classOrObject.toFirSourceElement(),
                         session,
                         classOrObject.nameAsSafeName,
                         status,
@@ -485,7 +490,7 @@ class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder
                     )
                 } else {
                     FirClassImpl(
-                        classOrObject,
+                        classOrObject.toFirSourceElement(),
                         session,
                         classOrObject.nameAsSafeName,
                         status,
@@ -533,7 +538,7 @@ class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder
 
         override fun visitObjectLiteralExpression(expression: KtObjectLiteralExpression, data: Unit): FirElement {
             val objectDeclaration = expression.objectDeclaration
-            return FirAnonymousObjectImpl(expression, session).apply {
+            return FirAnonymousObjectImpl(expression.toFirSourceElement(), session).apply {
                 objectDeclaration.extractAnnotationsTo(this)
                 objectDeclaration.extractSuperTypeListEntriesTo(this, null)
                 this.typeRef = superTypeRefs.first() // TODO
@@ -554,7 +559,7 @@ class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder
             }
             return withChildClassName(typeAlias.nameAsSafeName) {
                 val firTypeAlias = FirTypeAliasImpl(
-                    typeAlias,
+                    typeAlias.toFirSourceElement(),
                     session,
                     typeAlias.nameAsSafeName,
                     status,
@@ -576,7 +581,7 @@ class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder
             }
             val receiverType = function.receiverTypeReference.convertSafe<FirTypeRef>()
             val firFunction = if (function.name == null) {
-                FirAnonymousFunctionImpl(function, session, returnType, receiverType, FirAnonymousFunctionSymbol())
+                FirAnonymousFunctionImpl(function.toFirSourceElement(), session, returnType, receiverType, FirAnonymousFunctionSymbol())
             } else {
                 val status = FirDeclarationStatusImpl(
                     if (function.isLocal) Visibilities.LOCAL else function.visibility,
@@ -593,7 +598,7 @@ class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder
                     isSuspend = function.hasModifier(SUSPEND_KEYWORD)
                 }
                 FirSimpleFunctionImpl(
-                    function,
+                    function.toFirSourceElement(),
                     session,
                     returnType,
                     receiverType,
@@ -617,9 +622,10 @@ class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder
 
         override fun visitLambdaExpression(expression: KtLambdaExpression, data: Unit): FirElement {
             val literal = expression.functionLiteral
-            val returnType = FirImplicitTypeRefImpl(literal)
-            val receiverType = FirImplicitTypeRefImpl(literal)
-            return FirAnonymousFunctionImpl(literal, session, returnType, receiverType, FirAnonymousFunctionSymbol()).apply {
+            val literalSource = literal.toFirSourceElement()
+            val returnType = FirImplicitTypeRefImpl(literalSource)
+            val receiverType = FirImplicitTypeRefImpl(literalSource)
+            return FirAnonymousFunctionImpl(literalSource, session, returnType, receiverType, FirAnonymousFunctionSymbol()).apply {
                 context.firFunctions += this
                 var destructuringBlock: FirExpression? = null
                 for (valueParameter in literal.valueParameters) {
@@ -627,9 +633,9 @@ class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder
                     valueParameters += if (multiDeclaration != null) {
                         val name = Name.special("<destruct>")
                         val multiParameter = FirValueParameterImpl(
-                            valueParameter,
+                            valueParameter.toFirSourceElement(),
                             this@RawFirBuilder.session,
-                            FirImplicitTypeRefImpl(multiDeclaration),
+                            FirImplicitTypeRefImpl(multiDeclaration.toFirSourceElement()),
                             name,
                             FirVariableSymbol(name),
                             defaultValue = null,
@@ -646,16 +652,17 @@ class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder
                         ) { toFirOrImplicitType() }
                         multiParameter
                     } else {
-                        valueParameter.toFirValueParameter(FirImplicitTypeRefImpl(psi))
+                        valueParameter.toFirValueParameter(FirImplicitTypeRefImpl(source))
                     }
                 }
+                val expressionSource = expression.toFirSourceElement()
                 label = context.firLabels.pop() ?: context.firFunctionCalls.lastOrNull()?.calleeReference?.name?.let {
-                    FirLabelImpl(expression, it.asString())
+                    FirLabelImpl(expressionSource, it.asString())
                 }
                 val bodyExpression = literal.bodyExpression.toFirExpression("Lambda has no body")
                 body = if (bodyExpression is FirBlockImpl) {
                     if (bodyExpression.statements.isEmpty()) {
-                        bodyExpression.statements.add(FirUnitExpression(expression))
+                        bodyExpression.statements.add(FirUnitExpression(expressionSource))
                     }
                     if (destructuringBlock is FirBlock) {
                         for ((index, statement) in destructuringBlock.statements.withIndex()) {
@@ -683,7 +690,7 @@ class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder
                 isInner = owner.hasModifier(INNER_KEYWORD)
             }
             val firConstructor = FirConstructorImpl(
-                this,
+                this.toFirSourceElement(),
                 session,
                 delegatedSelfTypeRef,
                 null,
@@ -707,12 +714,13 @@ class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder
             hasPrimaryConstructor: Boolean
         ): FirDelegatedConstructorCall {
             val isThis = isCallToThis || (isImplicit && hasPrimaryConstructor)
+            val source = this.toFirSourceElement()
             val delegatedType = when {
                 isThis -> delegatedSelfTypeRef
-                else -> delegatedSuperTypeRef ?: FirErrorTypeRefImpl(this, "No super type")
+                else -> delegatedSuperTypeRef ?: FirErrorTypeRefImpl(source, "No super type")
             }
             return FirDelegatedConstructorCallImpl(
-                this,
+                source,
                 delegatedType,
                 isThis
             ).apply {
@@ -724,7 +732,7 @@ class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder
 
         override fun visitAnonymousInitializer(initializer: KtAnonymousInitializer, data: Unit): FirElement {
             return FirAnonymousInitializerImpl(
-                initializer,
+                initializer.toFirSourceElement(),
                 session,
                 if (stubMode) FirEmptyExpressionBlock() else initializer.body.toFirBlock()
             )
@@ -738,9 +746,10 @@ class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder
                 { property.initializer }.toFirExpression("Should have initializer")
             } else null
             val delegateExpression by lazy { property.delegate?.expression }
+            val propertySource = property.toFirSourceElement()
             val firProperty = if (property.isLocal) {
                 FirPropertyImpl(
-                    property,
+                    propertySource,
                     session,
                     propertyType,
                     null,
@@ -748,7 +757,7 @@ class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder
                     initializer,
                     delegateExpression?.let {
                         FirWrappedDelegateExpressionImpl(
-                            it,
+                            it.toFirSourceElement(),
                             it.toFirExpression("Incorrect delegate expression")
                         )
                     },
@@ -768,7 +777,7 @@ class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder
                     isLateInit = property.hasModifier(LATEINIT_KEYWORD)
                 }
                 FirPropertyImpl(
-                    property,
+                    propertySource,
                     session,
                     propertyType,
                     property.receiverTypeReference.convertSafe(),
@@ -776,7 +785,7 @@ class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder
                     initializer,
                     if (property.hasDelegate()) {
                         FirWrappedDelegateExpressionImpl(
-                            if (stubMode) null else delegateExpression,
+                            if (stubMode) null else delegateExpression?.toFirSourceElement(),
                             { delegateExpression }.toFirExpression("Should have delegate")
                         )
                     } else null,
@@ -797,18 +806,19 @@ class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder
 
         override fun visitTypeReference(typeReference: KtTypeReference, data: Unit): FirElement {
             val typeElement = typeReference.typeElement
+            val source = typeReference.toFirSourceElement()
             val isNullable = typeElement is KtNullableType
 
             fun KtTypeElement?.unwrapNullable(): KtTypeElement? =
                 if (this is KtNullableType) this.innerType.unwrapNullable() else this
 
             val firType = when (val unwrappedElement = typeElement.unwrapNullable()) {
-                is KtDynamicType -> FirDynamicTypeRefImpl(typeReference, isNullable)
+                is KtDynamicType -> FirDynamicTypeRefImpl(source, isNullable)
                 is KtUserType -> {
                     var referenceExpression = unwrappedElement.referenceExpression
                     if (referenceExpression != null) {
                         val userType = FirUserTypeRefImpl(
-                            typeReference, isNullable
+                            source, isNullable
                         )
                         var qualifier: KtUserType? = unwrappedElement
                         do {
@@ -826,12 +836,12 @@ class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder
 
                         userType
                     } else {
-                        FirErrorTypeRefImpl(typeReference, "Incomplete user type")
+                        FirErrorTypeRefImpl(source, "Incomplete user type")
                     }
                 }
                 is KtFunctionType -> {
                     val functionType = FirFunctionTypeRefImpl(
-                        typeReference,
+                        source,
                         isNullable,
                         unwrappedElement.receiverTypeReference.convertSafe(),
                         // TODO: probably implicit type should not be here
@@ -842,7 +852,7 @@ class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder
                     }
                     functionType
                 }
-                null -> FirErrorTypeRefImpl(typeReference, "Unwrapped type is null")
+                null -> FirErrorTypeRefImpl(source, "Unwrapped type is null")
                 else -> throw AssertionError("Unexpected type element: ${unwrappedElement.text}")
             }
 
@@ -854,7 +864,7 @@ class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder
 
         override fun visitAnnotationEntry(annotationEntry: KtAnnotationEntry, data: Unit): FirElement {
             val firAnnotationCall = FirAnnotationCallImpl(
-                annotationEntry,
+                annotationEntry.toFirSourceElement(),
                 annotationEntry.useSiteTarget?.getAnnotationUseSiteTarget(),
                 annotationEntry.typeReference.toFirOrErrorType()
             )
@@ -865,7 +875,7 @@ class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder
         override fun visitTypeParameter(parameter: KtTypeParameter, data: Unit): FirElement {
             val parameterName = parameter.nameAsSafeName
             val firTypeParameter = FirTypeParameterImpl(
-                parameter,
+                parameter.toFirSourceElement(),
                 session,
                 parameterName,
                 FirTypeParameterSymbol(),
@@ -890,8 +900,9 @@ class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder
 
         override fun visitTypeProjection(typeProjection: KtTypeProjection, data: Unit): FirElement {
             val projectionKind = typeProjection.projectionKind
+            val source = typeProjection.toFirSourceElement()
             if (projectionKind == KtProjectionKind.STAR) {
-                return FirStarProjectionImpl(typeProjection)
+                return FirStarProjectionImpl(source)
             }
             if (projectionKind == KtProjectionKind.NONE && typeProjection.text == "_") {
                 return FirTypePlaceholderProjection
@@ -899,7 +910,7 @@ class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder
             val typeReference = typeProjection.typeReference
             val firType = typeReference.toFirOrErrorType()
             return FirTypeProjectionWithVarianceImpl(
-                typeProjection,
+                source,
                 firType,
                 when (projectionKind) {
                     KtProjectionKind.IN -> Variance.IN_VARIANCE
@@ -914,7 +925,7 @@ class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder
             parameter.toFirValueParameter()
 
         override fun visitBlockExpression(expression: KtBlockExpression, data: Unit): FirElement {
-            return FirBlockImpl(expression).apply {
+            return FirBlockImpl(expression.toFirSourceElement()).apply {
                 for (statement in expression.statements) {
                     val firStatement = statement.toFirStatement("Statement expected: ${statement.text}")
                     if (firStatement !is FirBlock || firStatement.annotations.isNotEmpty()) {
@@ -927,7 +938,7 @@ class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder
         }
 
         override fun visitSimpleNameExpression(expression: KtSimpleNameExpression, data: Unit): FirElement {
-            return generateAccessExpression(expression, expression.getReferencedNameAsName())
+            return generateAccessExpression(expression.toFirSourceElement(), expression.getReferencedNameAsName())
         }
 
         override fun visitConstantExpression(expression: KtConstantExpression, data: Unit): FirElement =
@@ -940,29 +951,30 @@ class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder
         }
 
         override fun visitReturnExpression(expression: KtReturnExpression, data: Unit): FirElement {
+            val source = expression.toFirSourceElement()
             val result = expression.returnedExpression?.toFirExpression("Incorrect return expression")
-                ?: FirUnitExpression(expression)
-            return result.toReturn(expression, expression.getTargetLabel()?.getReferencedName())
+                ?: FirUnitExpression(source)
+            return result.toReturn(source, expression.getTargetLabel()?.getReferencedName())
         }
 
         override fun visitTryExpression(expression: KtTryExpression, data: Unit): FirElement {
             val tryBlock = expression.tryBlock.toFirBlock()
             val finallyBlock = expression.finallyBlock?.finalExpression?.toFirBlock()
-            return FirTryExpressionImpl(expression, tryBlock, finallyBlock).apply {
+            return FirTryExpressionImpl(expression.toFirSourceElement(), tryBlock, finallyBlock).apply {
                 for (clause in expression.catchClauses) {
                     val parameter = clause.catchParameter?.toFirValueParameter() ?: continue
                     val block = clause.catchBody.toFirBlock()
-                    catches += FirCatchImpl(clause, parameter, block)
+                    catches += FirCatchImpl(clause.toFirSourceElement(), parameter, block)
                 }
             }
         }
 
         override fun visitIfExpression(expression: KtIfExpression, data: Unit): FirElement {
-            return FirWhenExpressionImpl(expression, null, null).apply {
+            return FirWhenExpressionImpl(expression.toFirSourceElement(), null, null).apply {
                 val condition = expression.condition
                 val firCondition = condition.toFirExpression("If statement should have condition")
                 val trueBranch = expression.then.toFirBlock()
-                branches += FirWhenBranchImpl(condition, firCondition, trueBranch)
+                branches += FirWhenBranchImpl(condition?.toFirSourceElement(), firCondition, trueBranch)
                 expression.`else`?.let {
                     branches += FirWhenBranchImpl(
                         null, FirElseIfTrueCondition(null), it.toFirBlock()
@@ -981,7 +993,7 @@ class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder
                 is KtVariableDeclaration -> {
                     val name = ktSubjectExpression.nameAsSafeName
                     FirPropertyImpl(
-                        ktSubjectExpression,
+                        ktSubjectExpression?.toFirSourceElement(),
                         session,
                         ktSubjectExpression.typeReference.toFirOrImplicitType(),
                         null,
@@ -999,7 +1011,7 @@ class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder
             val hasSubject = subjectExpression != null
             val subject = FirWhenSubject()
             return FirWhenExpressionImpl(
-                expression,
+                expression?.toFirSourceElement(),
                 subjectExpression,
                 subjectVariable
             ).apply {
@@ -1008,24 +1020,25 @@ class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder
                 }
                 var thereIsElseBranch = false
                 for (entry in expression.entries) {
+                    val entrySource = entry.toFirSourceElement()
                     val branch = entry.expression.toFirBlock()
                     branches += if (!entry.isElse) {
                         if (hasSubject) {
                             val firCondition = entry.conditions.toFirWhenCondition(
-                                entry,
+                                entrySource,
                                 subject,
                                 { toFirExpression(it) },
                                 { toFirOrErrorType() }
                             )
-                            FirWhenBranchImpl(entry, firCondition, branch)
+                            FirWhenBranchImpl(entrySource, firCondition, branch)
                         } else {
                             val condition = entry.conditions.first() as? KtWhenConditionWithExpression
                             val firCondition = condition?.expression.toFirExpression("No expression in condition with expression")
-                            FirWhenBranchImpl(entry, firCondition, branch)
+                            FirWhenBranchImpl(entrySource, firCondition, branch)
                         }
                     } else {
                         thereIsElseBranch = true
-                        FirWhenBranchImpl(entry, FirElseIfTrueCondition(null), branch)
+                        FirWhenBranchImpl(entrySource, FirElseIfTrueCondition(null), branch)
                     }
                 }
 //                if (!thereIsElseBranch) {
@@ -1036,52 +1049,54 @@ class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder
 
         override fun visitDoWhileExpression(expression: KtDoWhileExpression, data: Unit): FirElement {
             return FirDoWhileLoopImpl(
-                expression, expression.condition.toFirExpression("No condition in do-while loop")
+                expression.toFirSourceElement(), expression.condition.toFirExpression("No condition in do-while loop")
             ).configure { expression.body.toFirBlock() }
         }
 
         override fun visitWhileExpression(expression: KtWhileExpression, data: Unit): FirElement {
             return FirWhileLoopImpl(
-                expression, expression.condition.toFirExpression("No condition in while loop")
+                expression.toFirSourceElement(), expression.condition.toFirExpression("No condition in while loop")
             ).configure { expression.body.toFirBlock() }
         }
 
         override fun visitForExpression(expression: KtForExpression, data: Unit?): FirElement {
             val rangeExpression = expression.loopRange.toFirExpression("No range in for loop")
             val parameter = expression.loopParameter
-            return FirBlockImpl(expression).apply {
+            val loopSource = expression.toFirSourceElement()
+            return FirBlockImpl(loopSource).apply {
+                val rangeSource = expression.loopRange?.toFirSourceElement()
                 val rangeVal =
-                    generateTemporaryVariable(this@RawFirBuilder.session, expression.loopRange, Name.special("<range>"), rangeExpression)
+                    generateTemporaryVariable(this@RawFirBuilder.session, rangeSource, Name.special("<range>"), rangeExpression)
                 statements += rangeVal
                 val iteratorVal = generateTemporaryVariable(
-                    this@RawFirBuilder.session, expression.loopRange, Name.special("<iterator>"),
-                    FirFunctionCallImpl(expression).apply {
-                        calleeReference = FirSimpleNamedReference(expression, Name.identifier("iterator"), null)
-                        explicitReceiver = generateResolvedAccessExpression(expression.loopRange, rangeVal)
+                    this@RawFirBuilder.session, rangeSource, Name.special("<iterator>"),
+                    FirFunctionCallImpl(loopSource).apply {
+                        calleeReference = FirSimpleNamedReference(loopSource, Name.identifier("iterator"), null)
+                        explicitReceiver = generateResolvedAccessExpression(rangeSource, rangeVal)
                     }
                 )
                 statements += iteratorVal
                 statements += FirWhileLoopImpl(
-                    expression,
-                    FirFunctionCallImpl(expression).apply {
-                        calleeReference = FirSimpleNamedReference(expression, Name.identifier("hasNext"), null)
-                        explicitReceiver = generateResolvedAccessExpression(expression, iteratorVal)
+                    loopSource,
+                    FirFunctionCallImpl(loopSource).apply {
+                        calleeReference = FirSimpleNamedReference(loopSource, Name.identifier("hasNext"), null)
+                        explicitReceiver = generateResolvedAccessExpression(loopSource, iteratorVal)
                     }
                 ).configure {
                     // NB: just body.toFirBlock() isn't acceptable here because we need to add some statements
                     val block = when (val body = expression.body) {
                         is KtBlockExpression -> body.accept(this@Visitor, Unit) as FirBlockImpl
-                        null -> FirBlockImpl(body)
-                        else -> FirBlockImpl(body).apply { statements += body.toFirStatement() }
+                        null -> FirBlockImpl(null)
+                        else -> FirBlockImpl(body.toFirSourceElement()).apply { statements += body.toFirStatement() }
                     }
                     if (parameter != null) {
                         val multiDeclaration = parameter.destructuringDeclaration
                         val firLoopParameter = generateTemporaryVariable(
-                            this@RawFirBuilder.session, expression.loopParameter,
+                            this@RawFirBuilder.session, expression.loopParameter?.toFirSourceElement(),
                             if (multiDeclaration != null) Name.special("<destruct>") else parameter.nameAsSafeName,
-                            FirFunctionCallImpl(expression).apply {
-                                calleeReference = FirSimpleNamedReference(expression, Name.identifier("next"), null)
-                                explicitReceiver = generateResolvedAccessExpression(expression, iteratorVal)
+                            FirFunctionCallImpl(loopSource).apply {
+                                calleeReference = FirSimpleNamedReference(loopSource, Name.identifier("next"), null)
+                                explicitReceiver = generateResolvedAccessExpression(loopSource, iteratorVal)
                             }
                         )
                         if (multiDeclaration != null) {
@@ -1107,22 +1122,23 @@ class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder
         }
 
         override fun visitBreakExpression(expression: KtBreakExpression, data: Unit): FirElement {
-            return FirBreakExpressionImpl(expression).bindLabel(expression)
+            return FirBreakExpressionImpl(expression.toFirSourceElement()).bindLabel(expression)
         }
 
         override fun visitContinueExpression(expression: KtContinueExpression, data: Unit): FirElement {
-            return FirContinueExpressionImpl(expression).bindLabel(expression)
+            return FirContinueExpressionImpl(expression.toFirSourceElement()).bindLabel(expression)
         }
 
         override fun visitBinaryExpression(expression: KtBinaryExpression, data: Unit): FirElement {
             val operationToken = expression.operationToken
             val leftArgument = expression.left.toFirExpression("No left operand")
             val rightArgument = expression.right.toFirExpression("No right operand")
+            val source = expression.toFirSourceElement()
             when (operationToken) {
                 ELVIS ->
-                    return leftArgument.generateNotNullOrOther(session, rightArgument, "elvis", expression)
+                    return leftArgument.generateNotNullOrOther(session, rightArgument, "elvis", source)
                 ANDAND, OROR ->
-                    return leftArgument.generateLazyLogicalOperation(rightArgument, operationToken == ANDAND, expression)
+                    return leftArgument.generateLazyLogicalOperation(rightArgument, operationToken == ANDAND, source)
                 in OperatorConventions.IN_OPERATIONS ->
                     return rightArgument.generateContainsOperation(
                         leftArgument, operationToken == NOT_IN, expression, expression.operationReference
@@ -1130,9 +1146,9 @@ class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder
             }
             val conventionCallName = operationToken.toBinaryName()
             return if (conventionCallName != null || operationToken == IDENTIFIER) {
-                FirFunctionCallImpl(expression).apply {
+                FirFunctionCallImpl(source).apply {
                     calleeReference = FirSimpleNamedReference(
-                        expression.operationReference,
+                        expression.operationReference.toFirSourceElement(),
                         conventionCallName ?: expression.operationReference.getReferencedNameAsName(),
                         null
                     )
@@ -1142,11 +1158,11 @@ class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder
             } else {
                 val firOperation = operationToken.toFirOperation()
                 if (firOperation in FirOperation.ASSIGNMENTS) {
-                    return expression.left.generateAssignment(expression, rightArgument, firOperation) {
+                    return expression.left.generateAssignment(source, rightArgument, firOperation) {
                         (this as KtExpression).toFirExpression("Incorrect expression in assignment: ${expression.text}")
                     }
                 } else {
-                    FirOperatorCallImpl(expression, firOperation).apply {
+                    FirOperatorCallImpl(source, firOperation).apply {
                         arguments += leftArgument
                         arguments += rightArgument
                     }
@@ -1157,7 +1173,7 @@ class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder
         override fun visitBinaryWithTypeRHSExpression(expression: KtBinaryExpressionWithTypeRHS, data: Unit): FirElement {
             val operation = expression.operationReference.getReferencedNameElementType().toFirOperation()
             return FirTypeOperatorCallImpl(
-                expression, operation, expression.right.toFirOrErrorType()
+                expression.toFirSourceElement(), operation, expression.right.toFirOrErrorType()
             ).apply {
                 arguments += expression.left.toFirExpression("No left operand")
             }
@@ -1165,7 +1181,7 @@ class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder
 
         override fun visitIsExpression(expression: KtIsExpression, data: Unit): FirElement {
             return FirTypeOperatorCallImpl(
-                expression, if (expression.isNegated) FirOperation.NOT_IS else FirOperation.IS,
+                expression.toFirSourceElement(), if (expression.isNegated) FirOperation.NOT_IS else FirOperation.IS,
                 expression.typeReference.toFirOrErrorType()
             ).apply {
                 arguments += expression.leftHandSide.toFirExpression("No left operand")
@@ -1187,15 +1203,15 @@ class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder
                         prefix = expression is KtPrefixExpression
                     ) { (this as KtExpression).toFirExpression("Incorrect expression inside inc/dec") }
                 }
-                FirFunctionCallImpl(expression).apply {
+                FirFunctionCallImpl(expression.toFirSourceElement()).apply {
                     calleeReference = FirSimpleNamedReference(
-                        expression.operationReference, conventionCallName, null
+                        expression.operationReference.toFirSourceElement(), conventionCallName, null
                     )
                     explicitReceiver = argument.toFirExpression("No operand")
                 }
             } else {
                 val firOperation = operationToken.toFirOperation()
-                FirOperatorCallImpl(expression, firOperation).apply {
+                FirOperatorCallImpl(expression.toFirSourceElement(), firOperation).apply {
                     arguments += argument.toFirExpression("No operand")
                 }
             }
@@ -1203,18 +1219,19 @@ class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder
 
         override fun visitCallExpression(expression: KtCallExpression, data: Unit): FirElement {
             val calleeExpression = expression.calleeExpression
-            return FirFunctionCallImpl(expression).apply {
+            val source = expression.toFirSourceElement()
+            return FirFunctionCallImpl(source).apply {
                 val calleeReference = when (calleeExpression) {
                     is KtSimpleNameExpression -> FirSimpleNamedReference(
-                        calleeExpression, calleeExpression.getReferencedNameAsName(), null
+                        calleeExpression.toFirSourceElement(), calleeExpression.getReferencedNameAsName(), null
                     )
                     null -> FirErrorNamedReferenceImpl(
-                        calleeExpression, "Call has no callee"
+                        null, "Call has no callee"
                     )
                     else -> {
                         arguments += calleeExpression.toFirExpression("Incorrect invoke receiver")
                         FirSimpleNamedReference(
-                            expression, OperatorNameConventions.INVOKE, null
+                            source, OperatorNameConventions.INVOKE, null
                         )
                     }
                 }
@@ -1230,8 +1247,9 @@ class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder
 
         override fun visitArrayAccessExpression(expression: KtArrayAccessExpression, data: Unit): FirElement {
             val arrayExpression = expression.arrayExpression
-            return FirFunctionCallImpl(expression).apply {
-                calleeReference = FirSimpleNamedReference(expression, OperatorNameConventions.GET, null)
+            val source = expression.toFirSourceElement()
+            return FirFunctionCallImpl(source).apply {
+                calleeReference = FirSimpleNamedReference(source, OperatorNameConventions.GET, null)
                 explicitReceiver = arrayExpression.toFirExpression("No array expression")
                 for (indexExpression in expression.indexExpressions) {
                     arguments += indexExpression.toFirExpression("Incorrect index expression")
@@ -1241,7 +1259,7 @@ class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder
 
         override fun visitQualifiedExpression(expression: KtQualifiedExpression, data: Unit): FirElement {
             val selector = expression.selectorExpression
-                ?: return FirErrorExpressionImpl(expression, "Qualified expression without selector")
+                ?: return FirErrorExpressionImpl(expression.toFirSourceElement(), "Qualified expression without selector")
             val firSelector = selector.toFirExpression("Incorrect selector expression")
             if (firSelector is FirModifiableQualifiedAccess) {
                 firSelector.safe = expression is KtSafeQualifiedExpression
@@ -1252,27 +1270,30 @@ class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder
 
         override fun visitThisExpression(expression: KtThisExpression, data: Unit): FirElement {
             val labelName = expression.getLabelName()
-            return FirThisReceiverExpressionImpl(expression, FirExplicitThisReference(expression, labelName))
+            val source = expression.toFirSourceElement()
+            return FirThisReceiverExpressionImpl(source, FirExplicitThisReference(source, labelName))
         }
 
         override fun visitSuperExpression(expression: KtSuperExpression, data: Unit): FirElement {
             val superType = expression.superTypeQualifier
-            return FirQualifiedAccessExpressionImpl(expression).apply {
-                calleeReference = FirExplicitSuperReference(expression, superType.toFirOrImplicitType())
+            val source = expression.toFirSourceElement()
+            return FirQualifiedAccessExpressionImpl(source).apply {
+                calleeReference = FirExplicitSuperReference(source, superType.toFirOrImplicitType())
             }
         }
 
         override fun visitParenthesizedExpression(expression: KtParenthesizedExpression, data: Unit): FirElement {
-            return expression.expression?.accept(this, data) ?: FirErrorExpressionImpl(expression, "Empty parentheses")
+            return expression.expression?.accept(this, data) ?: FirErrorExpressionImpl(expression.toFirSourceElement(), "Empty parentheses")
         }
 
         override fun visitLabeledExpression(expression: KtLabeledExpression, data: Unit): FirElement {
+            val source = expression.toFirSourceElement()
             val labelName = expression.getLabelName()
             val size = context.firLabels.size
             if (labelName != null) {
-                context.firLabels += FirLabelImpl(expression, labelName)
+                context.firLabels += FirLabelImpl(source, labelName)
             }
-            val result = expression.baseExpression?.accept(this, data) ?: FirErrorExpressionImpl(expression, "Empty label")
+            val result = expression.baseExpression?.accept(this, data) ?: FirErrorExpressionImpl(source, "Empty label")
             if (size != context.firLabels.size) {
                 context.firLabels.removeLast()
                 println("Unused label: ${expression.text}")
@@ -1283,18 +1304,18 @@ class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder
         override fun visitAnnotatedExpression(expression: KtAnnotatedExpression, data: Unit): FirElement {
             val rawResult = expression.baseExpression?.accept(this, data)
             val result = rawResult as? FirAbstractAnnotatedElement
-                ?: FirErrorExpressionImpl(expression, "Strange annotated expression: ${rawResult?.render()}")
+                ?: FirErrorExpressionImpl(expression.toFirSourceElement(), "Strange annotated expression: ${rawResult?.render()}")
             expression.extractAnnotationsTo(result)
             return result
         }
 
         override fun visitThrowExpression(expression: KtThrowExpression, data: Unit): FirElement {
-            return FirThrowExpressionImpl(expression, expression.thrownExpression.toFirExpression("Nothing to throw"))
+            return FirThrowExpressionImpl(expression.toFirSourceElement(), expression.thrownExpression.toFirExpression("Nothing to throw"))
         }
 
         override fun visitDestructuringDeclaration(multiDeclaration: KtDestructuringDeclaration, data: Unit): FirElement {
             val baseVariable = generateTemporaryVariable(
-                session, multiDeclaration, "destruct",
+                session, multiDeclaration.toFirSourceElement(), "destruct",
                 multiDeclaration.initializer.toFirExpression("Destructuring declaration without initializer")
             )
             return generateDestructuringBlock(
@@ -1309,22 +1330,22 @@ class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder
         }
 
         override fun visitClassLiteralExpression(expression: KtClassLiteralExpression, data: Unit): FirElement {
-            return FirGetClassCallImpl(expression).apply {
+            return FirGetClassCallImpl(expression.toFirSourceElement()).apply {
                 arguments += expression.receiverExpression.toFirExpression("No receiver in class literal")
             }
         }
 
         override fun visitCallableReferenceExpression(expression: KtCallableReferenceExpression, data: Unit): FirElement {
-            return FirCallableReferenceAccessImpl(expression).apply {
+            return FirCallableReferenceAccessImpl(expression.toFirSourceElement()).apply {
                 calleeReference = FirSimpleNamedReference(
-                    expression.callableReference, expression.callableReference.getReferencedNameAsName(), null
+                    expression.callableReference.toFirSourceElement(), expression.callableReference.getReferencedNameAsName(), null
                 )
                 explicitReceiver = expression.receiverExpression?.toFirExpression("Incorrect receiver expression")
             }
         }
 
         override fun visitCollectionLiteralExpression(expression: KtCollectionLiteralExpression, data: Unit): FirElement {
-            return FirArrayOfCallImpl(expression).apply {
+            return FirArrayOfCallImpl(expression.toFirSourceElement()).apply {
                 for (innerExpression in expression.getInnerExpressions()) {
                     arguments += innerExpression.toFirExpression("Incorrect collection literal argument")
                 }
@@ -1332,7 +1353,7 @@ class RawFirBuilder(session: FirSession, val stubMode: Boolean) : BaseFirBuilder
         }
 
         override fun visitExpression(expression: KtExpression, data: Unit): FirElement {
-            return FirExpressionStub(expression)
+            return FirExpressionStub(expression.toFirSourceElement())
         }
     }
 }

compiler/fir/psi2fir/tests/org/jetbrains/kotlin/fir/builder/RawFirBuilderTotalKotlinTestCase.kt

@@ -15,6 +15,7 @@ import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccess
 import org.jetbrains.kotlin.fir.expressions.FirStatement
 import org.jetbrains.kotlin.fir.expressions.impl.FirExpressionStub
+import org.jetbrains.kotlin.fir.psi
 import org.jetbrains.kotlin.fir.references.FirErrorNamedReference
 import org.jetbrains.kotlin.fir.render
 import org.jetbrains.kotlin.fir.visitors.FirVisitorVoid

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/CopyUtils.kt

@@ -5,7 +5,6 @@
 
 package org.jetbrains.kotlin.fir
 
-import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.contracts.description.InvocationKind
 import org.jetbrains.kotlin.fir.declarations.FirAnonymousFunction
 import org.jetbrains.kotlin.fir.declarations.FirTypeParameter
@@ -32,12 +31,12 @@ fun FirFunctionCall.copy(
     explicitReceiver: FirExpression? = this.explicitReceiver,
     dispatchReceiver: FirExpression = this.dispatchReceiver,
     extensionReceiver: FirExpression = this.extensionReceiver,
-    psi: PsiElement? = this.psi,
+    source: FirSourceElement? = this.source,
     safe: Boolean = this.safe,
     typeArguments: List<FirTypeProjection> = this.typeArguments,
     resultType: FirTypeRef = this.typeRef
 ): FirFunctionCall {
-    return FirFunctionCallImpl(psi).apply {
+    return FirFunctionCallImpl(source).apply {
         this.safe = safe
         this.annotations.addAll(annotations)
         this.arguments.addAll(arguments)
@@ -52,7 +51,7 @@ fun FirFunctionCall.copy(
 
 fun FirAnonymousFunction.copy(
     receiverTypeRef: FirTypeRef? = this.receiverTypeRef,
-    psi: PsiElement? = this.psi,
+    source: FirSourceElement? = this.source,
     session: FirSession = this.session,
     returnTypeRef: FirTypeRef = this.returnTypeRef,
     valueParameters: List<FirValueParameter> = this.valueParameters,
@@ -63,7 +62,7 @@ fun FirAnonymousFunction.copy(
     controlFlowGraphReference: FirControlFlowGraphReference = this.controlFlowGraphReference,
     invocationKind: InvocationKind? = this.invocationKind
 ): FirAnonymousFunction {
-    return FirAnonymousFunctionImpl(psi, session, returnTypeRef, receiverTypeRef, symbol).apply {
+    return FirAnonymousFunctionImpl(source, session, returnTypeRef, receiverTypeRef, symbol).apply {
         this.valueParameters.addAll(valueParameters)
         this.body = body
         this.annotations.addAll(annotations)
@@ -78,7 +77,7 @@ fun FirAnonymousFunction.copy(
 fun FirTypeRef.resolvedTypeFromPrototype(
     type: ConeKotlinType
 ): FirResolvedTypeRef {
-    return FirResolvedTypeRefImpl(psi, type).apply {
+    return FirResolvedTypeRefImpl(source, type).apply {
         annotations += this@resolvedTypeFromPrototype.annotations
     }
 }
@@ -88,7 +87,7 @@ fun FirTypeParameter.copy(
     annotations: List<FirAnnotationCall> = this.annotations
 ): FirTypeParameterImpl {
     return FirTypeParameterImpl(
-        psi, session, name, symbol, variance, isReified
+        source, session, name, symbol, variance, isReified
     ).apply {
         this.bounds += bounds
         this.annotations += annotations
@@ -98,7 +97,7 @@ fun FirTypeParameter.copy(
 fun FirWhenExpression.copy(
     resultType: FirTypeRef = this.typeRef,
     calleeReference: FirReference = this.calleeReference
-): FirWhenExpressionImpl = FirWhenExpressionImpl(psi, subject, subjectVariable).apply {
+): FirWhenExpressionImpl = FirWhenExpressionImpl(source, subject, subjectVariable).apply {
     this.calleeReference = calleeReference
     this@apply.branches.addAll(this@copy.branches)
     this.typeRef = resultType
@@ -108,7 +107,7 @@ fun FirWhenExpression.copy(
 fun FirTryExpression.copy(
     resultType: FirTypeRef = this.typeRef,
     calleeReference: FirReference = this.calleeReference
-): FirTryExpressionImpl = FirTryExpressionImpl(psi, tryBlock, finallyBlock).apply {
+): FirTryExpressionImpl = FirTryExpressionImpl(source, tryBlock, finallyBlock).apply {
     this.calleeReference = calleeReference
     this@apply.catches.addAll(this@copy.catches)
     this.typeRef = resultType

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirCallResolver.kt

@@ -203,7 +203,7 @@ class FirCallResolver(
         }
         if (referencedSymbol is FirClassLikeSymbol<*>) {
             val classId = referencedSymbol.classId
-            return FirResolvedQualifierImpl(nameReference.psi, classId.packageFqName, classId.relativeClassName).apply {
+            return FirResolvedQualifierImpl(nameReference.source, classId.packageFqName, classId.relativeClassName).apply {
                 resultType = typeForQualifier(this)
             }
         }
@@ -292,7 +292,7 @@ class FirCallResolver(
                 expectedType,
                 outerConstraintSystemBuilder,
                 lhs,
-                FirExpressionStub(callableReferenceAccess.psi).apply { replaceTypeRef(FirResolvedTypeRefImpl(null, lhs.type)) },
+                FirExpressionStub(callableReferenceAccess.source).apply { replaceTypeRef(FirResolvedTypeRefImpl(null, lhs.type)) },
                 callableReferenceAccess.explicitReceiver
             )
         }
@@ -353,14 +353,14 @@ class FirCallResolver(
         applicability: CandidateApplicability
     ): FirNamedReference {
         val name = namedReference.name
-        val psi = namedReference.psi
+        val source = namedReference.source
         return when {
             candidates.isEmpty() -> FirErrorNamedReferenceImpl(
-                psi, "Unresolved name: $name"
+                source, "Unresolved name: $name"
             )
             applicability < CandidateApplicability.SYNTHETIC_RESOLVED -> {
                 FirErrorNamedReferenceImpl(
-                    psi,
+                    source,
                     "Inapplicable($applicability): ${candidates.map { describeSymbol(it.symbol) }}"
                 )
             }
@@ -368,17 +368,17 @@ class FirCallResolver(
                 val candidate = candidates.single()
                 val coneSymbol = candidate.symbol
                 when {
-                    coneSymbol is FirBackingFieldSymbol -> FirBackingFieldReferenceImpl(psi, null, coneSymbol)
+                    coneSymbol is FirBackingFieldSymbol -> FirBackingFieldReferenceImpl(source, null, coneSymbol)
                     coneSymbol is FirVariableSymbol && (
                             coneSymbol !is FirPropertySymbol ||
                                     (coneSymbol.phasedFir(session) as FirMemberDeclaration).typeParameters.isEmpty()
                             ) ->
-                        FirResolvedNamedReferenceImpl(psi, name, coneSymbol)
-                    else -> FirNamedReferenceWithCandidate(psi, name, candidate)
+                        FirResolvedNamedReferenceImpl(source, name, coneSymbol)
+                    else -> FirNamedReferenceWithCandidate(source, name, candidate)
                 }
             }
             else -> FirErrorNamedReferenceImpl(
-                psi, "Ambiguity: $name, ${candidates.map { describeSymbol(it.symbol) }}"
+                source, "Ambiguity: $name, ${candidates.map { describeSymbol(it.symbol) }}"
             )
         }
     }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ResolveUtils.kt

@@ -210,7 +210,7 @@ fun FirFunction<*>.constructFunctionalTypeRef(session: FirSession): FirResolvedT
 
     val functionalType = createFunctionalType(parameters, receiverTypeRef?.coneTypeUnsafe(), rawReturnType)
 
-    return FirResolvedTypeRefImpl(psi, functionalType)
+    return FirResolvedTypeRefImpl(source, functionalType)
 }
 
 fun createFunctionalType(
@@ -287,7 +287,7 @@ fun <T : FirResolvable> BodyResolveComponents.typeFromCallee(access: T): FirReso
 
     return when (val newCallee = access.calleeReference) {
         is FirErrorNamedReference ->
-            FirErrorTypeRefImpl(access.psi, newCallee.errorReason)
+            FirErrorTypeRefImpl(access.source, newCallee.errorReason)
         is FirNamedReferenceWithCandidate -> {
             typeFromSymbol(newCallee.candidateSymbol, makeNullable)
         }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/SamResolution.kt

@@ -114,7 +114,7 @@ class FirSamResolverImpl(
 
         val newTypeParameters = firRegularClass.typeParameters.map { typeParameter ->
             FirTypeParameterImpl(
-                typeParameter.psi,
+                typeParameter.source,
                 firSession,
                 typeParameter.name,
                 FirTypeParameterSymbol(),
@@ -137,7 +137,7 @@ class FirSamResolverImpl(
 
         for ((newTypeParameter, oldTypeParameter) in newTypeParameters.zip(firRegularClass.typeParameters)) {
             newTypeParameter.bounds += oldTypeParameter.bounds.mapNotNull { typeRef ->
-                FirResolvedTypeRefImpl(typeRef.psi, substitutor.substituteOrSelf(typeRef.coneTypeSafe() ?: return@mapNotNull null))
+                FirResolvedTypeRefImpl(typeRef.source, substitutor.substituteOrSelf(typeRef.coneTypeSafe() ?: return@mapNotNull null))
             }
         }
 
@@ -170,9 +170,9 @@ class FirSamResolverImpl(
         ).apply {
             valueParameters += listOf(
                 FirValueParameterImpl(
-                    psi,
+                    source,
                     session,
-                    FirResolvedTypeRefImpl(firRegularClass.psi, substitutedFunctionType),
+                    FirResolvedTypeRefImpl(firRegularClass.source, substitutedFunctionType),
                     SAM_PARAMETER_NAME,
                     FirVariableSymbol(SAM_PARAMETER_NAME),
                     defaultValue = null,

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/FirNamedReferenceWithCandidate.kt

@@ -5,16 +5,16 @@
 
 package org.jetbrains.kotlin.fir.resolve.calls
 
-import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.references.impl.FirSimpleNamedReference
 import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
 import org.jetbrains.kotlin.name.Name
 
 class FirNamedReferenceWithCandidate(
-    psi: PsiElement?,
+    source: FirSourceElement?,
     name: Name,
     val candidate: Candidate
-) : FirSimpleNamedReference(psi, name, candidate.symbol) {
+) : FirSimpleNamedReference(source, name, candidate.symbol) {
     override val candidateSymbol: AbstractFirBasedSymbol<*>
         get() = candidate.symbol
 }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/PostponedArgumentsAnalyzer.kt

@@ -83,10 +83,10 @@ class PostponedArgumentsAnalyzer(
         val namedReference = when {
             candidate == null || applicability < CandidateApplicability.SYNTHETIC_RESOLVED ->
                 FirErrorNamedReferenceImpl(
-                    callableReferenceAccess.psi,
+                    callableReferenceAccess.source,
                     "Unresolved reference: ${callableReferenceAccess.calleeReference.name}"
                 )
-            else -> FirNamedReferenceWithCandidate(callableReferenceAccess.psi, callableReferenceAccess.calleeReference.name, candidate)
+            else -> FirNamedReferenceWithCandidate(callableReferenceAccess.source, callableReferenceAccess.calleeReference.name, candidate)
         }
 
         val transformedCalleeReference = callableReferenceAccess.transformCalleeReference(

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/FirControlFlowGraphReferenceImpl.kt

@@ -5,14 +5,14 @@
 
 package org.jetbrains.kotlin.fir.resolve.dfa
 
-import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference
 import org.jetbrains.kotlin.fir.resolve.dfa.cfg.ControlFlowGraph
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
 class FirControlFlowGraphReferenceImpl(val controlFlowGraph: ControlFlowGraph) : FirControlFlowGraphReference() {
-    override val psi: PsiElement? get() = null
+    override val source: FirSourceElement? get() = null
 
     override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {}
 

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/cfg/ControlFlowGraph.kt

@@ -5,8 +5,8 @@
 
 package org.jetbrains.kotlin.fir.resolve.dfa.cfg
 
-import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.fir.FirElement
+import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.declarations.FirAnonymousInitializer
 import org.jetbrains.kotlin.fir.declarations.FirFunction
 import org.jetbrains.kotlin.fir.declarations.FirProperty
@@ -167,7 +167,7 @@ class AnnotationExitNode(owner: ControlFlowGraph, override val fir: FirAnnotatio
 // ----------------------------------- Stub -----------------------------------
 
 object FirStub : FirElement {
-    override val psi: PsiElement? get() = null
+    override val source: FirSourceElement? get() = null
 
     override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {}
 

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/cfg/ControlFlowGraphRenderer.kt

@@ -11,6 +11,7 @@ import org.jetbrains.kotlin.fir.expressions.FirDoWhileLoop
 import org.jetbrains.kotlin.fir.expressions.FirLoop
 import org.jetbrains.kotlin.fir.expressions.FirWhileLoop
 import org.jetbrains.kotlin.fir.expressions.impl.FirElseIfTrueCondition
+import org.jetbrains.kotlin.fir.psi
 import org.jetbrains.kotlin.fir.render
 import org.jetbrains.kotlin.utils.DFS
 

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirCallCompletionResultsWriterTransformer.kt

@@ -53,7 +53,7 @@ class FirCallCompletionResultsWriterTransformer(
         return qualifiedAccessExpression.transformCalleeReference(
             StoreCalleeReference,
             FirResolvedNamedReferenceImpl(
-                calleeReference.psi,
+                calleeReference.source,
                 calleeReference.name,
                 calleeReference.candidateSymbol
             )
@@ -79,7 +79,7 @@ class FirCallCompletionResultsWriterTransformer(
         return callableReferenceAccess.transformCalleeReference(
             StoreCalleeReference,
             FirResolvedCallableReferenceImpl(
-                calleeReference.psi,
+                calleeReference.source,
                 calleeReference.name,
                 calleeReference.candidateSymbol
             ).apply {
@@ -97,7 +97,7 @@ class FirCallCompletionResultsWriterTransformer(
         return variableAssignment.transformCalleeReference(
             StoreCalleeReference,
             FirResolvedNamedReferenceImpl(
-                calleeReference.psi,
+                calleeReference.source,
                 calleeReference.name,
                 calleeReference.candidateSymbol
             )
@@ -116,14 +116,14 @@ class FirCallCompletionResultsWriterTransformer(
                     is FirTypeProjectionWithVariance -> {
                         val typeRef = argument.typeRef as FirResolvedTypeRef
                         FirTypeProjectionWithVarianceImpl(
-                            argument.psi,
+                            argument.source,
                             typeRef.withReplacedConeType(type),
                             argument.variance
                         )
                     }
                     else -> {
                         FirTypeProjectionWithVarianceImpl(
-                            argument?.psi,
+                            argument?.source,
                             FirResolvedTypeRefImpl(null, type),
                             Variance.INVARIANT
                         )
@@ -149,7 +149,7 @@ class FirCallCompletionResultsWriterTransformer(
             resultType = resultType,
             typeArguments = typeArguments,
             calleeReference = FirResolvedNamedReferenceImpl(
-                calleeReference.psi,
+                calleeReference.source,
                 calleeReference.name,
                 calleeReference.candidateSymbol
             ),
@@ -215,7 +215,7 @@ class FirCallCompletionResultsWriterTransformer(
         return whenExpression.copy(
             resultType = resultType,
             calleeReference = FirResolvedNamedReferenceImpl(
-                calleeReference.psi,
+                calleeReference.source,
                 calleeReference.name,
                 calleeReference.candidateSymbol
             )
@@ -241,7 +241,7 @@ class FirCallCompletionResultsWriterTransformer(
         return tryExpression.copy(
             resultType = resultType,
             calleeReference = FirResolvedNamedReferenceImpl(
-                calleeReference.psi,
+                calleeReference.source,
                 calleeReference.name,
                 calleeReference.candidateSymbol
             )

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSpecificTypeResolverTransformer.kt

@@ -29,7 +29,7 @@ class FirSpecificTypeResolverTransformer(
         val typeResolver = FirTypeResolver.getInstance(session)
         functionTypeRef.transformChildren(this, data)
         return FirResolvedFunctionTypeRefImpl(
-            functionTypeRef.psi,
+            functionTypeRef.source,
             typeResolver.resolveType(functionTypeRef, towerScope),
             functionTypeRef.isMarkedNullable,
             functionTypeRef.receiverTypeRef,
@@ -42,7 +42,7 @@ class FirSpecificTypeResolverTransformer(
 
     private fun transformType(typeRef: FirTypeRef, resolvedType: ConeKotlinType): CompositeTransformResult<FirTypeRef> {
         return FirResolvedTypeRefImpl(
-            typeRef.psi,
+            typeRef.source,
             resolvedType
         ).apply {
             annotations += typeRef.annotations

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSupertypeResolverTransformer.kt

@@ -9,7 +9,9 @@ import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.expressions.FirStatement
 import org.jetbrains.kotlin.fir.render
-import org.jetbrains.kotlin.fir.resolve.*
+import org.jetbrains.kotlin.fir.resolve.ScopeSession
+import org.jetbrains.kotlin.fir.resolve.firProvider
+import org.jetbrains.kotlin.fir.resolve.firSymbolProvider
 import org.jetbrains.kotlin.fir.scopes.addImportingScopes
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.fir.types.impl.FirErrorTypeRefImpl
@@ -162,7 +164,7 @@ class FirSupertypeResolverTransformer : FirAbstractTreeTransformer(phase = FirRe
                 val coneType = (superTypeRef as FirResolvedTypeRef).type
                 if (coneType is ConeTypeParameterType) {
                     resultingTypeRefs.add(
-                        FirErrorTypeRefImpl(superTypeRef.psi, "Type parameter cannot be a super-type: ${coneType.render()}")
+                        FirErrorTypeRefImpl(superTypeRef.source, "Type parameter cannot be a super-type: ${coneType.render()}")
                     )
                     continue
                 }
@@ -171,7 +173,7 @@ class FirSupertypeResolverTransformer : FirAbstractTreeTransformer(phase = FirRe
 
                 if (superTypeClassId.outerClasses().any { it.areSupertypesComputing() }) {
                     resultingTypeRefs.add(
-                        FirErrorTypeRefImpl(superTypeRef.psi, "Recursion detected: ${superTypeRef.render()}")
+                        FirErrorTypeRefImpl(superTypeRef.source, "Recursion detected: ${superTypeRef.render()}")
                     )
 
                     continue

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSyntheticCallGenerator.kt

@@ -164,7 +164,7 @@ class FirSyntheticCallGenerator(
         }
         return FirSimpleFunctionImpl(
             session = session,
-            psi = null,
+            source = null,
             symbol = symbol,
             name = name,
             status = status,
@@ -179,7 +179,7 @@ class FirSyntheticCallGenerator(
         val name = Name.identifier(name)
         return FirValueParameterImpl(
             session = session,
-            psi = null,
+            source = null,
             name = name,
             returnTypeRef = this,
             defaultValue = null,

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirDeclarationsResolveTransformer.kt

@@ -326,7 +326,7 @@ class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransformer)
                 val bodyExpectedType = returnTypeRefFromResolvedAtom ?: data
                 af = transformFunction(af, bodyExpectedType).single as FirAnonymousFunction
                 af = af.copy(
-                    returnTypeRef = af.body?.resultType ?: FirErrorTypeRefImpl(af.psi, "No result type for lambda")
+                    returnTypeRef = af.body?.resultType ?: FirErrorTypeRefImpl(af.source, "No result type for lambda")
                 )
                 af.replaceTypeRef(af.constructFunctionalTypeRef(session))
                 af.compose()

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt

@@ -5,7 +5,8 @@
 
 package org.jetbrains.kotlin.fir.resolve.transformers.body.resolve
 
-import org.jetbrains.kotlin.fir.*
+import org.jetbrains.kotlin.fir.BuiltinTypes
+import org.jetbrains.kotlin.fir.FirCallResolver
 import org.jetbrains.kotlin.fir.expressions.*
 import org.jetbrains.kotlin.fir.expressions.impl.FirErrorExpressionImpl
 import org.jetbrains.kotlin.fir.expressions.impl.FirExpressionWithSmartcastImpl
@@ -53,7 +54,7 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) :
 
     override fun transformExpression(expression: FirExpression, data: Any?): CompositeTransformResult<FirStatement> {
         if (expression.resultType is FirImplicitTypeRef && expression !is FirWrappedExpression) {
-            val type = FirErrorTypeRefImpl(expression.psi, "Type calculating for ${expression::class} is not supported")
+            val type = FirErrorTypeRefImpl(expression.source, "Type calculating for ${expression::class} is not supported")
             expression.resultType = type
         }
         return (expression.transformChildren(transformer, data) as FirStatement).compose()
@@ -81,7 +82,7 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) :
                 } else {
                     val superTypeRef = implicitReceiverStack.lastDispatchReceiver()
                         ?.boundSymbol?.phasedFir?.superTypeRefs?.firstOrNull()
-                        ?: FirErrorTypeRefImpl(qualifiedAccessExpression.psi, "No super type")
+                        ?: FirErrorTypeRefImpl(qualifiedAccessExpression.source, "No super type")
                     qualifiedAccessExpression.resultType = superTypeRef
                     callee.replaceSuperTypeRef(superTypeRef)
                 }
@@ -123,7 +124,7 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) :
         }
         val intersectedType = ConeTypeIntersector.intersectTypes(inferenceComponents.ctx as ConeInferenceContext, allTypes)
         // TODO: add check that intersectedType is not equal to original type
-        val intersectedTypeRef = FirResolvedTypeRefImpl(qualifiedAccessExpression.resultType.psi, intersectedType).apply {
+        val intersectedTypeRef = FirResolvedTypeRefImpl(qualifiedAccessExpression.resultType.source, intersectedType).apply {
             annotations += qualifiedAccessExpression.resultType.annotations
         }
         return FirExpressionWithSmartcastImpl(qualifiedAccessExpression, intersectedTypeRef, typesFromSmartCast)
@@ -167,7 +168,7 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) :
             else -> null
         }
         block.resultType = if (resultExpression == null) {
-            FirImplicitUnitTypeRef(block.psi)
+            FirImplicitUnitTypeRef(block.source)
         } else {
             (resultExpression.resultType as? FirResolvedTypeRef) ?: FirErrorTypeRefImpl(null, "No type for block")
         }
@@ -197,11 +198,11 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) :
             val operatorCall = operatorCall.transformArguments(this, noExpectedType)
             val (leftArgument, rightArgument) = operatorCall.arguments
 
-            fun createFunctionCall(name: Name) = FirFunctionCallImpl(operatorCall.psi).apply {
+            fun createFunctionCall(name: Name) = FirFunctionCallImpl(operatorCall.source).apply {
                 explicitReceiver = leftArgument
                 arguments += rightArgument
                 calleeReference = FirSimpleNamedReference(
-                    operatorCall.psi,
+                    operatorCall.source,
                     name,
                     candidateSymbol = null
                 )
@@ -224,14 +225,14 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) :
                 operatorCallReference == null || property?.isVal == true -> resolvedAssignCall.compose()
                 assignCallReference == null -> {
                     val assignment =
-                        FirVariableAssignmentImpl(operatorCall.psi, false, resolvedOperatorCall, FirOperation.ASSIGN).apply {
+                        FirVariableAssignmentImpl(operatorCall.source, false, resolvedOperatorCall, FirOperation.ASSIGN).apply {
                             lValue = (leftArgument as? FirQualifiedAccess)?.calleeReference
                                 ?: FirErrorNamedReferenceImpl(null, "Unresolved reference")
                         }
                     assignment.transform(transformer, noExpectedType)
                 }
                 else -> FirErrorExpressionImpl(
-                    operatorCall.psi,
+                    operatorCall.source,
                     "Operator overload ambiguity. $assignmentOperatorName and $simpleOperatorName are compatible"
                 ).compose()
             }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirClassSubstitutionScope.kt

@@ -6,9 +6,11 @@
 package org.jetbrains.kotlin.fir.scopes.impl
 
 import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
 import org.jetbrains.kotlin.fir.declarations.FirProperty
-import org.jetbrains.kotlin.fir.declarations.impl.*
+import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
+import org.jetbrains.kotlin.fir.declarations.impl.FirPropertyImpl
+import org.jetbrains.kotlin.fir.declarations.impl.FirSimpleFunctionImpl
+import org.jetbrains.kotlin.fir.declarations.impl.FirValueParameterImpl
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.substitution.substitutorByMap
 import org.jetbrains.kotlin.fir.resolve.transformers.ReturnTypeCalculatorWithJump
@@ -116,7 +118,7 @@ class FirClassSubstitutionScope(
                 // TODO: consider using here some light-weight functions instead of pseudo-real FirMemberFunctionImpl
                 // As second alternative, we can invent some light-weight kind of FirRegularClass
                 FirSimpleFunctionImpl(
-                    psi,
+                    source,
                     session,
                     baseFunction.returnTypeRef.withReplacedConeType(newReturnType),
                     baseFunction.receiverTypeRef?.withReplacedConeType(newReceiverType),
@@ -130,7 +132,7 @@ class FirClassSubstitutionScope(
                     ) { valueParameter, newType ->
                         with(valueParameter) {
                             FirValueParameterImpl(
-                                psi,
+                                source,
                                 session,
                                 this.returnTypeRef.withReplacedConeType(newType),
                                 name,
@@ -157,7 +159,7 @@ class FirClassSubstitutionScope(
             val symbol = FirPropertySymbol(baseSymbol.callableId, true, baseSymbol)
             with(baseProperty) {
                 FirPropertyImpl(
-                    psi,
+                    source,
                     session,
                     baseProperty.returnTypeRef.withReplacedConeType(newReturnType),
                     baseProperty.receiverTypeRef?.withReplacedConeType(newReceiverType),
@@ -182,7 +184,7 @@ fun FirTypeRef.withReplacedConeType(newType: ConeKotlinType?): FirResolvedTypeRe
     require(this is FirResolvedTypeRef)
     if (newType == null) return this
 
-    return FirResolvedTypeRefImpl(psi, newType).apply {
+    return FirResolvedTypeRefImpl(source, newType).apply {
         annotations += this@withReplacedConeType.annotations
     }
 

compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirAnnotationContainer.kt

@@ -5,7 +5,6 @@
 
 package org.jetbrains.kotlin.fir
 
-import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.visitors.*
 
@@ -15,7 +14,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  */
 
 interface FirAnnotationContainer : FirElement {
-    override val psi: PsiElement?
+    override val source: FirSourceElement?
     val annotations: List<FirAnnotationCall>
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitAnnotationContainer(this, data)

compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirControlFlowGraphOwner.kt

@@ -5,7 +5,6 @@
 
 package org.jetbrains.kotlin.fir
 
-import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference
 import org.jetbrains.kotlin.fir.visitors.*
 
@@ -15,7 +14,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  */
 
 interface FirControlFlowGraphOwner : FirElement {
-    override val psi: PsiElement?
+    override val source: FirSourceElement?
     val controlFlowGraphReference: FirControlFlowGraphReference
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitControlFlowGraphOwner(this, data)

compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirElement.kt

@@ -5,7 +5,6 @@
 
 package org.jetbrains.kotlin.fir
 
-import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
 import org.jetbrains.kotlin.fir.visitors.*
 
@@ -15,7 +14,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  */
 
 interface FirElement {
-    val psi: PsiElement?
+    val source: FirSourceElement?
 
     fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitElement(this, data)
 

compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirLabel.kt

@@ -5,7 +5,6 @@
 
 package org.jetbrains.kotlin.fir
 
-import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.fir.visitors.*
 
 /*
@@ -14,7 +13,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  */
 
 abstract class FirLabel : FirPureAbstractElement(), FirElement {
-    abstract override val psi: PsiElement?
+    abstract override val source: FirSourceElement?
     abstract val name: String
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitLabel(this, data)

compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirSourceElement.kt

@@ -0,0 +1,19 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.fir
+
+import com.intellij.psi.PsiElement
+
+abstract class FirSourceElement
+
+class FirPsiSourceElement(val psi: PsiElement) : FirSourceElement()
+
+val FirSourceElement?.psi: PsiElement? get() = (this as? FirPsiSourceElement)?.psi
+
+val FirElement.psi: PsiElement? get() = (source as? FirPsiSourceElement)?.psi
+
+@Suppress("NOTHING_TO_INLINE")
+inline fun PsiElement.toFirSourceElement(): FirPsiSourceElement = FirPsiSourceElement(this)

compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirSymbolOwner.kt

@@ -5,7 +5,6 @@
 
 package org.jetbrains.kotlin.fir
 
-import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
 import org.jetbrains.kotlin.fir.visitors.*
@@ -16,7 +15,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  */
 
 interface FirSymbolOwner<E> : FirElement where E : FirSymbolOwner<E>, E : FirDeclaration {
-    override val psi: PsiElement?
+    override val source: FirSourceElement?
     val symbol: AbstractFirBasedSymbol<E>
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitSymbolOwner(this, data)

compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirTargetElement.kt

@@ -5,7 +5,6 @@
 
 package org.jetbrains.kotlin.fir
 
-import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.fir.visitors.*
 
 /*
@@ -14,7 +13,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  */
 
 interface FirTargetElement : FirElement {
-    override val psi: PsiElement?
+    override val source: FirSourceElement?
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitTargetElement(this, data)
 }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/contracts/FirContractDescription.kt

@@ -5,9 +5,9 @@
 
 package org.jetbrains.kotlin.fir.contracts
 
-import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirPureAbstractElement
+import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.contracts.description.ConeEffectDeclaration
 import org.jetbrains.kotlin.fir.visitors.*
 
@@ -17,7 +17,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  */
 
 abstract class FirContractDescription : FirPureAbstractElement(), FirElement {
-    abstract override val psi: PsiElement?
+    abstract override val source: FirSourceElement?
     abstract val effects: List<ConeEffectDeclaration>
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitContractDescription(this, data)

compiler/fir/tree/src/org/jetbrains/kotlin/fir/contracts/impl/FirContractDescriptionImpl.kt

@@ -5,7 +5,7 @@
 
 package org.jetbrains.kotlin.fir.contracts.impl
 
-import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.contracts.FirContractDescription
 import org.jetbrains.kotlin.fir.contracts.description.ConeEffectDeclaration
 import org.jetbrains.kotlin.fir.visitors.*
@@ -16,7 +16,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  */
 
 class FirContractDescriptionImpl(
-    override val psi: PsiElement?
+    override val source: FirSourceElement?
 ) : FirContractDescription() {
     override val effects: MutableList<ConeEffectDeclaration> = mutableListOf()
 

compiler/fir/tree/src/org/jetbrains/kotlin/fir/contracts/impl/FirEmptyContractDescription.kt

@@ -5,14 +5,14 @@
 
 package org.jetbrains.kotlin.fir.contracts.impl
 
-import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.contracts.FirContractDescription
 import org.jetbrains.kotlin.fir.contracts.description.ConeEffectDeclaration
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
 object FirEmptyContractDescription : FirContractDescription() {
-    override val psi: PsiElement? get() = null
+    override val source: FirSourceElement? get() = null
     override val effects: List<ConeEffectDeclaration> get() = emptyList()
 
     override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirAnonymousFunction.kt

@@ -5,11 +5,11 @@
 
 package org.jetbrains.kotlin.fir.declarations
 
-import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.contracts.description.InvocationKind
 import org.jetbrains.kotlin.fir.FirLabel
 import org.jetbrains.kotlin.fir.FirPureAbstractElement
 import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirBlock
 import org.jetbrains.kotlin.fir.expressions.FirExpression
@@ -24,7 +24,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  */
 
 abstract class FirAnonymousFunction : FirPureAbstractElement(), FirFunction<FirAnonymousFunction>, FirExpression {
-    abstract override val psi: PsiElement?
+    abstract override val source: FirSourceElement?
     abstract override val session: FirSession
     abstract override val resolvePhase: FirResolvePhase
     abstract override val annotations: List<FirAnnotationCall>

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirAnonymousInitializer.kt

@@ -5,9 +5,9 @@
 
 package org.jetbrains.kotlin.fir.declarations
 
-import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.fir.FirPureAbstractElement
 import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.expressions.FirBlock
 import org.jetbrains.kotlin.fir.visitors.*
 
@@ -17,7 +17,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  */
 
 abstract class FirAnonymousInitializer : FirPureAbstractElement(), FirDeclaration {
-    abstract override val psi: PsiElement?
+    abstract override val source: FirSourceElement?
     abstract override val session: FirSession
     abstract override val resolvePhase: FirResolvePhase
     abstract val body: FirBlock?

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirAnonymousObject.kt

@@ -5,10 +5,10 @@
 
 package org.jetbrains.kotlin.fir.declarations
 
-import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.fir.FirPureAbstractElement
 import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.types.FirTypeRef
@@ -20,7 +20,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  */
 
 abstract class FirAnonymousObject : FirPureAbstractElement(), FirClass, FirExpression {
-    abstract override val psi: PsiElement?
+    abstract override val source: FirSourceElement?
     abstract override val session: FirSession
     abstract override val resolvePhase: FirResolvePhase
     abstract override val classKind: ClassKind

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirCallableDeclaration.kt

@@ -5,8 +5,8 @@
 
 package org.jetbrains.kotlin.fir.declarations
 
-import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.FirSymbolOwner
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
@@ -19,7 +19,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  */
 
 interface FirCallableDeclaration<F : FirCallableDeclaration<F>> : FirTypedDeclaration, FirSymbolOwner<F> {
-    override val psi: PsiElement?
+    override val source: FirSourceElement?
     override val session: FirSession
     override val resolvePhase: FirResolvePhase
     override val annotations: List<FirAnnotationCall>

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirCallableMemberDeclaration.kt

@@ -5,8 +5,8 @@
 
 package org.jetbrains.kotlin.fir.declarations
 
-import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 import org.jetbrains.kotlin.fir.types.FirTypeRef
@@ -20,7 +20,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  */
 
 interface FirCallableMemberDeclaration<F : FirCallableMemberDeclaration<F>> : FirCallableDeclaration<F>, FirMemberDeclaration {
-    override val psi: PsiElement?
+    override val source: FirSourceElement?
     override val session: FirSession
     override val resolvePhase: FirResolvePhase
     override val annotations: List<FirAnnotationCall>

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirClass.kt

@@ -5,10 +5,10 @@
 
 package org.jetbrains.kotlin.fir.declarations
 
-import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.fir.FirAnnotationContainer
 import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirStatement
 import org.jetbrains.kotlin.fir.types.FirTypeRef
@@ -20,7 +20,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  */
 
 interface FirClass : FirDeclaration, FirStatement, FirAnnotationContainer {
-    override val psi: PsiElement?
+    override val source: FirSourceElement?
     override val session: FirSession
     override val resolvePhase: FirResolvePhase
     val classKind: ClassKind

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirClassLikeDeclaration.kt

@@ -5,8 +5,8 @@
 
 package org.jetbrains.kotlin.fir.declarations
 
-import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.FirSymbolOwner
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirStatement
@@ -20,7 +20,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  */
 
 interface FirClassLikeDeclaration<F : FirClassLikeDeclaration<F>> : FirStatement, FirMemberDeclaration, FirSymbolOwner<F>, FirTypeParametersOwner {
-    override val psi: PsiElement?
+    override val source: FirSourceElement?
     override val annotations: List<FirAnnotationCall>
     override val session: FirSession
     override val resolvePhase: FirResolvePhase

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirConstructor.kt

@@ -5,8 +5,8 @@
 
 package org.jetbrains.kotlin.fir.declarations
 
-import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirBlock
 import org.jetbrains.kotlin.fir.expressions.FirDelegatedConstructorCall
@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  */
 
 interface FirConstructor : FirMemberFunction<FirConstructor> {
-    override val psi: PsiElement?
+    override val source: FirSourceElement?
     override val session: FirSession
     override val resolvePhase: FirResolvePhase
     override val returnTypeRef: FirTypeRef

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirContractDescriptionOwner.kt

@@ -5,8 +5,8 @@
 
 package org.jetbrains.kotlin.fir.declarations
 
-import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.fir.FirElement
+import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.contracts.FirContractDescription
 import org.jetbrains.kotlin.fir.visitors.*
 
@@ -16,7 +16,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  */
 
 interface FirContractDescriptionOwner : FirElement {
-    override val psi: PsiElement?
+    override val source: FirSourceElement?
     val contractDescription: FirContractDescription
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitContractDescriptionOwner(this, data)

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirDeclaration.kt

@@ -5,9 +5,9 @@
 
 package org.jetbrains.kotlin.fir.declarations
 
-import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.visitors.*
 
 /*
@@ -16,7 +16,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  */
 
 interface FirDeclaration : FirElement {
-    override val psi: PsiElement?
+    override val source: FirSourceElement?
     val session: FirSession
     val resolvePhase: FirResolvePhase
 

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirDeclarationStatus.kt

@@ -5,10 +5,10 @@
 
 package org.jetbrains.kotlin.fir.declarations
 
-import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.fir.FirElement
+import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.visitors.*
 
 /*
@@ -17,7 +17,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  */
 
 interface FirDeclarationStatus : FirElement {
-    override val psi: PsiElement?
+    override val source: FirSourceElement?
     val visibility: Visibility
     val modality: Modality?
     val isExpect: Boolean

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirEnumEntry.kt

@@ -5,10 +5,10 @@
 
 package org.jetbrains.kotlin.fir.declarations
 
-import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.fir.FirPureAbstractElement
 import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  */
 
 abstract class FirEnumEntry : FirPureAbstractElement(), FirRegularClass {
-    abstract override val psi: PsiElement?
+    abstract override val source: FirSourceElement?
     abstract override val session: FirSession
     abstract override val resolvePhase: FirResolvePhase
     abstract override val name: Name

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirErrorFunction.kt

@@ -5,9 +5,9 @@
 
 package org.jetbrains.kotlin.fir.declarations
 
-import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.fir.FirPureAbstractElement
 import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirBlock
 import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference
@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  */
 
 abstract class FirErrorFunction : FirPureAbstractElement(), FirFunction<FirErrorFunction> {
-    abstract override val psi: PsiElement?
+    abstract override val source: FirSourceElement?
     abstract override val session: FirSession
     abstract override val resolvePhase: FirResolvePhase
     abstract override val annotations: List<FirAnnotationCall>

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirField.kt

@@ -5,9 +5,9 @@
 
 package org.jetbrains.kotlin.fir.declarations
 
-import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.fir.FirPureAbstractElement
 import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.symbols.impl.FirDelegateFieldSymbol
@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  */
 
 abstract class FirField : FirPureAbstractElement(), FirVariable<FirField>, FirCallableMemberDeclaration<FirField> {
-    abstract override val psi: PsiElement?
+    abstract override val source: FirSourceElement?
     abstract override val session: FirSession
     abstract override val resolvePhase: FirResolvePhase
     abstract override val returnTypeRef: FirTypeRef

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirFile.kt

@@ -5,10 +5,10 @@
 
 package org.jetbrains.kotlin.fir.declarations
 
-import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.fir.FirAnnotationContainer
 import org.jetbrains.kotlin.fir.FirPureAbstractElement
 import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.fir.visitors.*
@@ -19,7 +19,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  */
 
 abstract class FirFile : FirPureAbstractElement(), FirAnnotationContainer, FirDeclaration {
-    abstract override val psi: PsiElement?
+    abstract override val source: FirSourceElement?
     abstract override val annotations: List<FirAnnotationCall>
     abstract override val session: FirSession
     abstract override val resolvePhase: FirResolvePhase

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirFunction.kt

@@ -5,10 +5,10 @@
 
 package org.jetbrains.kotlin.fir.declarations
 
-import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.fir.FirAnnotationContainer
 import org.jetbrains.kotlin.fir.FirControlFlowGraphOwner
 import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.FirTargetElement
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirBlock
@@ -24,7 +24,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  */
 
 interface FirFunction<F : FirFunction<F>> : FirCallableDeclaration<F>, FirControlFlowGraphOwner, FirTargetElement, FirAnnotationContainer, FirTypeParametersOwner, FirStatement {
-    override val psi: PsiElement?
+    override val source: FirSourceElement?
     override val session: FirSession
     override val resolvePhase: FirResolvePhase
     override val annotations: List<FirAnnotationCall>

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirImport.kt

@@ -5,9 +5,9 @@
 
 package org.jetbrains.kotlin.fir.declarations
 
-import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirPureAbstractElement
+import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.fir.visitors.*
@@ -18,7 +18,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  */
 
 abstract class FirImport : FirPureAbstractElement(), FirElement {
-    abstract override val psi: PsiElement?
+    abstract override val source: FirSourceElement?
     abstract val importedFqName: FqName?
     abstract val isAllUnder: Boolean
     abstract val aliasName: Name?

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirMemberDeclaration.kt

@@ -5,9 +5,9 @@
 
 package org.jetbrains.kotlin.fir.declarations
 
-import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.fir.FirAnnotationContainer
 import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.fir.visitors.*
@@ -18,7 +18,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  */
 
 interface FirMemberDeclaration : FirNamedDeclaration, FirAnnotationContainer {
-    override val psi: PsiElement?
+    override val source: FirSourceElement?
     override val session: FirSession
     override val resolvePhase: FirResolvePhase
     override val name: Name

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirMemberFunction.kt

@@ -5,8 +5,8 @@
 
 package org.jetbrains.kotlin.fir.declarations
 
-import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirBlock
 import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference
@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  */
 
 interface FirMemberFunction<F : FirMemberFunction<F>> : FirFunction<F>, FirCallableMemberDeclaration<F> {
-    override val psi: PsiElement?
+    override val source: FirSourceElement?
     override val session: FirSession
     override val resolvePhase: FirResolvePhase
     override val returnTypeRef: FirTypeRef

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirNamedDeclaration.kt

@@ -5,8 +5,8 @@
 
 package org.jetbrains.kotlin.fir.declarations
 
-import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.fir.visitors.*
 
@@ -16,7 +16,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  */
 
 interface FirNamedDeclaration : FirDeclaration {
-    override val psi: PsiElement?
+    override val source: FirSourceElement?
     override val session: FirSession
     override val resolvePhase: FirResolvePhase
     val name: Name

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirProperty.kt

@@ -5,10 +5,10 @@
 
 package org.jetbrains.kotlin.fir.declarations
 
-import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.fir.FirControlFlowGraphOwner
 import org.jetbrains.kotlin.fir.FirPureAbstractElement
 import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference
@@ -26,7 +26,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  */
 
 abstract class FirProperty : FirPureAbstractElement(), FirVariable<FirProperty>, FirControlFlowGraphOwner, FirTypeParametersOwner, FirCallableMemberDeclaration<FirProperty> {
-    abstract override val psi: PsiElement?
+    abstract override val source: FirSourceElement?
     abstract override val session: FirSession
     abstract override val resolvePhase: FirResolvePhase
     abstract override val returnTypeRef: FirTypeRef

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirPropertyAccessor.kt

@@ -5,9 +5,9 @@
 
 package org.jetbrains.kotlin.fir.declarations
 
-import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.fir.FirPureAbstractElement
 import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.contracts.FirContractDescription
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirBlock
@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  */
 
 abstract class FirPropertyAccessor : FirPureAbstractElement(), FirFunction<FirPropertyAccessor>, FirContractDescriptionOwner {
-    abstract override val psi: PsiElement?
+    abstract override val source: FirSourceElement?
     abstract override val session: FirSession
     abstract override val resolvePhase: FirResolvePhase
     abstract override val returnTypeRef: FirTypeRef

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirRegularClass.kt

@@ -5,9 +5,9 @@
 
 package org.jetbrains.kotlin.fir.declarations
 
-import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
 import org.jetbrains.kotlin.fir.types.FirTypeRef
@@ -20,7 +20,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  */
 
 interface FirRegularClass : FirNamedDeclaration, FirClassLikeDeclaration<FirRegularClass>, FirClass {
-    override val psi: PsiElement?
+    override val source: FirSourceElement?
     override val session: FirSession
     override val resolvePhase: FirResolvePhase
     override val name: Name

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirResolvedDeclarationStatus.kt

@@ -5,9 +5,9 @@
 
 package org.jetbrains.kotlin.fir.declarations
 
-import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibility
+import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.visitors.*
 
 /*
@@ -16,7 +16,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  */
 
 interface FirResolvedDeclarationStatus : FirDeclarationStatus {
-    override val psi: PsiElement?
+    override val source: FirSourceElement?
     override val visibility: Visibility
     override val modality: Modality?
     override val isExpect: Boolean

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirResolvedImport.kt

@@ -5,7 +5,7 @@
 
 package org.jetbrains.kotlin.fir.declarations
 
-import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
@@ -17,7 +17,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  */
 
 abstract class FirResolvedImport : FirImport() {
-    abstract override val psi: PsiElement?
+    abstract override val source: FirSourceElement?
     abstract override val importedFqName: FqName?
     abstract override val isAllUnder: Boolean
     abstract override val aliasName: Name?

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirSealedClass.kt

@@ -5,10 +5,10 @@
 
 package org.jetbrains.kotlin.fir.declarations
 
-import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.fir.FirPureAbstractElement
 import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
 import org.jetbrains.kotlin.fir.types.FirTypeRef
@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  */
 
 abstract class FirSealedClass : FirPureAbstractElement(), FirRegularClass {
-    abstract override val psi: PsiElement?
+    abstract override val source: FirSourceElement?
     abstract override val session: FirSession
     abstract override val resolvePhase: FirResolvePhase
     abstract override val name: Name

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirSimpleFunction.kt

@@ -5,9 +5,9 @@
 
 package org.jetbrains.kotlin.fir.declarations
 
-import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.fir.FirPureAbstractElement
 import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.contracts.FirContractDescription
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirBlock
@@ -24,7 +24,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  */
 
 abstract class FirSimpleFunction : FirPureAbstractElement(), FirMemberFunction<FirSimpleFunction>, FirContractDescriptionOwner {
-    abstract override val psi: PsiElement?
+    abstract override val source: FirSourceElement?
     abstract override val session: FirSession
     abstract override val resolvePhase: FirResolvePhase
     abstract override val returnTypeRef: FirTypeRef

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirTypeAlias.kt

@@ -5,9 +5,9 @@
 
 package org.jetbrains.kotlin.fir.declarations
 
-import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.fir.FirPureAbstractElement
 import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.symbols.impl.FirTypeAliasSymbol
 import org.jetbrains.kotlin.fir.types.FirTypeRef
@@ -20,7 +20,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  */
 
 abstract class FirTypeAlias : FirPureAbstractElement(), FirClassLikeDeclaration<FirTypeAlias> {
-    abstract override val psi: PsiElement?
+    abstract override val source: FirSourceElement?
     abstract override val session: FirSession
     abstract override val resolvePhase: FirResolvePhase
     abstract override val name: Name

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirTypeParameter.kt

@@ -5,10 +5,10 @@
 
 package org.jetbrains.kotlin.fir.declarations
 
-import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.fir.FirAnnotationContainer
 import org.jetbrains.kotlin.fir.FirPureAbstractElement
 import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.FirSymbolOwner
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol
@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  */
 
 abstract class FirTypeParameter : FirPureAbstractElement(), FirNamedDeclaration, FirSymbolOwner<FirTypeParameter>, FirAnnotationContainer {
-    abstract override val psi: PsiElement?
+    abstract override val source: FirSourceElement?
     abstract override val session: FirSession
     abstract override val resolvePhase: FirResolvePhase
     abstract override val name: Name

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirTypeParametersOwner.kt

@@ -5,8 +5,8 @@
 
 package org.jetbrains.kotlin.fir.declarations
 
-import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.fir.FirElement
+import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.visitors.*
 
 /*
@@ -15,7 +15,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  */
 
 interface FirTypeParametersOwner : FirElement {
-    override val psi: PsiElement?
+    override val source: FirSourceElement?
     val typeParameters: List<FirTypeParameter>
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitTypeParametersOwner(this, data)

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirTypedDeclaration.kt

@@ -5,9 +5,9 @@
 
 package org.jetbrains.kotlin.fir.declarations
 
-import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.fir.FirAnnotationContainer
 import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.visitors.*
@@ -18,7 +18,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  */
 
 interface FirTypedDeclaration : FirDeclaration, FirAnnotationContainer {
-    override val psi: PsiElement?
+    override val source: FirSourceElement?
     override val session: FirSession
     override val resolvePhase: FirResolvePhase
     override val annotations: List<FirAnnotationCall>

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirValueParameter.kt

@@ -5,9 +5,9 @@
 
 package org.jetbrains.kotlin.fir.declarations
 
-import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.fir.FirPureAbstractElement
 import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.symbols.impl.FirDelegateFieldSymbol
@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  */
 
 abstract class FirValueParameter : FirPureAbstractElement(), FirVariable<FirValueParameter> {
-    abstract override val psi: PsiElement?
+    abstract override val source: FirSourceElement?
     abstract override val session: FirSession
     abstract override val resolvePhase: FirResolvePhase
     abstract override val returnTypeRef: FirTypeRef

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirVariable.kt

@@ -5,8 +5,8 @@
 
 package org.jetbrains.kotlin.fir.declarations
 
-import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.expressions.FirStatement
@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  */
 
 interface FirVariable<F : FirVariable<F>> : FirCallableDeclaration<F>, FirNamedDeclaration, FirStatement {
-    override val psi: PsiElement?
+    override val source: FirSourceElement?
     override val session: FirSession
     override val resolvePhase: FirResolvePhase
     override val returnTypeRef: FirTypeRef

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirAnonymousFunctionImpl.kt

@@ -5,10 +5,10 @@
 
 package org.jetbrains.kotlin.fir.declarations.impl
 
-import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.contracts.description.InvocationKind
 import org.jetbrains.kotlin.fir.FirLabel
 import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.declarations.FirAnonymousFunction
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.declarations.FirTypeParameter
@@ -29,7 +29,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  */
 
 class FirAnonymousFunctionImpl(
-    override val psi: PsiElement?,
+    override val source: FirSourceElement?,
     override val session: FirSession,
     override var returnTypeRef: FirTypeRef,
     override var receiverTypeRef: FirTypeRef?,

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirAnonymousInitializerImpl.kt

@@ -5,8 +5,8 @@
 
 package org.jetbrains.kotlin.fir.declarations.impl
 
-import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.declarations.FirAnonymousInitializer
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.expressions.FirBlock
@@ -18,7 +18,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  */
 
 class FirAnonymousInitializerImpl(
-    override val psi: PsiElement?,
+    override val source: FirSourceElement?,
     override val session: FirSession,
     override var body: FirBlock?
 ) : FirAnonymousInitializer() {

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirAnonymousObjectImpl.kt

@@ -5,9 +5,9 @@
 
 package org.jetbrains.kotlin.fir.declarations.impl
 
-import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.declarations.FirAnonymousObject
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  */
 
 class FirAnonymousObjectImpl(
-    override val psi: PsiElement?,
+    override val source: FirSourceElement?,
     override val session: FirSession
 ) : FirAnonymousObject(), FirModifiableClass, FirAbstractAnnotatedElement {
     override var resolvePhase: FirResolvePhase = FirResolvePhase.RAW_FIR

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirClassImpl.kt

@@ -5,10 +5,10 @@
 
 package org.jetbrains.kotlin.fir.declarations.impl
 
-import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.fir.FirPureAbstractElement
 import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirDeclarationStatus
 import org.jetbrains.kotlin.fir.declarations.FirRegularClass
@@ -28,7 +28,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  */
 
 class FirClassImpl(
-    override val psi: PsiElement?,
+    override val source: FirSourceElement?,
     override val session: FirSession,
     override val name: Name,
     override var status: FirDeclarationStatus,

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirConstructorImpl.kt

@@ -5,8 +5,8 @@
 
 package org.jetbrains.kotlin.fir.declarations.impl
 
-import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.declarations.FirConstructor
 import org.jetbrains.kotlin.fir.declarations.FirDeclarationStatus
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
@@ -30,7 +30,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  */
 
 open class FirConstructorImpl(
-    override val psi: PsiElement?,
+    override val source: FirSourceElement?,
     override val session: FirSession,
     override var returnTypeRef: FirTypeRef,
     override var receiverTypeRef: FirTypeRef?,

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirDeclarationStatusImpl.kt

@@ -5,10 +5,10 @@
 
 package org.jetbrains.kotlin.fir.declarations.impl
 
-import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.fir.FirPureAbstractElement
+import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.declarations.FirDeclarationStatus
 import org.jetbrains.kotlin.fir.declarations.impl.FirDeclarationStatusImpl.Modifier.*
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
@@ -18,7 +18,7 @@ open class FirDeclarationStatusImpl(
     override val visibility: Visibility,
     override val modality: Modality?
 ) : FirPureAbstractElement(), FirDeclarationStatus {
-    override val psi: PsiElement? get() = null
+    override val source: FirSourceElement? get() = null
     protected var flags: Int = 0
 
     private operator fun get(modifier: Modifier): Boolean = (flags and modifier.mask) != 0

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirDefaultPropertyAccessor.kt

@@ -5,10 +5,10 @@
 
 package org.jetbrains.kotlin.fir.declarations.impl
 
-import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.declarations.FirValueParameter
 import org.jetbrains.kotlin.fir.expressions.FirBlock
@@ -21,13 +21,13 @@ import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 
 abstract class FirDefaultPropertyAccessor(
-    psi: PsiElement?,
+    source: FirSourceElement?,
     session: FirSession,
     propertyTypeRef: FirTypeRef,
     isGetter: Boolean,
     visibility: Visibility,
     symbol: FirPropertyAccessorSymbol
-) : FirPropertyAccessorImpl(psi, session, propertyTypeRef, symbol, isGetter, FirDeclarationStatusImpl(visibility, Modality.FINAL)) {
+) : FirPropertyAccessorImpl(source, session, propertyTypeRef, symbol, isGetter, FirDeclarationStatusImpl(visibility, Modality.FINAL)) {
     override var resolvePhase = FirResolvePhase.BODY_RESOLVE
 
     final override var body: FirBlock?
@@ -36,25 +36,25 @@ abstract class FirDefaultPropertyAccessor(
 }
 
 class FirDefaultPropertyGetter(
-    psi: PsiElement?,
+    source: FirSourceElement?,
     session: FirSession,
     propertyTypeRef: FirTypeRef,
     visibility: Visibility,
     symbol: FirPropertyAccessorSymbol = FirPropertyAccessorSymbol()
-) : FirDefaultPropertyAccessor(psi, session, propertyTypeRef, isGetter = true, visibility = visibility, symbol = symbol) {
+) : FirDefaultPropertyAccessor(source, session, propertyTypeRef, isGetter = true, visibility = visibility, symbol = symbol) {
     override val valueParameters: MutableList<FirValueParameter> = mutableListOf()
 }
 
 class FirDefaultPropertySetter(
-    psi: PsiElement?,
+    source: FirSourceElement?,
     session: FirSession,
     propertyTypeRef: FirTypeRef,
     visibility: Visibility,
     symbol: FirPropertyAccessorSymbol = FirPropertyAccessorSymbol()
-) : FirDefaultPropertyAccessor(psi, session, FirImplicitUnitTypeRef(psi), isGetter = false, visibility = visibility, symbol = symbol) {
+) : FirDefaultPropertyAccessor(source, session, FirImplicitUnitTypeRef(source), isGetter = false, visibility = visibility, symbol = symbol) {
     override val valueParameters: MutableList<FirValueParameter> = mutableListOf(
         FirDefaultSetterValueParameter(
-            psi,
+            source,
             session,
             propertyTypeRef,
             FirVariableSymbol(

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirDefaultSetterValueParameter.kt

@@ -5,8 +5,8 @@
 
 package org.jetbrains.kotlin.fir.declarations.impl
 
-import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.declarations.FirPropertyAccessor
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.declarations.FirValueParameter
@@ -25,7 +25,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  */
 
 class FirDefaultSetterValueParameter(
-    override val psi: PsiElement?,
+    override val source: FirSourceElement?,
     override val session: FirSession,
     override var returnTypeRef: FirTypeRef,
     override val symbol: FirVariableSymbol<FirValueParameter>

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirEnumEntryImpl.kt

@@ -5,11 +5,11 @@
 
 package org.jetbrains.kotlin.fir.declarations.impl
 
-import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirDeclarationStatus
 import org.jetbrains.kotlin.fir.declarations.FirEnumEntry
@@ -31,7 +31,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  */
 
 class FirEnumEntryImpl(
-    override val psi: PsiElement?,
+    override val source: FirSourceElement?,
     override val session: FirSession,
     override val name: Name,
     override val symbol: FirClassSymbol

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirErrorFunctionImpl.kt

@@ -5,8 +5,8 @@
 
 package org.jetbrains.kotlin.fir.declarations.impl
 
-import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.declarations.FirErrorFunction
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.declarations.FirTypeParameter
@@ -27,7 +27,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  */
 
 class FirErrorFunctionImpl(
-    override val psi: PsiElement?,
+    override val source: FirSourceElement?,
     override val session: FirSession,
     override val reason: String,
     override val symbol: FirErrorFunctionSymbol

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirFileImpl.kt

@@ -5,8 +5,8 @@
 
 package org.jetbrains.kotlin.fir.declarations.impl
 
-import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirFile
 import org.jetbrains.kotlin.fir.declarations.FirImport
@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  */
 
 class FirFileImpl(
-    override val psi: PsiElement?,
+    override val source: FirSourceElement?,
     override val session: FirSession,
     override val name: String,
     override val packageFqName: FqName

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirImportImpl.kt

@@ -5,7 +5,7 @@
 
 package org.jetbrains.kotlin.fir.declarations.impl
 
-import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.declarations.FirImport
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
@@ -17,7 +17,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  */
 
 class FirImportImpl(
-    override val psi: PsiElement?,
+    override val source: FirSourceElement?,
     override val importedFqName: FqName?,
     override val isAllUnder: Boolean,
     override val aliasName: Name?

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirModifiableClass.kt

@@ -5,9 +5,9 @@
 
 package org.jetbrains.kotlin.fir.declarations.impl
 
-import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.declarations.FirClass
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  */
 
 interface FirModifiableClass : FirClass, FirAbstractAnnotatedElement {
-    override val psi: PsiElement?
+    override val source: FirSourceElement?
     override val session: FirSession
     override var resolvePhase: FirResolvePhase
     override val classKind: ClassKind

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirModifiableConstructor.kt

@@ -5,9 +5,9 @@
 
 package org.jetbrains.kotlin.fir.declarations.impl
 
-import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.fir.FirPureAbstractElement
 import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.declarations.FirConstructor
 import org.jetbrains.kotlin.fir.declarations.FirDeclarationStatus
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
@@ -31,7 +31,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  */
 
 abstract class FirModifiableConstructor : FirPureAbstractElement(), FirConstructor, FirModifiableTypeParametersOwner, FirAbstractAnnotatedElement {
-    abstract override val psi: PsiElement?
+    abstract override val source: FirSourceElement?
     abstract override val session: FirSession
     abstract override var resolvePhase: FirResolvePhase
     abstract override var returnTypeRef: FirTypeRef

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirModifiableFunction.kt

@@ -5,8 +5,8 @@
 
 package org.jetbrains.kotlin.fir.declarations.impl
 
-import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.declarations.FirFunction
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.declarations.FirTypeParameter
@@ -26,7 +26,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  */
 
 interface FirModifiableFunction<F : FirFunction<F>>  : FirFunction<F>, FirAbstractAnnotatedElement {
-    override val psi: PsiElement?
+    override val source: FirSourceElement?
     override val session: FirSession
     override var resolvePhase: FirResolvePhase
     override val annotations: MutableList<FirAnnotationCall>

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirModifiableRegularClass.kt

@@ -5,9 +5,9 @@
 
 package org.jetbrains.kotlin.fir.declarations.impl
 
-import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirDeclarationStatus
 import org.jetbrains.kotlin.fir.declarations.FirRegularClass
@@ -27,7 +27,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  */
 
 interface FirModifiableRegularClass : FirRegularClass, FirModifiableClass, FirModifiableTypeParametersOwner, FirAbstractAnnotatedElement {
-    override val psi: PsiElement?
+    override val source: FirSourceElement?
     override val session: FirSession
     override var resolvePhase: FirResolvePhase
     override val name: Name