[FE] Create separate class for context receiver value

compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java

@@ -965,8 +965,8 @@ public class DescriptorResolver {
             receiverType = typeResolver.resolveType(scopeForDeclarationResolutionWithTypeParameters, receiverTypeRef, trace, true);
             AnnotationSplitter splitter = new AnnotationSplitter(storageManager, receiverType.getAnnotations(), EnumSet.of(RECEIVER));
             receiverDescriptor = DescriptorFactory.createExtensionReceiverParameterForCallable(
-                    propertyDescriptor, receiverType, splitter.getAnnotationsForTarget(RECEIVER),
+                    propertyDescriptor, receiverType, splitter.getAnnotationsForTarget(RECEIVER)
-                    false);
+            );
             receiverToLabelMap.put(receiverDescriptor, receiverTypeRef.nameForReceiverLabel());
         }
 
@@ -1046,9 +1046,9 @@ public class DescriptorResolver {
         return Lists.reverse(contextReceivers).stream().map(contextReceiver -> {
             KotlinType receiverType = contextReceiversToTypes.get(contextReceiver);
             AnnotationSplitter splitter = new AnnotationSplitter(storageManager, receiverType.getAnnotations(), EnumSet.of(RECEIVER));
-            ReceiverParameterDescriptor receiverDescriptor = DescriptorFactory.createExtensionReceiverParameterForCallable(
+            ReceiverParameterDescriptor receiverDescriptor = DescriptorFactory.createContextReceiverParameterForCallable(
-                    propertyDescriptor, receiverType, splitter.getAnnotationsForTarget(RECEIVER),
+                    propertyDescriptor, receiverType, splitter.getAnnotationsForTarget(RECEIVER)
-                    true);
+            );
             String contextReceiverName = contextReceiver.name();
             if (contextReceiverName != null) {
                 receiverToLabelMap.put(receiverDescriptor, contextReceiverName);

compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionDescriptorResolver.kt

@@ -232,7 +232,7 @@ class FunctionDescriptorResolver(
         val extensionReceiver = receiverType?.let {
             val splitter = AnnotationSplitter(storageManager, receiverType.annotations, EnumSet.of(AnnotationUseSiteTarget.RECEIVER))
             DescriptorFactory.createExtensionReceiverParameterForCallable(
-                functionDescriptor, it, splitter.getAnnotationsForTarget(AnnotationUseSiteTarget.RECEIVER), false
+                functionDescriptor, it, splitter.getAnnotationsForTarget(AnnotationUseSiteTarget.RECEIVER)
             )
         }?.apply {
             val extensionReceiverName = receiverTypeRef?.nameForReceiverLabel()
@@ -243,15 +243,16 @@ class FunctionDescriptorResolver(
 
         val contextReceiverDescriptors = contextReceiverTypes.mapNotNull { type ->
             val splitter = AnnotationSplitter(storageManager, type.annotations, EnumSet.of(AnnotationUseSiteTarget.RECEIVER))
-            DescriptorFactory.createExtensionReceiverParameterForCallable(
+            DescriptorFactory.createContextReceiverParameterForCallable(
-                functionDescriptor, type, splitter.getAnnotationsForTarget(AnnotationUseSiteTarget.RECEIVER), true
+                functionDescriptor, type, splitter.getAnnotationsForTarget(AnnotationUseSiteTarget.RECEIVER)
             )
         }
-        contextReceiverDescriptors.reversed().zip(contextReceivers.lastIndex downTo 0).forEach { (contextReceiverDescriptor, i) ->
+        contextReceiverDescriptors.zip(0 until contextReceivers.size).reversed()
-            contextReceivers[i].name()?.let {
+            .forEach { (contextReceiverDescriptor, i) ->
-                receiverToLabelMap[contextReceiverDescriptor] = it
+                contextReceivers[i].name()?.let {
+                    receiverToLabelMap[contextReceiverDescriptor] = it
+                }
             }
-        }
         trace.record(BindingContext.DESCRIPTOR_TO_NAMED_RECEIVERS, functionDescriptor, receiverToLabelMap)
         functionDescriptor.initialize(
             extensionReceiver,

compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java

@@ -66,6 +66,7 @@ import org.jetbrains.kotlin.resolve.checkers.UnderscoreChecker;
 import org.jetbrains.kotlin.resolve.constants.*;
 import org.jetbrains.kotlin.resolve.scopes.LexicalScopeKind;
 import org.jetbrains.kotlin.resolve.scopes.LexicalWritableScope;
+import org.jetbrains.kotlin.resolve.scopes.receivers.ContextReceiver;
 import org.jetbrains.kotlin.resolve.scopes.receivers.ExpressionReceiver;
 import org.jetbrains.kotlin.resolve.scopes.receivers.ExtensionReceiver;
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue;
@@ -599,7 +600,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
             else if (!receivers.isEmpty()) {
                 // `this` cannot point to context receiver
                 for (ReceiverParameterDescriptor receiver : receivers) {
-                    if (!(receiver.getValue() instanceof ExtensionReceiver) || !((ExtensionReceiver) receiver.getValue()).isContextReceiver()) {
+                    if (!(receiver.getValue() instanceof ContextReceiver)) {
                         result = receiver;
                         break;
                     }

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/ArgumentsGenerationUtils.kt

@@ -95,11 +95,11 @@ fun StatementGenerator.generateReceiver(ktDefaultElement: KtElement, receiver: R
 fun StatementGenerator.generateReceiver(defaultStartOffset: Int, defaultEndOffset: Int, receiver: ReceiverValue): IntermediateValue {
     val irReceiverType =
         when (receiver) {
-            is ExtensionReceiver -> {
+            is ExtensionReceiver ->
-                val receiverParameters =
+                receiver.declarationDescriptor.extensionReceiverParameter!!.type.toIrType()
-                    receiver.declarationDescriptor.contextReceiverParameters + listOfNotNull(receiver.declarationDescriptor.extensionReceiverParameter)
+            is ContextReceiver -> {
-                val receiverParameter = receiverParameters.firstOrNull { it.value == receiver }
+                val receiverParameter = receiver.declarationDescriptor.contextReceiverParameters.firstOrNull()
-                    ?: receiver.declarationDescriptor.extensionReceiverParameter!!
+                    ?: error("Unknown receiver: $receiver")
                 receiverParameter.type.toIrType()
             }
             else ->
@@ -142,10 +142,14 @@ fun StatementGenerator.generateReceiver(defaultStartOffset: Int, defaultEndOffse
                 is ExpressionReceiver ->
                     generateExpression(receiver.expression)
                 is ExtensionReceiver -> {
-                    val receiverParameters = listOfNotNull(receiver.declarationDescriptor.extensionReceiverParameter) +
+                    IrGetValueImpl(
-                            receiver.declarationDescriptor.contextReceiverParameters
+                        defaultStartOffset, defaultStartOffset, irReceiverType,
-                    val receiverParameter = receiverParameters.singleOrNull { it.value == receiver }
+                        context.symbolTable.referenceValueParameter(receiver.declarationDescriptor.extensionReceiverParameter!!)
-                        ?: receiver.declarationDescriptor.extensionReceiverParameter!!
+                    )
+                }
+                is ContextReceiver -> {
+                    val receiverParameter = receiver.declarationDescriptor.contextReceiverParameters
+                        .single { it.value == receiver }
                     IrGetValueImpl(
                         defaultStartOffset, defaultStartOffset, irReceiverType,
                         context.symbolTable.referenceValueParameter(receiverParameter)

core/descriptors/src/org/jetbrains/kotlin/resolve/DescriptorFactory.java

@@ -22,6 +22,7 @@ import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.descriptors.annotations.Annotations;
 import org.jetbrains.kotlin.descriptors.impl.*;
 import org.jetbrains.kotlin.name.Name;
+import org.jetbrains.kotlin.resolve.scopes.receivers.ContextReceiver;
 import org.jetbrains.kotlin.resolve.scopes.receivers.ExtensionReceiver;
 import org.jetbrains.kotlin.types.KotlinType;
 import org.jetbrains.kotlin.types.Variance;
@@ -189,18 +190,19 @@ public class DescriptorFactory {
             @Nullable KotlinType receiverParameterType,
             @NotNull Annotations annotations
     ) {
-        return createExtensionReceiverParameterForCallable(owner, receiverParameterType, annotations, false);
+        return receiverParameterType == null
+               ? null
+               : new ReceiverParameterDescriptorImpl(owner, new ExtensionReceiver(owner, receiverParameterType, null), annotations);
     }
 
     @Nullable
-    public static ReceiverParameterDescriptor createExtensionReceiverParameterForCallable(
+    public static ReceiverParameterDescriptor createContextReceiverParameterForCallable(
             @NotNull CallableDescriptor owner,
             @Nullable KotlinType receiverParameterType,
-            @NotNull Annotations annotations,
+            @NotNull Annotations annotations
-            boolean isContextReceiver
     ) {
         return receiverParameterType == null
                ? null
-               : new ReceiverParameterDescriptorImpl(owner, new ExtensionReceiver(owner, receiverParameterType, null, isContextReceiver), annotations);
+               : new ReceiverParameterDescriptorImpl(owner, new ContextReceiver(owner, receiverParameterType, null), annotations);
     }
 }

core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/receivers/ContextReceiver.kt

@@ -0,0 +1,19 @@
+/*
+ * Copyright 2010-2021 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.resolve.scopes.receivers
+
+import org.jetbrains.kotlin.descriptors.CallableDescriptor
+import org.jetbrains.kotlin.types.KotlinType
+
+class ContextReceiver(
+    override val declarationDescriptor: CallableDescriptor,
+    receiverType: KotlinType,
+    original: ReceiverValue?
+) : AbstractReceiverValue(receiverType, original), ImplicitReceiver {
+    override fun replaceType(newType: KotlinType): ReceiverValue = ContextReceiver(declarationDescriptor, newType, original)
+
+    override fun toString(): String = "Cxt { $declarationDescriptor }"
+}

core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/receivers/ExtensionReceiver.java

@@ -35,25 +35,14 @@ import org.jetbrains.kotlin.types.checker.NewKotlinTypeChecker;
 public class ExtensionReceiver extends AbstractReceiverValue implements ImplicitReceiver {
 
     private final CallableDescriptor descriptor;
-    private final boolean isContextReceiver;
 
     public ExtensionReceiver(
             @NotNull CallableDescriptor callableDescriptor,
             @NotNull KotlinType receiverType,
             @Nullable ReceiverValue original
-    ) {
-        this(callableDescriptor, receiverType, original, false);
-    }
-
-    public ExtensionReceiver(
-            @NotNull CallableDescriptor callableDescriptor,
-            @NotNull KotlinType receiverType,
-            @Nullable ReceiverValue original,
-            boolean isContextReceiver
     ) {
         super(receiverType, original);
         this.descriptor = callableDescriptor;
-        this.isContextReceiver = isContextReceiver;
     }
 
     @NotNull
@@ -72,8 +61,4 @@ public class ExtensionReceiver extends AbstractReceiverValue implements Implicit
     public String toString() {
         return getType() + ": Ext {" + descriptor + "}";
     }
-
-    public boolean isContextReceiver() {
-        return isContextReceiver;
-    }
 }