[FIR] Make extensionReceiver and dispatchReceiver nullable

Get rid of FirNoReceiverExpression

^KT-59650 Fixed

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

@@ -39,7 +39,6 @@ import org.jetbrains.kotlin.fir.declarations.fullyExpandedClass
 import org.jetbrains.kotlin.fir.diagnostics.FirDiagnosticHolder
 import org.jetbrains.kotlin.fir.expressions.*
 import org.jetbrains.kotlin.fir.expressions.builder.buildFunctionCall
-import org.jetbrains.kotlin.fir.expressions.impl.FirNoReceiverExpression
 import org.jetbrains.kotlin.fir.psi
 import org.jetbrains.kotlin.fir.realPsi
 import org.jetbrains.kotlin.fir.references.*
@@ -58,6 +57,7 @@ import org.jetbrains.kotlin.fir.symbols.SymbolInternals
 import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.fir.utils.exceptions.withFirEntry
+import org.jetbrains.kotlin.fir.utils.exceptions.withFirSymbolEntry
 import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.*
@@ -70,8 +70,10 @@ import org.jetbrains.kotlin.util.OperatorNameConventions
 import org.jetbrains.kotlin.util.OperatorNameConventions.EQUALS
 import org.jetbrains.kotlin.utils.addIfNotNull
 import org.jetbrains.kotlin.utils.addToStdlib.safeAs
+import org.jetbrains.kotlin.utils.exceptions.checkWithAttachment
 import org.jetbrains.kotlin.utils.exceptions.errorWithAttachment
 import org.jetbrains.kotlin.utils.exceptions.rethrowExceptionWithDetails
