Rename: this object, receiver argument -> dispatch receiver, extension receiver

compiler/backend-common/src/bridges/impl.kt

@@ -87,7 +87,7 @@ public fun findTraitImplementation(descriptor: CallableMemberDescriptor): Callab
 
     // If this implementation is already generated into one of the superclasses, we need not generate it again, it'll be inherited
     val containingClass = descriptor.getContainingDeclaration() as ClassDescriptor
-    val implClassType = implementation!!.getExpectedThisObject()!!.getType()
+    val implClassType = implementation!!.getDispatchReceiverParameter()!!.getType()
     for (supertype in containingClass.getDefaultType().getConstructor().getSupertypes()) {
         if (!DescriptorUtils.isTrait(supertype.getConstructor().getDeclarationDescriptor()!!) &&
             TypeUtils.getAllSupertypes(supertype).contains(implClassType)) {

compiler/backend/src/org/jetbrains/jet/codegen/AccessorForFunctionDescriptor.java

@@ -44,8 +44,8 @@ public class AccessorForFunctionDescriptor extends SimpleFunctionDescriptorImpl
               Kind.DECLARATION, SourceElement.NO_SOURCE);
         this.calleeDescriptor = descriptor;
 
-        initialize(DescriptorUtils.getReceiverParameterType(descriptor.getReceiverParameter()),
-                   descriptor instanceof ConstructorDescriptor ? NO_RECEIVER_PARAMETER : descriptor.getExpectedThisObject(),
+        initialize(DescriptorUtils.getReceiverParameterType(descriptor.getExtensionReceiverParameter()),
+                   descriptor instanceof ConstructorDescriptor ? NO_RECEIVER_PARAMETER : descriptor.getDispatchReceiverParameter(),
                    copyTypeParameters(descriptor),
                    copyValueParameters(descriptor),
                    descriptor.getReturnType(),

compiler/backend/src/org/jetbrains/jet/codegen/AccessorForPropertyDescriptor.java

@@ -34,14 +34,14 @@ public class AccessorForPropertyDescriptor extends PropertyDescriptorImpl implem
     private final PropertyDescriptor calleeDescriptor;
 
     public AccessorForPropertyDescriptor(@NotNull PropertyDescriptor pd, @NotNull DeclarationDescriptor containingDeclaration, int index) {
-        this(pd, pd.getType(), DescriptorUtils.getReceiverParameterType(pd.getReceiverParameter()), pd.getExpectedThisObject(), containingDeclaration, index);
+        this(pd, pd.getType(), DescriptorUtils.getReceiverParameterType(pd.getExtensionReceiverParameter()), pd.getDispatchReceiverParameter(), containingDeclaration, index);
     }
 
     protected AccessorForPropertyDescriptor(
             @NotNull PropertyDescriptor original,
             @NotNull JetType propertyType,
             @Nullable JetType receiverType,
-            @Nullable ReceiverParameterDescriptor expectedThisObject,
+            @Nullable ReceiverParameterDescriptor dispatchReceiverParameter,
             @NotNull DeclarationDescriptor containingDeclaration,
             int index
     ) {
@@ -50,7 +50,7 @@ public class AccessorForPropertyDescriptor extends PropertyDescriptorImpl implem
               Kind.DECLARATION, SourceElement.NO_SOURCE);
 
         this.calleeDescriptor = original;
-        setType(propertyType, Collections.<TypeParameterDescriptorImpl>emptyList(), expectedThisObject, receiverType);
+        setType(propertyType, Collections.<TypeParameterDescriptorImpl>emptyList(), dispatchReceiverParameter, receiverType);
         initialize(new Getter(this), new Setter(this));
     }
 

compiler/backend/src/org/jetbrains/jet/codegen/AsmUtil.java

@@ -667,7 +667,7 @@ public class AsmUtil {
     }
 
     public static int getVisibilityForSpecialPropertyBackingField(@NotNull PropertyDescriptor propertyDescriptor, boolean isDelegate) {
-        boolean isExtensionProperty = propertyDescriptor.getReceiverParameter() != null;
+        boolean isExtensionProperty = propertyDescriptor.getExtensionReceiverParameter() != null;
         if (isDelegate || isExtensionProperty) {
             return ACC_PRIVATE;
         }
@@ -688,7 +688,7 @@ public class AsmUtil {
     }
 
     public static boolean isPropertyWithBackingFieldCopyInOuterClass(@NotNull PropertyDescriptor propertyDescriptor) {
-        boolean isExtensionProperty = propertyDescriptor.getReceiverParameter() != null;
+        boolean isExtensionProperty = propertyDescriptor.getExtensionReceiverParameter() != null;
         DeclarationDescriptor propertyContainer = propertyDescriptor.getContainingDeclaration();
         return !propertyDescriptor.isVar()
                && !isExtensionProperty

compiler/backend/src/org/jetbrains/jet/codegen/ClosureCodegen.java

@@ -230,7 +230,7 @@ public class ClosureCodegen extends ParentCodegenAware {
         InstructionAdapter iv = new InstructionAdapter(mv);
         iv.load(0, asmType);
 
-        ReceiverParameterDescriptor receiver = funDescriptor.getReceiverParameter();
+        ReceiverParameterDescriptor receiver = funDescriptor.getExtensionReceiverParameter();
         int count = 1;
         if (receiver != null) {
             StackValue.local(count, bridge.getArgumentTypes()[count - 1]).put(typeMapper.mapType(receiver.getType()), iv);
@@ -328,7 +328,7 @@ public class ClosureCodegen extends ParentCodegenAware {
     @NotNull
     public static FunctionDescriptor getErasedInvokeFunction(@NotNull FunctionDescriptor funDescriptor) {
         int arity = funDescriptor.getValueParameters().size();
-        ClassDescriptor funClass = funDescriptor.getReceiverParameter() == null
+        ClassDescriptor funClass = funDescriptor.getExtensionReceiverParameter() == null
                                    ? KotlinBuiltIns.getInstance().getFunction(arity)
                                    : KotlinBuiltIns.getInstance().getExtensionFunction(arity);
         return funClass.getDefaultType().getMemberScope().getFunctions(Name.identifier("invoke")).iterator().next();

compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java

@@ -1880,7 +1880,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
         boolean isBackingFieldInAnotherClass = AsmUtil.isPropertyWithBackingFieldInOuterClass(propertyDescriptor);
         boolean isStatic = DescriptorUtils.isStaticDeclaration(propertyDescriptor);
         boolean isSuper = superExpression != null;
-        boolean isExtensionProperty = propertyDescriptor.getReceiverParameter() != null;
+        boolean isExtensionProperty = propertyDescriptor.getExtensionReceiverParameter() != null;
 
         JetType delegateType = getPropertyDelegateType(propertyDescriptor, bindingContext);
         boolean isDelegatedProperty = delegateType != null;
@@ -2479,7 +2479,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
         PackageFragmentDescriptor containingPackage = (PackageFragmentDescriptor) descriptor.getContainingDeclaration();
         String packageClassInternalName = PackageClassUtils.getPackageClassInternalName(containingPackage.getFqName());
 
-        ReceiverParameterDescriptor receiverParameter = descriptor.getReceiverParameter();
+        ReceiverParameterDescriptor receiverParameter = descriptor.getExtensionReceiverParameter();
         Method factoryMethod;
         if (receiverParameter != null) {
             Type[] parameterTypes = new Type[] {JAVA_STRING_TYPE, K_PACKAGE_IMPL_TYPE, getType(Class.class)};
@@ -2556,21 +2556,21 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
             JetCallExpression fakeExpression = constructFakeFunctionCall();
             final List<? extends ValueArgument> fakeArguments = fakeExpression.getValueArguments();
 
-            final ReceiverValue thisObject = computeAndSaveReceiver(signature, codegen, referencedFunction.getExpectedThisObject());
-            final ReceiverValue extensionReceiver = computeAndSaveReceiver(signature, codegen, referencedFunction.getReceiverParameter());
+            final ReceiverValue dispatchReceiver = computeAndSaveReceiver(signature, codegen, referencedFunction.getDispatchReceiverParameter());
+            final ReceiverValue extensionReceiver = computeAndSaveReceiver(signature, codegen, referencedFunction.getExtensionReceiverParameter());
             computeAndSaveArguments(fakeArguments, codegen);
 
             ResolvedCall<CallableDescriptor> fakeResolvedCall = new DelegatingResolvedCall<CallableDescriptor>(resolvedCall) {
                 @NotNull
                 @Override
-                public ReceiverValue getReceiverArgument() {
+                public ReceiverValue getExtensionReceiver() {
                     return extensionReceiver;
                 }
 
                 @NotNull
                 @Override
-                public ReceiverValue getThisObject() {
-                    return thisObject;
+                public ReceiverValue getDispatchReceiver() {
+                    return dispatchReceiver;
                 }
 
                 @NotNull
@@ -3316,17 +3316,17 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
 
         ConstructorDescriptor constructor = (ConstructorDescriptor) resolvedCall.getResultingDescriptor();
 
-        ReceiverParameterDescriptor expectedThisObject = constructor.getExpectedThisObject();
-        if (expectedThisObject != null) {
-            Type receiverType = typeMapper.mapType(expectedThisObject.getType());
-            generateReceiverValue(resolvedCall.getThisObject(), receiverType);
+        ReceiverParameterDescriptor dispatchReceiver = constructor.getDispatchReceiverParameter();
+        if (dispatchReceiver != null) {
+            Type receiverType = typeMapper.mapType(dispatchReceiver.getType());
+            generateReceiverValue(resolvedCall.getDispatchReceiver(), receiverType);
         }
 
         MutableClosure closure = bindingContext.get(CLOSURE, constructor.getContainingDeclaration());
 
-        // Resolved call to local class constructor doesn't have expectedThisObject, so we need to generate closure on stack
+        // Resolved call to local class constructor doesn't have dispatchReceiver, so we need to generate closure on stack
         // See StackValue.receiver for more info
-        pushClosureOnStack(closure, expectedThisObject != null, defaultCallGenerator);
+        pushClosureOnStack(closure, dispatchReceiver != null, defaultCallGenerator);
 
         ConstructorDescriptor originalOfSamAdapter = (ConstructorDescriptor) SamCodegenUtil.getOriginalIfSamAdapter(constructor);
         CallableMethod method = typeMapper.mapToCallableMethod(originalOfSamAdapter == null ? constructor : originalOfSamAdapter);
@@ -3463,7 +3463,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
             else {
                 gen(array, arrayType); // intrinsic method
 
-                int index = operationDescriptor.getReceiverParameter() != null ? 1 : 0;
+                int index = operationDescriptor.getExtensionReceiverParameter() != null ? 1 : 0;
 
                 for (JetExpression jetExpression : expression.getIndexExpressions()) {
                     gen(jetExpression, argumentTypes[index]);

compiler/backend/src/org/jetbrains/jet/codegen/FunctionCodegen.java

@@ -39,7 +39,6 @@ import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.psi.JetNamedFunction;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
-import org.jetbrains.jet.lang.resolve.ResolvePackage;
 import org.jetbrains.jet.lang.resolve.annotations.AnnotationsPackage;
 import org.jetbrains.jet.lang.resolve.calls.CallResolverUtil;
 import org.jetbrains.jet.lang.resolve.constants.ArrayValue;
@@ -236,7 +235,7 @@ public class FunctionCodegen extends ParentCodegenAware {
                 }
 
                 if (kind == JvmMethodParameterKind.RECEIVER) {
-                    ReceiverParameterDescriptor receiver = functionDescriptor.getReceiverParameter();
+                    ReceiverParameterDescriptor receiver = functionDescriptor.getExtensionReceiverParameter();
                     nullableType = receiver == null || receiver.getType().isNullable();
                 }
                 else {
@@ -271,12 +270,12 @@ public class FunctionCodegen extends ParentCodegenAware {
 
     @Nullable
     private static Type getThisTypeForFunction(@NotNull FunctionDescriptor functionDescriptor, @NotNull MethodContext context, @NotNull JetTypeMapper typeMapper) {
-        ReceiverParameterDescriptor expectedThisObject = functionDescriptor.getExpectedThisObject();
+        ReceiverParameterDescriptor dispatchReceiver = functionDescriptor.getDispatchReceiverParameter();
         if (functionDescriptor instanceof ConstructorDescriptor) {
             return typeMapper.mapType(functionDescriptor);
         }
-        else if (expectedThisObject != null) {
-            return typeMapper.mapType(expectedThisObject.getType());
+        else if (dispatchReceiver != null) {
+            return typeMapper.mapType(dispatchReceiver.getType());
         }
         else if (isFunctionLiteral(functionDescriptor) || isLocalNamedFun(functionDescriptor)) {
             return typeMapper.mapType(context.getThisDescriptor());

compiler/backend/src/org/jetbrains/jet/codegen/JvmCodegenUtil.java

@@ -172,7 +172,7 @@ public class JvmCodegenUtil {
         if (!isCallInsideSameClassAsDeclared(property, context) && !isDebuggerContext(context)) return false;
 
         // Delegated and extension properties have no backing fields
-        if (isDelegated || property.getReceiverParameter() != null) return false;
+        if (isDelegated || property.getExtensionReceiverParameter() != null) return false;
 
         // Class object properties cannot be accessed directly because their backing fields are stored in the containing class
         if (DescriptorUtils.isClassObject(property.getContainingDeclaration())) return false;
@@ -203,7 +203,7 @@ public class JvmCodegenUtil {
     }
 
     @Nullable
-    public static ClassDescriptor getExpectedThisObjectForConstructorCall(
+    public static ClassDescriptor getDispatchReceiverParameterForConstructorCall(
             @NotNull ConstructorDescriptor descriptor,
             @Nullable CalculatedClosure closure
     ) {
@@ -214,10 +214,10 @@ public class JvmCodegenUtil {
 
         //for compilation against binaries
         //TODO: It's best to use this code also for compilation against sources
-        // but sometimes structures that have expectedThisObject (bug?) mapped to static classes
-        ReceiverParameterDescriptor expectedThisObject = descriptor.getExpectedThisObject();
-        if (expectedThisObject != null) {
-            ClassDescriptor expectedThisClass = (ClassDescriptor) expectedThisObject.getContainingDeclaration();
+        // but sometimes structures that have dispatchReceiver (bug?) mapped to static classes
+        ReceiverParameterDescriptor dispatchReceiver = descriptor.getDispatchReceiverParameter();
+        if (dispatchReceiver != null) {
+            ClassDescriptor expectedThisClass = (ClassDescriptor) dispatchReceiver.getContainingDeclaration();
             if (!expectedThisClass.getKind().isSingleton()) {
                 return expectedThisClass;
             }

compiler/backend/src/org/jetbrains/jet/codegen/JvmRuntimeTypes.java

@@ -91,7 +91,7 @@ public class JvmRuntimeTypes {
 
     @NotNull
     public Collection<JetType> getSupertypesForClosure(@NotNull FunctionDescriptor descriptor) {
-        ReceiverParameterDescriptor receiverParameter = descriptor.getReceiverParameter();
+        ReceiverParameterDescriptor receiverParameter = descriptor.getExtensionReceiverParameter();
 
         List<TypeProjection> typeArguments = new ArrayList<TypeProjection>(2);
 
@@ -127,21 +127,21 @@ public class JvmRuntimeTypes {
 
     @NotNull
     public Collection<JetType> getSupertypesForFunctionReference(@NotNull FunctionDescriptor descriptor) {
-        ReceiverParameterDescriptor receiverParameter = descriptor.getReceiverParameter();
-        ReceiverParameterDescriptor expectedThisObject = descriptor.getExpectedThisObject();
+        ReceiverParameterDescriptor extensionReceiver = descriptor.getExtensionReceiverParameter();
+        ReceiverParameterDescriptor dispatchReceiver = descriptor.getDispatchReceiverParameter();
 
         List<TypeProjection> typeArguments = new ArrayList<TypeProjection>(2);
 
         ClassDescriptor classDescriptor;
         JetType receiverType;
-        if (receiverParameter != null) {
+        if (extensionReceiver != null) {
             classDescriptor = kExtensionFunctionImpl;
-            receiverType = receiverParameter.getType();
+            receiverType = extensionReceiver.getType();
             typeArguments.add(new TypeProjectionImpl(receiverType));
         }
-        else if (expectedThisObject != null) {
+        else if (dispatchReceiver != null) {
             classDescriptor = kMemberFunctionImpl;
-            receiverType = expectedThisObject.getType();
+            receiverType = dispatchReceiver.getType();
             typeArguments.add(new TypeProjectionImpl(receiverType));
         }
         else {
@@ -165,7 +165,7 @@ public class JvmRuntimeTypes {
                 receiverType,
                 ExpressionTypingUtils.getValueParametersTypes(descriptor.getValueParameters()),
                 descriptor.getReturnType(),
-                receiverParameter != null
+                extensionReceiver != null
         );
 
         return Arrays.asList(kFunctionImplType, kFunctionType);

compiler/backend/src/org/jetbrains/jet/codegen/PropertyCodegen.java

@@ -206,7 +206,7 @@ public class PropertyCodegen {
     private void generateSyntheticMethodIfNeeded(@NotNull PropertyDescriptor descriptor) {
         if (descriptor.getAnnotations().isEmpty()) return;
 
-        ReceiverParameterDescriptor receiver = descriptor.getReceiverParameter();
+        ReceiverParameterDescriptor receiver = descriptor.getExtensionReceiverParameter();
         String name = JvmAbi.getSyntheticMethodNameForAnnotatedProperty(descriptor.getName());
         String desc = receiver == null ? "()V" : "(" + typeMapper.mapType(receiver.getType()) + ")V";
 
@@ -395,7 +395,7 @@ public class PropertyCodegen {
                 v.areturn(type);
             }
             else if (callableDescriptor instanceof PropertySetterDescriptor) {
-                ReceiverParameterDescriptor receiverParameter = propertyDescriptor.getReceiverParameter();
+                ReceiverParameterDescriptor receiverParameter = propertyDescriptor.getExtensionReceiverParameter();
                 if (receiverParameter != null) {
                     paramCode += codegen.typeMapper.mapType(receiverParameter.getType()).getSize();
                 }

compiler/backend/src/org/jetbrains/jet/codegen/StackValue.java

@@ -333,7 +333,7 @@ public abstract class StackValue {
             ExpressionCodegen codegen,
             @Nullable CallableMethod callableMethod
     ) {
-        if (resolvedCall.getThisObject().exists() || resolvedCall.getReceiverArgument().exists() || isLocalFunCall(callableMethod)) {
+        if (resolvedCall.getDispatchReceiver().exists() || resolvedCall.getExtensionReceiver().exists() || isLocalFunCall(callableMethod)) {
             return new CallReceiver(resolvedCall, receiver, codegen, callableMethod, true);
         }
         return receiver;
@@ -692,7 +692,7 @@ public abstract class StackValue {
                 v.store(firstParamIndex, type);
             }
 
-            ReceiverValue receiverParameter = resolvedGetCall.getReceiverArgument();
+            ReceiverValue receiverParameter = resolvedGetCall.getExtensionReceiver();
             int receiverIndex = -1;
             if (receiverParameter.exists()) {
                 Type type = codegen.typeMapper.mapType(receiverParameter.getType());
@@ -700,9 +700,9 @@ public abstract class StackValue {
                 v.store(receiverIndex, type);
             }
 
-            ReceiverValue thisObject = resolvedGetCall.getThisObject();
+            ReceiverValue dispatchReceiver = resolvedGetCall.getDispatchReceiver();
             int thisIndex = -1;
-            if (thisObject.exists()) {
+            if (dispatchReceiver.exists()) {
                 thisIndex = frame.enterTemp(OBJECT_TYPE);
                 v.store(thisIndex, OBJECT_TYPE);
             }
@@ -723,14 +723,14 @@ public abstract class StackValue {
                 throw new UnsupportedOperationException();
             }
 
-            if (resolvedSetCall.getThisObject().exists()) {
-                if (resolvedSetCall.getReceiverArgument().exists()) {
-                    codegen.generateReceiverValue(resolvedSetCall.getThisObject(), OBJECT_TYPE);
+            if (resolvedSetCall.getDispatchReceiver().exists()) {
+                if (resolvedSetCall.getExtensionReceiver().exists()) {
+                    codegen.generateReceiverValue(resolvedSetCall.getDispatchReceiver(), OBJECT_TYPE);
                 }
                 v.load(realReceiverIndex, realReceiverType);
             }
             else {
-                if (resolvedSetCall.getReceiverArgument().exists()) {
+                if (resolvedSetCall.getExtensionReceiver().exists()) {
                     v.load(realReceiverIndex, realReceiverType);
                 }
                 else {
@@ -780,13 +780,13 @@ public abstract class StackValue {
                 }
             }
 
-            if (call.getThisObject().exists()) {
-                if (call.getReceiverArgument().exists()) {
+            if (call.getDispatchReceiver().exists()) {
+                if (call.getExtensionReceiver().exists()) {
                     return false;
                 }
             }
             else {
-                if (codegen.typeMapper.mapType(call.getResultingDescriptor().getReceiverParameter().getType())
+                if (codegen.typeMapper.mapType(call.getResultingDescriptor().getExtensionReceiverParameter().getType())
                             .getSize() != 1) {
                     return false;
                 }
@@ -1107,14 +1107,14 @@ public abstract class StackValue {
         ) {
             CallableDescriptor descriptor = resolvedCall.getResultingDescriptor();
 
-            ReceiverParameterDescriptor expectedThisObject = descriptor.getExpectedThisObject();
-            ReceiverParameterDescriptor receiverParameter = descriptor.getReceiverParameter();
+            ReceiverParameterDescriptor dispatchReceiver = descriptor.getDispatchReceiverParameter();
+            ReceiverParameterDescriptor extensionReceiver = descriptor.getExtensionReceiverParameter();
 
-            if (receiverParameter != null) {
-                return callableMethod != null ? callableMethod.getReceiverClass() : typeMapper.mapType(receiverParameter.getType());
+            if (extensionReceiver != null) {
+                return callableMethod != null ? callableMethod.getReceiverClass() : typeMapper.mapType(extensionReceiver.getType());
             }
-            else if (expectedThisObject != null) {
-                return callableMethod != null ? callableMethod.getThisType() : typeMapper.mapType(expectedThisObject.getType());
+            else if (dispatchReceiver != null) {
+                return callableMethod != null ? callableMethod.getThisType() : typeMapper.mapType(dispatchReceiver.getType());
             }
             else if (isLocalFunCall(callableMethod)) {
                 return callableMethod.getGenerateCalleeType();
@@ -1127,28 +1127,28 @@ public abstract class StackValue {
         public void put(Type type, InstructionAdapter v) {
             CallableDescriptor descriptor = resolvedCall.getResultingDescriptor();
 
-            ReceiverValue thisObject = resolvedCall.getThisObject();
-            ReceiverValue receiverArgument = resolvedCall.getReceiverArgument();
+            ReceiverValue dispatchReceiver = resolvedCall.getDispatchReceiver();
+            ReceiverValue extensionReceiver = resolvedCall.getExtensionReceiver();
             int depth = 0;
-            if (thisObject.exists()) {
+            if (dispatchReceiver.exists()) {
                 if (!AnnotationsPackage.isPlatformStaticInObject(descriptor)) {
-                    if (receiverArgument.exists()) {
+                    if (extensionReceiver.exists()) {
                         //noinspection ConstantConditions
                         Type resultType =
                                 callableMethod != null ?
                                 callableMethod.getOwner() :
-                                codegen.typeMapper.mapType(descriptor.getExpectedThisObject().getType());
+                                codegen.typeMapper.mapType(descriptor.getDispatchReceiverParameter().getType());
 
-                        codegen.generateReceiverValue(thisObject, resultType);
+                        codegen.generateReceiverValue(dispatchReceiver, resultType);
                     }
                     else {
-                        genReceiver(v, thisObject, type, null, 0);
+                        genReceiver(v, dispatchReceiver, type, null, 0);
                     }
                     depth = 1;
                 }
             }
             else if (isLocalFunCall(callableMethod)) {
-                assert receiver == none() || receiverArgument.exists() :
+                assert receiver == none() || extensionReceiver.exists() :
                         "Receiver should be present only for local extension function: " + callableMethod;
                 StackValue value = codegen.findLocalOrCapturedValue(descriptor.getOriginal());
                 assert value != null : "Local fun should be found in locals or in captured params: " + resolvedCall;
@@ -1157,8 +1157,8 @@ public abstract class StackValue {
                 depth = 1;
             }
 
-            if (putReceiverArgumentOnStack && receiverArgument.exists()) {
-                genReceiver(v, receiverArgument, type, descriptor.getReceiverParameter(), depth);
+            if (putReceiverArgumentOnStack && extensionReceiver.exists()) {
+                genReceiver(v, extensionReceiver, type, descriptor.getExtensionReceiverParameter(), depth);
             }
         }
 

compiler/backend/src/org/jetbrains/jet/codegen/TailRecursionCodegen.java

@@ -75,7 +75,7 @@ public class TailRecursionCodegen {
         }
         assignParameterValues(fd, callable, arguments);
         if (callable.getReceiverClass() != null) {
-            if (resolvedCall.getReceiverArgument() != fd.getReceiverParameter().getValue()) {
+            if (resolvedCall.getExtensionReceiver() != fd.getExtensionReceiverParameter().getValue()) {
                 StackValue expression = context.getReceiverExpression(codegen.typeMapper);
                 expression.store(callable.getReceiverClass(), v);
             }

compiler/backend/src/org/jetbrains/jet/codegen/binding/MutableClosure.java

@@ -56,7 +56,7 @@ public final class MutableClosure implements CalculatedClosure {
         DeclarationDescriptor classContainer = classDescriptor.getContainingDeclaration();
         if (classContainer instanceof CallableMemberDescriptor) {
             CallableMemberDescriptor member = getDirectMember((CallableMemberDescriptor) classContainer);
-            if (member.getReceiverParameter() != null) {
+            if (member.getExtensionReceiverParameter() != null) {
                 return member;
             }
         }
@@ -86,7 +86,7 @@ public final class MutableClosure implements CalculatedClosure {
     public JetType getCaptureReceiverType() {
         if (captureReceiver) {
             //noinspection ConstantConditions
-            ReceiverParameterDescriptor parameter = enclosingReceiverDescriptor.getReceiverParameter();
+            ReceiverParameterDescriptor parameter = enclosingReceiverDescriptor.getExtensionReceiverParameter();
             assert parameter != null : "Receiver parameter should exist in " + enclosingReceiverDescriptor;
             return parameter.getType();
         }

compiler/backend/src/org/jetbrains/jet/codegen/context/CodegenContext.java

@@ -109,7 +109,7 @@ public abstract class CodegenContext<T extends DeclarationDescriptor> {
     public final CallableDescriptor getCallableDescriptorWithReceiver() {
         if (contextDescriptor instanceof CallableDescriptor) {
             CallableDescriptor callableDescriptor = (CallableDescriptor) getContextDescriptor();
-            return callableDescriptor.getReceiverParameter() != null ? callableDescriptor : null;
+            return callableDescriptor.getExtensionReceiverParameter() != null ? callableDescriptor : null;
         }
         return null;
     }

compiler/backend/src/org/jetbrains/jet/codegen/context/LocalLookup.java

@@ -125,7 +125,7 @@ public interface LocalLookup {
             ) {
                 if (closure.getEnclosingReceiverDescriptor() != d) return null;
 
-                JetType receiverType = ((CallableDescriptor) d).getReceiverParameter().getType();
+                JetType receiverType = ((CallableDescriptor) d).getExtensionReceiverParameter().getType();
                 Type type = state.getTypeMapper().mapType(receiverType);
                 StackValue innerValue = StackValue.field(type, classType, CAPTURED_RECEIVER_FIELD, false);
                 closure.setCaptureReceiver();
@@ -137,7 +137,7 @@ public interface LocalLookup {
             @Override
             public StackValue outerValue(@NotNull EnclosedValueDescriptor d, @NotNull ExpressionCodegen codegen) {
                 CallableDescriptor descriptor = (CallableDescriptor) d.getDescriptor();
-                return StackValue.local(descriptor.getExpectedThisObject() != null ? 1 : 0, d.getType());
+                return StackValue.local(descriptor.getDispatchReceiverParameter() != null ? 1 : 0, d.getType());
             }
         };
 

compiler/backend/src/org/jetbrains/jet/codegen/context/MethodContext.java

@@ -59,7 +59,7 @@ public class MethodContext extends CodegenContext<CallableMemberDescriptor> {
     public StackValue getReceiverExpression(JetTypeMapper typeMapper) {
         assert getCallableDescriptorWithReceiver() != null;
         @SuppressWarnings("ConstantConditions")
-        Type asmType = typeMapper.mapType(getCallableDescriptorWithReceiver().getReceiverParameter().getType());
+        Type asmType = typeMapper.mapType(getCallableDescriptorWithReceiver().getExtensionReceiverParameter().getType());
         return StackValue.local(AsmUtil.getReceiverIndex(this, getContextDescriptor()), asmType);
     }
 

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/Clone.java

@@ -58,8 +58,8 @@ public class Clone extends IntrinsicMethod {
     }
 
     private static boolean isSuperCall(@NotNull ResolvedCall<?> resolvedCall) {
-        ReceiverValue thisObject = resolvedCall.getThisObject();
-        return thisObject instanceof ExpressionReceiver &&
-               ((ExpressionReceiver) thisObject).getExpression() instanceof JetSuperExpression;
+        ReceiverValue dispatchReceiver = resolvedCall.getDispatchReceiver();
+        return dispatchReceiver instanceof ExpressionReceiver &&
+               ((ExpressionReceiver) dispatchReceiver).getExpression() instanceof JetSuperExpression;
     }
 }

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/IntrinsicsMap.java

@@ -106,7 +106,7 @@ class IntrinsicsMap {
 
     @Nullable
     private static FqNameUnsafe getReceiverParameterFqName(@NotNull CallableMemberDescriptor descriptor) {
-        ReceiverParameterDescriptor receiverParameter = descriptor.getReceiverParameter();
+        ReceiverParameterDescriptor receiverParameter = descriptor.getExtensionReceiverParameter();
         if (receiverParameter == null) return null;
 
         ClassifierDescriptor classifier = receiverParameter.getType().getConstructor().getDeclarationDescriptor();

compiler/backend/src/org/jetbrains/jet/codegen/state/JetTypeMapper.java

@@ -524,7 +524,7 @@ public class JetTypeMapper {
         Type calleeType = isLocalNamedFun(functionDescriptor) ? owner : null;
 
         Type receiverParameterType;
-        ReceiverParameterDescriptor receiverParameter = functionDescriptor.getOriginal().getReceiverParameter();
+        ReceiverParameterDescriptor receiverParameter = functionDescriptor.getOriginal().getExtensionReceiverParameter();
         if (receiverParameter != null) {
             receiverParameterType = mapType(receiverParameter.getType());
         }
@@ -624,7 +624,7 @@ public class JetTypeMapper {
             sw.writeParametersStart();
             writeThisIfNeeded(f, kind, sw);
 
-            ReceiverParameterDescriptor receiverParameter = f.getReceiverParameter();
+            ReceiverParameterDescriptor receiverParameter = f.getExtensionReceiverParameter();
             if (receiverParameter != null) {
                 writeParameter(sw, JvmMethodParameterKind.RECEIVER, receiverParameter.getType());
             }
@@ -664,7 +664,7 @@ public class JetTypeMapper {
     public Method mapDefaultMethod(@NotNull FunctionDescriptor functionDescriptor, @NotNull OwnerKind kind, @NotNull CodegenContext<?> context) {
         Method jvmSignature = mapSignature(functionDescriptor, kind).getAsmMethod();
         Type ownerType = mapOwner(functionDescriptor, isCallInsideSameModuleAsDeclared(functionDescriptor, context, getOutDirectory()));
-        String descriptor = getDefaultDescriptor(jvmSignature, functionDescriptor.getReceiverParameter() != null);
+        String descriptor = getDefaultDescriptor(jvmSignature, functionDescriptor.getExtensionReceiverParameter() != null);
         boolean isConstructor = "<init>".equals(jvmSignature.getName());
         if (!isStaticMethod(kind, functionDescriptor) && !isConstructor) {
             descriptor = descriptor.replace("(", "(" + ownerType.getDescriptor());
@@ -713,7 +713,7 @@ public class JetTypeMapper {
         if (kind == OwnerKind.TRAIT_IMPL) {
             thisType = getTraitImplThisParameterClass((ClassDescriptor) descriptor.getContainingDeclaration());
         }
-        else if (isAccessor(descriptor) && descriptor.getExpectedThisObject() != null) {
+        else if (isAccessor(descriptor) && descriptor.getDispatchReceiverParameter() != null) {
             thisType = (ClassDescriptor) descriptor.getContainingDeclaration();
         }
         else return;
@@ -804,7 +804,7 @@ public class JetTypeMapper {
     private void writeAdditionalConstructorParameters(@NotNull ConstructorDescriptor descriptor, @NotNull BothSignatureWriter sw) {
         CalculatedClosure closure = bindingContext.get(CodegenBinding.CLOSURE, descriptor.getContainingDeclaration());
 
-        ClassDescriptor captureThis = getExpectedThisObjectForConstructorCall(descriptor, closure);
+        ClassDescriptor captureThis = getDispatchReceiverParameterForConstructorCall(descriptor, closure);
         if (captureThis != null) {
             writeParameter(sw, JvmMethodParameterKind.OUTER, captureThis.getDefaultType());
         }
@@ -930,7 +930,7 @@ public class JetTypeMapper {
             return asmTypeForAnonymousClass(bindingContext, (FunctionDescriptor) descriptor);
         }
         else if (descriptor instanceof PropertyDescriptor || descriptor instanceof FunctionDescriptor) {
-            ReceiverParameterDescriptor receiverParameter = ((CallableDescriptor) descriptor).getReceiverParameter();
+            ReceiverParameterDescriptor receiverParameter = ((CallableDescriptor) descriptor).getExtensionReceiverParameter();
             assert receiverParameter != null : "Callable should have a receiver parameter: " + descriptor;
             return StackValue.sharedTypeForType(mapType(receiverParameter.getType()));
         }

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/SignaturesPropagationData.java

@@ -215,7 +215,7 @@ public class SignaturesPropagationData {
                     new Function<FunctionDescriptor, TypeAndName>() {
                         @Override
                         public TypeAndName fun(FunctionDescriptor superFunction) {
-                            ReceiverParameterDescriptor receiver = superFunction.getReceiverParameter();
+                            ReceiverParameterDescriptor receiver = superFunction.getExtensionReceiverParameter();
                             int index = receiver != null ? originalIndex - 1 : originalIndex;
                             if (index == -1) {
                                 assert receiver != null : "can't happen: index is -1, while function is not extension";
@@ -318,7 +318,7 @@ public class SignaturesPropagationData {
         boolean someSupersNotExtension = false;
 
         for (FunctionDescriptor superFunction : superFunctions) {
-            if (superFunction.getReceiverParameter() != null)  {
+            if (superFunction.getExtensionReceiverParameter() != null)  {
                 someSupersExtension = true;
             }
             else {
@@ -343,7 +343,7 @@ public class SignaturesPropagationData {
         boolean someSupersNotVararg = false;
         for (FunctionDescriptor superFunction : superFunctions) {
             int originalIndex = originalParam.getIndex();
-            int index = superFunction.getReceiverParameter() != null ? originalIndex - 1 : originalIndex;
+            int index = superFunction.getExtensionReceiverParameter() != null ? originalIndex - 1 : originalIndex;
             if (index != -1 && superFunction.getValueParameters().get(index).getVarargElementType() != null) {
                 someSupersVararg = true;
             }

compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetControlFlowProcessor.java

@@ -929,10 +929,10 @@ public class JetControlFlowProcessor {
 
         private ReceiverValue getExplicitReceiverValue(ResolvedCall<?> resolvedCall) {
             switch(resolvedCall.getExplicitReceiverKind()) {
-                case THIS_OBJECT:
-                    return resolvedCall.getThisObject();
-                case RECEIVER_ARGUMENT:
-                    return resolvedCall.getReceiverArgument();
+                case DISPATCH_RECEIVER:
+                    return resolvedCall.getDispatchReceiver();
+                case EXTENSION_RECEIVER:
+                    return resolvedCall.getExtensionReceiver();
                 default:
                     return ReceiverValue.NO_RECEIVER;
             }
@@ -1533,8 +1533,8 @@ public class JetControlFlowProcessor {
         private Map<PseudoValue, ReceiverValue> getReceiverValues(ResolvedCall<?> resolvedCall) {
             SmartFMap<PseudoValue, ReceiverValue> receiverValues = SmartFMap.emptyMap();
             JetElement callElement = resolvedCall.getCall().getCallElement();
-            receiverValues = getReceiverValues(callElement, resolvedCall.getThisObject(), receiverValues);
-            receiverValues = getReceiverValues(callElement, resolvedCall.getReceiverArgument(), receiverValues);
+            receiverValues = getReceiverValues(callElement, resolvedCall.getDispatchReceiver(), receiverValues);
+            receiverValues = getReceiverValues(callElement, resolvedCall.getExtensionReceiver(), receiverValues);
             return receiverValues;
         }
 

compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetFlowInformationProvider.java

@@ -794,9 +794,9 @@ public class JetFlowInformationProvider {
                                 new TailRecursionDetector(subroutine, callInstruction)
                         );
 
-                        boolean sameThisObject = sameThisObject(resolvedCall);
+                        boolean sameDispatchReceiver = sameDispatchReceiver(resolvedCall);
 
-                        TailRecursionKind kind = isTail && sameThisObject ? TAIL_CALL : NON_TAIL;
+                        TailRecursionKind kind = isTail && sameDispatchReceiver ? TAIL_CALL : NON_TAIL;
 
                         KindAndCall kindAndCall = calls.get(element);
                         calls.put(element,
@@ -831,31 +831,31 @@ public class JetFlowInformationProvider {
         }
     }
 
-    private boolean sameThisObject(ResolvedCall<?> resolvedCall) {
+    private boolean sameDispatchReceiver(ResolvedCall<?> resolvedCall) {
         // A tail call is not allowed to change dispatch receiver
         //   class C {
         //       fun foo(other: C) {
         //           other.foo(this) // not a tail call
         //       }
         //   }
-        ReceiverParameterDescriptor thisObject = resolvedCall.getResultingDescriptor().getExpectedThisObject();
-        ReceiverValue thisObjectValue = resolvedCall.getThisObject();
-        if (thisObject == null || !thisObjectValue.exists()) return true;
+        ReceiverParameterDescriptor dispatchReceiverParameter = resolvedCall.getResultingDescriptor().getDispatchReceiverParameter();
+        ReceiverValue dispatchReceiverValue = resolvedCall.getDispatchReceiver();
+        if (dispatchReceiverParameter == null || !dispatchReceiverValue.exists()) return true;
 
         DeclarationDescriptor classDescriptor = null;
-        if (thisObjectValue instanceof ThisReceiver) {
+        if (dispatchReceiverValue instanceof ThisReceiver) {
             // foo() -- implicit receiver
-            classDescriptor = ((ThisReceiver) thisObjectValue).getDeclarationDescriptor();
+            classDescriptor = ((ThisReceiver) dispatchReceiverValue).getDeclarationDescriptor();
         }
-        else if (thisObjectValue instanceof ExpressionReceiver) {
-            JetExpression expression = JetPsiUtil.deparenthesize(((ExpressionReceiver) thisObjectValue).getExpression());
+        else if (dispatchReceiverValue instanceof ExpressionReceiver) {
+            JetExpression expression = JetPsiUtil.deparenthesize(((ExpressionReceiver) dispatchReceiverValue).getExpression());
             if (expression instanceof JetThisExpression) {
                 // this.foo() -- explicit receiver
                 JetThisExpression thisExpression = (JetThisExpression) expression;
                 classDescriptor = trace.get(BindingContext.REFERENCE_TARGET, thisExpression.getInstanceReference());
             }
         }
-        return thisObject.getContainingDeclaration() == classDescriptor;
+        return dispatchReceiverParameter.getContainingDeclaration() == classDescriptor;
     }
 
     private static TailRecursionKind combineKinds(TailRecursionKind kind, @Nullable TailRecursionKind existingKind) {

compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/pseudocodeUtil.kt

@@ -37,14 +37,14 @@ fun getReceiverTypePredicate(resolvedCall: ResolvedCall<*>, receiverValue: Recei
     if (callableDescriptor == null) return null
 
     when (receiverValue) {
-        resolvedCall.getReceiverArgument() -> {
-            val receiverParameter = callableDescriptor.getReceiverParameter()
+        resolvedCall.getExtensionReceiver() -> {
+            val receiverParameter = callableDescriptor.getExtensionReceiverParameter()
             if (receiverParameter != null) return receiverParameter.getType().getSubtypesPredicate()
         }
-        resolvedCall.getThisObject() -> {
+        resolvedCall.getDispatchReceiver() -> {
             val rootCallableDescriptors = OverridingUtil.getTopmostOverridenDescriptors(callableDescriptor)
             return or(rootCallableDescriptors.map {
-                it.getExpectedThisObject()?.getType()?.let { TypeUtils.makeNullableIfNeeded(it, resolvedCall.isSafeCall()) }?.getSubtypesPredicate()
+                it.getDispatchReceiverParameter()?.getType()?.let { TypeUtils.makeNullableIfNeeded(it, resolvedCall.isSafeCall()) }?.getSubtypesPredicate()
             }.filterNotNull())
         }
     }

compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/rendering/Renderers.java

@@ -228,7 +228,7 @@ public class Renderers {
              .text("None of the following substitutions");
 
         for (CallableDescriptor substitutedDescriptor : substitutedDescriptors) {
-            JetType receiverType = DescriptorUtils.getReceiverParameterType(substitutedDescriptor.getReceiverParameter());
+            JetType receiverType = DescriptorUtils.getReceiverParameterType(substitutedDescriptor.getExtensionReceiverParameter());
 
             final Collection<ConstraintPosition> errorPositions = Sets.newHashSet();
             List<JetType> parameterTypes = Lists.newArrayList();

compiler/frontend/src/org/jetbrains/jet/lang/evaluate/ConstantExpressionEvaluator.kt

@@ -567,8 +567,8 @@ fun isIntegerType(value: Any?) = value is Byte || value is Short || value is Int
 
 private fun getReceiverExpressionType(resolvedCall: ResolvedCall<*>): JetType? {
     return when (resolvedCall.getExplicitReceiverKind()) {
-        ExplicitReceiverKind.THIS_OBJECT -> resolvedCall.getThisObject().getType()
-        ExplicitReceiverKind.RECEIVER_ARGUMENT -> resolvedCall.getReceiverArgument().getType()
+        ExplicitReceiverKind.DISPATCH_RECEIVER -> resolvedCall.getDispatchReceiver().getType()
+        ExplicitReceiverKind.EXTENSION_RECEIVER -> resolvedCall.getExtensionReceiver().getType()
         ExplicitReceiverKind.NO_EXPLICIT_RECEIVER -> null
         ExplicitReceiverKind.BOTH_RECEIVERS -> null
         else -> null

compiler/frontend/src/org/jetbrains/jet/lang/psi/Call.java

@@ -34,7 +34,7 @@ public interface Call {
     ReceiverValue getExplicitReceiver();
 
     @NotNull
-    ReceiverValue getThisObject();
+    ReceiverValue getDispatchReceiver();
 
     @Nullable
     JetExpression getCalleeExpression();

compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationResolver.java

@@ -319,7 +319,7 @@ public class DeclarationResolver {
                     public boolean apply(@Nullable DeclarationDescriptor descriptor) {
                         if (descriptor instanceof PropertyDescriptor) {
                             PropertyDescriptor propertyDescriptor = (PropertyDescriptor)descriptor;
-                            return propertyDescriptor.getReceiverParameter() == null;
+                            return propertyDescriptor.getExtensionReceiverParameter() == null;
                         }
                         return true;
                     }
@@ -459,7 +459,7 @@ public class DeclarationResolver {
                             new Function1<VariableDescriptor, Boolean>() {
                                 @Override
                                 public Boolean invoke(VariableDescriptor descriptor) {
-                                    return descriptor.getReceiverParameter() == null;
+                                    return descriptor.getExtensionReceiverParameter() == null;
                                 }
                             }
                     )

compiler/frontend/src/org/jetbrains/jet/lang/resolve/DelegatedPropertyResolver.java

@@ -224,7 +224,7 @@ public class DelegatedPropertyResolver {
                 expressionTypingServices, trace, scope,
                 DataFlowInfo.EMPTY, TypeUtils.NO_EXPECTED_TYPE);
 
-        boolean hasThis = propertyDescriptor.getReceiverParameter() != null || propertyDescriptor.getExpectedThisObject() != null;
+        boolean hasThis = propertyDescriptor.getExtensionReceiverParameter() != null || propertyDescriptor.getDispatchReceiverParameter() != null;
 
         List<JetExpression> arguments = Lists.newArrayList();
         JetPsiFactory psiFactory = JetPsiFactory(delegateExpression);
@@ -358,11 +358,11 @@ public class DelegatedPropertyResolver {
             }
 
             private void addConstraintForThisValue(ConstraintSystem constraintSystem, FunctionDescriptor resultingDescriptor) {
-                ReceiverParameterDescriptor receiverParameter = propertyDescriptor.getReceiverParameter();
-                ReceiverParameterDescriptor thisObject = propertyDescriptor.getExpectedThisObject();
+                ReceiverParameterDescriptor extensionReceiver = propertyDescriptor.getExtensionReceiverParameter();
+                ReceiverParameterDescriptor dispatchReceiver = propertyDescriptor.getDispatchReceiverParameter();
                 JetType typeOfThis =
-                        receiverParameter != null ? receiverParameter.getType() :
-                        thisObject != null ? thisObject.getType() :
+                        extensionReceiver != null ? extensionReceiver.getType() :
+                        dispatchReceiver != null ? dispatchReceiver.getType() :
                         KotlinBuiltIns.getInstance().getNullableNothingType();
 
                 List<ValueParameterDescriptor> valueParameters = resultingDescriptor.getValueParameters();

compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorResolver.java

@@ -362,7 +362,7 @@ public class DescriptorResolver {
         Visibility visibility = resolveVisibilityFromModifiers(function, getDefaultVisibility(function, containingDescriptor));
         functionDescriptor.initialize(
                 receiverType,
-                getExpectedThisObjectIfNeeded(containingDescriptor),
+                getDispatchReceiverParameterIfNeeded(containingDescriptor),
                 typeParameterDescriptors,
                 valueParameterDescriptors,
                 returnType,
@@ -959,7 +959,7 @@ public class DescriptorResolver {
         }
 
         ReceiverParameterDescriptor receiverDescriptor =
-                DescriptorFactory.createReceiverParameterForCallable(propertyDescriptor, receiverType);
+                DescriptorFactory.createExtensionReceiverParameterForCallable(propertyDescriptor, receiverType);
 
         ReceiverParameterDescriptor implicitInitializerReceiver = property.hasDelegate() ? NO_RECEIVER_PARAMETER : receiverDescriptor;
 
@@ -968,7 +968,7 @@ public class DescriptorResolver {
 
         JetType type = getVariableType(propertyDescriptor, propertyScope, property, dataFlowInfo, true, trace);
 
-        propertyDescriptor.setType(type, typeParameterDescriptors, getExpectedThisObjectIfNeeded(containingDeclaration),
+        propertyDescriptor.setType(type, typeParameterDescriptors, getDispatchReceiverParameterIfNeeded(containingDeclaration),
                                    receiverDescriptor);
 
         PropertyGetterDescriptorImpl getter = resolvePropertyGetterDescriptor(scopeWithTypeParameters, property, propertyDescriptor, trace);
@@ -1332,7 +1332,7 @@ public class DescriptorResolver {
                 toSourceElement(parameter)
         );
         propertyDescriptor.setType(type, Collections.<TypeParameterDescriptor>emptyList(),
-                                   getExpectedThisObjectIfNeeded(classDescriptor), NO_RECEIVER_PARAMETER);
+                                   getDispatchReceiverParameterIfNeeded(classDescriptor), NO_RECEIVER_PARAMETER);
 
         PropertyGetterDescriptorImpl getter = DescriptorFactory.createDefaultGetter(propertyDescriptor);
         PropertySetterDescriptor setter =

compiler/frontend/src/org/jetbrains/jet/lang/resolve/FunctionDescriptorUtil.java

@@ -75,7 +75,7 @@ public class FunctionDescriptorUtil {
     @NotNull
     public static JetScope getFunctionInnerScope(@NotNull JetScope outerScope, @NotNull FunctionDescriptor descriptor, @NotNull BindingTrace trace) {
         WritableScope parameterScope = new WritableScopeImpl(outerScope, descriptor, new TraceBasedRedeclarationHandler(trace), "Function inner scope");
-        ReceiverParameterDescriptor receiver = descriptor.getReceiverParameter();
+        ReceiverParameterDescriptor receiver = descriptor.getExtensionReceiverParameter();
         if (receiver != null) {
             parameterScope.setImplicitReceiver(receiver);
         }
@@ -93,14 +93,14 @@ public class FunctionDescriptorUtil {
     public static void initializeFromFunctionType(
             @NotNull FunctionDescriptorImpl functionDescriptor,
             @NotNull JetType functionType,
-            @Nullable ReceiverParameterDescriptor expectedThisObject,
+            @Nullable ReceiverParameterDescriptor dispatchReceiverParameter,
             @NotNull Modality modality,
             @NotNull Visibility visibility
     ) {
 
         assert KotlinBuiltIns.getInstance().isFunctionOrExtensionFunctionType(functionType);
         functionDescriptor.initialize(KotlinBuiltIns.getInstance().getReceiverType(functionType),
-                                      expectedThisObject,
+                                      dispatchReceiverParameter,
                                       Collections.<TypeParameterDescriptorImpl>emptyList(),
                                       KotlinBuiltIns.getInstance().getValueParameters(functionDescriptor, functionType),
                                       KotlinBuiltIns.getInstance().getReturnTypeFromFunctionType(functionType),
@@ -149,10 +149,10 @@ public class FunctionDescriptorUtil {
             );
             idx++;
         }
-        ReceiverParameterDescriptor receiver = function.getReceiverParameter();
+        ReceiverParameterDescriptor receiver = function.getExtensionReceiverParameter();
         descriptor.initialize(
                 receiver == null ? null : receiver.getType(),
-                function.getExpectedThisObject(),
+                function.getDispatchReceiverParameter(),
                 function.getTypeParameters(),
                 parameters,
                 function.getReturnType(),

compiler/frontend/src/org/jetbrains/jet/lang/resolve/MemberComparator.java

@@ -37,7 +37,7 @@ public class MemberComparator implements Comparator<DeclarationDescriptor> {
             return 6;
         }
         else if (descriptor instanceof PropertyDescriptor) {
-            if (((PropertyDescriptor)descriptor).getReceiverParameter() == null) {
+            if (((PropertyDescriptor)descriptor).getExtensionReceiverParameter() == null) {
                 return 5;
             }
             else {
@@ -45,7 +45,7 @@ public class MemberComparator implements Comparator<DeclarationDescriptor> {
             }
         }
         else if (descriptor instanceof FunctionDescriptor) {
-            if (((FunctionDescriptor)descriptor).getReceiverParameter() == null) {
+            if (((FunctionDescriptor)descriptor).getExtensionReceiverParameter() == null) {
                 return 3;
             }
             else {
@@ -74,8 +74,8 @@ public class MemberComparator implements Comparator<DeclarationDescriptor> {
             CallableDescriptor c1 = (CallableDescriptor) o1;
             CallableDescriptor c2 = (CallableDescriptor) o2;
 
-            ReceiverParameterDescriptor c1ReceiverParameter = c1.getReceiverParameter();
-            ReceiverParameterDescriptor c2ReceiverParameter = c2.getReceiverParameter();
+            ReceiverParameterDescriptor c1ReceiverParameter = c1.getExtensionReceiverParameter();
+            ReceiverParameterDescriptor c2ReceiverParameter = c2.getExtensionReceiverParameter();
             assert (c1ReceiverParameter != null) == (c2ReceiverParameter != null);
             if (c1ReceiverParameter != null) {
                 String r1 = RENDERER.renderType(c1ReceiverParameter.getType());

compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallCompleter.kt

@@ -184,7 +184,7 @@ public class CallCompleter(
             return
         }
 
-        val receiverType = if (getReceiverArgument().exists()) getReceiverArgument().getType() else null
+        val receiverType = if (getExtensionReceiver().exists()) getExtensionReceiver().getType() else null
         val errorData = InferenceErrorData.create(
                 getCandidateDescriptor(), getConstraintSystem()!!, valueArgumentsCheckingResult.argumentTypes,
                 receiverType, context.expectedType)

compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolverUtil.java

@@ -17,12 +17,9 @@
 package org.jetbrains.jet.lang.resolve.calls;
 
 import com.google.common.collect.Lists;
-import com.intellij.psi.PsiElement;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.psi.*;
-import org.jetbrains.jet.lang.resolve.calls.context.BasicCallResolutionContext;
 import org.jetbrains.jet.lang.resolve.calls.inference.ConstraintPosition;
 import org.jetbrains.jet.lang.resolve.calls.inference.ConstraintSystem;
 import org.jetbrains.jet.lang.resolve.scopes.receivers.ExpressionReceiver;
@@ -139,14 +136,14 @@ public class CallResolverUtil {
 
     public static boolean isInvokeCallOnVariable(@NotNull Call call) {
         if (call.getCallType() != Call.CallType.INVOKE) return false;
-        ReceiverValue thisObject = call.getThisObject();
-        //calleeExpressionAsThisObject for invoke is always ExpressionReceiver, see CallForImplicitInvoke
-        JetExpression expression = ((ExpressionReceiver) thisObject).getExpression();
+        ReceiverValue dispatchReceiver = call.getDispatchReceiver();
+        //calleeExpressionAsDispatchReceiver for invoke is always ExpressionReceiver, see CallForImplicitInvoke
+        JetExpression expression = ((ExpressionReceiver) dispatchReceiver).getExpression();
         return expression instanceof JetSimpleNameExpression;
     }
 
     public static boolean isInvokeCallOnExpressionWithBothReceivers(@NotNull Call call) {
         if (call.getCallType() != Call.CallType.INVOKE || isInvokeCallOnVariable(call)) return false;
-        return call.getExplicitReceiver().exists() && call.getThisObject().exists();
+        return call.getExplicitReceiver().exists() && call.getDispatchReceiver().exists();
     }
 }

compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallTransformer.java

@@ -103,7 +103,7 @@ public class CallTransformer<D extends CallableDescriptor, F extends D> {
 
             assert candidate.getDescriptor() instanceof VariableDescriptor;
 
-            boolean hasReceiver = candidate.getReceiverArgument().exists();
+            boolean hasReceiver = candidate.getExtensionReceiver().exists();
             Call variableCall = stripCallArguments(task.call);
             ResolutionCandidate<CallableDescriptor> variableCandidate = getVariableCallCandidate(candidate, variableCall);
             if (!hasReceiver) {
@@ -118,7 +118,7 @@ public class CallTransformer<D extends CallableDescriptor, F extends D> {
             ResolutionCandidate<CallableDescriptor> candidateWithoutReceiver = ResolutionCandidate.create(
                     variableCandidate.getCall(),
                     variableCandidate.getDescriptor(),
-                    variableCandidate.getThisObject(),
+                    variableCandidate.getDispatchReceiver(),
                     ReceiverValue.NO_RECEIVER,
                     ExplicitReceiverKind.NO_EXPLICIT_RECEIVER, false);
 
@@ -145,8 +145,8 @@ public class CallTransformer<D extends CallableDescriptor, F extends D> {
             return ResolutionCandidate.create(
                     variableCall,
                     candidate.getDescriptor(),
-                    candidate.getThisObject(),
-                    candidate.getReceiverArgument(),
+                    candidate.getDispatchReceiver(),
+                    candidate.getExtensionReceiver(),
                     candidate.getExplicitReceiverKind(),
                     candidate.isSafeCall());
         }
@@ -252,18 +252,18 @@ public class CallTransformer<D extends CallableDescriptor, F extends D> {
     public static class CallForImplicitInvoke extends DelegatingCall {
         final Call outerCall;
         final ReceiverValue explicitExtensionReceiver;
-        final ExpressionReceiver calleeExpressionAsThisObject;
+        final ExpressionReceiver calleeExpressionAsDispatchReceiver;
         final JetSimpleNameExpression fakeInvokeExpression;
 
         public CallForImplicitInvoke(
                 @NotNull ReceiverValue explicitExtensionReceiver,
-                @NotNull ExpressionReceiver calleeExpressionAsThisObject,
+                @NotNull ExpressionReceiver calleeExpressionAsDispatchReceiver,
                 @NotNull Call call
         ) {
             super(call);
             this.outerCall = call;
             this.explicitExtensionReceiver = explicitExtensionReceiver;
-            this.calleeExpressionAsThisObject = calleeExpressionAsThisObject;
+            this.calleeExpressionAsDispatchReceiver = calleeExpressionAsDispatchReceiver;
             this.fakeInvokeExpression = (JetSimpleNameExpression) JetPsiFactory(call.getCallElement()).createExpression( "invoke");
         }
 
@@ -275,8 +275,8 @@ public class CallTransformer<D extends CallableDescriptor, F extends D> {
 
         @NotNull
         @Override
-        public ExpressionReceiver getThisObject() {
-            return calleeExpressionAsThisObject;
+        public ExpressionReceiver getDispatchReceiver() {
+            return calleeExpressionAsDispatchReceiver;
         }
 
         @Override

compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CandidateResolver.java

@@ -117,7 +117,7 @@ public class CandidateResolver {
                 }
             }
         }
-        if (!checkThisObject(context)) {
+        if (!checkDispatchReceiver(context)) {
             candidateCall.addStatus(OTHER_ERROR);
         }
 
@@ -168,18 +168,18 @@ public class CandidateResolver {
 
         // 'super' cannot be passed as an argument, for receiver arguments expression typer does not track this
         // See TaskPrioritizer for more
-        JetSuperExpression superExpression = TaskPrioritizer.getReceiverSuper(candidateCall.getReceiverArgument());
+        JetSuperExpression superExpression = TaskPrioritizer.getReceiverSuper(candidateCall.getExtensionReceiver());
         if (superExpression != null) {
             context.trace.report(SUPER_IS_NOT_AN_EXPRESSION.on(superExpression, superExpression.getText()));
             candidateCall.addStatus(OTHER_ERROR);
         }
     }
 
-    private static boolean checkThisObject(@NotNull CallCandidateResolutionContext<?> context) {
+    private static boolean checkDispatchReceiver(@NotNull CallCandidateResolutionContext<?> context) {
         MutableResolvedCall<? extends CallableDescriptor> candidateCall = context.candidateCall;
         CallableDescriptor candidateDescriptor = candidateCall.getCandidateDescriptor();
-        ReceiverValue thisObject = candidateCall.getThisObject();
-        if (thisObject.exists()) {
+        ReceiverValue dispatchReceiver = candidateCall.getDispatchReceiver();
+        if (dispatchReceiver.exists()) {
             ClassDescriptor nestedClass = null;
             if (candidateDescriptor instanceof ConstructorDescriptor
                 && DescriptorUtils.isStaticNestedClass(candidateDescriptor.getContainingDeclaration())) {
@@ -194,7 +194,7 @@ public class CandidateResolver {
             }
         }
 
-        assert (thisObject.exists() == (candidateCall.getResultingDescriptor().getExpectedThisObject() != null))
+        assert (dispatchReceiver.exists() == (candidateCall.getResultingDescriptor().getDispatchReceiverParameter() != null))
                 : "Shouldn't happen because of TaskPrioritizer: " + candidateDescriptor;
 
         return true;
@@ -202,7 +202,7 @@ public class CandidateResolver {
 
     private static boolean checkOuterClassMemberIsAccessible(@NotNull CallCandidateResolutionContext<?> context) {
         // In "this@Outer.foo()" the error will be reported on "this@Outer" instead
-        if (context.call.getExplicitReceiver().exists() || context.call.getThisObject().exists()) return true;
+        if (context.call.getExplicitReceiver().exists() || context.call.getDispatchReceiver().exists()) return true;
 
         ClassDescriptor candidateThis = getDeclaringClass(context.candidateCall.getCandidateDescriptor());
         if (candidateThis == null || candidateThis.getKind().isSingleton()) return true;
@@ -212,7 +212,7 @@ public class CandidateResolver {
 
     @Nullable
     private static ClassDescriptor getDeclaringClass(@NotNull CallableDescriptor candidate) {
-        ReceiverParameterDescriptor expectedThis = candidate.getExpectedThisObject();
+        ReceiverParameterDescriptor expectedThis = candidate.getDispatchReceiverParameter();
         if (expectedThis == null) return null;
         DeclarationDescriptor descriptor = expectedThis.getContainingDeclaration();
         return descriptor instanceof ClassDescriptor ? (ClassDescriptor) descriptor : null;
@@ -338,8 +338,8 @@ public class CandidateResolver {
 
         // Receiver
         // Error is already reported if something is missing
-        ReceiverValue receiverArgument = candidateCall.getReceiverArgument();
-        ReceiverParameterDescriptor receiverParameter = candidateWithFreshVariables.getReceiverParameter();
+        ReceiverValue receiverArgument = candidateCall.getExtensionReceiver();
+        ReceiverParameterDescriptor receiverParameter = candidateWithFreshVariables.getExtensionReceiverParameter();
         if (receiverArgument.exists() && receiverParameter != null) {
             JetType receiverType =
                     context.candidateCall.isSafeCall()
@@ -452,13 +452,13 @@ public class CandidateResolver {
 
         resultStatus = resultStatus.combine(checkReceiver(
                 context, candidateCall, trace,
-                candidateCall.getResultingDescriptor().getReceiverParameter(),
-                candidateCall.getReceiverArgument(), candidateCall.getExplicitReceiverKind().isReceiver(), false));
+                candidateCall.getResultingDescriptor().getExtensionReceiverParameter(),
+                candidateCall.getExtensionReceiver(), candidateCall.getExplicitReceiverKind().isExtensionReceiver(), false));
 
         resultStatus = resultStatus.combine(checkReceiver(
                 context, candidateCall, trace,
-                candidateCall.getResultingDescriptor().getExpectedThisObject(), candidateCall.getThisObject(),
-                candidateCall.getExplicitReceiverKind().isThisObject(),
+                candidateCall.getResultingDescriptor().getDispatchReceiverParameter(), candidateCall.getDispatchReceiver(),
+                candidateCall.getExplicitReceiverKind().isDispatchReceiver(),
                 // for the invocation 'foo(1)' where foo is a variable of function type we should mark 'foo' if there is unsafe call error
                 context.call instanceof CallForImplicitInvoke));
         return resultStatus;
@@ -545,15 +545,15 @@ public class CandidateResolver {
         MutableResolvedCall<D> candidateCall = context.candidateCall;
         D candidateDescriptor = candidateCall.getCandidateDescriptor();
 
-        ReceiverParameterDescriptor receiverDescriptor = candidateDescriptor.getReceiverParameter();
-        ReceiverParameterDescriptor expectedThisObjectDescriptor = candidateDescriptor.getExpectedThisObject();
+        ReceiverParameterDescriptor extensionReceiver = candidateDescriptor.getExtensionReceiverParameter();
+        ReceiverParameterDescriptor dispatchReceiver = candidateDescriptor.getDispatchReceiverParameter();
         ResolutionStatus status = SUCCESS;
         // For the expressions like '42.(f)()' where f: String.() -> Unit we'd like to generate a type mismatch error on '1',
         // not to throw away the candidate, so the following check is skipped.
         if (!CallResolverUtil.isInvokeCallOnExpressionWithBothReceivers(context.call)) {
-            status = status.combine(checkReceiverTypeError(context, receiverDescriptor, candidateCall.getReceiverArgument()));
+            status = status.combine(checkReceiverTypeError(context, extensionReceiver, candidateCall.getExtensionReceiver()));
         }
-        status = status.combine(checkReceiverTypeError(context, expectedThisObjectDescriptor, candidateCall.getThisObject()));
+        status = status.combine(checkReceiverTypeError(context, dispatchReceiver, candidateCall.getDispatchReceiver()));
         return status;
     }
 

compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/InlineCallResolverExtension.java

@@ -66,7 +66,7 @@ public class InlineCallResolverExtension implements CallResolverExtension {
         }
 
         //add extension receiver as inlinable
-        ReceiverParameterDescriptor receiverParameter = descriptor.getReceiverParameter();
+        ReceiverParameterDescriptor receiverParameter = descriptor.getExtensionReceiverParameter();
         if (receiverParameter != null) {
             if (isInlinableParameter(receiverParameter)) {
                 inlinableParameters.add(receiverParameter);
@@ -83,8 +83,8 @@ public class InlineCallResolverExtension implements CallResolverExtension {
 
         //checking that only invoke or inlinable extension called on function parameter
         CallableDescriptor targetDescriptor = resolvedCall.getResultingDescriptor();
-        checkCallWithReceiver(context, targetDescriptor, resolvedCall.getThisObject(), expression);
-        checkCallWithReceiver(context, targetDescriptor, resolvedCall.getReceiverArgument(), expression);
+        checkCallWithReceiver(context, targetDescriptor, resolvedCall.getDispatchReceiver(), expression);
+        checkCallWithReceiver(context, targetDescriptor, resolvedCall.getExtensionReceiver(), expression);
 
         if (inlinableParameters.contains(targetDescriptor)) {
             if (!isInsideCall(expression)) {
@@ -167,7 +167,7 @@ public class InlineCallResolverExtension implements CallResolverExtension {
             ExtensionReceiver extensionReceiver = (ExtensionReceiver) receiver;
             CallableDescriptor extension = extensionReceiver.getDeclarationDescriptor();
 
-            varDescriptor = extension.getReceiverParameter();
+            varDescriptor = extension.getExtensionReceiverParameter();
             assert varDescriptor != null : "Extension should have receiverParameterDescriptor: " + extension;
 
             receiverExpression = expression;

compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ValueArgumentsToParametersMapper.java

@@ -269,8 +269,8 @@ import static org.jetbrains.jet.lang.resolve.calls.ValueArgumentsToParametersMap
         private void checkReceiverArgument() {
             D candidate = candidateCall.getCandidateDescriptor();
 
-            ReceiverParameterDescriptor receiverParameter = candidate.getReceiverParameter();
-            ReceiverValue receiverArgument = candidateCall.getReceiverArgument();
+            ReceiverParameterDescriptor receiverParameter = candidate.getExtensionReceiverParameter();
+            ReceiverValue receiverArgument = candidateCall.getExtensionReceiver();
             if (receiverParameter != null &&!receiverArgument.exists()) {
                 tracing.missingReceiver(candidateCall.getTrace(), receiverParameter);
                 setStatus(ERROR);

compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/autocasts/DataFlowValueFactory.java

@@ -23,7 +23,6 @@ import org.jetbrains.jet.JetNodeTypes;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.BindingContext;
-import org.jetbrains.jet.lang.resolve.JetModuleUtil;
 import org.jetbrains.jet.lang.resolve.calls.callUtil.CallUtilPackage;
 import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall;
 import org.jetbrains.jet.lang.resolve.scopes.receivers.*;
@@ -173,7 +172,7 @@ public class DataFlowValueFactory {
             // assert resolvedCall != null : "Cannot create right identifier info if the resolved call is not known yet for " + declarationDescriptor;
 
             IdentifierInfo receiverInfo =
-                    resolvedCall != null ? getIdForImplicitReceiver(resolvedCall.getThisObject(), simpleNameExpression) : null;
+                    resolvedCall != null ? getIdForImplicitReceiver(resolvedCall.getDispatchReceiver(), simpleNameExpression) : null;
 
             VariableDescriptor variableDescriptor = (VariableDescriptor) declarationDescriptor;
             return combineInfo(receiverInfo, createInfo(variableDescriptor, isStableVariable(variableDescriptor)));
@@ -200,7 +199,7 @@ public class DataFlowValueFactory {
     @NotNull
     private static IdentifierInfo getIdForThisReceiver(@Nullable DeclarationDescriptor descriptorOfThisReceiver) {
         if (descriptorOfThisReceiver instanceof CallableDescriptor) {
-            ReceiverParameterDescriptor receiverParameter = ((CallableDescriptor) descriptorOfThisReceiver).getReceiverParameter();
+            ReceiverParameterDescriptor receiverParameter = ((CallableDescriptor) descriptorOfThisReceiver).getExtensionReceiverParameter();
             assert receiverParameter != null : "'This' refers to the callable member without a receiver parameter: " + descriptorOfThisReceiver;
             return createInfo(receiverParameter.getValue(), true);
         }

compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/model/DelegatingResolvedCall.java

@@ -57,14 +57,14 @@ public abstract class DelegatingResolvedCall<D extends CallableDescriptor> imple
 
     @NotNull
     @Override
-    public ReceiverValue getReceiverArgument() {
-        return resolvedCall.getReceiverArgument();
+    public ReceiverValue getExtensionReceiver() {
+        return resolvedCall.getExtensionReceiver();
     }
 
     @NotNull
     @Override
-    public ReceiverValue getThisObject() {
-        return resolvedCall.getThisObject();
+    public ReceiverValue getDispatchReceiver() {
+        return resolvedCall.getDispatchReceiver();
     }
 
     @NotNull

compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/model/ResolvedCall.java

@@ -45,11 +45,11 @@ public interface ResolvedCall<D extends CallableDescriptor> {
 
     /** If the target was an extension function or property, this is the value for its receiver parameter */
     @NotNull
-    ReceiverValue getReceiverArgument();
+    ReceiverValue getExtensionReceiver();
 
     /** If the target was a member of a class, this is the object of that class to call it on */
     @NotNull
-    ReceiverValue getThisObject();
+    ReceiverValue getDispatchReceiver();
 
     /** Determines whether receiver argument or this object is substituted for explicit receiver */
     @NotNull

compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/model/ResolvedCallImpl.java

@@ -71,8 +71,8 @@ public class ResolvedCallImpl<D extends CallableDescriptor> implements MutableRe
     private final Call call;
     private final D candidateDescriptor;
     private D resultingDescriptor; // Probably substituted
-    private final ReceiverValue thisObject; // receiver object of a method
-    private final ReceiverValue receiverArgument; // receiver of an extension function
+    private final ReceiverValue dispatchReceiver; // receiver object of a method
+    private final ReceiverValue extensionReceiver; // receiver of an extension function
     private final ExplicitReceiverKind explicitReceiverKind;
     private final boolean isSafeCall;
 
@@ -96,8 +96,8 @@ public class ResolvedCallImpl<D extends CallableDescriptor> implements MutableRe
     ) {
         this.call = candidate.getCall();
         this.candidateDescriptor = candidate.getDescriptor();
-        this.thisObject = candidate.getThisObject();
-        this.receiverArgument = candidate.getReceiverArgument();
+        this.dispatchReceiver = candidate.getDispatchReceiver();
+        this.extensionReceiver = candidate.getExtensionReceiver();
         this.explicitReceiverKind = candidate.getExplicitReceiverKind();
         this.isSafeCall = candidate.isSafeCall();
         this.trace = trace;
@@ -212,14 +212,14 @@ public class ResolvedCallImpl<D extends CallableDescriptor> implements MutableRe
 
     @Override
     @NotNull
-    public ReceiverValue getReceiverArgument() {
-        return receiverArgument;
+    public ReceiverValue getExtensionReceiver() {
+        return extensionReceiver;
     }
 
     @Override
     @NotNull
-    public ReceiverValue getThisObject() {
-        return thisObject;
+    public ReceiverValue getDispatchReceiver() {
+        return dispatchReceiver;
     }
 
     @Override

compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/results/OverloadingConflictResolver.java

@@ -139,8 +139,8 @@ public class OverloadingConflictResolver {
         if (OverrideResolver.overrides(f, g)) return true;
         if (OverrideResolver.overrides(g, f)) return false;
 
-        ReceiverParameterDescriptor receiverOfF = f.getReceiverParameter();
-        ReceiverParameterDescriptor receiverOfG = g.getReceiverParameter();
+        ReceiverParameterDescriptor receiverOfF = f.getExtensionReceiverParameter();
+        ReceiverParameterDescriptor receiverOfG = g.getExtensionReceiverParameter();
         if (receiverOfF != null && receiverOfG != null) {
             if (!typeMoreSpecific(receiverOfF.getType(), receiverOfG.getType())) return false;
         }

compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/tasks/CallableDescriptorCollectors.java

@@ -30,7 +30,6 @@ import org.jetbrains.jet.lang.types.JetType;
 import java.util.*;
 
 import static org.jetbrains.jet.lang.resolve.LibrarySourceHacks.filterOutMembersFromLibrarySource;
-import static org.jetbrains.jet.lang.resolve.descriptorUtil.DescriptorUtilPackage.getClassObjectReferenceTarget;
 
 @SuppressWarnings("unchecked")
 public class CallableDescriptorCollectors<D extends CallableDescriptor> implements Iterable<CallableDescriptorCollector<D>> {
@@ -57,7 +56,7 @@ public class CallableDescriptorCollectors<D extends CallableDescriptor> implemen
         public Collection<FunctionDescriptor> getNonExtensionsByName(JetScope scope, Name name, @NotNull BindingTrace bindingTrace) {
             Set<FunctionDescriptor> functions = Sets.newLinkedHashSet();
             for (FunctionDescriptor function : scope.getFunctions(name)) {
-                if (function.getReceiverParameter() == null) {
+                if (function.getExtensionReceiverParameter() == null) {
                     functions.add(function);
                 }
             }
@@ -118,7 +117,7 @@ public class CallableDescriptorCollectors<D extends CallableDescriptor> implemen
 
             Set<VariableDescriptor> variables = Sets.newLinkedHashSet();
             for (VariableDescriptor variable : scope.getProperties(name)) {
-                if (variable.getReceiverParameter() == null) {
+                if (variable.getExtensionReceiverParameter() == null) {
                     variables.add(variable);
                 }
             }

compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/tasks/ExplicitReceiverKind.java

@@ -17,20 +17,20 @@
 package org.jetbrains.jet.lang.resolve.calls.tasks;
 
 public enum ExplicitReceiverKind {
-    RECEIVER_ARGUMENT,
-    THIS_OBJECT,
+    EXTENSION_RECEIVER,
+    DISPATCH_RECEIVER,
     NO_EXPLICIT_RECEIVER,
 
     // A very special case.
     // In a call 'b.foo(1)' where class 'Foo' has an extension member 'fun B.invoke(Int)' function 'invoke' has two explicit receivers:
-    // 'b' (as receiver argument) and 'foo' (as this object).
+    // 'b' (as extension receiver) and 'foo' (as dispatch receiver).
     BOTH_RECEIVERS;
 
-    public boolean isReceiver() {
-        return this == RECEIVER_ARGUMENT || this == BOTH_RECEIVERS;
+    public boolean isExtensionReceiver() {
+        return this == EXTENSION_RECEIVER || this == BOTH_RECEIVERS;
     }
 
-    public boolean isThisObject() {
-        return this == THIS_OBJECT || this == BOTH_RECEIVERS;
+    public boolean isDispatchReceiver() {
+        return this == DISPATCH_RECEIVER || this == BOTH_RECEIVERS;
     }
 }

compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/tasks/ResolutionCandidate.java

@@ -31,19 +31,19 @@ import static org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue.NO_R
 public class ResolutionCandidate<D extends CallableDescriptor> {
     private final Call call;
     private final D candidateDescriptor;
-    private ReceiverValue thisObject; // receiver object of a method
-    private ReceiverValue receiverArgument; // receiver of an extension function
+    private ReceiverValue dispatchReceiver; // receiver object of a method
+    private ReceiverValue extensionReceiver; // receiver of an extension function
     private ExplicitReceiverKind explicitReceiverKind;
     private Boolean isSafeCall;
 
     private ResolutionCandidate(
-            @NotNull Call call, @NotNull D descriptor, @NotNull ReceiverValue thisObject,
-            @NotNull ReceiverValue receiverArgument, @NotNull ExplicitReceiverKind explicitReceiverKind, @Nullable Boolean isSafeCall
+            @NotNull Call call, @NotNull D descriptor, @NotNull ReceiverValue dispatchReceiver,
+            @NotNull ReceiverValue extensionReceiver, @NotNull ExplicitReceiverKind explicitReceiverKind, @Nullable Boolean isSafeCall
     ) {
         this.call = call;
         this.candidateDescriptor = descriptor;
-        this.thisObject = thisObject;
-        this.receiverArgument = receiverArgument;
+        this.dispatchReceiver = dispatchReceiver;
+        this.extensionReceiver = extensionReceiver;
         this.explicitReceiverKind = explicitReceiverKind;
         this.isSafeCall = isSafeCall;
     }
@@ -60,18 +60,18 @@ public class ResolutionCandidate<D extends CallableDescriptor> {
     }
 
     public static <D extends CallableDescriptor> ResolutionCandidate<D> create(
-            @NotNull Call call, @NotNull D descriptor, @NotNull ReceiverValue thisObject,
+            @NotNull Call call, @NotNull D descriptor, @NotNull ReceiverValue dispatchReceiver,
             @NotNull ReceiverValue receiverArgument, @NotNull ExplicitReceiverKind explicitReceiverKind, boolean isSafeCall
     ) {
-        return new ResolutionCandidate<D>(call, descriptor, thisObject, receiverArgument, explicitReceiverKind, isSafeCall);
+        return new ResolutionCandidate<D>(call, descriptor, dispatchReceiver, receiverArgument, explicitReceiverKind, isSafeCall);
     }
 
-    public void setThisObject(@NotNull ReceiverValue thisObject) {
-        this.thisObject = thisObject;
+    public void setDispatchReceiver(@NotNull ReceiverValue dispatchReceiver) {
+        this.dispatchReceiver = dispatchReceiver;
     }
 
-    public void setReceiverArgument(@NotNull ReceiverValue receiverArgument) {
-        this.receiverArgument = receiverArgument;
+    public void setExtensionReceiver(@NotNull ReceiverValue extensionReceiver) {
+        this.extensionReceiver = extensionReceiver;
     }
 
     public void setExplicitReceiverKind(@NotNull ExplicitReceiverKind explicitReceiverKind) {
@@ -89,13 +89,13 @@ public class ResolutionCandidate<D extends CallableDescriptor> {
     }
 
     @NotNull
-    public ReceiverValue getThisObject() {
-        return thisObject;
+    public ReceiverValue getDispatchReceiver() {
+        return dispatchReceiver;
     }
 
     @NotNull
-    public ReceiverValue getReceiverArgument() {
-        return receiverArgument;
+    public ReceiverValue getExtensionReceiver() {
+        return extensionReceiver;
     }
 
     @NotNull

compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/tasks/TaskPrioritizer.java

@@ -109,7 +109,7 @@ public class TaskPrioritizer {
     ) {
         ProgressIndicatorProvider.checkCanceled();
 
-        boolean resolveInvoke = c.context.call.getThisObject().exists();
+        boolean resolveInvoke = c.context.call.getDispatchReceiver().exists();
         if (resolveInvoke) {
             addCandidatesForInvoke(receiver, c);
             return;
@@ -138,7 +138,7 @@ public class TaskPrioritizer {
                 Collection<D> membersForThisVariant =
                         callableDescriptorCollector.getMembersByName(type, c.name, c.context.trace);
                 convertWithReceivers(membersForThisVariant, explicitReceiver,
-                                     NO_RECEIVER, members, createKind(THIS_OBJECT, isExplicit), c.context.call);
+                                     NO_RECEIVER, members, createKind(DISPATCH_RECEIVER, isExplicit), c.context.call);
             }
             c.result.addCandidates(members);
         }
@@ -147,12 +147,12 @@ public class TaskPrioritizer {
             //member extensions
             for (ReceiverValue implicitReceiver : implicitReceivers) {
                 addMemberExtensionCandidates(implicitReceiver, explicitReceiver,
-                                             callableDescriptorCollector, c, createKind(RECEIVER_ARGUMENT, isExplicit));
+                                             callableDescriptorCollector, c, createKind(EXTENSION_RECEIVER, isExplicit));
             }
             //extensions
             Collection<ResolutionCandidate<D>> extensions = convertWithImpliedThis(
                     c.scope, explicitReceiver, callableDescriptorCollector.getNonMembersByName(c.scope, c.name, c.context.trace),
-                    createKind(RECEIVER_ARGUMENT, isExplicit), c.context.call);
+                    createKind(EXTENSION_RECEIVER, isExplicit), c.context.call);
             c.result.addCandidates(extensions);
         }
     }
@@ -163,15 +163,15 @@ public class TaskPrioritizer {
     }
 
     private static <D extends CallableDescriptor, F extends D> void addMemberExtensionCandidates(
-            @NotNull ReceiverValue thisObject,
+            @NotNull ReceiverValue dispatchReceiver,
             @NotNull ReceiverValue receiverParameter,
             @NotNull CallableDescriptorCollector<D> callableDescriptorCollector, TaskPrioritizerContext<D, F> c,
             @NotNull ExplicitReceiverKind receiverKind
     ) {
         Collection<D> memberExtensions = callableDescriptorCollector.getNonMembersByName(
-                thisObject.getType().getMemberScope(), c.name, c.context.trace);
+                dispatchReceiver.getType().getMemberScope(), c.name, c.context.trace);
         c.result.addCandidates(convertWithReceivers(
-                memberExtensions, thisObject, receiverParameter, receiverKind, c.context.call));
+                memberExtensions, dispatchReceiver, receiverParameter, receiverKind, c.context.call));
     }
 
     private static <D extends CallableDescriptor, F extends D> void addCandidatesForNoReceiver(
@@ -214,7 +214,7 @@ public class TaskPrioritizer {
 
         // For 'a.foo()' where foo has function type,
         // a is explicitReceiver, foo is variableReceiver.
-        ReceiverValue variableReceiver = c.context.call.getThisObject();
+        ReceiverValue variableReceiver = c.context.call.getDispatchReceiver();
         assert variableReceiver.exists() : "'Invoke' call hasn't got variable receiver";
 
         // For invocation a.foo() explicit receiver 'a'
@@ -239,45 +239,45 @@ public class TaskPrioritizer {
         }
         // with (a) { foo() }
         for (ReceiverValue implicitReceiver : implicitReceivers) {
-            addCandidatesWhenInvokeIsMemberAndExtensionToExplicitReceiver(variableReceiver, implicitReceiver, c, THIS_OBJECT);
+            addCandidatesWhenInvokeIsMemberAndExtensionToExplicitReceiver(variableReceiver, implicitReceiver, c, DISPATCH_RECEIVER);
         }
     }
 
     private static <D extends CallableDescriptor, F extends D> void addCandidatesWhenInvokeIsMemberAndExtensionToExplicitReceiver(
-            @NotNull ReceiverValue thisObject,
+            @NotNull ReceiverValue dispatchReceiver,
             @NotNull ReceiverValue receiverParameter,
             @NotNull TaskPrioritizerContext<D, F> c,
             @NotNull ExplicitReceiverKind receiverKind
     ) {
         for (CallableDescriptorCollector<D> callableDescriptorCollector : c.callableDescriptorCollectors) {
-            addMemberExtensionCandidates(thisObject, receiverParameter, callableDescriptorCollector, c, receiverKind);
+            addMemberExtensionCandidates(dispatchReceiver, receiverParameter, callableDescriptorCollector, c, receiverKind);
         }
     }
 
     private static <D extends CallableDescriptor> Collection<ResolutionCandidate<D>> convertWithReceivers(
             @NotNull Collection<D> descriptors,
-            @NotNull ReceiverValue thisObject,
-            @NotNull ReceiverValue receiverParameter,
+            @NotNull ReceiverValue dispatchReceiver,
+            @NotNull ReceiverValue extensionReceiver,
             @NotNull ExplicitReceiverKind explicitReceiverKind,
             @NotNull Call call
     ) {
         Collection<ResolutionCandidate<D>> result = Lists.newArrayList();
-        convertWithReceivers(descriptors, thisObject, receiverParameter, result, explicitReceiverKind, call);
+        convertWithReceivers(descriptors, dispatchReceiver, extensionReceiver, result, explicitReceiverKind, call);
         return result;
     }
 
     private static <D extends CallableDescriptor> void convertWithReceivers(
             @NotNull Collection<D> descriptors,
-            @NotNull ReceiverValue thisObject,
-            @NotNull ReceiverValue receiverParameter,
+            @NotNull ReceiverValue dispatchReceiver,
+            @NotNull ReceiverValue extensionReceiver,
             @NotNull Collection<ResolutionCandidate<D>> result,
             @NotNull ExplicitReceiverKind explicitReceiverKind,
             @NotNull Call call
     ) {
         for (D descriptor : descriptors) {
             ResolutionCandidate<D> candidate = ResolutionCandidate.create(call, descriptor);
-            candidate.setThisObject(thisObject);
-            candidate.setReceiverArgument(receiverParameter);
+            candidate.setDispatchReceiver(dispatchReceiver);
+            candidate.setExtensionReceiver(extensionReceiver);
             candidate.setExplicitReceiverKind(explicitReceiverKind);
             result.add(candidate);
         }
@@ -301,7 +301,7 @@ public class TaskPrioritizer {
         Collection<ResolutionCandidate<D>> result = Lists.newArrayList();
         for (D descriptor : descriptors) {
             ResolutionCandidate<D> candidate = ResolutionCandidate.create(call, descriptor);
-            candidate.setReceiverArgument(receiverParameter);
+            candidate.setExtensionReceiver(receiverParameter);
             candidate.setExplicitReceiverKind(receiverKind);
             if (setImpliedThis(scope, candidate)) {
                 result.add(candidate);
@@ -314,13 +314,13 @@ public class TaskPrioritizer {
             @NotNull JetScope scope,
             @NotNull ResolutionCandidate<D> candidate
     ) {
-        ReceiverParameterDescriptor expectedThisObject = candidate.getDescriptor().getExpectedThisObject();
-        if (expectedThisObject == null) return true;
+        ReceiverParameterDescriptor dispatchReceiver = candidate.getDescriptor().getDispatchReceiverParameter();
+        if (dispatchReceiver == null) return true;
         List<ReceiverParameterDescriptor> receivers = scope.getImplicitReceiversHierarchy();
         for (ReceiverParameterDescriptor receiver : receivers) {
-            if (JetTypeChecker.DEFAULT.isSubtypeOf(receiver.getType(), expectedThisObject.getType())) {
+            if (JetTypeChecker.DEFAULT.isSubtypeOf(receiver.getType(), dispatchReceiver.getType())) {
                 // TODO : Autocasts & nullability
-                candidate.setThisObject(expectedThisObject.getValue());
+                candidate.setDispatchReceiver(dispatchReceiver.getValue());
                 return true;
             }
         }

compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/util/CallMaker.java

@@ -134,7 +134,7 @@ public class CallMaker {
 
         @NotNull
         @Override
-        public ReceiverValue getThisObject() {
+        public ReceiverValue getDispatchReceiver() {
             return ReceiverValue.NO_RECEIVER;
         }
 
@@ -277,7 +277,7 @@ public class CallMaker {
 
             @NotNull
             @Override
-            public ReceiverValue getThisObject() {
+            public ReceiverValue getDispatchReceiver() {
                 return ReceiverValue.NO_RECEIVER;
             }
 

compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/util/DelegatingCall.java

@@ -46,8 +46,8 @@ public class DelegatingCall implements Call {
 
     @NotNull
     @Override
-    public ReceiverValue getThisObject() {
-        return delegate.getThisObject();
+    public ReceiverValue getDispatchReceiver() {
+        return delegate.getDispatchReceiver();
     }
 
     @Override

compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/util/FakeCallableDescriptorForObject.kt

@@ -43,9 +43,9 @@ public class FakeCallableDescriptorForObject(
 
     public fun getReferencedDescriptor(): ClassDescriptor = classDescriptor.getClassObjectReferenceTarget()
 
-    override fun getReceiverParameter(): ReceiverParameterDescriptor? = null
+    override fun getExtensionReceiverParameter(): ReceiverParameterDescriptor? = null
 
-    override fun getExpectedThisObject(): ReceiverParameterDescriptor? = null
+    override fun getDispatchReceiverParameter(): ReceiverParameterDescriptor? = null
 
     override fun getTypeParameters(): List<TypeParameterDescriptor> = Collections.emptyList()
 

compiler/frontend/src/org/jetbrains/jet/lang/resolve/extension/InlineAnalyzerExtension.java

@@ -121,7 +121,7 @@ public class InlineAnalyzerExtension implements FunctionAnalyzerExtension.Analyz
         for (ValueParameterDescriptor parameter : parameters) {
             hasInlinable |= checkInlinableParameter(parameter, function.getValueParameters().get(index++), functionDescriptor, trace);
         }
-        ReceiverParameterDescriptor receiverParameter = functionDescriptor.getReceiverParameter();
+        ReceiverParameterDescriptor receiverParameter = functionDescriptor.getExtensionReceiverParameter();
         if (receiverParameter != null) {
             JetTypeReference receiver = function.getReceiverTypeRef();
             assert receiver != null : "Descriptor has a receiver but psi doesn't " + function.getText();

compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/JetScopeUtils.java

@@ -64,7 +64,7 @@ public final class JetScopeUtils {
         for (DeclarationDescriptor descriptor : scope.getAllDescriptors()) {
             if (descriptor instanceof CallableDescriptor) {
                 CallableDescriptor callDescriptor = (CallableDescriptor) descriptor;
-                if (callDescriptor.getReceiverParameter() != null) {
+                if (callDescriptor.getExtensionReceiverParameter() != null) {
                     result.add(callDescriptor);
                 }
             }
@@ -81,7 +81,7 @@ public final class JetScopeUtils {
         JetScope propertyDeclarationInnerScope =
                 getPropertyDeclarationInnerScope(propertyDescriptor, parentScope,
                                                  propertyDescriptor.getTypeParameters(),
-                                                 propertyDescriptor.getReceiverParameter(), trace);
+                                                 propertyDescriptor.getExtensionReceiverParameter(), trace);
         WritableScope accessorScope = new WritableScopeImpl(propertyDeclarationInnerScope, parentScope.getContainingDeclaration(),
                                                             new TraceBasedRedeclarationHandler(trace), "Accessor Scope");
         accessorScope.changeLockLevel(WritableScope.LockLevel.READING);

compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WritableScopeImpl.java

@@ -210,7 +210,7 @@ public class WritableScopeImpl extends WritableScopeWithImports {
             checkForPropertyRedeclaration(name, variableDescriptor);
             getPropertyGroups().put(name, variableDescriptor);
         }
-        if (variableDescriptor.getReceiverParameter() == null) {
+        if (variableDescriptor.getExtensionReceiverParameter() == null) {
             checkForRedeclaration(name, variableDescriptor);
             // TODO : Should this always happen?
             getVariableOrClassDescriptors().put(name, variableDescriptor);
@@ -347,9 +347,9 @@ public class WritableScopeImpl extends WritableScopeWithImports {
     
     private void checkForPropertyRedeclaration(@NotNull Name name, VariableDescriptor variableDescriptor) {
         Set<VariableDescriptor> properties = getPropertyGroups().get(name);
-        ReceiverParameterDescriptor receiverParameter = variableDescriptor.getReceiverParameter();
+        ReceiverParameterDescriptor receiverParameter = variableDescriptor.getExtensionReceiverParameter();
         for (VariableDescriptor oldProperty : properties) {
-            ReceiverParameterDescriptor receiverParameterForOldVariable = oldProperty.getReceiverParameter();
+            ReceiverParameterDescriptor receiverParameterForOldVariable = oldProperty.getExtensionReceiverParameter();
             if (((receiverParameter != null && receiverParameterForOldVariable != null) &&
                  (JetTypeChecker.DEFAULT.equalTypes(receiverParameter.getType(), receiverParameterForOldVariable.getType())))) {
                 redeclarationHandler.handleRedeclaration(oldProperty, variableDescriptor);

compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/BasicExpressionTypingVisitor.java

@@ -481,21 +481,21 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
         }
         if (descriptor == null) return null;
 
-        ReceiverParameterDescriptor receiverParameter = descriptor.getReceiverParameter();
-        ReceiverParameterDescriptor expectedThisObject = descriptor.getExpectedThisObject();
-        if (receiverParameter != null && expectedThisObject != null && descriptor instanceof CallableMemberDescriptor) {
+        ReceiverParameterDescriptor extensionReceiver = descriptor.getExtensionReceiverParameter();
+        ReceiverParameterDescriptor dispatchReceiver = descriptor.getDispatchReceiverParameter();
+        if (extensionReceiver != null && dispatchReceiver != null && descriptor instanceof CallableMemberDescriptor) {
             context.trace.report(EXTENSION_IN_CLASS_REFERENCE_NOT_ALLOWED.on(reference, (CallableMemberDescriptor) descriptor));
             return null;
         }
 
         JetType receiverType = null;
-        if (receiverParameter != null) {
-            receiverType = receiverParameter.getType();
+        if (extensionReceiver != null) {
+            receiverType = extensionReceiver.getType();
         }
-        else if (expectedThisObject != null) {
-            receiverType = expectedThisObject.getType();
+        else if (dispatchReceiver != null) {
+            receiverType = dispatchReceiver.getType();
         }
-        boolean isExtension = receiverParameter != null;
+        boolean isExtension = extensionReceiver != null;
 
         if (descriptor instanceof FunctionDescriptor) {
             return createFunctionReferenceType(expression, context, (FunctionDescriptor) descriptor, receiverType, isExtension);

compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ClosureExpressionsTypingVisitor.java

@@ -111,7 +111,7 @@ public class ClosureExpressionsTypingVisitor extends ExpressionTypingVisitor {
         JetType safeReturnType = computeReturnType(expression, context, functionDescriptor, functionTypeExpected);
         functionDescriptor.setReturnType(safeReturnType);
 
-        JetType receiver = DescriptorUtils.getReceiverParameterType(functionDescriptor.getReceiverParameter());
+        JetType receiver = DescriptorUtils.getReceiverParameterType(functionDescriptor.getExtensionReceiverParameter());
         List<JetType> valueParametersTypes = ExpressionTypingUtils.getValueParametersTypes(functionDescriptor.getValueParameters());
         JetType resultType = KotlinBuiltIns.getInstance().getFunctionType(
                 Annotations.EMPTY, receiver, valueParametersTypes, safeReturnType);

compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ControlStructureTypingUtils.java

@@ -186,7 +186,7 @@ public class ControlStructureTypingUtils {
 
             @NotNull
             @Override
-            public ReceiverValue getThisObject() {
+            public ReceiverValue getDispatchReceiver() {
                 return ReceiverValue.NO_RECEIVER;
             }
 

compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingUtils.java

@@ -221,7 +221,7 @@ public class ExpressionTypingUtils {
             @NotNull JetType receiverType,
             @NotNull CallableDescriptor callableDescriptor
     ) {
-        ReceiverParameterDescriptor receiverParameter = callableDescriptor.getReceiverParameter();
+        ReceiverParameterDescriptor receiverParameter = callableDescriptor.getExtensionReceiverParameter();
 
         if (!receiverArgument.exists() && receiverParameter == null) {
             // Both receivers do not exist

compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/LabelResolver.java

@@ -189,11 +189,11 @@ public class LabelResolver {
             }
             else if (declarationDescriptor instanceof FunctionDescriptor) {
                 FunctionDescriptor functionDescriptor = (FunctionDescriptor) declarationDescriptor;
-                thisReceiver = functionDescriptor.getReceiverParameter();
+                thisReceiver = functionDescriptor.getExtensionReceiverParameter();
             }
             else if (declarationDescriptor instanceof PropertyDescriptor) {
                 PropertyDescriptor propertyDescriptor = (PropertyDescriptor) declarationDescriptor;
-                thisReceiver = propertyDescriptor.getReceiverParameter();
+                thisReceiver = propertyDescriptor.getExtensionReceiverParameter();
             }
             else {
                 throw new UnsupportedOperationException("Unsupported descriptor: " + declarationDescriptor); // TODO
@@ -218,7 +218,7 @@ public class LabelResolver {
                 DeclarationDescriptor declarationDescriptor =
                         context.trace.getBindingContext().get(BindingContext.DECLARATION_TO_DESCRIPTOR, element);
                 if (declarationDescriptor instanceof FunctionDescriptor) {
-                    ReceiverParameterDescriptor thisReceiver = ((FunctionDescriptor) declarationDescriptor).getReceiverParameter();
+                    ReceiverParameterDescriptor thisReceiver = ((FunctionDescriptor) declarationDescriptor).getExtensionReceiverParameter();
                     if (thisReceiver != null) {
                         context.trace.record(LABEL_TARGET, targetLabel, element);
                         context.trace.record(REFERENCE_TARGET, referenceExpression, declarationDescriptor);

compiler/testData/resolvedCalls/arguments/functionLiterals/chainedLambdas.txt

@@ -12,8 +12,8 @@ Candidate descriptor: fun <T, S, R> foo(t: T, f: (T) -> S, g: (S) -> R): Unit de
 Resulting descriptor: fun <T, S, R> foo(t: Int, f: (Int) -> String, g: (String) -> Int): Unit defined in root package
 
 Explicit receiver kind = NO_EXPLICIT_RECEIVER
-This object = NO_RECEIVER
-Receiver argument = NO_RECEIVER
+Dispatch receiver = NO_RECEIVER
+Extension receiver = NO_RECEIVER
 
 Value arguments mapping:
 

compiler/testData/resolvedCalls/arguments/functionLiterals/notInferredLambdaReturnType.txt

@@ -11,8 +11,8 @@ Candidate descriptor: fun <T> foo(f: () -> T): Unit defined in root package
 Resulting descriptor: fun <T> foo(f: () -> ???): Unit defined in root package
 
 Explicit receiver kind = NO_EXPLICIT_RECEIVER
-This object = NO_RECEIVER
-Receiver argument = NO_RECEIVER
+Dispatch receiver = NO_RECEIVER
+Extension receiver = NO_RECEIVER
 
 Value arguments mapping:
 

compiler/testData/resolvedCalls/arguments/functionLiterals/notInferredLambdaType.txt

@@ -11,8 +11,8 @@ Candidate descriptor: fun <T> foo(f: (T) -> String): Unit defined in root packag
 Resulting descriptor: fun <T> foo(f: (???) -> String): Unit defined in root package
 
 Explicit receiver kind = NO_EXPLICIT_RECEIVER
-This object = NO_RECEIVER
-Receiver argument = NO_RECEIVER
+Dispatch receiver = NO_RECEIVER
+Extension receiver = NO_RECEIVER
 
 Value arguments mapping:
 

compiler/testData/resolvedCalls/arguments/functionLiterals/simpleGenericLambda.txt

@@ -11,8 +11,8 @@ Candidate descriptor: fun <T> foo(f: (T) -> String): Unit defined in root packag
 Resulting descriptor: fun <T> foo(f: (Int) -> String): Unit defined in root package
 
 Explicit receiver kind = NO_EXPLICIT_RECEIVER
-This object = NO_RECEIVER
-Receiver argument = NO_RECEIVER
+Dispatch receiver = NO_RECEIVER
+Extension receiver = NO_RECEIVER
 
 Value arguments mapping:
 

compiler/testData/resolvedCalls/arguments/functionLiterals/simpleLambda.txt

@@ -10,8 +10,8 @@ Resolved call:
 Resulting descriptor: fun foo(f: (Int) -> String): Unit defined in root package
 
 Explicit receiver kind = NO_EXPLICIT_RECEIVER
-This object = NO_RECEIVER
-Receiver argument = NO_RECEIVER
+Dispatch receiver = NO_RECEIVER
+Extension receiver = NO_RECEIVER
 
 Value arguments mapping:
 

compiler/testData/resolvedCalls/arguments/functionLiterals/unmappedLambda.txt

@@ -10,8 +10,8 @@ Resolved call:
 Resulting descriptor: fun foo(): Unit defined in root package
 
 Explicit receiver kind = NO_EXPLICIT_RECEIVER
-This object = NO_RECEIVER
-Receiver argument = NO_RECEIVER
+Dispatch receiver = NO_RECEIVER
+Extension receiver = NO_RECEIVER
 
 Value arguments mapping:
 

compiler/testData/resolvedCalls/arguments/genericCalls/inferredParameter.txt

@@ -13,8 +13,8 @@ Candidate descriptor: fun <T> foo(t: T, l: List<T>): Unit defined in root packag
 Resulting descriptor: fun <T> foo(t: Comparable<out Any?>, l: List<Comparable<out Any?>>): Unit defined in root package
 
 Explicit receiver kind = NO_EXPLICIT_RECEIVER
-This object = NO_RECEIVER
-Receiver argument = NO_RECEIVER
+Dispatch receiver = NO_RECEIVER
+Extension receiver = NO_RECEIVER
 
 Value arguments mapping:
 

compiler/testData/resolvedCalls/arguments/genericCalls/simpleGeneric.txt

@@ -13,8 +13,8 @@ Candidate descriptor: fun <T> foo(t: T): Unit defined in root package
 Resulting descriptor: fun <T> foo(t: A): Unit defined in root package
 
 Explicit receiver kind = NO_EXPLICIT_RECEIVER
-This object = NO_RECEIVER
-Receiver argument = NO_RECEIVER
+Dispatch receiver = NO_RECEIVER
+Extension receiver = NO_RECEIVER
 
 Value arguments mapping:
 

compiler/testData/resolvedCalls/arguments/genericCalls/uninferredParameter.txt

@@ -13,8 +13,8 @@ Candidate descriptor: fun <T> foo(t: T, l: MutableList<T>): Unit defined in root
 Resulting descriptor: fun <T> foo(t: ???, l: MutableList<???>): Unit defined in root package
 
 Explicit receiver kind = NO_EXPLICIT_RECEIVER
-This object = NO_RECEIVER
-Receiver argument = NO_RECEIVER
+Dispatch receiver = NO_RECEIVER
+Extension receiver = NO_RECEIVER
 
 Value arguments mapping:
 

compiler/testData/resolvedCalls/arguments/genericCalls/uninferredParameterTypeMismatch.txt

@@ -11,8 +11,8 @@ Candidate descriptor: fun <T> foo(l: List<T>): Unit defined in root package
 Resulting descriptor: fun <T> foo(l: List<???>): Unit defined in root package
 
 Explicit receiver kind = NO_EXPLICIT_RECEIVER
-This object = NO_RECEIVER
-Receiver argument = NO_RECEIVER
+Dispatch receiver = NO_RECEIVER
+Extension receiver = NO_RECEIVER
 
 Value arguments mapping:
 

compiler/testData/resolvedCalls/arguments/namedArguments/positionedAfterNamed.txt

@@ -13,8 +13,8 @@ Resolved call:
 Resulting descriptor: fun foo(a: A, b: B): Unit defined in root package
 
 Explicit receiver kind = NO_EXPLICIT_RECEIVER
-This object = NO_RECEIVER
-Receiver argument = NO_RECEIVER
+Dispatch receiver = NO_RECEIVER
+Extension receiver = NO_RECEIVER
 
 Value arguments mapping:
 

compiler/testData/resolvedCalls/arguments/namedArguments/shiftedArgsMatch.txt

@@ -13,8 +13,8 @@ Resolved call:
 Resulting descriptor: fun foo(a: A, b: B): Unit defined in root package
 
 Explicit receiver kind = NO_EXPLICIT_RECEIVER
-This object = NO_RECEIVER
-Receiver argument = NO_RECEIVER
+Dispatch receiver = NO_RECEIVER
+Extension receiver = NO_RECEIVER
 
 Value arguments mapping:
 

compiler/testData/resolvedCalls/arguments/oneArgument/argumentHasNoType.txt

@@ -12,8 +12,8 @@ Resolved call:
 Resulting descriptor: fun foo(a: A): Unit defined in root package
 
 Explicit receiver kind = NO_EXPLICIT_RECEIVER
-This object = NO_RECEIVER
-Receiver argument = NO_RECEIVER
+Dispatch receiver = NO_RECEIVER
+Extension receiver = NO_RECEIVER
 
 Value arguments mapping:
 

compiler/testData/resolvedCalls/arguments/oneArgument/simpleMatch.txt

@@ -12,8 +12,8 @@ Resolved call:
 Resulting descriptor: fun foo(a: A): Unit defined in root package
 
 Explicit receiver kind = NO_EXPLICIT_RECEIVER
-This object = NO_RECEIVER
-Receiver argument = NO_RECEIVER
+Dispatch receiver = NO_RECEIVER
+Extension receiver = NO_RECEIVER
 
 Value arguments mapping:
 

compiler/testData/resolvedCalls/arguments/oneArgument/typeMismatch.txt

@@ -12,8 +12,8 @@ Resolved call:
 Resulting descriptor: fun foo(a: A): Unit defined in root package
 
 Explicit receiver kind = NO_EXPLICIT_RECEIVER
-This object = NO_RECEIVER
-Receiver argument = NO_RECEIVER
+Dispatch receiver = NO_RECEIVER
+Extension receiver = NO_RECEIVER
 
 Value arguments mapping:
 

compiler/testData/resolvedCalls/arguments/oneArgument/unmappedArgument.txt

@@ -10,8 +10,8 @@ Resolved call:
 Resulting descriptor: fun foo(): Unit defined in root package
 
 Explicit receiver kind = NO_EXPLICIT_RECEIVER
-This object = NO_RECEIVER
-Receiver argument = NO_RECEIVER
+Dispatch receiver = NO_RECEIVER
+Extension receiver = NO_RECEIVER
 
 Value arguments mapping:
 

compiler/testData/resolvedCalls/arguments/realExamples/emptyList.txt

@@ -15,8 +15,8 @@ Candidate descriptor: fun <T> foo(t: T): Unit defined in root package
 Resulting descriptor: fun <T> foo(t: List<???>): Unit defined in root package
 
 Explicit receiver kind = NO_EXPLICIT_RECEIVER
-This object = NO_RECEIVER
-Receiver argument = NO_RECEIVER
+Dispatch receiver = NO_RECEIVER
+Extension receiver = NO_RECEIVER
 
 Value arguments mapping:
 

compiler/testData/resolvedCalls/arguments/realExamples/emptyMutableList.txt

@@ -15,8 +15,8 @@ Candidate descriptor: fun <T> foo(t: T): Unit defined in root package
 Resulting descriptor: fun <T> foo(t: MutableList<???>): Unit defined in root package
 
 Explicit receiver kind = NO_EXPLICIT_RECEIVER
-This object = NO_RECEIVER
-Receiver argument = NO_RECEIVER
+Dispatch receiver = NO_RECEIVER
+Extension receiver = NO_RECEIVER
 
 Value arguments mapping:
 

compiler/testData/resolvedCalls/arguments/severalCandidates/mostSpecific.txt

@@ -14,8 +14,8 @@ Resolved call:
 Resulting descriptor: fun foo(a: A, s: String): Unit defined in root package
 
 Explicit receiver kind = NO_EXPLICIT_RECEIVER
-This object = NO_RECEIVER
-Receiver argument = NO_RECEIVER
+Dispatch receiver = NO_RECEIVER
+Extension receiver = NO_RECEIVER
 
 Value arguments mapping:
 

compiler/testData/resolvedCalls/differentCallElements/annotationCall.txt

@@ -8,8 +8,8 @@ Resolved call:
 Resulting descriptor: constructor MyA(i: Int) defined in MyA
 
 Explicit receiver kind = NO_EXPLICIT_RECEIVER
-This object = NO_RECEIVER
-Receiver argument = NO_RECEIVER
+Dispatch receiver = NO_RECEIVER
+Extension receiver = NO_RECEIVER
 
 Value arguments mapping:
 

compiler/testData/resolvedCalls/differentCallElements/delegatorToSuperCall.txt

@@ -8,5 +8,5 @@ Resolved call:
 Resulting descriptor: constructor A() defined in A
 
 Explicit receiver kind = NO_EXPLICIT_RECEIVER
-This object = NO_RECEIVER
-Receiver argument = NO_RECEIVER
+Dispatch receiver = NO_RECEIVER
+Extension receiver = NO_RECEIVER

compiler/testData/resolvedCalls/differentCallElements/simpleArrayAccess.txt

@@ -7,9 +7,9 @@ Resolved call:
 
 Resulting descriptor: fun get(index: Int): Int defined in kotlin.Array
 
-Explicit receiver kind = THIS_OBJECT
-This object = array {Array<Int>}
-Receiver argument = NO_RECEIVER
+Explicit receiver kind = DISPATCH_RECEIVER
+Dispatch receiver = array {Array<Int>}
+Extension receiver = NO_RECEIVER
 
 Value arguments mapping:
 

compiler/testData/resolvedCalls/explicitReceiverIsDispatchReceiver.txt

@@ -11,6 +11,6 @@ Resolved call:
 
 Resulting descriptor: fun foo(): Unit defined in A
 
-Explicit receiver kind = THIS_OBJECT
-This object = a {A}
-Receiver argument = NO_RECEIVER
+Explicit receiver kind = DISPATCH_RECEIVER
+Dispatch receiver = a {A}
+Extension receiver = NO_RECEIVER

compiler/testData/resolvedCalls/explicitReceiverIsExtensionReceiver.txt

@@ -11,6 +11,6 @@ Resolved call:
 
 Resulting descriptor: fun A.foo(): Unit defined in root package
 
-Explicit receiver kind = RECEIVER_ARGUMENT
-This object = NO_RECEIVER
-Receiver argument = a {A}
+Explicit receiver kind = EXTENSION_RECEIVER
+Dispatch receiver = NO_RECEIVER
+Extension receiver = a {A}

compiler/testData/resolvedCalls/functionTypes/invokeForExtensionFunctionType.txt

@@ -8,5 +8,5 @@ Resolved call:
 Resulting descriptor: fun Int.invoke(): Unit defined in kotlin.ExtensionFunction0
 
 Explicit receiver kind = BOTH_RECEIVERS
-This object = f {ExtensionFunction0<Int, Unit>}
-Receiver argument = 1 {Int}
+Dispatch receiver = f {ExtensionFunction0<Int, Unit>}
+Extension receiver = 1 {Int}

compiler/testData/resolvedCalls/functionTypes/invokeForFunctionType.txt

@@ -7,6 +7,6 @@ Resolved call:
 
 Resulting descriptor: fun invoke(): Unit defined in kotlin.Function0
 
-Explicit receiver kind = THIS_OBJECT
-This object = f {Function0<Unit>}
-Receiver argument = NO_RECEIVER
+Explicit receiver kind = DISPATCH_RECEIVER
+Dispatch receiver = f {Function0<Unit>}
+Extension receiver = NO_RECEIVER

compiler/testData/resolvedCalls/functionTypes/valOfExtensionFunctionType.txt

@@ -12,5 +12,5 @@ Resolved call:
 Resulting descriptor: val foo: Int.() -> Unit defined in A
 
 Explicit receiver kind = NO_EXPLICIT_RECEIVER
-This object = Class{A}
-Receiver argument = NO_RECEIVER
+Dispatch receiver = Class{A}
+Extension receiver = NO_RECEIVER

compiler/testData/resolvedCalls/functionTypes/valOfExtensionFunctionTypeInvoke.txt

@@ -12,5 +12,5 @@ Resolved call:
 Resulting descriptor: fun Int.invoke(): Unit defined in kotlin.ExtensionFunction0
 
 Explicit receiver kind = BOTH_RECEIVERS
-This object = foo {ExtensionFunction0<Int, Unit>}
-Receiver argument = 1 {Int}
+Dispatch receiver = foo {ExtensionFunction0<Int, Unit>}
+Extension receiver = 1 {Int}

compiler/testData/resolvedCalls/functionTypes/valOfFunctionType.txt

@@ -11,6 +11,6 @@ Resolved call:
 
 Resulting descriptor: val foo: (Int) -> Int defined in A
 
-Explicit receiver kind = THIS_OBJECT
-This object = a {A}
-Receiver argument = NO_RECEIVER
+Explicit receiver kind = DISPATCH_RECEIVER
+Dispatch receiver = a {A}
+Extension receiver = NO_RECEIVER

compiler/testData/resolvedCalls/functionTypes/valOfFunctionTypeInvoke.txt

@@ -11,9 +11,9 @@ Resolved call:
 
 Resulting descriptor: fun invoke(p1: Int): Int defined in kotlin.Function1
 
-Explicit receiver kind = THIS_OBJECT
-This object = foo {Function1<Int, Int>}
-Receiver argument = NO_RECEIVER
+Explicit receiver kind = DISPATCH_RECEIVER
+Dispatch receiver = foo {Function1<Int, Int>}
+Extension receiver = NO_RECEIVER
 
 Value arguments mapping:
 

compiler/testData/resolvedCalls/hasBothDispatchAndExtensionReceivers.kt

@@ -8,4 +8,4 @@ fun bar(a: A, b: B) {
     with (a) {
         b.<caret>foo()
     }
-}
+}

compiler/testData/resolvedCalls/hasBothDispatchAndExtensionReceivers.txt

@@ -15,6 +15,6 @@ Resolved call:
 
 Resulting descriptor: fun B.foo(): Unit defined in A
 
-Explicit receiver kind = RECEIVER_ARGUMENT
-This object = AExt{fun A.<anonymous>(): Unit defined in bar}
-Receiver argument = b {B}
+Explicit receiver kind = EXTENSION_RECEIVER
+Dispatch receiver = AExt{fun A.<anonymous>(): Unit defined in bar}
+Extension receiver = b {B}

compiler/testData/resolvedCalls/hasBothDispatchAndExtensionReceiversWithoutExplicitReceiver.kt

@@ -10,4 +10,4 @@ fun bar(a: A, b: B) {
             <caret>foo()
         }
     }
-}
+}

compiler/testData/resolvedCalls/hasBothDispatchAndExtensionReceiversWithoutExplicitReceiver.txt

@@ -18,5 +18,5 @@ Resolved call:
 Resulting descriptor: fun B.foo(): Unit defined in A
 
 Explicit receiver kind = NO_EXPLICIT_RECEIVER
-This object = AExt{fun A.<anonymous>(): Unit defined in bar}
-Receiver argument = BExt{fun B.<anonymous>(): Unit defined in bar.<anonymous>}
+Dispatch receiver = AExt{fun A.<anonymous>(): Unit defined in bar}
+Extension receiver = BExt{fun B.<anonymous>(): Unit defined in bar.<anonymous>}

compiler/testData/resolvedCalls/implicitReceiverIsDispatchReceiver.txt

@@ -12,5 +12,5 @@ Resolved call:
 Resulting descriptor: fun foo(): Unit defined in A
 
 Explicit receiver kind = NO_EXPLICIT_RECEIVER
-This object = AExt{fun A.bar(): Unit defined in root package}
-Receiver argument = NO_RECEIVER
+Dispatch receiver = AExt{fun A.bar(): Unit defined in root package}
+Extension receiver = NO_RECEIVER

compiler/testData/resolvedCalls/implicitReceiverIsExtensionReceiver.txt

@@ -12,5 +12,5 @@ Resolved call:
 Resulting descriptor: fun A.foo(): Unit defined in root package
 
 Explicit receiver kind = NO_EXPLICIT_RECEIVER
-This object = NO_RECEIVER
-Receiver argument = AExt{fun A.bar(): Unit defined in root package}
+Dispatch receiver = NO_RECEIVER
+Extension receiver = AExt{fun A.bar(): Unit defined in root package}

compiler/testData/resolvedCalls/impliedThisNoExplicitReceiver.txt

@@ -11,5 +11,5 @@ Resolved call:
 Resulting descriptor: fun foo(): Unit defined in A
 
 Explicit receiver kind = NO_EXPLICIT_RECEIVER
-This object = Class{A}
-Receiver argument = NO_RECEIVER
+Dispatch receiver = Class{A}
+Extension receiver = NO_RECEIVER