[FIR] Stop resolving to context receivers

#KT-72994

Author: cypressious

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

@@ -1291,14 +1291,7 @@ internal class KaFirCompilerFacility(
             val id = when (calleeReference) {
                 is FirThisReference -> when (val boundSymbol = calleeReference.boundSymbol) {
                     is FirClassSymbol -> CodeFragmentCapturedId(boundSymbol)
-                    is FirReceiverParameterSymbol, is FirValueParameterSymbol -> {
-                        when (val referencedSymbol = calleeReference.referencedMemberSymbol) {
-                            // Specific (deprecated) case for a class context receiver
-                            // TODO: remove with KT-72994
-                            is FirClassSymbol -> CodeFragmentCapturedId(referencedSymbol)
-                            else -> CodeFragmentCapturedId(boundSymbol)
-                        }
-                    }
+                    is FirReceiverParameterSymbol -> CodeFragmentCapturedId(boundSymbol)
                     is FirTypeParameterSymbol, is FirTypeAliasSymbol -> errorWithFirSpecificEntries(
                         message = "Unexpected FirThisOwnerSymbol ${calleeReference::class.simpleName}", fir = boundSymbol.fir
                     )

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

@@ -135,9 +135,6 @@ private class KaFirCompletionExtensionCandidateChecker(
 
         return buildList {
             addAll(towerDataContext.implicitValueStorage.implicitReceivers)
-            for (towerDataElement in towerDataContext.towerDataElements) {
-                addAll(towerDataElement.contextReceiverGroup.orEmpty())
-            }
         }
     }
 

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

@@ -1109,7 +1109,6 @@ internal class KaFirResolver(
                     is FirReceiverParameterSymbol -> firSymbolBuilder.callableBuilder.buildExtensionReceiverSymbol(firSymbol)
                         ?: return null
 
-                    is FirValueParameterSymbol -> firSymbolBuilder.variableBuilder.buildParameterSymbol(firSymbol)
                     is FirTypeAliasSymbol, is FirTypeParameterSymbol -> errorWithFirSpecificEntries(
                         message = "Unexpected ${FirThisOwnerSymbol::class.simpleName}: ${firSymbol::class.simpleName}",
                         fir = firSymbol.fir

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

@@ -306,8 +306,8 @@ internal class KaFirScopeProvider(
 
         val implicitValues = towerDataElementsIndexed.flatMap { (index, towerDataElement) ->
             buildList {
-                val receivers = listOfNotNull(towerDataElement.implicitReceiver) + towerDataElement.contextReceiverGroup.orEmpty()
-                for (receiver in receivers) {
+                val receiver = towerDataElement.implicitReceiver
+                if (receiver != null) {
                     val receiverValue = KaBaseScopeImplicitReceiverValue(
                         backingType = firSymbolBuilder.typeBuilder.buildKtType(receiver.type),
                         ownerSymbol = firSymbolBuilder.buildSymbol(receiver.referencedMemberSymbol),

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

@@ -123,7 +123,6 @@ internal object FirReferenceResolveHelper {
                     listOfNotNull(
                         when (boundSymbol) {
                             is FirReceiverParameterSymbol -> boundSymbol.containingDeclarationSymbol
-                            is FirValueParameterSymbol -> boundSymbol.containingDeclarationSymbol
                             else -> boundSymbol as FirBasedSymbol<*>?
                         }?.buildSymbol(symbolBuilder)
                     )

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/compile/CodeFragmentCapturedValueAnalyzer.kt

@@ -183,52 +183,21 @@ private class CodeFragmentCapturedValueVisitor(
                         is FirClassSymbol<*> -> {
                             registerClassSymbolIfNotObject(symbol)
                         }
-                        // TODO(KT-72994) remove branch when context receivers are removed
-                        is FirValueParameterSymbol -> {
-                            val valueParameter = symbol.fir
-                            val referencedSymbol = element.referencedMemberSymbol
-                            if (referencedSymbol is FirClassSymbol) {
-                                // Specific (deprecated) case for a class context receiver
-                                registerClassSymbolIfNotObject(referencedSymbol)
-                            } else {
-                                val labelName = valueParameter.name
-                                if (labelName != SpecialNames.UNDERSCORE_FOR_UNUSED_VAR) {
-                                    val isCrossingInlineBounds = isCrossingInlineBounds(element, symbol)
-                                    val index = when (val containingDeclaration = symbol.containingDeclarationSymbol.fir) {
-                                        is FirCallableDeclaration -> containingDeclaration.contextParameters.indexOf(
-                                            valueParameter
-                                        )
-                                        is FirRegularClass -> containingDeclaration.contextParameters.indexOf(valueParameter)
-                                        else -> errorWithFirSpecificEntries(
-                                            message = "Unexpected containing declaration ${containingDeclaration::class.simpleName}",
-                                            fir = containingDeclaration
-                                        )
-                                    }
-                                    val capturedValue = CodeFragmentCapturedValue
-                                        .ContextReceiver(index, labelName, isCrossingInlineBounds, depth)
-                                    register(
-                                        CodeFragmentCapturedSymbol(
-                                            capturedValue,
-                                            symbol,
-                                            valueParameter.returnTypeRef
-                                        )
-                                    )
-                                }
+                        is FirReceiverParameterSymbol -> {
+                            if (symbol.captureValueInAnalyze) {
+                                val receiverParameter = symbol.fir
+                                val labelName = element.labelName
+                                    ?: (receiverParameter.containingDeclarationSymbol as? FirAnonymousFunctionSymbol)?.label?.name
+                                    ?: (receiverParameter.containingDeclarationSymbol as FirCallableSymbol).name.asString()
+
+                                val typeRef = receiverParameter.typeRef
+                                val isCrossingInlineBounds = isCrossingInlineBounds(element, symbol)
+                                val capturedValue = CodeFragmentCapturedValue.ExtensionReceiver(labelName, isCrossingInlineBounds, depth)
+                                register(
+                                    CodeFragmentCapturedSymbol(capturedValue, receiverParameter.symbol, typeRef)
+                                )
                             }
                         }
-                        is FirReceiverParameterSymbol if symbol.captureValueInAnalyze -> {
-                            val receiverParameter = symbol.fir
-                            val labelName = element.labelName
-                                ?: (receiverParameter.containingDeclarationSymbol as? FirAnonymousFunctionSymbol)?.label?.name
-                                ?: (receiverParameter.containingDeclarationSymbol as FirCallableSymbol).name.asString()
-
-                            val typeRef = receiverParameter.typeRef
-                            val isCrossingInlineBounds = isCrossingInlineBounds(element, symbol)
-                            val capturedValue = CodeFragmentCapturedValue.ExtensionReceiver(labelName, isCrossingInlineBounds, depth)
-                            register(
-                                CodeFragmentCapturedSymbol(capturedValue, receiverParameter.symbol, typeRef)
-                            )
-                        }
                         is FirTypeAliasSymbol, is FirTypeParameterSymbol -> errorWithFirSpecificEntries(
                             message = "Unexpected FirThisOwnerSymbol ${symbol::class.simpleName}", fir = symbol.fir
                         )

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirBodyLazyResolver.kt

@@ -60,8 +60,6 @@ import org.jetbrains.kotlin.psi.KtDeclaration
 import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi.KtProperty
-import org.jetbrains.kotlin.psi.KtStatementExpression
-import org.jetbrains.kotlin.psi.KtVariableDeclaration
 import org.jetbrains.kotlin.utils.exceptions.checkWithAttachment
 import org.jetbrains.kotlin.utils.exceptions.errorWithAttachment
 import org.jetbrains.kotlin.utils.exceptions.requireWithAttachment
@@ -823,7 +821,6 @@ private class LLFirBodyTargetResolver(target: LLFirResolveTarget) : LLFirAbstrac
     ): FirTowerDataElement = FirTowerDataElement(
         scope?.withReplacedSessionOrNull(session, scopeSession) ?: scope,
         implicitReceiver?.withReplacedSessionOrNull(session, scopeSession),
-        contextReceiverGroup?.map { it.withReplacedSessionOrNull(session, scopeSession) },
         contextParameterGroup,
         isLocal,
         staticScopeOwnerSymbol

analysis/low-level-api-fir/testFixtures/org/jetbrains/kotlin/analysis/low/level/api/fir/AbstractContextCollectorTest.kt

@@ -116,21 +116,6 @@ internal object ElementContextRenderer {
                         }
                     }
 
-                    towerDataElement.contextReceiverGroup?.takeIf { it.isNotEmpty() }?.let { contextReceiverValues ->
-                        appendBlock("Context receivers:") {
-                            for (contextReceiverValue in contextReceiverValues) {
-                                appendSymbol(contextReceiverValue.boundSymbol).appendLine()
-
-                                appendBlock {
-                                    append("Type: ").appendType(contextReceiverValue.type).appendLine()
-                                    contextReceiverValue.labelName?.let { labelName ->
-                                        append("Label: ").appendLine(labelName)
-                                    }
-                                }
-                            }
-                        }
-                    }
-
                     towerDataElement.contextParameterGroup?.takeIf { it.isNotEmpty() }?.let { contextParameterValues ->
                         appendBlock("Context parameters:") {
                             for (contextParameterValue in contextParameterValues) {

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

@@ -5,7 +5,6 @@
 
 package org.jetbrains.kotlin.fir.backend
 
-import org.jetbrains.kotlin.descriptors.DescriptorVisibilities
 import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.fir.backend.generators.isExternalParent
@@ -19,18 +18,15 @@ import org.jetbrains.kotlin.fir.lazy.Fir2IrLazyClass
 import org.jetbrains.kotlin.fir.resolve.getContainingClassSymbol
 import org.jetbrains.kotlin.fir.resolve.providers.symbolProvider
 import org.jetbrains.kotlin.fir.resolve.toClassSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirReplSnippetSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirTypeAliasSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase
 import org.jetbrains.kotlin.fir.types.ConeClassLikeLookupTag
-import org.jetbrains.kotlin.ir.UNDEFINED_OFFSET
 import org.jetbrains.kotlin.ir.declarations.*
-import org.jetbrains.kotlin.ir.declarations.impl.IrFactoryImpl
 import org.jetbrains.kotlin.ir.symbols.*
-import org.jetbrains.kotlin.ir.symbols.impl.*
+import org.jetbrains.kotlin.ir.symbols.impl.IrClassSymbolImpl
+import org.jetbrains.kotlin.ir.symbols.impl.IrEnumEntrySymbolImpl
+import org.jetbrains.kotlin.ir.symbols.impl.IrTypeAliasSymbolImpl
+import org.jetbrains.kotlin.ir.symbols.impl.IrTypeParameterSymbolImpl
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.name.SpecialNames
 import org.jetbrains.kotlin.utils.addToStdlib.runIf
@@ -284,30 +280,6 @@ class Fir2IrClassifierStorage(
         return getIrClass(lookupTag)?.symbol
     }
 
-    // TODO(KT-72994) remove when context receivers are removed
-    fun getFieldsWithContextReceiversForClass(irClass: IrClass, klass: FirClass): List<IrField> {
-        if (klass !is FirRegularClass || klass.contextParameters.isEmpty()) return emptyList()
-
-        return fieldsForContextReceivers.getOrPut(irClass) {
-            klass.contextParameters.withIndex().map { (index, contextReceiver) ->
-                IrFactoryImpl.createField(
-                    startOffset = UNDEFINED_OFFSET,
-                    endOffset = UNDEFINED_OFFSET,
-                    origin = IrDeclarationOrigin.FIELD_FOR_CLASS_CONTEXT_RECEIVER,
-                    name = Name.identifier("contextReceiverField$index"),
-                    visibility = DescriptorVisibilities.PRIVATE,
-                    symbol = IrFieldSymbolImpl(),
-                    type = contextReceiver.returnTypeRef.toIrType(),
-                    isFinal = true,
-                    isStatic = false,
-                    isExternal = false,
-                ).also {
-                    it.parent = irClass
-                }
-            }
-        }
-    }
-
     fun getIrClassForNotFoundClass(classLikeLookupTag: ConeClassLikeLookupTag): IrClass {
         return notFoundClassCache.getOrPut(classLikeLookupTag) {
             classifiersGenerator.createIrClassForNotFoundClass(classLikeLookupTag)

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

@@ -237,10 +237,6 @@ class Fir2IrConverter(
             }
         }
 
-        // `irClass` is a source class and definitely is not a lazy class
-        @OptIn(UnsafeDuringIrConstructionAPI::class)
-        irClass.declarations.addAll(classifierStorage.getFieldsWithContextReceiversForClass(irClass, klass))
-
         val irConstructor = klass.primaryConstructorIfAny(session)?.let {
             declarationStorage.createAndCacheIrConstructor(it.fir, { irClass }, isLocal = klass.isLocal)
         }