+import org.jetbrains.kotlin.utils.exceptions.withPsiEntry
 
 internal class KtFirCallResolver(
     override val analysisSession: KtFirAnalysisSession,
@@ -391,8 +393,8 @@ internal class KtFirCallResolver(
         } ?: KtSubstitutor.Empty(token)
 
         fun createKtPartiallyAppliedSymbolForImplicitInvoke(
-            dispatchReceiver: FirExpression,
-            extensionReceiver: FirExpression,
+            dispatchReceiver: FirExpression?,
+            extensionReceiver: FirExpression?,
             explicitReceiverKind: ExplicitReceiverKind
         ): KtPartiallyAppliedSymbol<KtCallableSymbol, KtCallableSignature<KtCallableSymbol>> {
             isImplicitInvoke = true
@@ -413,24 +415,54 @@ internal class KtFirCallResolver(
                 }
 
             // Specially handle @ExtensionFunctionType
-            if (dispatchReceiver.coneTypeSafe<ConeKotlinType>()?.isExtensionFunctionType == true) {
+            if (dispatchReceiver?.coneTypeSafe<ConeKotlinType>()?.isExtensionFunctionType == true) {
                 firstArgIsExtensionReceiver = true
             }
 
             val dispatchReceiverValue: KtReceiverValue?
             val extensionReceiverValue: KtReceiverValue?
-            if (explicitReceiverKind == ExplicitReceiverKind.DISPATCH_RECEIVER) {
-                dispatchReceiverValue =
-                    KtExplicitReceiverValue(explicitReceiverPsi, dispatchReceiver.resolvedType.asKtType(), false, token)
-                if (firstArgIsExtensionReceiver) {
-                    extensionReceiverValue = (fir as FirFunctionCall).arguments.firstOrNull()?.toKtReceiverValue()
-                } else {
-                    extensionReceiverValue = extensionReceiver.toKtReceiverValue()
+            when (explicitReceiverKind) {
+                ExplicitReceiverKind.DISPATCH_RECEIVER -> {
+                    checkWithAttachment(
+                        dispatchReceiver != null,
+                        { "Dispatch receiver must be not null if explicitReceiverKind is DISPATCH_RECEIVER" }
+                    ) {
+                        withPsiEntry("explicitReceiverPsi", explicitReceiverPsi)
+                        extensionReceiver?.let { withFirEntry("extensionReceiver", it) }
+                        withFirSymbolEntry("target", targetSymbol)
+                    }
+                    dispatchReceiverValue =
+                        KtExplicitReceiverValue(explicitReceiverPsi, dispatchReceiver.resolvedType.asKtType(), false, token)
+                    if (firstArgIsExtensionReceiver) {
+                        extensionReceiverValue = (fir as FirFunctionCall).arguments.firstOrNull()?.toKtReceiverValue()
+                    } else {
+                        extensionReceiverValue = extensionReceiver?.toKtReceiverValue()
+                    }
+                }
+
+                ExplicitReceiverKind.EXTENSION_RECEIVER -> {
+                    checkWithAttachment(
+                        extensionReceiver != null,
+                        { "Extension receiver must be not null if explicitReceiverKind is EXTENSION_RECEIVER" }
+                    ) {
+                        withPsiEntry("explicitReceiverPsi", explicitReceiverPsi)
+                        dispatchReceiver?.let { withFirEntry("dispatchReceiver", it) }
+                        withFirSymbolEntry("target", targetSymbol)
+                    }
+
+                    dispatchReceiverValue = dispatchReceiver?.toKtReceiverValue()
+                    extensionReceiverValue =
+                        KtExplicitReceiverValue(explicitReceiverPsi, extensionReceiver.resolvedType.asKtType(), false, token)
+                }
+
+                else -> {
+                    errorWithAttachment("Implicit invoke call can not have no explicit receiver") {
+                        withPsiEntry("explicitReceiverPsi", explicitReceiverPsi)
+                        withFirSymbolEntry("targetSymbol", targetSymbol)
+                        dispatchReceiver?.let { withFirEntry("dispatchReceiver", it) }
+                        extensionReceiver?.let { withFirEntry("extensionReceiver", it) }
+                    }
                 }
-            } else {
-                dispatchReceiverValue = dispatchReceiver.toKtReceiverValue()
-                extensionReceiverValue =
-                    KtExplicitReceiverValue(explicitReceiverPsi, extensionReceiver.resolvedType.asKtType(), false, token)
             }
             return KtPartiallyAppliedSymbol(
                 with(analysisSession) { unsubstitutedKtSignature.substitute(substitutor) },
@@ -445,8 +477,8 @@ internal class KtFirCallResolver(
             ) {
                 // Implicit invoke (e.g., `x()`) will have a different callee symbol (e.g., `x`) than the candidate (e.g., `invoke`).
                 createKtPartiallyAppliedSymbolForImplicitInvoke(
-                    candidate.dispatchReceiver ?: FirNoReceiverExpression,
-                    candidate.chosenExtensionReceiver ?: FirNoReceiverExpression,
+                    candidate.dispatchReceiver,
+                    candidate.chosenExtensionReceiver,
                     candidate.explicitReceiverKind
                 )
             } else {
@@ -466,14 +498,14 @@ internal class KtFirCallResolver(
         } else if (fir is FirQualifiedAccessExpression) {
             KtPartiallyAppliedSymbol(
                 with(analysisSession) { unsubstitutedKtSignature.substitute(substitutor) },
-                fir.dispatchReceiver.toKtReceiverValue(),
-                fir.extensionReceiver.toKtReceiverValue()
+                fir.dispatchReceiver?.toKtReceiverValue(),
+                fir.extensionReceiver?.toKtReceiverValue()
             )
         } else if (fir is FirVariableAssignment) {
             KtPartiallyAppliedSymbol(
                 with(analysisSession) { unsubstitutedKtSignature.substitute(substitutor) },
-                fir.dispatchReceiver.toKtReceiverValue(),
-                fir.extensionReceiver.toKtReceiverValue()
+                fir.dispatchReceiver?.toKtReceiverValue(),
+                fir.extensionReceiver?.toKtReceiverValue()
             )
         } else {
             KtPartiallyAppliedSymbol(unsubstitutedKtSignature, _dispatchReceiver = null, _extensionReceiver = null)
@@ -765,8 +797,8 @@ internal class KtFirCallResolver(
         val ktSignature = variableSymbol.toKtSignature()
         return KtPartiallyAppliedSymbol(
             with(analysisSession) { ktSignature.substitute(substitutor.toKtSubstitutor()) },
-            dispatchReceiver.toKtReceiverValue(),
-            extensionReceiver.toKtReceiverValue(),
+            dispatchReceiver?.toKtReceiverValue(),
+            extensionReceiver?.toKtReceiverValue(),
         )
     }
 
@@ -776,15 +808,31 @@ internal class KtFirCallResolver(
         val operationSymbol =
             (calleeReference as? FirResolvedNamedReference)?.resolvedSymbol as? FirNamedFunctionSymbol ?: return null
         val substitutor = createConeSubstitutorFromTypeArguments() ?: return null
+        val explicitReceiver = this.explicitReceiver
+        val dispatchReceiver = this.dispatchReceiver
+        val extensionReceiver = this.extensionReceiver
+
+        checkWithAttachment(
+            (explicitReceiver != null) == (explicitReceiverPsiSupplement != null),
+            { "FIR and PSI for explicit receiver are inconsistent (one of them is null)" }
+        ) {
+            withPsiEntry("explicitReceiverPsi", explicitReceiverPsiSupplement)
+            if (explicitReceiver != null) {
+                withFirEntry("explicitReceiverFir", explicitReceiver)
+            } else {
+                withEntry("explicitReceiverFir", "null")
+            }
+        }
+
         val dispatchReceiverValue = if (explicitReceiverPsiSupplement != null && explicitReceiver == dispatchReceiver) {
-            explicitReceiverPsiSupplement.toExplicitReceiverValue(dispatchReceiver.resolvedType.asKtType())
+            explicitReceiverPsiSupplement.toExplicitReceiverValue(dispatchReceiver!!.resolvedType.asKtType())
         } else {
-            dispatchReceiver.toKtReceiverValue()
+            dispatchReceiver?.toKtReceiverValue()
         }
         val extensionReceiverValue = if (explicitReceiverPsiSupplement != null && explicitReceiver == extensionReceiver) {
-            explicitReceiverPsiSupplement.toExplicitReceiverValue(extensionReceiver.resolvedType.asKtType())
+            explicitReceiverPsiSupplement.toExplicitReceiverValue(extensionReceiver!!.resolvedType.asKtType())
         } else {
-            extensionReceiver.toKtReceiverValue()
+            extensionReceiver?.toKtReceiverValue()
         }
         val ktSignature = operationSymbol.toKtSignature()
         return KtPartiallyAppliedSymbol(

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

@@ -391,7 +391,7 @@ private val FirQualifiedAccessExpression.dispatchedWithoutImport: Boolean
     get() = when {
         isQualifiedWithPackage -> true
         dispatchReceiver is FirThisReceiverExpression -> true
-        dispatchReceiver == explicitReceiver -> true
+        explicitReceiver != null && dispatchReceiver == explicitReceiver -> true
         else -> false
     }
 

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

@@ -38,7 +38,6 @@ import org.jetbrains.kotlin.fir.declarations.utils.classId
 import org.jetbrains.kotlin.fir.expressions.*
 import org.jetbrains.kotlin.fir.expressions.builder.buildFunctionCall
 import org.jetbrains.kotlin.fir.expressions.builder.buildPropertyAccessExpression
-import org.jetbrains.kotlin.fir.expressions.impl.FirNoReceiverExpression
 import org.jetbrains.kotlin.fir.java.scopes.JavaClassMembersEnhancementScope
 import org.jetbrains.kotlin.fir.references.FirErrorNamedReference
 import org.jetbrains.kotlin.fir.references.FirNamedReference
@@ -1103,7 +1102,7 @@ private class ElementsToShortenCollector(
         if (qualifiedAccess.explicitReceiver !is FirResolvedQualifier) return false
 
         // if there is no extension receiver necessary, then it can be removed
-        return qualifiedAccess.extensionReceiver is FirNoReceiverExpression
+        return qualifiedAccess.extensionReceiver == null
     }
 
     private fun findUnambiguousReferencedCallableId(namedReference: FirNamedReference): FirCallableSymbol<*>? {

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

@@ -102,7 +102,7 @@ internal class KtFirSmartcastProvider(
             KtImplicitReceiverSmartCastKind.EXTENSION -> firExpression.extensionReceiver
         }
 
-        if (receiver == firExpression.explicitReceiver) return null
+        if (receiver == null || receiver == firExpression.explicitReceiver) return null
         if (!receiver.isStableSmartcast()) return null
 
         val type = receiver.coneTypeSafe<ConeKotlinType>()?.asKtType() ?: return null

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/references/FirReferenceResolveHelper.kt

@@ -422,7 +422,7 @@ internal object FirReferenceResolveHelper {
         // accessing the `super` property on `this`, hence this weird looking if condition. In addition, the current class type is available
         // from the dispatch receiver `this`.
         if (expression is KtLabelReferenceExpression && fir is FirPropertyAccessExpression && fir.calleeReference is FirSuperReference) {
-            return listOfNotNull(fir.dispatchReceiver.coneTypeOrNull?.toTargetSymbol(session, symbolBuilder))
+            return listOfNotNull(fir.dispatchReceiver?.coneTypeOrNull?.toTargetSymbol(session, symbolBuilder))
         }
         val receiverOrImplicitInvoke = if (fir is FirImplicitInvokeCall) {
             fir.explicitReceiver?.unwrapSmartcastExpression()

compiler/fir/checkers/checkers.js/src/org/jetbrains/kotlin/fir/analysis/js/checkers/expression/FirJsModuleQualifiedAccessChecker.kt

@@ -12,7 +12,6 @@ import org.jetbrains.kotlin.fir.analysis.checkers.expression.FirQualifiedAccessE
 import org.jetbrains.kotlin.fir.analysis.checkers.getContainingClassSymbol
 import org.jetbrains.kotlin.fir.analysis.js.checkers.checkJsModuleUsage
 import org.jetbrains.kotlin.fir.expressions.*
-import org.jetbrains.kotlin.fir.expressions.impl.FirNoReceiverExpression
 import org.jetbrains.kotlin.fir.references.toResolvedBaseSymbol
 import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.types.toRegularClassSymbol
@@ -36,7 +35,7 @@ object FirJsModuleQualifiedAccessChecker : FirQualifiedAccessExpressionChecker()
         }
 
         return when (val receiver = expression.dispatchReceiver) {
-            is FirNoReceiverExpression -> listOfNotNull(calleeSymbol?.to(expression.calleeReference.source))
+            null -> listOfNotNull(calleeSymbol?.to(expression.calleeReference.source))
             is FirResolvedQualifier -> {
                 val classSymbol = receiver.symbol
                 if (expression is FirCallableReferenceAccess) {

compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/expression/FirJvmProtectedInSuperClassCompanionCallChecker.kt

@@ -18,7 +18,6 @@ import org.jetbrains.kotlin.fir.declarations.getAnnotationByClassId
 import org.jetbrains.kotlin.fir.declarations.utils.isCompanion
 import org.jetbrains.kotlin.fir.declarations.utils.visibility
 import org.jetbrains.kotlin.fir.expressions.*
-import org.jetbrains.kotlin.fir.expressions.impl.FirNoReceiverExpression
 import org.jetbrains.kotlin.fir.references.toResolvedCallableSymbol
 import org.jetbrains.kotlin.fir.resolve.defaultType
 import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol
@@ -37,7 +36,6 @@ object FirJvmProtectedInSuperClassCompanionCallChecker : FirBasicExpressionCheck
             else -> null
         } ?: return
 
-        if (dispatchReceiver is FirNoReceiverExpression) return
         val dispatchClassSymbol = dispatchReceiver.resolvedType.toRegularClassSymbol(context.session) ?: return
         val calleeReference = expression.calleeReference
         val resolvedSymbol = calleeReference?.toResolvedCallableSymbol() ?: return

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/cfa/FirPropertyInitializationAnalyzer.kt

@@ -93,7 +93,7 @@ private fun PropertyInitializationInfoData.checkPropertyAccesses(
     scopes: MutableMap<FirPropertySymbol, FirDeclaration?>
 ) {
     fun FirQualifiedAccessExpression.hasCorrectReceiver() =
-        (dispatchReceiver.unwrapSmartcastExpression() as? FirThisReceiverExpression)?.calleeReference?.boundSymbol == receiver
+        (dispatchReceiver?.unwrapSmartcastExpression() as? FirThisReceiverExpression)?.calleeReference?.boundSymbol == receiver
 
     for (node in graph.nodes) {
         when {

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/cfa/util/PropertyInitializationInfoCollector.kt

@@ -52,7 +52,7 @@ class PropertyInitializationInfoCollector(
         data: PathAwarePropertyInitializationInfo
     ): PathAwarePropertyInitializationInfo {
         val dataForNode = visitNode(node, data)
-        val receiver = (node.fir.dispatchReceiver.unwrapSmartcastExpression() as? FirThisReceiverExpression)?.calleeReference?.boundSymbol
+        val receiver = (node.fir.dispatchReceiver?.unwrapSmartcastExpression() as? FirThisReceiverExpression)?.calleeReference?.boundSymbol
         if (receiver != expectedReceiver) return dataForNode
         val symbol = node.fir.calleeReference?.toResolvedPropertySymbol() ?: return dataForNode
         if (symbol !in localProperties) return dataForNode

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirConstChecks.kt

@@ -15,7 +15,6 @@ import org.jetbrains.kotlin.fir.declarations.utils.isConst
 import org.jetbrains.kotlin.fir.declarations.utils.isStatic
 import org.jetbrains.kotlin.fir.declarations.utils.modality
 import org.jetbrains.kotlin.fir.expressions.*
-import org.jetbrains.kotlin.fir.expressions.impl.FirNoReceiverExpression
 import org.jetbrains.kotlin.fir.languageVersionSettings
 import org.jetbrains.kotlin.fir.references.FirErrorNamedReference
 import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
@@ -33,9 +32,10 @@ import org.jetbrains.kotlin.util.OperatorNameConventions
 fun ConeKotlinType.canBeUsedForConstVal(): Boolean = with(lowerBoundIfFlexible()) { isPrimitive || isString || isUnsignedType }
 
 internal fun checkConstantArguments(
-    expression: FirExpression,
+    expression: FirExpression?,
     session: FirSession,
 ): ConstantArgumentKind? {
+    if (expression == null) return null
     val expressionSymbol = expression.toReference()?.toResolvedCallableSymbol(discardErrorReference = true)
     val classKindOfParent = (expressionSymbol?.getReferencedClassSymbol(session) as? FirRegularClassSymbol)?.classKind
     val intrinsicConstEvaluation = session.languageVersionSettings.supportsFeature(LanguageFeature.IntrinsicConstEvaluation)
@@ -139,7 +139,7 @@ internal fun checkConstantArguments(
             }
 
             for (exp in expression.arguments.plus(expression.dispatchReceiver).plus(expression.extensionReceiver)) {
-                if (exp is FirNoReceiverExpression) continue
+                if (exp == null) continue
                 val expClassId = exp.resolvedType.lowerBoundIfFlexible().classId
                 // TODO, KT-59823: add annotation for allowed constant types
                 if (expClassId !in StandardClassIds.constantAllowedTypes) {
@@ -166,8 +166,7 @@ internal fun checkConstantArguments(
             val property = propertySymbol.fir
             when {
                 property.unwrapFakeOverrides().symbol.canBeEvaluated() || property.isCompileTimeBuiltinProperty() -> {
-                    val receiver =
-                        listOf(expression.dispatchReceiver, expression.extensionReceiver).single { it != FirNoReceiverExpression }
+                    val receiver = listOf(expression.dispatchReceiver, expression.extensionReceiver).single { it != null }!!
                     return checkConstantArguments(receiver, session)
                 }
                 propertySymbol.isLocal || propertySymbol.callableId.className?.isRoot == false -> return ConstantArgumentKind.NOT_CONST
@@ -238,7 +237,7 @@ private fun FirFunctionCall.isCompileTimeBuiltinCall(): Boolean {
     val symbol = calleeReference.resolvedSymbol as? FirCallableSymbol
     if (!symbol.fromKotlin()) return false
 
-    val coneType = this.dispatchReceiver.coneTypeSafe<ConeKotlinType>()
+    val coneType = this.dispatchReceiver?.coneTypeSafe<ConeKotlinType>()
     val receiverClassId = coneType?.lowerBoundIfFlexible()?.classId
 
     if (receiverClassId in StandardClassIds.unsignedTypes) return false

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirInlineDeclarationChecker.kt

@@ -158,11 +158,12 @@ object FirInlineDeclarationChecker : FirFunctionChecker() {
 
         private fun checkReceiver(
             qualifiedAccessExpression: FirQualifiedAccessExpression,
-            receiverExpression: FirExpression,
+            receiverExpression: FirExpression?,
             targetSymbol: FirBasedSymbol<*>?,
             context: CheckerContext,
             reporter: DiagnosticReporter,
         ) {
+            if (receiverExpression == null) return
             val receiverSymbol = receiverExpression.toResolvedCallableSymbol() ?: return
             if (receiverSymbol in inlinableParameters) {
                 if (!isInvokeOrInlineExtension(targetSymbol)) {
@@ -287,8 +288,8 @@ object FirInlineDeclarationChecker : FirFunctionChecker() {
             } as? FirQualifiedAccessExpression ?: return
 
             if (receiver.calleeReference is FirSuperReference) {
-                val dispatchReceiverType = receiver.dispatchReceiver.resolvedType
-                val classSymbol = dispatchReceiverType.toSymbol(session) ?: return
+                val dispatchReceiverType = receiver.dispatchReceiver?.resolvedType
+                val classSymbol = dispatchReceiverType?.toSymbol(session) ?: return
                 if (!classSymbol.isDefinedInInlineFunction()) {
                     reporter.reportOn(
                         receiver.source,

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirTailrecFunctionChecker.kt

@@ -16,7 +16,6 @@ import org.jetbrains.kotlin.fir.declarations.utils.isTailRec
 import org.jetbrains.kotlin.fir.declarations.utils.visibility
 import org.jetbrains.kotlin.fir.expressions.FirThisReceiverExpression
 import org.jetbrains.kotlin.fir.expressions.arguments
-import org.jetbrains.kotlin.fir.expressions.impl.FirNoReceiverExpression
 import org.jetbrains.kotlin.fir.references.toResolvedCallableSymbol
 import org.jetbrains.kotlin.fir.resolve.dfa.cfg.*
 import org.jetbrains.kotlin.fir.resolve.dfa.controlFlowGraph
@@ -75,7 +74,7 @@ object FirTailrecFunctionChecker : FirSimpleFunctionChecker() {
                 }
                 val dispatchReceiver = functionCall.dispatchReceiver
                 val dispatchReceiverOwner = declaration.dispatchReceiverType?.toSymbol(context.session) as? FirClassSymbol<*>
-                val sameReceiver = dispatchReceiver is FirNoReceiverExpression ||
+                val sameReceiver = dispatchReceiver == null ||
                         (dispatchReceiver is FirThisReceiverExpression && dispatchReceiver.calleeReference.boundSymbol == dispatchReceiverOwner) ||
                         dispatchReceiverOwner?.classKind?.isSingleton == true
                 if (!sameReceiver) {

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirBreakOrContinueJumpsAcrossFunctionBoundaryChecker.kt

@@ -13,7 +13,6 @@ import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.expressions.*
-import org.jetbrains.kotlin.fir.expressions.impl.FirNoReceiverExpression
 
 object FirBreakOrContinueJumpsAcrossFunctionBoundaryChecker : FirLoopJumpChecker() {
     override fun check(expression: FirLoopJump, context: CheckerContext, reporter: DiagnosticReporter) {
@@ -67,7 +66,6 @@ object FirBreakOrContinueJumpsAcrossFunctionBoundaryChecker : FirLoopJumpChecker
                 }
                 is FirVariable -> return findPathAndCheck(element.initializer)
                 is FirWrappedExpression -> return findPathAndCheck(element.expression)
-                is FirNoReceiverExpression -> return false
                 is FirFunctionCall -> {
                     if (findPathAndCheck(element.extensionReceiver) || findPathAndCheck(element.dispatchReceiver)) {
                         return true
@@ -121,4 +119,4 @@ object FirBreakOrContinueJumpsAcrossFunctionBoundaryChecker : FirLoopJumpChecker
         findPathAndCheck(expression.target.labeledElement.block)
     }
 
-}
+}

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirConventionFunctionCallChecker.kt

@@ -39,7 +39,7 @@ object FirConventionFunctionCallChecker : FirFunctionCallChecker() {
 
     private fun checkPropertyAsOperator(
         callExpression: FirFunctionCall,
-        receiver: FirExpression,
+        receiver: FirExpression?,
         context: CheckerContext,
         reporter: DiagnosticReporter
     ) {
@@ -48,7 +48,7 @@ object FirConventionFunctionCallChecker : FirFunctionCallChecker() {
             sourceKind !is KtFakeSourceElementKind.GeneratedComparisonExpression &&
             sourceKind !is KtFakeSourceElementKind.DesugaredCompoundAssignment
         ) return
-        val unwrapped = receiver.unwrapSmartcastExpression()
+        val unwrapped = receiver?.unwrapSmartcastExpression()
         if (unwrapped !is FirPropertyAccessExpression) return
         val diagnostic = unwrapped.nonFatalDiagnostics.firstIsInstanceOrNull<ConePropertyAsOperator>() ?: return
         reporter.reportOn(callExpression.calleeReference.source, FirErrors.PROPERTY_AS_OPERATOR, diagnostic.symbol, context)

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirMissingDependencyClassChecker.kt

@@ -10,7 +10,6 @@ import org.jetbrains.kotlin.diagnostics.reportOn
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
 import org.jetbrains.kotlin.fir.expressions.FirFunctionCall
-import org.jetbrains.kotlin.fir.expressions.impl.FirNoReceiverExpression
 import org.jetbrains.kotlin.fir.references.isError
 import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeInapplicableCandidateError
 import org.jetbrains.kotlin.fir.resolve.toSymbol
@@ -48,7 +47,7 @@ object FirMissingDependencyClassChecker : FirFunctionCallChecker() {
         }
 
         expression.coneTypeOrNull?.let(::consider)
-        expression.extensionReceiver.takeIf { it !is FirNoReceiverExpression }?.coneTypeOrNull?.let(::consider)
+        expression.extensionReceiver?.coneTypeOrNull?.let(::consider)
         expression.argumentList.arguments.forEach { it.coneTypeOrNull?.let(::consider) }
     }
 

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirOptInUsageAccessChecker.kt

@@ -15,7 +15,6 @@ import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessExpression
 import org.jetbrains.kotlin.fir.expressions.FirStatement
 import org.jetbrains.kotlin.fir.expressions.FirVariableAssignment
 import org.jetbrains.kotlin.fir.expressions.calleeReference
-import org.jetbrains.kotlin.fir.expressions.impl.FirNoReceiverExpression
 import org.jetbrains.kotlin.fir.references.toResolvedBaseSymbol
 import org.jetbrains.kotlin.fir.resolve.fullyExpandedType
 import org.jetbrains.kotlin.fir.types.resolvedType
@@ -37,8 +36,7 @@ object FirOptInUsageAccessChecker : FirBasicExpressionChecker() {
                         loadExperimentalitiesFromTypeArguments(context, emptyList())
                 reportNotAcceptedExperimentalities(experimentalities, expression.lValue, context, reporter)
             } else if (expression is FirQualifiedAccessExpression) {
-                val dispatchReceiverType =
-                    expression.dispatchReceiver.takeIf { it !is FirNoReceiverExpression }?.resolvedType?.fullyExpandedType(context.session)
+                val dispatchReceiverType = expression.dispatchReceiver?.resolvedType?.fullyExpandedType(context.session)
 
                 val experimentalities = resolvedSymbol.loadExperimentalities(context, fromSetter = false, dispatchReceiverType) +
                         loadExperimentalitiesFromTypeArguments(context, expression.typeArguments)

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirReassignmentAndInvisibleSetterChecker.kt

@@ -146,7 +146,7 @@ object FirReassignmentAndInvisibleSetterChecker : FirVariableAssignmentChecker()
             && property.requiresInitialization(isForClassInitialization = false)
         ) return
         if (
-            isInOwnersInitializer(expression.dispatchReceiver.unwrapSmartcastExpression(), context)
+            isInOwnersInitializer(expression.dispatchReceiver?.unwrapSmartcastExpression(), context)
             && property.requiresInitialization(isForClassInitialization = true)
         ) return
 
@@ -167,7 +167,7 @@ object FirReassignmentAndInvisibleSetterChecker : FirVariableAssignmentChecker()
         return containingGraph != null
     }
 
-    private fun isInOwnersInitializer(receiver: FirExpression, context: CheckerContext): Boolean {
+    private fun isInOwnersInitializer(receiver: FirExpression?, context: CheckerContext): Boolean {
         val uninitializedThisSymbol = (receiver as? FirThisReceiverExpression)?.calleeReference?.boundSymbol ?: return false
         val containingDeclarations = context.containingDeclarations
 

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirRecursiveProblemChecker.kt

@@ -15,7 +15,6 @@ import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.expressions.FirLambdaArgumentExpression
 import org.jetbrains.kotlin.fir.expressions.FirStatement
-import org.jetbrains.kotlin.fir.expressions.impl.FirNoReceiverExpression
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.psi.KtLambdaArgument
 
@@ -23,8 +22,7 @@ object FirRecursiveProblemChecker : FirBasicExpressionChecker() {
     override fun check(expression: FirStatement, context: CheckerContext, reporter: DiagnosticReporter) {
         if (
             expression !is FirExpression ||
-            expression.source?.kind is KtFakeSourceElementKind ||
-            expression.isExpressionWithAlwaysImplicitTypeRef
+            expression.source?.kind is KtFakeSourceElementKind
         ) {
             return
         }
@@ -42,6 +40,4 @@ object FirRecursiveProblemChecker : FirBasicExpressionChecker() {
 
         checkConeType(expression.resolvedType)
     }
-
-    private val FirStatement.isExpressionWithAlwaysImplicitTypeRef get() = this is FirNoReceiverExpression
 }

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirSuspendCallChecker.kt

@@ -18,7 +18,6 @@ import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
 import org.jetbrains.kotlin.fir.declarations.getAnnotationByClassId
 import org.jetbrains.kotlin.fir.declarations.utils.isSuspend
 import org.jetbrains.kotlin.fir.expressions.*
-import org.jetbrains.kotlin.fir.expressions.impl.FirNoReceiverExpression
 import org.jetbrains.kotlin.fir.references.FirResolvedCallableReference
 import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
 import org.jetbrains.kotlin.fir.references.resolved
@@ -220,8 +219,9 @@ object FirSuspendCallChecker : FirQualifiedAccessExpressionChecker() {
         session: FirSession,
         calledDeclarationSymbol: FirCallableSymbol<*>
     ): Triple<FirExpression?, FirExpression?, ConeKotlinType?> {
+        val dispatchReceiver = dispatchReceiver
         if (this is FirImplicitInvokeCall &&
-            dispatchReceiver != FirNoReceiverExpression && dispatchReceiver.resolvedType.isSuspendOrKSuspendFunctionType(session)
+            dispatchReceiver != null && dispatchReceiver.resolvedType.isSuspendOrKSuspendFunctionType(session)
         ) {
             val variableForInvoke = dispatchReceiver
             val variableForInvokeType = variableForInvoke.resolvedType
@@ -237,8 +237,8 @@ object FirSuspendCallChecker : FirQualifiedAccessExpressionChecker() {
         }
 
         return Triple(
-            dispatchReceiver.takeIf { it !is FirNoReceiverExpression },
-            extensionReceiver.takeIf { it !is FirNoReceiverExpression },
+            dispatchReceiver,
+            extensionReceiver,
             calledDeclarationSymbol.resolvedReceiverTypeRef?.coneType,
         )
     }

compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/constant/FirToConstantValueTransformer.kt

@@ -167,7 +167,7 @@ internal object FirToConstantValueTransformer : FirDefaultVisitor<ConstantValue<
                 if (callableName !in constantIntrinsicCalls) return null
 
                 val dispatchReceiver = qualifiedAccessExpression.dispatchReceiver
-                val dispatchReceiverValue = dispatchReceiver.toConstantValue(data) ?: return null
+                val dispatchReceiverValue = dispatchReceiver?.toConstantValue(data) ?: return null
                 when (callableName) {
                     "toByte" -> ByteValue((dispatchReceiverValue.value as Number).toByte())
                     "toLong" -> LongValue((dispatchReceiverValue.value as Number).toLong())
@@ -284,7 +284,7 @@ internal object FirToConstantValueChecker : FirDefaultVisitor<Boolean, FirSessio
                 val dispatchReceiver = qualifiedAccessExpression.dispatchReceiver
                 when (symbol.callableId.callableName.asString()) {
                     !in constantIntrinsicCalls -> false
-                    else -> dispatchReceiver.accept(this, data)
+                    else -> dispatchReceiver?.accept(this, data) ?: false
                 }
             }
 

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

@@ -23,7 +23,6 @@ import org.jetbrains.kotlin.fir.declarations.utils.isInline
 import org.jetbrains.kotlin.fir.declarations.utils.isJava
 import org.jetbrains.kotlin.fir.declarations.utils.isStatic
 import org.jetbrains.kotlin.fir.expressions.*
-import org.jetbrains.kotlin.fir.expressions.impl.FirNoReceiverExpression
 import org.jetbrains.kotlin.fir.extensions.FirExtensionApiInternals
 import org.jetbrains.kotlin.fir.extensions.declarationGenerators
 import org.jetbrains.kotlin.fir.extensions.extensionService
@@ -163,7 +162,7 @@ fun FirClassifierSymbol<*>.toSymbol(
 
 context(Fir2IrComponents)
 private fun FirBasedSymbol<*>.toSymbolForCall(
-    dispatchReceiver: FirExpression,
+    dispatchReceiver: FirExpression?,
     preferGetter: Boolean,
     explicitReceiver: FirExpression? = null,
     isDelegate: Boolean = false,
@@ -184,7 +183,7 @@ private fun FirBasedSymbol<*>.toSymbolForCall(
 context(Fir2IrComponents)
 @OptIn(ExperimentalContracts::class)
 fun FirReference.toSymbolForCall(
-    dispatchReceiver: FirExpression,
+    dispatchReceiver: FirExpression?,
     explicitReceiver: FirExpression?,
     preferGetter: Boolean = true,
     isDelegate: Boolean = false,
@@ -220,7 +219,7 @@ private fun FirResolvedQualifier.toLookupTag(session: FirSession): ConeClassLike
 
 context(Fir2IrComponents)
 private fun FirCallableSymbol<*>.toSymbolForCall(
-    dispatchReceiver: FirExpression,
+    dispatchReceiver: FirExpression?,
     preferGetter: Boolean,
     // Note: in fact LHS for callable references and explicit receiver for normal qualified accesses
     explicitReceiver: FirExpression? = null,
@@ -233,7 +232,7 @@ private fun FirCallableSymbol<*>.toSymbolForCall(
             (dispatchReceiver as? FirResolvedQualifier)?.toLookupTag(session)
         }
         // Member fake override or bound callable reference
-        dispatchReceiver !is FirNoReceiverExpression -> {
+        dispatchReceiver != null -> {
             val callSiteDispatchReceiverType = dispatchReceiver.resolvedType
             val declarationSiteDispatchReceiverType = dispatchReceiverType
             val type = if (callSiteDispatchReceiverType is ConeDynamicType && declarationSiteDispatchReceiverType != null) {

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/AdapterGenerator.kt

@@ -5,7 +5,6 @@
 
 package org.jetbrains.kotlin.fir.backend.generators
 
-import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.descriptors.DescriptorVisibilities
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.fir.backend.*
@@ -13,7 +12,6 @@ import org.jetbrains.kotlin.fir.containingClassLookupTag
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.utils.*
 import org.jetbrains.kotlin.fir.expressions.*
-import org.jetbrains.kotlin.fir.expressions.impl.FirNoReceiverExpression
 import org.jetbrains.kotlin.fir.references.FirResolvedCallableReference
 import org.jetbrains.kotlin.fir.render
 import org.jetbrains.kotlin.fir.resolve.FirSamResolver
@@ -38,7 +36,6 @@ import org.jetbrains.kotlin.ir.expressions.impl.*
 import org.jetbrains.kotlin.ir.symbols.IrConstructorSymbol
 import org.jetbrains.kotlin.ir.symbols.IrFunctionSymbol
 import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol
-import org.jetbrains.kotlin.ir.symbols.IrSymbolInternals
 import org.jetbrains.kotlin.ir.symbols.impl.IrSimpleFunctionSymbolImpl
 import org.jetbrains.kotlin.ir.symbols.impl.IrValueParameterSymbolImpl
 import org.jetbrains.kotlin.ir.types.*
@@ -186,12 +183,13 @@ internal class AdapterGenerator(
         }
     }
 
+    @Suppress("FoldInitializerAndIfToElvis")
     private fun FirCallableReferenceAccess.findBoundReceiver(
         explicitReceiverExpression: IrExpression?,
         isDispatch: Boolean
     ): IrExpression? {
         val firReceiver = if (isDispatch) dispatchReceiver else extensionReceiver
-        if (firReceiver is FirNoReceiverExpression) {
+        if (firReceiver == null) {
             return null
         }
         with(callGenerator) {

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/CallAndReferenceGenerator.kt

@@ -18,7 +18,6 @@ import org.jetbrains.kotlin.fir.declarations.utils.isStatic
 import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnostic
 import org.jetbrains.kotlin.fir.expressions.*
 import org.jetbrains.kotlin.fir.expressions.builder.buildAnnotationCall
-import org.jetbrains.kotlin.fir.expressions.impl.FirNoReceiverExpression
 import org.jetbrains.kotlin.fir.references.*
 import org.jetbrains.kotlin.fir.references.builder.buildResolvedNamedReference
 import org.jetbrains.kotlin.fir.resolve.*
@@ -412,7 +411,7 @@ class CallAndReferenceGenerator(
 
             return qualifiedAccess.convertWithOffsets { startOffset, endOffset ->
                 if (calleeReference is FirSuperReference) {
-                    if (dispatchReceiver !is FirNoReceiverExpression) {
+                    if (dispatchReceiver != null) {
                         return@convertWithOffsets visitor.convertToIrExpression(dispatchReceiver)
                     }
                 }
@@ -435,7 +434,7 @@ class CallAndReferenceGenerator(
                             typeArgumentsCount = firSymbol.typeParameterSymbols.size,
                             valueArgumentsCount = valueParametersNumber,
                             origin = calleeReference.statementOrigin(),
-                            superQualifierSymbol = dispatchReceiver.superQualifierSymbol()
+                            superQualifierSymbol = dispatchReceiver?.superQualifierSymbol()
                         )
                     }
 
@@ -446,7 +445,7 @@ class CallAndReferenceGenerator(
                             typeArgumentsCount = calleeReference.toResolvedCallableSymbol()!!.fir.typeParameters.size,
                             valueArgumentsCount = 0,
                             origin = IrStatementOrigin.GET_LOCAL_PROPERTY,
-                            superQualifierSymbol = dispatchReceiver.superQualifierSymbol()
+                            superQualifierSymbol = dispatchReceiver?.superQualifierSymbol()
                         )
                     }
 
@@ -462,13 +461,13 @@ class CallAndReferenceGenerator(
                                     typeArgumentsCount = property.typeParameters.size,
                                     valueArgumentsCount = property.contextReceivers.size,
                                     origin = IrStatementOrigin.GET_PROPERTY,
-                                    superQualifierSymbol = dispatchReceiver.superQualifierSymbol()
+                                    superQualifierSymbol = dispatchReceiver?.superQualifierSymbol()
                                 )
                             }
 
                             backingFieldSymbol != null -> IrGetFieldImpl(
                                 startOffset, endOffset, backingFieldSymbol, irType,
-                                superQualifierSymbol = dispatchReceiver.superQualifierSymbol()
+                                superQualifierSymbol = dispatchReceiver?.superQualifierSymbol()
                             )
 
                             else -> IrErrorCallExpressionImpl(
@@ -488,7 +487,7 @@ class CallAndReferenceGenerator(
                         IrGetFieldImpl(
                             startOffset, endOffset, symbol, irType,
                             origin = IrStatementOrigin.GET_PROPERTY.takeIf { calleeReference !is FirDelegateFieldReference },
-                            superQualifierSymbol = dispatchReceiver.superQualifierSymbol()
+                            superQualifierSymbol = dispatchReceiver?.superQualifierSymbol()
                         )
                     }
 
@@ -618,7 +617,7 @@ class CallAndReferenceGenerator(
                                 typeArgumentsCount = firProperty.typeParameters.size,
                                 valueArgumentsCount = 1 + firProperty.contextReceivers.size,
                                 origin = origin,
-                                superQualifierSymbol = variableAssignment.dispatchReceiver.superQualifierSymbol()
+                                superQualifierSymbol = variableAssignment.dispatchReceiver?.superQualifierSymbol()
                             ).apply {
                                 putContextReceiverArguments(lValue)
                                 putValueArgument(0, assignedValue)
@@ -645,7 +644,7 @@ class CallAndReferenceGenerator(
                                 typeArgumentsCount = firProperty.typeParameters.size,
                                 valueArgumentsCount = 1 + firProperty.contextReceivers.size,
                                 origin = origin,
-                                superQualifierSymbol = variableAssignment.dispatchReceiver.superQualifierSymbol()
+                                superQualifierSymbol = variableAssignment.dispatchReceiver?.superQualifierSymbol()
                             ).apply {
                                 putValueArgument(putContextReceiverArguments(lValue), assignedValue)
                             }
@@ -653,7 +652,7 @@ class CallAndReferenceGenerator(
                             backingFieldSymbol != null -> IrSetFieldImpl(
                                 startOffset, endOffset, backingFieldSymbol, type,
                                 origin = null, // NB: to be consistent with PSI2IR, origin should be null here
-                                superQualifierSymbol = variableAssignment.dispatchReceiver.superQualifierSymbol()
+                                superQualifierSymbol = variableAssignment.dispatchReceiver?.superQualifierSymbol()
                             ).apply {
                                 value = assignedValue
                             }
@@ -1202,7 +1201,7 @@ class CallAndReferenceGenerator(
             return explicitReceiverExpression
         }
 
-        return firReceiver.takeIf { it !is FirNoReceiverExpression }
+        return firReceiver
             ?.let { visitor.convertToIrReceiverExpression(it, calleeReference, this as? FirCallableReferenceAccess) }
             ?: explicitReceiverExpression
     }
@@ -1216,7 +1215,7 @@ class CallAndReferenceGenerator(
                 val resolvedFirSymbol = qualifiedAccess.toResolvedCallableSymbol()
                 if (resolvedFirSymbol?.dispatchReceiverType != null) {
                     val baseDispatchReceiver = qualifiedAccess.findIrDispatchReceiver(explicitReceiverExpression)
-                    var firDispatchReceiver = qualifiedAccess.dispatchReceiver.takeUnless { it is FirNoReceiverExpression }
+                    var firDispatchReceiver = qualifiedAccess.dispatchReceiver
                     if (firDispatchReceiver is FirPropertyAccessExpression && firDispatchReceiver.calleeReference is FirSuperReference) {
                         firDispatchReceiver = firDispatchReceiver.dispatchReceiver
                     }
@@ -1247,9 +1246,10 @@ class CallAndReferenceGenerator(
                             ?: error("Symbol for call ${qualifiedAccess.render()} not found")
                         symbol.fir.receiverParameter?.typeRef?.let { receiverType ->
                             with(visitor.implicitCastInserter) {
+                                val extensionReceiver = qualifiedAccess.extensionReceiver!!
                                 it.cast(
-                                    qualifiedAccess.extensionReceiver,
-                                    qualifiedAccess.extensionReceiver.resolvedType,
+                                    extensionReceiver,
+                                    extensionReceiver.resolvedType,
                                     receiverType.coneType,
                                 )
                             }

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/ClassMemberGenerator.kt

@@ -19,7 +19,6 @@ import org.jetbrains.kotlin.fir.declarations.utils.isFromEnumClass
 import org.jetbrains.kotlin.fir.declarations.utils.visibility
 import org.jetbrains.kotlin.fir.expressions.FirDelegatedConstructorCall
 import org.jetbrains.kotlin.fir.expressions.FirExpression
-import org.jetbrains.kotlin.fir.expressions.impl.FirNoReceiverExpression
 import org.jetbrains.kotlin.fir.extensions.declarationGenerators
 import org.jetbrains.kotlin.fir.extensions.extensionService
 import org.jetbrains.kotlin.fir.extensions.generatedMembers
@@ -409,7 +408,7 @@ internal class ClassMemberGenerator(
                         }
                     }
                 }
-                if (firDispatchReceiver !is FirNoReceiverExpression) {
+                if (firDispatchReceiver != null) {
                     it.dispatchReceiver = visitor.convertToIrExpression(firDispatchReceiver)
                 }
                 with(callGenerator) {

compiler/fir/providers/src/org/jetbrains/kotlin/fir/FirVisibilityChecker.kt

@@ -366,7 +366,7 @@ abstract class FirVisibilityChecker : FirSessionComponent {
         var dispatchReceiverType = dispatchReceiver.resolvedType
         if (dispatchReceiver is FirPropertyAccessExpression && dispatchReceiver.calleeReference is FirSuperReference) {
             // Special 'super' case: type of this, not of super, should be taken for the check below
-            dispatchReceiverType = dispatchReceiver.dispatchReceiver.resolvedType
+            dispatchReceiverType = dispatchReceiver.dispatchReceiver!!.resolvedType
         }
         val typeCheckerState = session.typeContext.newTypeCheckerState(
             errorTypesEqualToAnything = false,

compiler/fir/raw-fir/psi2fir/tests/org/jetbrains/kotlin/fir/builder/AbstractRawFirBuilderTestCase.kt

@@ -21,7 +21,6 @@ import org.jetbrains.kotlin.fir.declarations.FirValueParameter
 import org.jetbrains.kotlin.fir.declarations.impl.FirResolvedDeclarationStatusImpl
 import org.jetbrains.kotlin.fir.expressions.*
 import org.jetbrains.kotlin.fir.expressions.impl.FirContractCallBlock
-import org.jetbrains.kotlin.fir.expressions.impl.FirNoReceiverExpression
 import org.jetbrains.kotlin.fir.references.impl.FirStubReference
 import org.jetbrains.kotlin.fir.render
 import org.jetbrains.kotlin.fir.renderer.FirRenderer
@@ -94,7 +93,6 @@ abstract class AbstractRawFirBuilderTestCase : KtParsingTestCase(
             if (hasNoAcceptAndTransform(this::class.simpleName, property.name)) continue
 
             when (val childElement = property.getter.apply { isAccessible = true }.call(this)) {
-                is FirNoReceiverExpression -> continue
                 is FirElement -> childElement.traverseChildren(result)
                 is List<*> -> childElement.filterIsInstance<FirElement>().forEach { it.traverseChildren(result) }
                 else -> continue
@@ -184,7 +182,7 @@ abstract class AbstractRawFirBuilderTestCase : KtParsingTestCase(
 }
 
 private fun throwTwiceVisitingError(element: FirElement, parent: FirElement?) {
-    if (element is FirTypeRef || element is FirNoReceiverExpression || element is FirTypeParameter ||
+    if (element is FirTypeRef || element is FirTypeParameter ||
         element is FirTypeProjection || element is FirValueParameter || element is FirAnnotation || element is FirFunctionTypeParameter ||
         element is FirEmptyContractDescription ||
         element is FirStubReference || element.isExtensionFunctionAnnotation || element is FirEmptyArgumentList ||

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

@@ -13,7 +13,6 @@ import org.jetbrains.kotlin.fir.expressions.FirSmartCastExpression
 import org.jetbrains.kotlin.fir.expressions.FirThisReceiverExpression
 import org.jetbrains.kotlin.fir.expressions.builder.buildThisReceiverExpressionCopy
 import org.jetbrains.kotlin.fir.expressions.impl.FirExpressionStub
-import org.jetbrains.kotlin.fir.expressions.impl.FirNoReceiverExpression
 import org.jetbrains.kotlin.fir.resolve.inference.InferenceComponents
 import org.jetbrains.kotlin.fir.resolve.inference.PostponedResolvedAtom
 import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
@@ -118,13 +117,13 @@ class Candidate(
     private var sourcesWereUpdated = false
 
     // FirExpressionStub can be located here in case of callable reference resolution
-    fun dispatchReceiverExpression(): FirExpression {
-        return dispatchReceiver?.takeIf { it !is FirExpressionStub } ?: FirNoReceiverExpression
+    fun dispatchReceiverExpression(): FirExpression? {
+        return dispatchReceiver?.takeIf { it !is FirExpressionStub }
     }
 
     // FirExpressionStub can be located here in case of callable reference resolution
-    fun chosenExtensionReceiverExpression(): FirExpression {
-        return chosenExtensionReceiver?.takeIf { it !is FirExpressionStub } ?: FirNoReceiverExpression
+    fun chosenExtensionReceiverExpression(): FirExpression? {
+        return chosenExtensionReceiver?.takeIf { it !is FirExpressionStub }
     }
 
     fun contextReceiverArguments(): List<FirExpression> {

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/tower/FirInvokeResolveTowerExtension.kt

@@ -277,7 +277,7 @@ private fun BodyResolveComponents.createExplicitReceiverForInvoke(
     candidate: Candidate,
     info: CallInfo,
     invokeBuiltinExtensionMode: Boolean,
-    extensionReceiverExpression: FirExpression
+    extensionReceiverExpression: FirExpression?
 ): FirExpression? {
     return when (val symbol = candidate.symbol) {
         is FirCallableSymbol<*> -> createExplicitReceiverForInvokeByCallable(
@@ -300,7 +300,7 @@ private fun BodyResolveComponents.createExplicitReceiverForInvokeByCallable(
     candidate: Candidate,
     info: CallInfo,
     invokeBuiltinExtensionMode: Boolean,
-    extensionReceiverExpression: FirExpression,
+    extensionReceiverExpression: FirExpression?,
     symbol: FirCallableSymbol<*>
 ): FirExpression {
     return FirPropertyAccessExpressionBuilder().apply {

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

@@ -15,7 +15,6 @@ import org.jetbrains.kotlin.fir.contracts.description.ConeReturnsEffectDeclarati
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyAccessor
 import org.jetbrains.kotlin.fir.expressions.*
-import org.jetbrains.kotlin.fir.expressions.impl.FirNoReceiverExpression
 import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference
 import org.jetbrains.kotlin.fir.references.toResolvedPropertySymbol
 import org.jetbrains.kotlin.fir.resolve.*
@@ -836,9 +835,9 @@ abstract class FirDataFlowAnalyzer(
     }
 
     private fun FirStatement.orderedArguments(callee: FirFunction): Array<out FirExpression?>? {
-        fun FirQualifiedAccessExpression.firstReceiver(): FirExpression? =
-            (extensionReceiver.takeIf { it != FirNoReceiverExpression }
-                ?: dispatchReceiver.takeIf { it != FirNoReceiverExpression })
+        fun FirQualifiedAccessExpression.firstReceiver(): FirExpression? {
+            return extensionReceiver ?: dispatchReceiver
+        }
 
         val receiver = when (this) {
             is FirQualifiedAccessExpression -> firstReceiver()
@@ -1066,7 +1065,7 @@ abstract class FirDataFlowAnalyzer(
     }
 
     private fun exitBooleanNot(flow: MutableFlow, expression: FirFunctionCall) {
-        val argumentVariable = variableStorage.get(flow, expression.dispatchReceiver) ?: return
+        val argumentVariable = variableStorage.get(flow, expression.dispatchReceiver!!) ?: return
         val expressionVariable = variableStorage.createSynthetic(expression)
         // Alternatively: (expression == true => argument == false) && (expression == false => argument == true)
         // Which implementation is faster and/or consumes less memory is an open question.

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

@@ -122,8 +122,8 @@ class FirCallCompletionResultsWriterTransformer(
         if (!declaration.isWrappedIntegerOperator()) {
             val expectedDispatchReceiverType = (declaration as? FirCallableDeclaration)?.dispatchReceiverType
             val expectedExtensionReceiverType = (declaration as? FirCallableDeclaration)?.receiverParameter?.typeRef?.coneType
-            dispatchReceiver = dispatchReceiver.transformSingle(integerOperatorApproximator, expectedDispatchReceiverType)
-            extensionReceiver = extensionReceiver.transformSingle(integerOperatorApproximator, expectedExtensionReceiverType)
+            dispatchReceiver = dispatchReceiver?.transformSingle(integerOperatorApproximator, expectedDispatchReceiverType)
+            extensionReceiver = extensionReceiver?.transformSingle(integerOperatorApproximator, expectedExtensionReceiverType)
         }
 
         (qualifiedAccessExpression as? FirQualifiedAccessExpression)?.apply {

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

@@ -1287,7 +1287,7 @@ open class FirExpressionsResolveTransformer(transformer: FirAbstractBodyResolveT
             .resolveDelegatingConstructorCall(delegatedConstructorCall, constructorType, containingClass.symbol.toLookupTag())
 
         if (reference is FirThisReference && reference.boundSymbol == null) {
-            resolvedCall.dispatchReceiver.coneTypeSafe<ConeClassLikeType>()?.lookupTag?.toSymbol(session)?.let {
+            resolvedCall.dispatchReceiver?.coneTypeSafe<ConeClassLikeType>()?.lookupTag?.toSymbol(session)?.let {
                 reference.replaceBoundSymbol(it)
             }
         }

compiler/fir/semantics/src/org/jetbrains/kotlin/fir/resolve/dfa/VariableStorageImpl.kt

@@ -17,7 +17,6 @@ import org.jetbrains.kotlin.fir.declarations.utils.isFinal
 import org.jetbrains.kotlin.fir.declarations.utils.modality
 import org.jetbrains.kotlin.fir.declarations.utils.visibility
 import org.jetbrains.kotlin.fir.expressions.*
-import org.jetbrains.kotlin.fir.expressions.impl.FirNoReceiverExpression
 import org.jetbrains.kotlin.fir.moduleData
 import org.jetbrains.kotlin.fir.originalOrSelf
 import org.jetbrains.kotlin.fir.references.FirThisReference
@@ -108,8 +107,8 @@ class VariableStorageImpl(private val session: FirSession) : VariableStorage() {
         // TODO: don't create receiver variables if not going to create the composed variable either?
         return Identifier(
             symbol,
-            expression?.dispatchReceiver?.takeIf { it != FirNoReceiverExpression }?.let { getOrCreate(flow, it) },
-            expression?.extensionReceiver?.takeIf { it != FirNoReceiverExpression }?.let { getOrCreate(flow, it) }
+            expression?.dispatchReceiver?.let { getOrCreate(flow, it) },
+            expression?.extensionReceiver?.let { getOrCreate(flow, it) }
         )
     }
 

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/FirCallableReferenceAccess.kt

@@ -26,8 +26,8 @@ abstract class FirCallableReferenceAccess : FirQualifiedAccessExpression() {
     abstract override val contextReceiverArguments: List<FirExpression>
     abstract override val typeArguments: List<FirTypeProjection>
     abstract override val explicitReceiver: FirExpression?
-    abstract override val dispatchReceiver: FirExpression
-    abstract override val extensionReceiver: FirExpression
+    abstract override val dispatchReceiver: FirExpression?
+    abstract override val extensionReceiver: FirExpression?
     abstract override val source: KtSourceElement?
     abstract override val nonFatalDiagnostics: List<ConeDiagnostic>
     abstract override val calleeReference: FirNamedReference
@@ -49,9 +49,9 @@ abstract class FirCallableReferenceAccess : FirQualifiedAccessExpression() {
 
     abstract override fun replaceExplicitReceiver(newExplicitReceiver: FirExpression?)
 
-    abstract override fun replaceDispatchReceiver(newDispatchReceiver: FirExpression)
+    abstract override fun replaceDispatchReceiver(newDispatchReceiver: FirExpression?)
 
-    abstract override fun replaceExtensionReceiver(newExtensionReceiver: FirExpression)
+    abstract override fun replaceExtensionReceiver(newExtensionReceiver: FirExpression?)
 
     @FirImplementationDetail
     abstract override fun replaceSource(newSource: KtSourceElement?)

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/FirComponentCall.kt

@@ -25,8 +25,8 @@ abstract class FirComponentCall : FirFunctionCall() {
     abstract override val annotations: List<FirAnnotation>
     abstract override val contextReceiverArguments: List<FirExpression>
     abstract override val typeArguments: List<FirTypeProjection>
-    abstract override val dispatchReceiver: FirExpression
-    abstract override val extensionReceiver: FirExpression
+    abstract override val dispatchReceiver: FirExpression?
+    abstract override val extensionReceiver: FirExpression?
     abstract override val source: KtSourceElement?
     abstract override val nonFatalDiagnostics: List<ConeDiagnostic>
     abstract override val argumentList: FirArgumentList
@@ -49,9 +49,9 @@ abstract class FirComponentCall : FirFunctionCall() {
 
     abstract override fun replaceTypeArguments(newTypeArguments: List<FirTypeProjection>)
 
-    abstract override fun replaceDispatchReceiver(newDispatchReceiver: FirExpression)
+    abstract override fun replaceDispatchReceiver(newDispatchReceiver: FirExpression?)
 
-    abstract override fun replaceExtensionReceiver(newExtensionReceiver: FirExpression)
+    abstract override fun replaceExtensionReceiver(newExtensionReceiver: FirExpression?)
 
     @FirImplementationDetail
     abstract override fun replaceSource(newSource: KtSourceElement?)

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/FirDelegatedConstructorCall.kt

@@ -23,7 +23,7 @@ abstract class FirDelegatedConstructorCall : FirPureAbstractElement(), FirResolv
     abstract override val argumentList: FirArgumentList
     abstract override val contextReceiverArguments: List<FirExpression>
     abstract val constructedTypeRef: FirTypeRef
-    abstract val dispatchReceiver: FirExpression
+    abstract val dispatchReceiver: FirExpression?
     abstract override val calleeReference: FirReference
     abstract val isThis: Boolean
     abstract val isSuper: Boolean
@@ -42,7 +42,7 @@ abstract class FirDelegatedConstructorCall : FirPureAbstractElement(), FirResolv
 
     abstract fun replaceConstructedTypeRef(newConstructedTypeRef: FirTypeRef)
 
-    abstract fun replaceDispatchReceiver(newDispatchReceiver: FirExpression)
+    abstract fun replaceDispatchReceiver(newDispatchReceiver: FirExpression?)
 
     abstract override fun replaceCalleeReference(newCalleeReference: FirReference)
 

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/FirFunctionCall.kt

@@ -26,8 +26,8 @@ abstract class FirFunctionCall : FirQualifiedAccessExpression(), FirCall {
     abstract override val contextReceiverArguments: List<FirExpression>
     abstract override val typeArguments: List<FirTypeProjection>
     abstract override val explicitReceiver: FirExpression?
-    abstract override val dispatchReceiver: FirExpression
-    abstract override val extensionReceiver: FirExpression
+    abstract override val dispatchReceiver: FirExpression?
+    abstract override val extensionReceiver: FirExpression?
     abstract override val source: KtSourceElement?
     abstract override val nonFatalDiagnostics: List<ConeDiagnostic>
     abstract override val argumentList: FirArgumentList
@@ -50,9 +50,9 @@ abstract class FirFunctionCall : FirQualifiedAccessExpression(), FirCall {
 
     abstract override fun replaceExplicitReceiver(newExplicitReceiver: FirExpression?)
 
-    abstract override fun replaceDispatchReceiver(newDispatchReceiver: FirExpression)
+    abstract override fun replaceDispatchReceiver(newDispatchReceiver: FirExpression?)
 
-    abstract override fun replaceExtensionReceiver(newExtensionReceiver: FirExpression)
+    abstract override fun replaceExtensionReceiver(newExtensionReceiver: FirExpression?)
 
     @FirImplementationDetail
     abstract override fun replaceSource(newSource: KtSourceElement?)

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/FirImplicitInvokeCall.kt

@@ -26,8 +26,8 @@ abstract class FirImplicitInvokeCall : FirFunctionCall() {
     abstract override val contextReceiverArguments: List<FirExpression>
     abstract override val typeArguments: List<FirTypeProjection>
     abstract override val explicitReceiver: FirExpression?
-    abstract override val dispatchReceiver: FirExpression
-    abstract override val extensionReceiver: FirExpression
+    abstract override val dispatchReceiver: FirExpression?
+    abstract override val extensionReceiver: FirExpression?
     abstract override val source: KtSourceElement?
     abstract override val nonFatalDiagnostics: List<ConeDiagnostic>
     abstract override val argumentList: FirArgumentList
@@ -50,9 +50,9 @@ abstract class FirImplicitInvokeCall : FirFunctionCall() {
 
     abstract override fun replaceExplicitReceiver(newExplicitReceiver: FirExpression?)
 
-    abstract override fun replaceDispatchReceiver(newDispatchReceiver: FirExpression)
+    abstract override fun replaceDispatchReceiver(newDispatchReceiver: FirExpression?)
 
-    abstract override fun replaceExtensionReceiver(newExtensionReceiver: FirExpression)
+    abstract override fun replaceExtensionReceiver(newExtensionReceiver: FirExpression?)
 
     @FirImplementationDetail
     abstract override fun replaceSource(newSource: KtSourceElement?)

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/FirIntegerLiteralOperatorCall.kt

@@ -31,8 +31,8 @@ abstract class FirIntegerLiteralOperatorCall : FirFunctionCall() {
     abstract override val argumentList: FirArgumentList
     abstract override val calleeReference: FirNamedReference
     abstract override val origin: FirFunctionCallOrigin
-    abstract override val dispatchReceiver: FirExpression
-    abstract override val extensionReceiver: FirExpression
+    abstract override val dispatchReceiver: FirExpression?
+    abstract override val extensionReceiver: FirExpression?
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitIntegerLiteralOperatorCall(this, data)
 
@@ -61,9 +61,9 @@ abstract class FirIntegerLiteralOperatorCall : FirFunctionCall() {
 
     abstract override fun replaceCalleeReference(newCalleeReference: FirReference)
 
-    abstract override fun replaceDispatchReceiver(newDispatchReceiver: FirExpression)
+    abstract override fun replaceDispatchReceiver(newDispatchReceiver: FirExpression?)
 
-    abstract override fun replaceExtensionReceiver(newExtensionReceiver: FirExpression)
+    abstract override fun replaceExtensionReceiver(newExtensionReceiver: FirExpression?)
 
     abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirIntegerLiteralOperatorCall
 

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/FirMultiDelegatedConstructorCall.kt

@@ -22,7 +22,7 @@ abstract class FirMultiDelegatedConstructorCall : FirDelegatedConstructorCall()
     abstract override val argumentList: FirArgumentList
     abstract override val contextReceiverArguments: List<FirExpression>
     abstract override val constructedTypeRef: FirTypeRef
-    abstract override val dispatchReceiver: FirExpression
+    abstract override val dispatchReceiver: FirExpression?
     abstract override val calleeReference: FirReference
     abstract override val isThis: Boolean
     abstract override val isSuper: Boolean
@@ -42,7 +42,7 @@ abstract class FirMultiDelegatedConstructorCall : FirDelegatedConstructorCall()
 
     abstract override fun replaceConstructedTypeRef(newConstructedTypeRef: FirTypeRef)
 
-    abstract override fun replaceDispatchReceiver(newDispatchReceiver: FirExpression)
+    abstract override fun replaceDispatchReceiver(newDispatchReceiver: FirExpression?)
 
     abstract override fun replaceCalleeReference(newCalleeReference: FirReference)
 

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/FirPropertyAccessExpression.kt

@@ -26,8 +26,8 @@ abstract class FirPropertyAccessExpression : FirQualifiedAccessExpression() {
     abstract override val contextReceiverArguments: List<FirExpression>
     abstract override val typeArguments: List<FirTypeProjection>
     abstract override val explicitReceiver: FirExpression?
-    abstract override val dispatchReceiver: FirExpression
-    abstract override val extensionReceiver: FirExpression
+    abstract override val dispatchReceiver: FirExpression?
+    abstract override val extensionReceiver: FirExpression?
     abstract override val source: KtSourceElement?
     abstract override val nonFatalDiagnostics: List<ConeDiagnostic>
 
@@ -49,9 +49,9 @@ abstract class FirPropertyAccessExpression : FirQualifiedAccessExpression() {
 
     abstract override fun replaceExplicitReceiver(newExplicitReceiver: FirExpression?)
 
-    abstract override fun replaceDispatchReceiver(newDispatchReceiver: FirExpression)
+    abstract override fun replaceDispatchReceiver(newDispatchReceiver: FirExpression?)
 
-    abstract override fun replaceExtensionReceiver(newExtensionReceiver: FirExpression)
+    abstract override fun replaceExtensionReceiver(newExtensionReceiver: FirExpression?)
 
     @FirImplementationDetail
     abstract override fun replaceSource(newSource: KtSourceElement?)

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/FirQualifiedAccessExpression.kt

@@ -26,8 +26,8 @@ abstract class FirQualifiedAccessExpression : FirExpression(), FirResolvable, Fi
     abstract override val contextReceiverArguments: List<FirExpression>
     abstract val typeArguments: List<FirTypeProjection>
     abstract val explicitReceiver: FirExpression?
-    abstract val dispatchReceiver: FirExpression
-    abstract val extensionReceiver: FirExpression
+    abstract val dispatchReceiver: FirExpression?
+    abstract val extensionReceiver: FirExpression?
     abstract override val source: KtSourceElement?
     abstract val nonFatalDiagnostics: List<ConeDiagnostic>
 
@@ -49,9 +49,9 @@ abstract class FirQualifiedAccessExpression : FirExpression(), FirResolvable, Fi
 
     abstract fun replaceExplicitReceiver(newExplicitReceiver: FirExpression?)
 
-    abstract fun replaceDispatchReceiver(newDispatchReceiver: FirExpression)
+    abstract fun replaceDispatchReceiver(newDispatchReceiver: FirExpression?)
 
-    abstract fun replaceExtensionReceiver(newExtensionReceiver: FirExpression)
+    abstract fun replaceExtensionReceiver(newExtensionReceiver: FirExpression?)
 
     @FirImplementationDetail
     abstract fun replaceSource(newSource: KtSourceElement?)

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/FirThisReceiverExpression.kt

@@ -26,8 +26,8 @@ abstract class FirThisReceiverExpression : FirQualifiedAccessExpression() {
     abstract override val contextReceiverArguments: List<FirExpression>
     abstract override val typeArguments: List<FirTypeProjection>
     abstract override val explicitReceiver: FirExpression?
-    abstract override val dispatchReceiver: FirExpression
-    abstract override val extensionReceiver: FirExpression
+    abstract override val dispatchReceiver: FirExpression?
+    abstract override val extensionReceiver: FirExpression?
     abstract override val source: KtSourceElement?
     abstract override val nonFatalDiagnostics: List<ConeDiagnostic>
     abstract override val calleeReference: FirThisReference
@@ -49,9 +49,9 @@ abstract class FirThisReceiverExpression : FirQualifiedAccessExpression() {
 
     abstract override fun replaceExplicitReceiver(newExplicitReceiver: FirExpression?)
 
-    abstract override fun replaceDispatchReceiver(newDispatchReceiver: FirExpression)
+    abstract override fun replaceDispatchReceiver(newDispatchReceiver: FirExpression?)
 
-    abstract override fun replaceExtensionReceiver(newExtensionReceiver: FirExpression)
+    abstract override fun replaceExtensionReceiver(newExtensionReceiver: FirExpression?)
 
     @FirImplementationDetail
     abstract override fun replaceSource(newSource: KtSourceElement?)

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/builder/FirAbstractFunctionCallBuilder.kt

@@ -34,8 +34,8 @@ interface FirAbstractFunctionCallBuilder : FirQualifiedAccessExpressionBuilder,
     abstract override val contextReceiverArguments: MutableList<FirExpression>
     abstract override val typeArguments: MutableList<FirTypeProjection>
     abstract override var explicitReceiver: FirExpression?
-    abstract override var dispatchReceiver: FirExpression
-    abstract override var extensionReceiver: FirExpression
+    abstract override var dispatchReceiver: FirExpression?
+    abstract override var extensionReceiver: FirExpression?
     abstract override var source: KtSourceElement?
     abstract override val nonFatalDiagnostics: MutableList<ConeDiagnostic>
     abstract override var argumentList: FirArgumentList

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/builder/FirCallableReferenceAccessBuilder.kt

@@ -20,7 +20,6 @@ import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.expressions.builder.FirExpressionBuilder
 import org.jetbrains.kotlin.fir.expressions.builder.FirQualifiedAccessExpressionBuilder
 import org.jetbrains.kotlin.fir.expressions.impl.FirCallableReferenceAccessImpl
-import org.jetbrains.kotlin.fir.expressions.impl.FirNoReceiverExpression
 import org.jetbrains.kotlin.fir.references.FirNamedReference
 import org.jetbrains.kotlin.fir.references.FirReference
 import org.jetbrains.kotlin.fir.types.ConeKotlinType
@@ -39,8 +38,8 @@ class FirCallableReferenceAccessBuilder : FirQualifiedAccessExpressionBuilder, F
     override val contextReceiverArguments: MutableList<FirExpression> = mutableListOf()
     override val typeArguments: MutableList<FirTypeProjection> = mutableListOf()
     override var explicitReceiver: FirExpression? = null
-    override var dispatchReceiver: FirExpression = FirNoReceiverExpression
-    override var extensionReceiver: FirExpression = FirNoReceiverExpression
+    override var dispatchReceiver: FirExpression? = null
+    override var extensionReceiver: FirExpression? = null
     override var source: KtSourceElement? = null
     override val nonFatalDiagnostics: MutableList<ConeDiagnostic> = mutableListOf()
     lateinit var calleeReference: FirNamedReference

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/builder/FirComponentCallBuilder.kt

@@ -23,7 +23,6 @@ import org.jetbrains.kotlin.fir.expressions.FirFunctionCallOrigin
 import org.jetbrains.kotlin.fir.expressions.builder.FirCallBuilder
 import org.jetbrains.kotlin.fir.expressions.builder.FirExpressionBuilder
 import org.jetbrains.kotlin.fir.expressions.impl.FirComponentCallImpl
-import org.jetbrains.kotlin.fir.expressions.impl.FirNoReceiverExpression
 import org.jetbrains.kotlin.fir.references.FirNamedReference
 import org.jetbrains.kotlin.fir.references.FirReference
 import org.jetbrains.kotlin.fir.references.impl.FirSimpleNamedReference
@@ -43,8 +42,8 @@ class FirComponentCallBuilder : FirCallBuilder, FirAnnotationContainerBuilder, F
     override val annotations: MutableList<FirAnnotation> = mutableListOf()
     val contextReceiverArguments: MutableList<FirExpression> = mutableListOf()
     val typeArguments: MutableList<FirTypeProjection> = mutableListOf()
-    var dispatchReceiver: FirExpression = FirNoReceiverExpression
-    var extensionReceiver: FirExpression = FirNoReceiverExpression
+    var dispatchReceiver: FirExpression? = null
+    var extensionReceiver: FirExpression? = null
     override var source: KtSourceElement? = null
     val nonFatalDiagnostics: MutableList<ConeDiagnostic> = mutableListOf()
     override var argumentList: FirArgumentList = FirEmptyArgumentList

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/builder/FirDelegatedConstructorCallBuilder.kt

@@ -19,7 +19,6 @@ import org.jetbrains.kotlin.fir.expressions.FirEmptyArgumentList
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.expressions.builder.FirCallBuilder
 import org.jetbrains.kotlin.fir.expressions.impl.FirDelegatedConstructorCallImpl
-import org.jetbrains.kotlin.fir.expressions.impl.FirNoReceiverExpression
 import org.jetbrains.kotlin.fir.references.FirReference
 import org.jetbrains.kotlin.fir.references.impl.FirExplicitSuperReference
 import org.jetbrains.kotlin.fir.references.impl.FirExplicitThisReference
@@ -38,7 +37,7 @@ class FirDelegatedConstructorCallBuilder : FirCallBuilder, FirAnnotationContaine
     override var argumentList: FirArgumentList = FirEmptyArgumentList
     val contextReceiverArguments: MutableList<FirExpression> = mutableListOf()
     lateinit var constructedTypeRef: FirTypeRef
-    var dispatchReceiver: FirExpression = FirNoReceiverExpression
+    var dispatchReceiver: FirExpression? = null
     lateinit var calleeReference: FirReference
     var isThis: Boolean by kotlin.properties.Delegates.notNull<Boolean>()
 

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/builder/FirFunctionCallBuilder.kt

@@ -23,7 +23,6 @@ import org.jetbrains.kotlin.fir.expressions.FirFunctionCallOrigin
 import org.jetbrains.kotlin.fir.expressions.builder.FirAbstractFunctionCallBuilder
 import org.jetbrains.kotlin.fir.expressions.builder.FirExpressionBuilder
 import org.jetbrains.kotlin.fir.expressions.impl.FirFunctionCallImpl
-import org.jetbrains.kotlin.fir.expressions.impl.FirNoReceiverExpression
 import org.jetbrains.kotlin.fir.references.FirNamedReference
 import org.jetbrains.kotlin.fir.references.FirReference
 import org.jetbrains.kotlin.fir.types.ConeKotlinType
@@ -42,8 +41,8 @@ open class FirFunctionCallBuilder : FirAbstractFunctionCallBuilder, FirAnnotatio
     override val contextReceiverArguments: MutableList<FirExpression> = mutableListOf()
     override val typeArguments: MutableList<FirTypeProjection> = mutableListOf()
     override var explicitReceiver: FirExpression? = null
-    override var dispatchReceiver: FirExpression = FirNoReceiverExpression
-    override var extensionReceiver: FirExpression = FirNoReceiverExpression
+    override var dispatchReceiver: FirExpression? = null
+    override var extensionReceiver: FirExpression? = null
     override var source: KtSourceElement? = null
     override val nonFatalDiagnostics: MutableList<ConeDiagnostic> = mutableListOf()
     override var argumentList: FirArgumentList = FirEmptyArgumentList

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/builder/FirImplicitInvokeCallBuilder.kt

@@ -23,7 +23,6 @@ import org.jetbrains.kotlin.fir.expressions.FirImplicitInvokeCall
 import org.jetbrains.kotlin.fir.expressions.builder.FirAbstractFunctionCallBuilder
 import org.jetbrains.kotlin.fir.expressions.builder.FirExpressionBuilder
 import org.jetbrains.kotlin.fir.expressions.impl.FirImplicitInvokeCallImpl
-import org.jetbrains.kotlin.fir.expressions.impl.FirNoReceiverExpression
 import org.jetbrains.kotlin.fir.references.FirNamedReference
 import org.jetbrains.kotlin.fir.references.FirReference
 import org.jetbrains.kotlin.fir.types.ConeKotlinType
@@ -42,8 +41,8 @@ open class FirImplicitInvokeCallBuilder : FirAbstractFunctionCallBuilder, FirAnn
     override val contextReceiverArguments: MutableList<FirExpression> = mutableListOf()
     override val typeArguments: MutableList<FirTypeProjection> = mutableListOf()
     override var explicitReceiver: FirExpression? = null
-    override var dispatchReceiver: FirExpression = FirNoReceiverExpression
-    override var extensionReceiver: FirExpression = FirNoReceiverExpression
+    override var dispatchReceiver: FirExpression? = null
+    override var extensionReceiver: FirExpression? = null
     override var source: KtSourceElement? = null
     override val nonFatalDiagnostics: MutableList<ConeDiagnostic> = mutableListOf()
     override var argumentList: FirArgumentList = FirEmptyArgumentList

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/builder/FirIntegerLiteralOperatorCallBuilder.kt

@@ -23,7 +23,6 @@ import org.jetbrains.kotlin.fir.expressions.FirIntegerLiteralOperatorCall
 import org.jetbrains.kotlin.fir.expressions.builder.FirAbstractFunctionCallBuilder
 import org.jetbrains.kotlin.fir.expressions.builder.FirExpressionBuilder
 import org.jetbrains.kotlin.fir.expressions.impl.FirIntegerLiteralOperatorCallImpl
-import org.jetbrains.kotlin.fir.expressions.impl.FirNoReceiverExpression
 import org.jetbrains.kotlin.fir.references.FirNamedReference
 import org.jetbrains.kotlin.fir.references.FirReference
 import org.jetbrains.kotlin.fir.types.ConeKotlinType
@@ -47,8 +46,8 @@ open class FirIntegerLiteralOperatorCallBuilder : FirAbstractFunctionCallBuilder
     override var argumentList: FirArgumentList = FirEmptyArgumentList
     override lateinit var calleeReference: FirNamedReference
     override lateinit var origin: FirFunctionCallOrigin
-    override var dispatchReceiver: FirExpression = FirNoReceiverExpression
-    override var extensionReceiver: FirExpression = FirNoReceiverExpression
+    override var dispatchReceiver: FirExpression? = null
+    override var extensionReceiver: FirExpression? = null
 
     override fun build(): FirIntegerLiteralOperatorCall {
         return FirIntegerLiteralOperatorCallImpl(

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/builder/FirPropertyAccessExpressionBuilder.kt

@@ -19,7 +19,6 @@ import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.expressions.FirPropertyAccessExpression
 import org.jetbrains.kotlin.fir.expressions.builder.FirExpressionBuilder
 import org.jetbrains.kotlin.fir.expressions.builder.FirQualifiedAccessExpressionBuilder
-import org.jetbrains.kotlin.fir.expressions.impl.FirNoReceiverExpression
 import org.jetbrains.kotlin.fir.expressions.impl.FirPropertyAccessExpressionImpl
 import org.jetbrains.kotlin.fir.references.FirReference
 import org.jetbrains.kotlin.fir.types.ConeKotlinType
@@ -39,8 +38,8 @@ class FirPropertyAccessExpressionBuilder : FirQualifiedAccessExpressionBuilder,
     override val contextReceiverArguments: MutableList<FirExpression> = mutableListOf()
     override val typeArguments: MutableList<FirTypeProjection> = mutableListOf()
     override var explicitReceiver: FirExpression? = null
-    override var dispatchReceiver: FirExpression = FirNoReceiverExpression
-    override var extensionReceiver: FirExpression = FirNoReceiverExpression
+    override var dispatchReceiver: FirExpression? = null
+    override var extensionReceiver: FirExpression? = null
     override var source: KtSourceElement? = null
     override val nonFatalDiagnostics: MutableList<ConeDiagnostic> = mutableListOf()
 

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/builder/FirQualifiedAccessExpressionBuilder.kt

@@ -29,8 +29,8 @@ interface FirQualifiedAccessExpressionBuilder {
     abstract val contextReceiverArguments: MutableList<FirExpression>
     abstract val typeArguments: MutableList<FirTypeProjection>
     abstract var explicitReceiver: FirExpression?
-    abstract var dispatchReceiver: FirExpression
-    abstract var extensionReceiver: FirExpression
+    abstract var dispatchReceiver: FirExpression?
+    abstract var extensionReceiver: FirExpression?
     abstract var source: KtSourceElement?
     abstract val nonFatalDiagnostics: MutableList<ConeDiagnostic>
 

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/builder/FirThisReceiverExpressionBuilder.kt

@@ -19,7 +19,6 @@ import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.expressions.FirThisReceiverExpression
 import org.jetbrains.kotlin.fir.expressions.builder.FirExpressionBuilder
 import org.jetbrains.kotlin.fir.expressions.builder.FirQualifiedAccessExpressionBuilder
-import org.jetbrains.kotlin.fir.expressions.impl.FirNoReceiverExpression
 import org.jetbrains.kotlin.fir.expressions.impl.FirThisReceiverExpressionImpl
 import org.jetbrains.kotlin.fir.references.FirReference
 import org.jetbrains.kotlin.fir.references.FirThisReference
@@ -65,14 +64,14 @@ class FirThisReceiverExpressionBuilder : FirQualifiedAccessExpressionBuilder, Fi
         }
 
     @Deprecated("Modification of 'dispatchReceiver' has no impact for FirThisReceiverExpressionBuilder", level = DeprecationLevel.HIDDEN)
-    override var dispatchReceiver: FirExpression
+    override var dispatchReceiver: FirExpression?
         get() = throw IllegalStateException()
         set(_) {
             throw IllegalStateException()
         }
 
     @Deprecated("Modification of 'extensionReceiver' has no impact for FirThisReceiverExpressionBuilder", level = DeprecationLevel.HIDDEN)
-    override var extensionReceiver: FirExpression
+    override var extensionReceiver: FirExpression?
         get() = throw IllegalStateException()
         set(_) {
             throw IllegalStateException()

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/impl/FirCallableReferenceAccessImpl.kt

@@ -32,8 +32,8 @@ internal class FirCallableReferenceAccessImpl(
     override var contextReceiverArguments: MutableOrEmptyList<FirExpression>,
     override var typeArguments: MutableOrEmptyList<FirTypeProjection>,
     override var explicitReceiver: FirExpression?,
-    override var dispatchReceiver: FirExpression,
-    override var extensionReceiver: FirExpression,
+    override var dispatchReceiver: FirExpression?,
+    override var extensionReceiver: FirExpression?,
     override var source: KtSourceElement?,
     override var nonFatalDiagnostics: MutableOrEmptyList<ConeDiagnostic>,
     override var calleeReference: FirNamedReference,
@@ -45,10 +45,10 @@ internal class FirCallableReferenceAccessImpl(
         typeArguments.forEach { it.accept(visitor, data) }
         explicitReceiver?.accept(visitor, data)
         if (dispatchReceiver !== explicitReceiver) {
-            dispatchReceiver.accept(visitor, data)
+            dispatchReceiver?.accept(visitor, data)
         }
         if (extensionReceiver !== explicitReceiver && extensionReceiver !== dispatchReceiver) {
-            extensionReceiver.accept(visitor, data)
+            extensionReceiver?.accept(visitor, data)
         }
         calleeReference.accept(visitor, data)
     }
@@ -59,10 +59,10 @@ internal class FirCallableReferenceAccessImpl(
         transformTypeArguments(transformer, data)
         explicitReceiver = explicitReceiver?.transform(transformer, data)
         if (dispatchReceiver !== explicitReceiver) {
-            dispatchReceiver = dispatchReceiver.transform(transformer, data)
+            dispatchReceiver = dispatchReceiver?.transform(transformer, data)
         }
         if (extensionReceiver !== explicitReceiver && extensionReceiver !== dispatchReceiver) {
-            extensionReceiver = extensionReceiver.transform(transformer, data)
+            extensionReceiver = extensionReceiver?.transform(transformer, data)
         }
         transformCalleeReference(transformer, data)
         return this
@@ -108,11 +108,11 @@ internal class FirCallableReferenceAccessImpl(
         explicitReceiver = newExplicitReceiver
     }
 
-    override fun replaceDispatchReceiver(newDispatchReceiver: FirExpression) {
+    override fun replaceDispatchReceiver(newDispatchReceiver: FirExpression?) {
         dispatchReceiver = newDispatchReceiver
     }
 
-    override fun replaceExtensionReceiver(newExtensionReceiver: FirExpression) {
+    override fun replaceExtensionReceiver(newExtensionReceiver: FirExpression?) {
         extensionReceiver = newExtensionReceiver
     }
 

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/impl/FirComponentCallImpl.kt

@@ -36,8 +36,8 @@ internal class FirComponentCallImpl(
     override var annotations: MutableOrEmptyList<FirAnnotation>,
     override var contextReceiverArguments: MutableOrEmptyList<FirExpression>,
     override var typeArguments: MutableOrEmptyList<FirTypeProjection>,
-    override var dispatchReceiver: FirExpression,
-    override var extensionReceiver: FirExpression,
+    override var dispatchReceiver: FirExpression?,
+    override var extensionReceiver: FirExpression?,
     override var source: KtSourceElement?,
     override var nonFatalDiagnostics: MutableOrEmptyList<ConeDiagnostic>,
     override var argumentList: FirArgumentList,
@@ -55,10 +55,10 @@ internal class FirComponentCallImpl(
         calleeReference.accept(visitor, data)
         explicitReceiver.accept(visitor, data)
         if (dispatchReceiver !== explicitReceiver) {
-            dispatchReceiver.accept(visitor, data)
+            dispatchReceiver?.accept(visitor, data)
         }
         if (extensionReceiver !== explicitReceiver && extensionReceiver !== dispatchReceiver) {
-            extensionReceiver.accept(visitor, data)
+            extensionReceiver?.accept(visitor, data)
         }
     }
 
@@ -70,10 +70,10 @@ internal class FirComponentCallImpl(
         transformCalleeReference(transformer, data)
         explicitReceiver = explicitReceiver.transform(transformer, data)
         if (dispatchReceiver !== explicitReceiver) {
-            dispatchReceiver = dispatchReceiver.transform(transformer, data)
+            dispatchReceiver = dispatchReceiver?.transform(transformer, data)
         }
         if (extensionReceiver !== explicitReceiver && extensionReceiver !== dispatchReceiver) {
-            extensionReceiver = extensionReceiver.transform(transformer, data)
+            extensionReceiver = extensionReceiver?.transform(transformer, data)
         }
         return this
     }
@@ -114,11 +114,11 @@ internal class FirComponentCallImpl(
         typeArguments = newTypeArguments.toMutableOrEmpty()
     }
 
-    override fun replaceDispatchReceiver(newDispatchReceiver: FirExpression) {
+    override fun replaceDispatchReceiver(newDispatchReceiver: FirExpression?) {
         dispatchReceiver = newDispatchReceiver
     }
 
-    override fun replaceExtensionReceiver(newExtensionReceiver: FirExpression) {
+    override fun replaceExtensionReceiver(newExtensionReceiver: FirExpression?) {
         extensionReceiver = newExtensionReceiver
     }
 

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/impl/FirDelegatedConstructorCallImpl.kt

@@ -31,7 +31,7 @@ internal class FirDelegatedConstructorCallImpl(
     override var argumentList: FirArgumentList,
     override var contextReceiverArguments: MutableOrEmptyList<FirExpression>,
     override var constructedTypeRef: FirTypeRef,
-    override var dispatchReceiver: FirExpression,
+    override var dispatchReceiver: FirExpression?,
     override var calleeReference: FirReference,
     override val isThis: Boolean,
 ) : FirDelegatedConstructorCall() {
@@ -60,7 +60,7 @@ internal class FirDelegatedConstructorCallImpl(
     }
 
     override fun <D> transformDispatchReceiver(transformer: FirTransformer<D>, data: D): FirDelegatedConstructorCallImpl {
-        dispatchReceiver = dispatchReceiver.transform(transformer, data)
+        dispatchReceiver = dispatchReceiver?.transform(transformer, data)
         return this
     }
 
@@ -85,7 +85,7 @@ internal class FirDelegatedConstructorCallImpl(
         constructedTypeRef = newConstructedTypeRef
     }
 
-    override fun replaceDispatchReceiver(newDispatchReceiver: FirExpression) {
+    override fun replaceDispatchReceiver(newDispatchReceiver: FirExpression?) {
         dispatchReceiver = newDispatchReceiver
     }
 

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/impl/FirFunctionCallImpl.kt

@@ -34,8 +34,8 @@ open class FirFunctionCallImpl @FirImplementationDetail constructor(
     override var contextReceiverArguments: MutableOrEmptyList<FirExpression>,
     override var typeArguments: MutableOrEmptyList<FirTypeProjection>,
     override var explicitReceiver: FirExpression?,
-    override var dispatchReceiver: FirExpression,
-    override var extensionReceiver: FirExpression,
+    override var dispatchReceiver: FirExpression?,
+    override var extensionReceiver: FirExpression?,
     override var source: KtSourceElement?,
     override var nonFatalDiagnostics: MutableOrEmptyList<ConeDiagnostic>,
     override var argumentList: FirArgumentList,
@@ -48,10 +48,10 @@ open class FirFunctionCallImpl @FirImplementationDetail constructor(
         typeArguments.forEach { it.accept(visitor, data) }
         explicitReceiver?.accept(visitor, data)
         if (dispatchReceiver !== explicitReceiver) {
-            dispatchReceiver.accept(visitor, data)
+            dispatchReceiver?.accept(visitor, data)
         }
         if (extensionReceiver !== explicitReceiver && extensionReceiver !== dispatchReceiver) {
-            extensionReceiver.accept(visitor, data)
+            extensionReceiver?.accept(visitor, data)
         }
         argumentList.accept(visitor, data)
         calleeReference.accept(visitor, data)
@@ -63,10 +63,10 @@ open class FirFunctionCallImpl @FirImplementationDetail constructor(
         transformTypeArguments(transformer, data)
         explicitReceiver = explicitReceiver?.transform(transformer, data)
         if (dispatchReceiver !== explicitReceiver) {
-            dispatchReceiver = dispatchReceiver.transform(transformer, data)
+            dispatchReceiver = dispatchReceiver?.transform(transformer, data)
         }
         if (extensionReceiver !== explicitReceiver && extensionReceiver !== dispatchReceiver) {
-            extensionReceiver = extensionReceiver.transform(transformer, data)
+            extensionReceiver = extensionReceiver?.transform(transformer, data)
         }
         argumentList = argumentList.transform(transformer, data)
         transformCalleeReference(transformer, data)
@@ -113,11 +113,11 @@ open class FirFunctionCallImpl @FirImplementationDetail constructor(
         explicitReceiver = newExplicitReceiver
     }
 
-    override fun replaceDispatchReceiver(newDispatchReceiver: FirExpression) {
+    override fun replaceDispatchReceiver(newDispatchReceiver: FirExpression?) {
         dispatchReceiver = newDispatchReceiver
     }
 
-    override fun replaceExtensionReceiver(newExtensionReceiver: FirExpression) {
+    override fun replaceExtensionReceiver(newExtensionReceiver: FirExpression?) {
         extensionReceiver = newExtensionReceiver
     }
 

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/impl/FirImplicitInvokeCallImpl.kt

@@ -34,8 +34,8 @@ internal class FirImplicitInvokeCallImpl(
     override var contextReceiverArguments: MutableOrEmptyList<FirExpression>,
     override var typeArguments: MutableOrEmptyList<FirTypeProjection>,
     override var explicitReceiver: FirExpression?,
-    override var dispatchReceiver: FirExpression,
-    override var extensionReceiver: FirExpression,
+    override var dispatchReceiver: FirExpression?,
+    override var extensionReceiver: FirExpression?,
     override var source: KtSourceElement?,
     override var nonFatalDiagnostics: MutableOrEmptyList<ConeDiagnostic>,
     override var argumentList: FirArgumentList,
@@ -49,10 +49,10 @@ internal class FirImplicitInvokeCallImpl(
         typeArguments.forEach { it.accept(visitor, data) }
         explicitReceiver?.accept(visitor, data)
         if (dispatchReceiver !== explicitReceiver) {
-            dispatchReceiver.accept(visitor, data)
+            dispatchReceiver?.accept(visitor, data)
         }
         if (extensionReceiver !== explicitReceiver && extensionReceiver !== dispatchReceiver) {
-            extensionReceiver.accept(visitor, data)
+            extensionReceiver?.accept(visitor, data)
         }
         argumentList.accept(visitor, data)
         calleeReference.accept(visitor, data)
@@ -64,10 +64,10 @@ internal class FirImplicitInvokeCallImpl(
         transformTypeArguments(transformer, data)
         explicitReceiver = explicitReceiver?.transform(transformer, data)
         if (dispatchReceiver !== explicitReceiver) {
-            dispatchReceiver = dispatchReceiver.transform(transformer, data)
+            dispatchReceiver = dispatchReceiver?.transform(transformer, data)
         }
         if (extensionReceiver !== explicitReceiver && extensionReceiver !== dispatchReceiver) {
-            extensionReceiver = extensionReceiver.transform(transformer, data)
+            extensionReceiver = extensionReceiver?.transform(transformer, data)
         }
         argumentList = argumentList.transform(transformer, data)
         transformCalleeReference(transformer, data)
@@ -114,11 +114,11 @@ internal class FirImplicitInvokeCallImpl(
         explicitReceiver = newExplicitReceiver
     }
 
-    override fun replaceDispatchReceiver(newDispatchReceiver: FirExpression) {
+    override fun replaceDispatchReceiver(newDispatchReceiver: FirExpression?) {
         dispatchReceiver = newDispatchReceiver
     }
 
-    override fun replaceExtensionReceiver(newExtensionReceiver: FirExpression) {
+    override fun replaceExtensionReceiver(newExtensionReceiver: FirExpression?) {
         extensionReceiver = newExtensionReceiver
     }
 

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/impl/FirIntegerLiteralOperatorCallImpl.kt

@@ -39,8 +39,8 @@ internal class FirIntegerLiteralOperatorCallImpl(
     override var argumentList: FirArgumentList,
     override var calleeReference: FirNamedReference,
     override val origin: FirFunctionCallOrigin,
-    override var dispatchReceiver: FirExpression,
-    override var extensionReceiver: FirExpression,
+    override var dispatchReceiver: FirExpression?,
+    override var extensionReceiver: FirExpression?,
 ) : FirIntegerLiteralOperatorCall() {
     override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
         annotations.forEach { it.accept(visitor, data) }
@@ -48,10 +48,10 @@ internal class FirIntegerLiteralOperatorCallImpl(
         typeArguments.forEach { it.accept(visitor, data) }
         explicitReceiver?.accept(visitor, data)
         if (dispatchReceiver !== explicitReceiver) {
-            dispatchReceiver.accept(visitor, data)
+            dispatchReceiver?.accept(visitor, data)
         }
         if (extensionReceiver !== explicitReceiver && extensionReceiver !== dispatchReceiver) {
-            extensionReceiver.accept(visitor, data)
+            extensionReceiver?.accept(visitor, data)
         }
         argumentList.accept(visitor, data)
         calleeReference.accept(visitor, data)
@@ -63,10 +63,10 @@ internal class FirIntegerLiteralOperatorCallImpl(
         transformTypeArguments(transformer, data)
         explicitReceiver = explicitReceiver?.transform(transformer, data)
         if (dispatchReceiver !== explicitReceiver) {
-            dispatchReceiver = dispatchReceiver.transform(transformer, data)
+            dispatchReceiver = dispatchReceiver?.transform(transformer, data)
         }
         if (extensionReceiver !== explicitReceiver && extensionReceiver !== dispatchReceiver) {
-            extensionReceiver = extensionReceiver.transform(transformer, data)
+            extensionReceiver = extensionReceiver?.transform(transformer, data)
         }
         argumentList = argumentList.transform(transformer, data)
         transformCalleeReference(transformer, data)
@@ -94,12 +94,12 @@ internal class FirIntegerLiteralOperatorCallImpl(
     }
 
     override fun <D> transformDispatchReceiver(transformer: FirTransformer<D>, data: D): FirIntegerLiteralOperatorCallImpl {
-        dispatchReceiver = dispatchReceiver.transform(transformer, data)
+        dispatchReceiver = dispatchReceiver?.transform(transformer, data)
         return this
     }
 
     override fun <D> transformExtensionReceiver(transformer: FirTransformer<D>, data: D): FirIntegerLiteralOperatorCallImpl {
-        extensionReceiver = extensionReceiver.transform(transformer, data)
+        extensionReceiver = extensionReceiver?.transform(transformer, data)
         return this
     }
 
@@ -145,11 +145,11 @@ internal class FirIntegerLiteralOperatorCallImpl(
         replaceCalleeReference(newCalleeReference)
     }
 
-    override fun replaceDispatchReceiver(newDispatchReceiver: FirExpression) {
+    override fun replaceDispatchReceiver(newDispatchReceiver: FirExpression?) {
         dispatchReceiver = newDispatchReceiver
     }
 
-    override fun replaceExtensionReceiver(newExtensionReceiver: FirExpression) {
+    override fun replaceExtensionReceiver(newExtensionReceiver: FirExpression?) {
         extensionReceiver = newExtensionReceiver
     }
 }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/impl/FirLazyDelegatedConstructorCall.kt

@@ -33,7 +33,7 @@ class FirLazyDelegatedConstructorCall @FirImplementationDetail constructor(
     override val annotations: List<FirAnnotation> get() = error("FirLazyDelegatedConstructorCall should be calculated before accessing")
     override val argumentList: FirArgumentList get() = error("FirLazyDelegatedConstructorCall should be calculated before accessing")
     override val contextReceiverArguments: List<FirExpression> get() = error("FirLazyDelegatedConstructorCall should be calculated before accessing")
-    override val dispatchReceiver: FirExpression get() = error("FirLazyDelegatedConstructorCall should be calculated before accessing")
+    override val dispatchReceiver: FirExpression? get() = error("FirLazyDelegatedConstructorCall should be calculated before accessing")
     override val isSuper: Boolean get() = !isThis
 
     override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
@@ -70,7 +70,7 @@ class FirLazyDelegatedConstructorCall @FirImplementationDetail constructor(
         constructedTypeRef = newConstructedTypeRef
     }
 
-    override fun replaceDispatchReceiver(newDispatchReceiver: FirExpression) {}
+    override fun replaceDispatchReceiver(newDispatchReceiver: FirExpression?) {}
 
     override fun replaceCalleeReference(newCalleeReference: FirReference) {
         calleeReference = newCalleeReference

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/impl/FirMultiDelegatedConstructorCallImpl.kt

@@ -33,7 +33,7 @@ class FirMultiDelegatedConstructorCallImpl @FirImplementationDetail constructor(
     override val argumentList: FirArgumentList get() = delegatedConstructorCalls.last().argumentList
     override val contextReceiverArguments: List<FirExpression> get() = delegatedConstructorCalls.last().contextReceiverArguments
     override val constructedTypeRef: FirTypeRef get() = delegatedConstructorCalls.last().constructedTypeRef
-    override val dispatchReceiver: FirExpression get() = delegatedConstructorCalls.last().dispatchReceiver
+    override val dispatchReceiver: FirExpression? get() = delegatedConstructorCalls.last().dispatchReceiver
     override val calleeReference: FirReference get() = delegatedConstructorCalls.last().calleeReference
     override val isThis: Boolean get() = delegatedConstructorCalls.last().isThis
     override val isSuper: Boolean get() = !isThis
@@ -72,7 +72,7 @@ class FirMultiDelegatedConstructorCallImpl @FirImplementationDetail constructor(
 
     override fun replaceConstructedTypeRef(newConstructedTypeRef: FirTypeRef) {}
 
-    override fun replaceDispatchReceiver(newDispatchReceiver: FirExpression) {}
+    override fun replaceDispatchReceiver(newDispatchReceiver: FirExpression?) {}
 
     override fun replaceCalleeReference(newCalleeReference: FirReference) {}
 

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/impl/FirPropertyAccessExpressionImpl.kt

@@ -32,8 +32,8 @@ class FirPropertyAccessExpressionImpl @FirImplementationDetail constructor(
     override var contextReceiverArguments: MutableOrEmptyList<FirExpression>,
     override var typeArguments: MutableOrEmptyList<FirTypeProjection>,
     override var explicitReceiver: FirExpression?,
-    override var dispatchReceiver: FirExpression,
-    override var extensionReceiver: FirExpression,
+    override var dispatchReceiver: FirExpression?,
+    override var extensionReceiver: FirExpression?,
     override var source: KtSourceElement?,
     override var nonFatalDiagnostics: MutableOrEmptyList<ConeDiagnostic>,
 ) : FirPropertyAccessExpression() {
@@ -44,10 +44,10 @@ class FirPropertyAccessExpressionImpl @FirImplementationDetail constructor(
         typeArguments.forEach { it.accept(visitor, data) }
         explicitReceiver?.accept(visitor, data)
         if (dispatchReceiver !== explicitReceiver) {
-            dispatchReceiver.accept(visitor, data)
+            dispatchReceiver?.accept(visitor, data)
         }
         if (extensionReceiver !== explicitReceiver && extensionReceiver !== dispatchReceiver) {
-            extensionReceiver.accept(visitor, data)
+            extensionReceiver?.accept(visitor, data)
         }
     }
 
@@ -58,10 +58,10 @@ class FirPropertyAccessExpressionImpl @FirImplementationDetail constructor(
         transformTypeArguments(transformer, data)
         explicitReceiver = explicitReceiver?.transform(transformer, data)
         if (dispatchReceiver !== explicitReceiver) {
-            dispatchReceiver = dispatchReceiver.transform(transformer, data)
+            dispatchReceiver = dispatchReceiver?.transform(transformer, data)
         }
         if (extensionReceiver !== explicitReceiver && extensionReceiver !== dispatchReceiver) {
-            extensionReceiver = extensionReceiver.transform(transformer, data)
+            extensionReceiver = extensionReceiver?.transform(transformer, data)
         }
         return this
     }
@@ -110,11 +110,11 @@ class FirPropertyAccessExpressionImpl @FirImplementationDetail constructor(
         explicitReceiver = newExplicitReceiver
     }
 
-    override fun replaceDispatchReceiver(newDispatchReceiver: FirExpression) {
+    override fun replaceDispatchReceiver(newDispatchReceiver: FirExpression?) {
         dispatchReceiver = newDispatchReceiver
     }
 
-    override fun replaceExtensionReceiver(newExtensionReceiver: FirExpression) {
+    override fun replaceExtensionReceiver(newExtensionReceiver: FirExpression?) {
         extensionReceiver = newExtensionReceiver
     }
 

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/impl/FirThisReceiverExpressionImpl.kt

@@ -12,7 +12,6 @@ import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnostic
 import org.jetbrains.kotlin.fir.expressions.FirAnnotation
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.expressions.FirThisReceiverExpression
-import org.jetbrains.kotlin.fir.expressions.impl.FirNoReceiverExpression
 import org.jetbrains.kotlin.fir.references.FirReference
 import org.jetbrains.kotlin.fir.references.FirThisReference
 import org.jetbrains.kotlin.fir.types.ConeKotlinType
@@ -38,8 +37,8 @@ internal class FirThisReceiverExpressionImpl(
     override val isImplicit: Boolean,
 ) : FirThisReceiverExpression() {
     override var explicitReceiver: FirExpression? = null
-    override var dispatchReceiver: FirExpression = FirNoReceiverExpression
-    override var extensionReceiver: FirExpression = FirNoReceiverExpression
+    override var dispatchReceiver: FirExpression? = null
+    override var extensionReceiver: FirExpression? = null
 
     override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
         annotations.forEach { it.accept(visitor, data) }
@@ -47,10 +46,10 @@ internal class FirThisReceiverExpressionImpl(
         typeArguments.forEach { it.accept(visitor, data) }
         explicitReceiver?.accept(visitor, data)
         if (dispatchReceiver !== explicitReceiver) {
-            dispatchReceiver.accept(visitor, data)
+            dispatchReceiver?.accept(visitor, data)
         }
         if (extensionReceiver !== explicitReceiver && extensionReceiver !== dispatchReceiver) {
-            extensionReceiver.accept(visitor, data)
+            extensionReceiver?.accept(visitor, data)
         }
         calleeReference.accept(visitor, data)
     }
@@ -61,10 +60,10 @@ internal class FirThisReceiverExpressionImpl(
         transformTypeArguments(transformer, data)
         explicitReceiver = explicitReceiver?.transform(transformer, data)
         if (dispatchReceiver !== explicitReceiver) {
-            dispatchReceiver = dispatchReceiver.transform(transformer, data)
+            dispatchReceiver = dispatchReceiver?.transform(transformer, data)
         }
         if (extensionReceiver !== explicitReceiver && extensionReceiver !== dispatchReceiver) {
-            extensionReceiver = extensionReceiver.transform(transformer, data)
+            extensionReceiver = extensionReceiver?.transform(transformer, data)
         }
         transformCalleeReference(transformer, data)
         return this
@@ -110,11 +109,11 @@ internal class FirThisReceiverExpressionImpl(
         explicitReceiver = newExplicitReceiver
     }
 
-    override fun replaceDispatchReceiver(newDispatchReceiver: FirExpression) {
+    override fun replaceDispatchReceiver(newDispatchReceiver: FirExpression?) {
         dispatchReceiver = newDispatchReceiver
     }
 
-    override fun replaceExtensionReceiver(newExtensionReceiver: FirExpression) {
+    override fun replaceExtensionReceiver(newExtensionReceiver: FirExpression?) {
         extensionReceiver = newExtensionReceiver
     }
 

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirExpressionUtil.kt

@@ -15,7 +15,6 @@ import org.jetbrains.kotlin.fir.expressions.builder.buildConstExpression
 import org.jetbrains.kotlin.fir.expressions.builder.buildErrorExpression
 import org.jetbrains.kotlin.fir.expressions.builder.buildErrorLoop
 import org.jetbrains.kotlin.fir.expressions.impl.FirBlockImpl
-import org.jetbrains.kotlin.fir.expressions.impl.FirNoReceiverExpression
 import org.jetbrains.kotlin.fir.expressions.impl.FirResolvedArgumentList
 import org.jetbrains.kotlin.fir.expressions.impl.FirSingleExpressionBlock
 import org.jetbrains.kotlin.fir.references.*
@@ -135,9 +134,9 @@ private fun FirExpression.unwrapAndFlattenArgumentTo(list: MutableList<FirExpres
 
 val FirVariableAssignment.explicitReceiver: FirExpression? get() = unwrapLValue()?.explicitReceiver
 
-val FirVariableAssignment.dispatchReceiver: FirExpression get() = unwrapLValue()?.dispatchReceiver ?: FirNoReceiverExpression
+val FirVariableAssignment.dispatchReceiver: FirExpression? get() = unwrapLValue()?.dispatchReceiver
 
-val FirVariableAssignment.extensionReceiver: FirExpression get() = unwrapLValue()?.extensionReceiver ?: FirNoReceiverExpression
+val FirVariableAssignment.extensionReceiver: FirExpression? get() = unwrapLValue()?.extensionReceiver
 
 val FirVariableAssignment.calleeReference: FirReference? get() = lValue.toReference()
 
@@ -160,11 +159,11 @@ fun FirExpression.unwrapSmartcastExpression(): FirExpression =
 
 /**
  * A callable reference is bound iff
- * - one of [dispatchReceiver] or [extensionReceiver] is **not** [FirNoReceiverExpression] and
+ * - one of [dispatchReceiver] or [extensionReceiver] is **not** null and
  * - it's not referring to a static member.
  */
 val FirCallableReferenceAccess.isBound: Boolean
-    get() = (dispatchReceiver != FirNoReceiverExpression || extensionReceiver != FirNoReceiverExpression) &&
+    get() = (dispatchReceiver != null || extensionReceiver != null) &&
             calleeReference.toResolvedCallableSymbol()?.isStatic != true
 
 val FirQualifiedAccessExpression.allReceiverExpressions: List<FirExpression>

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirNoReceiverExpression.kt

@@ -1,35 +0,0 @@
-/*
- * 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.expressions.impl
-
-import org.jetbrains.kotlin.KtSourceElement
-import org.jetbrains.kotlin.fir.expressions.FirAnnotation
-import org.jetbrains.kotlin.fir.expressions.FirExpression
-import org.jetbrains.kotlin.fir.types.ConeKotlinType
-import org.jetbrains.kotlin.fir.visitors.FirTransformer
-import org.jetbrains.kotlin.fir.visitors.FirVisitor
-
-object FirNoReceiverExpression : FirExpression() {
-    override val source: KtSourceElement? get() = null
-    override val coneTypeOrNull: ConeKotlinType? get() = null
-    override val annotations: List<FirAnnotation> get() = emptyList()
-
-    override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {}
-
-    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirNoReceiverExpression {
-        return this
-    }
-
-    override fun replaceAnnotations(newAnnotations: List<FirAnnotation>) {
-        throw AssertionError("Mutating annotations of FirNoReceiverExpression is not supported")
-    }
-
-    override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirExpression {
-        return this
-    }
-
-    override fun replaceConeTypeOrNull(newConeTypeOrNull: ConeKotlinType?) {}
-}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/renderer/FirRenderer.kt

@@ -662,7 +662,6 @@ class FirRenderer(
                     is FirExpressionStub -> "STUB"
                     is FirUnitExpression -> "Unit"
                     is FirElseIfTrueCondition -> "else"
-                    is FirNoReceiverExpression -> ""
                     else -> "??? ${expression.javaClass}"
                 }
             )
@@ -748,7 +747,7 @@ class FirRenderer(
         override fun visitDelegatedConstructorCall(delegatedConstructorCall: FirDelegatedConstructorCall) {
             if (delegatedConstructorCall !is FirLazyDelegatedConstructorCall) {
                 val dispatchReceiver = delegatedConstructorCall.dispatchReceiver
-                if (dispatchReceiver !is FirNoReceiverExpression) {
+                if (dispatchReceiver != null) {
                     dispatchReceiver.accept(this)
                     print(".")
                 }
@@ -996,17 +995,17 @@ class FirRenderer(
             val extensionReceiver = qualifiedAccess.extensionReceiver
             var hasSomeReceiver = true
             when {
-                dispatchReceiver !is FirNoReceiverExpression && extensionReceiver !is FirNoReceiverExpression -> {
+                dispatchReceiver != null && extensionReceiver != null -> {
                     print("(")
                     dispatchReceiver.accept(this)
                     print(", ")
                     extensionReceiver.accept(this)
                     print(")")
                 }
-                dispatchReceiver !is FirNoReceiverExpression -> {
+                dispatchReceiver != null -> {
                     dispatchReceiver.accept(this)
                 }
-                extensionReceiver !is FirNoReceiverExpression -> {
+                extensionReceiver != null -> {
                     extensionReceiver.accept(this)
                 }
                 explicitReceiver != null -> {

compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/BuilderConfigurator.kt

@@ -212,8 +212,7 @@ object BuilderConfigurator : AbstractBuilderConfigurator<FirTreeBuilder>(FirTree
             default("argumentList") {
                 value = "FirEmptyArgumentList"
             }
-            default("dispatchReceiver", "FirNoReceiverExpression")
-            useTypes(noReceiverExpressionType)
+            defaultNull("dispatchReceiver")
             useTypes(emptyArgumentListType)
         }
 

compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/FieldSets.kt

@@ -26,8 +26,8 @@ object FieldSets {
     val receivers by lazy {
         fieldSet(
             field("explicitReceiver", expression, nullable = true, withReplace = true).withTransform(),
-            field("dispatchReceiver", expression, withReplace = true),
-            field("extensionReceiver", expression, withReplace = true)
+            field("dispatchReceiver", expression, nullable = true, withReplace = true),
+            field("extensionReceiver", expression, nullable = true, withReplace = true)
         )
     }
 

compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/NodeConfigurator.kt

@@ -234,8 +234,8 @@ object NodeConfigurator : AbstractFieldConfigurator<FirTreeBuilder>(FirTreeBuild
 
         integerLiteralOperatorCall.configure {
             // we need methods for transformation of receivers
-            +field("dispatchReceiver", expression, withReplace = true).withTransform()
-            +field("extensionReceiver", expression, withReplace = true).withTransform()
+            +field("dispatchReceiver", expression, nullable = true, withReplace = true).withTransform()
+            +field("extensionReceiver", expression, nullable = true, withReplace = true).withTransform()
         }
 
         comparisonExpression.configure {
@@ -411,7 +411,7 @@ object NodeConfigurator : AbstractFieldConfigurator<FirTreeBuilder>(FirTreeBuild
 
         delegatedConstructorCall.configure {
             +field("constructedTypeRef", typeRef, withReplace = true)
-            +field("dispatchReceiver", expression, withReplace = true).withTransform()
+            +field("dispatchReceiver", expression, nullable = true, withReplace = true).withTransform()
             +field("calleeReference", reference, withReplace = true)
             generateBooleanFields("this", "super")
         }

compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/Types.kt

@@ -56,7 +56,6 @@ val referenceToSimpleExpressionType = generatedType("", "FirExpressionRef<FirExp
 val safeCallCheckedSubjectReferenceType = generatedType("", "FirExpressionRef<FirCheckedSafeCallSubject>")
 
 val firModuleDataType = type("fir", "FirModuleData")
-val noReceiverExpressionType = generatedType("expressions.impl", "FirNoReceiverExpression", firType = true)
 val firImplicitTypeWithoutSourceType = generatedType("types.impl", "FirImplicitTypeRefImplWithoutSource")
 val firQualifierPartType = type("fir.types", "FirQualifierPart")
 val simpleNamedReferenceType = generatedType("references.impl", "FirSimpleNamedReference")

compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/context/AbstractBuilderConfigurator.kt

@@ -6,7 +6,6 @@
 package org.jetbrains.kotlin.fir.tree.generator.context
 
 import org.jetbrains.kotlin.fir.tree.generator.model.*
-import org.jetbrains.kotlin.fir.tree.generator.noReceiverExpressionType
 import org.jetbrains.kotlin.fir.tree.generator.util.DummyDelegate
 import kotlin.properties.ReadOnlyProperty
 import kotlin.reflect.KProperty
@@ -27,9 +26,7 @@ abstract class AbstractBuilderConfigurator<T : AbstractFirTreeBuilder>(val firTr
             if (!notNullExplicitReceiver) {
                 defaultNull("explicitReceiver")
             }
-            default("dispatchReceiver", "FirNoReceiverExpression")
-            default("extensionReceiver", "FirNoReceiverExpression")
-            useTypes(noReceiverExpressionType)
+            defaultNull("dispatchReceiver", "extensionReceiver")
         }
 
         fun default(field: String, value: String) {

compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/context/AbstractFirTreeImplementationConfigurator.kt

@@ -7,7 +7,6 @@ package org.jetbrains.kotlin.fir.tree.generator.context
 
 import org.jetbrains.kotlin.fir.tree.generator.constructClassLikeTypeImport
 import org.jetbrains.kotlin.fir.tree.generator.model.*
-import org.jetbrains.kotlin.fir.tree.generator.noReceiverExpressionType
 import org.jetbrains.kotlin.fir.tree.generator.printer.call
 import org.jetbrains.kotlin.fir.tree.generator.standardClassIdsType
 
@@ -109,10 +108,7 @@ abstract class AbstractFirTreeImplementationConfigurator {
         }
 
         fun defaultNoReceivers() {
-            defaultNull("explicitReceiver")
-            default("dispatchReceiver", "FirNoReceiverExpression")
-            default("extensionReceiver", "FirNoReceiverExpression")
-            useTypes(noReceiverExpressionType)
+            defaultNull("explicitReceiver", "dispatchReceiver", "extensionReceiver")
         }
 
         fun default(field: String, value: String) {

compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/printer/implementation.kt

@@ -223,7 +223,7 @@ fun SmartPrinter.printImplementation(implementation: Implementation) {
                                     println(
                                         """
                                     |if (dispatchReceiver !== explicitReceiver) {
-                                    |            dispatchReceiver = dispatchReceiver.transform(transformer, data)
+                                    |            dispatchReceiver = dispatchReceiver?.transform(transformer, data)
                                     |        }
                                 """.trimMargin(),
                                     )
@@ -232,7 +232,7 @@ fun SmartPrinter.printImplementation(implementation: Implementation) {
                                     println(
                                         """
                                     |if (extensionReceiver !== explicitReceiver && extensionReceiver !== dispatchReceiver) {
-                                    |            extensionReceiver = extensionReceiver.transform(transformer, data)
+                                    |            extensionReceiver = extensionReceiver?.transform(transformer, data)
                                     |        }
                                 """.trimMargin(),
                                     )

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/handlers/FirDiagnosticsHandler.kt

@@ -212,7 +212,7 @@ class FirDiagnosticsHandler(testServices: TestServices) : FirAnalysisHandler(tes
                 val calleeDeclaration = element.calleeReference.toResolvedCallableSymbol() ?: return
                 val isInvokeCallWithDynamicReceiver = calleeDeclaration.name == OperatorNameConventions.INVOKE
                         && element is FirQualifiedAccessExpression
-                        && element.dispatchReceiver.coneTypeOrNull?.isFunctionTypeWithDynamicReceiver(firFile.moduleData.session) == true
+                        && element.dispatchReceiver?.coneTypeOrNull?.isFunctionTypeWithDynamicReceiver(firFile.moduleData.session) == true
 
                 if (calleeDeclaration.origin !is FirDeclarationOrigin.DynamicScope && !isInvokeCallWithDynamicReceiver) {
                     return

compiler/visualizer/render-fir/src/org/jetbrains/kotlin/compiler/visualizer/FirVisualizer.kt

@@ -13,7 +13,6 @@ import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.utils.isLocal
 import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnostic
 import org.jetbrains.kotlin.fir.expressions.*
-import org.jetbrains.kotlin.fir.expressions.impl.FirNoReceiverExpression
 import org.jetbrains.kotlin.fir.references.*
 import org.jetbrains.kotlin.fir.renderer.ConeTypeRendererForDebugging
 import org.jetbrains.kotlin.fir.resolve.defaultType
@@ -558,18 +557,21 @@ class FirVisualizer(private val firFile: FirFile) : BaseRenderer() {
             }
 
             var withExtensionFunctionType = false
+
+            val extensionReceiver = call.extensionReceiver
+            val dispatchReceiver = call.dispatchReceiver
             when {
-                call.extensionReceiver !is FirNoReceiverExpression -> {
+                extensionReceiver != null -> {
                     // render type from symbol because this way it will be consistent with psi render
                     fir.receiverParameter?.accept(this, data)
                     data.append(".").append(callableName)
                 }
-                call.dispatchReceiver.resolvedType.isExtensionFunctionType -> {
+                dispatchReceiver?.resolvedType?.isExtensionFunctionType == true-> {
                     withExtensionFunctionType = true
                     fir.valueParameters.first().returnTypeRef.accept(this, data)
                     data.append(".").append(callableName)
                 }
-                call.dispatchReceiver !is FirNoReceiverExpression -> {
+                dispatchReceiver != null -> {
                     data.append("(")
                     val dispatch = fir.dispatchReceiverType!!.tryToRenderConeAsFunctionTypeString()
                         .let { if (it.endsWith("!")) it.dropLast(1) else it } // this hack drop flexible annotation for receiver

compiler/visualizer/render-fir/src/org/jetbrains/kotlin/compiler/visualizer/Psi2FirMapper.kt

@@ -25,8 +25,8 @@ class Psi2FirMapper(val map: MutableMap<PsiElement, MutableList<FirElement>>) :
     }
 
     override fun visitCallableReferenceAccess(callableReferenceAccess: FirCallableReferenceAccess) {
-        visitElement(callableReferenceAccess.extensionReceiver)
-        visitElement(callableReferenceAccess.dispatchReceiver)
+        callableReferenceAccess.extensionReceiver?.let { visitElement(it) }
+        callableReferenceAccess.dispatchReceiver?.let { visitElement(it) }
         callableReferenceAccess.explicitReceiver?.let { visitElement(it) }
 
         val psi = (callableReferenceAccess.calleeReference.psi as? KtCallableReferenceExpression)?.children?.last()
@@ -35,4 +35,4 @@ class Psi2FirMapper(val map: MutableMap<PsiElement, MutableList<FirElement>>) :
             map[psi]?.add(callableReferenceAccess.calleeReference)
         }
     }
-}
+}