ReceiverDescriptor renamed to ReceiverValue

2012-10-31 13:28:35 +04:00
parent c079625f5b
commit 4955ce5caa
49 changed files with 230 additions and 237 deletions
@@ -36,7 +36,7 @@ import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.resolve.scopes.JetScopeUtils;
 import org.jetbrains.jet.lang.resolve.scopes.receivers.ExpressionReceiver;
-import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue;
 import org.jetbrains.jet.lang.types.ErrorUtils;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.NamespaceType;
@@ -65,7 +65,7 @@ public final class TipsManager {
            if (expressionType != null && resolutionScope != null && !ErrorUtils.isErrorType(expressionType)) {
                if (!(expressionType instanceof NamespaceType)) {
-                    ExpressionReceiver receiverDescriptor = new ExpressionReceiver(receiverExpression, expressionType);
+                    ExpressionReceiver receiverValue = new ExpressionReceiver(receiverExpression, expressionType);
                    Set<DeclarationDescriptor> descriptors = new HashSet<DeclarationDescriptor>();
                    DataFlowInfo info = context.get(BindingContext.NON_DEFAULT_EXPRESSION_DATA_FLOW, expression);
@@ -74,9 +74,9 @@ public final class TipsManager {
                    }
                    AutoCastServiceImpl autoCastService = new AutoCastServiceImpl(info, context);
-                    List<ReceiverDescriptor> variantsForExplicitReceiver = autoCastService.getVariantsForReceiver(receiverDescriptor);
+                    List<ReceiverValue> variantsForExplicitReceiver = autoCastService.getVariantsForReceiver(receiverValue);
-                    for (ReceiverDescriptor descriptor : variantsForExplicitReceiver) {
+                    for (ReceiverValue descriptor : variantsForExplicitReceiver) {
                        descriptors.addAll(includeExternalCallableExtensions(
                                excludePrivateDescriptors(descriptor.getType().getMemberScope().getAllDescriptors()),
                                resolutionScope, descriptor));
@@ -188,10 +188,10 @@ public final class TipsManager {
    private static Set<DeclarationDescriptor> includeExternalCallableExtensions(
            @NotNull Collection<DeclarationDescriptor> descriptors,
            @NotNull final JetScope externalScope,
-            @NotNull final ReceiverDescriptor receiverDescriptor
+            @NotNull final ReceiverValue receiverValue
    ) {
        // It's impossible to add extension function for namespace
-        JetType receiverType = receiverDescriptor.getType();
+        JetType receiverType = receiverValue.getType();
        if (receiverType instanceof NamespaceType) {
            return new HashSet<DeclarationDescriptor>(descriptors);
        }
@@ -203,7 +203,7 @@ public final class TipsManager {
                                    new Predicate<CallableDescriptor>() {
                                        @Override
                                        public boolean apply(CallableDescriptor callableDescriptor) {
-                                            return ExpressionTypingUtils.checkIsExtensionCallable(receiverDescriptor, callableDescriptor);
+                                            return ExpressionTypingUtils.checkIsExtensionCallable(receiverValue, callableDescriptor);
                                        }
                                    }));
@@ -1716,7 +1716,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
    ) {
        FunctionDescriptor fd = (FunctionDescriptor) resolvedCall.getResultingDescriptor();
        boolean superCall = false;
-        ReceiverDescriptor explicitReceiver = call.getExplicitReceiver();
+        ReceiverValue explicitReceiver = call.getExplicitReceiver();
        if (explicitReceiver instanceof ExpressionReceiver) {
            final JetExpression receiverExpression = ((ExpressionReceiver) explicitReceiver).getExpression();
            if (receiverExpression instanceof JetSuperExpression) {
@@ -1886,7 +1886,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
        receiver.put(receiver.type, v);
    }
-    public void generateFromResolvedCall(@NotNull ReceiverDescriptor descriptor, @NotNull Type type) {
+    public void generateFromResolvedCall(@NotNull ReceiverValue descriptor, @NotNull Type type) {
        if (descriptor instanceof ClassReceiver) {
            Type exprType = asmType(descriptor.getType());
            ClassReceiver classReceiver = (ClassReceiver) descriptor;
@@ -3432,7 +3432,7 @@ The "returned" value of try expression with no finally is either the last expres
        v.athrow();
    }
-    private Call makeFakeCall(ReceiverDescriptor initializerAsReceiver) {
+    private Call makeFakeCall(ReceiverValue initializerAsReceiver) {
        JetSimpleNameExpression fake = JetPsiFactory.createSimpleName(state.getProject(), "fake");
        return CallMaker.makeCall(fake, initializerAsReceiver);
    }
@@ -33,7 +33,7 @@ import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall;
 import org.jetbrains.jet.lang.resolve.java.JvmAbi;
 import org.jetbrains.jet.lang.resolve.java.JvmClassName;
 import org.jetbrains.jet.lang.resolve.java.JvmPrimitiveType;
-import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue;
 import org.jetbrains.jet.lexer.JetTokens;
 import java.util.List;
@@ -751,7 +751,7 @@ public abstract class StackValue {
                    }
                }
-                ReceiverDescriptor receiverParameter = resolvedGetCall.getReceiverArgument();
+                ReceiverValue receiverParameter = resolvedGetCall.getReceiverArgument();
                int receiverIndex = -1;
                if (receiverParameter.exists()) {
                    Type type = codegen.typeMapper.mapType(receiverParameter.getType());
@@ -762,7 +762,7 @@ public abstract class StackValue {
                    v.store((receiverIndex = lastIndex) - sz, type);
                }
-                ReceiverDescriptor thisObject = resolvedGetCall.getThisObject();
+                ReceiverValue thisObject = resolvedGetCall.getThisObject();
                int thisIndex = -1;
                if (thisObject.exists()) {
                    frame.enterTemp(OBJECT_TYPE);
@@ -1262,8 +1262,8 @@ public abstract class StackValue {
                ExpressionCodegen codegen,
                CallableMethod callableMethod
        ) {
-            ReceiverDescriptor thisObject = resolvedCall.getThisObject();
+            ReceiverValue thisObject = resolvedCall.getThisObject();
-            ReceiverDescriptor receiverArgument = resolvedCall.getReceiverArgument();
+            ReceiverValue receiverArgument = resolvedCall.getReceiverArgument();
            CallableDescriptor descriptor = resolvedCall.getResultingDescriptor();
@@ -1305,8 +1305,8 @@ public abstract class StackValue {
        public void put(Type type, InstructionAdapter v) {
            CallableDescriptor descriptor = resolvedCall.getResultingDescriptor();
-            ReceiverDescriptor thisObject = resolvedCall.getThisObject();
+            ReceiverValue thisObject = resolvedCall.getThisObject();
-            ReceiverDescriptor receiverArgument = resolvedCall.getReceiverArgument();
+            ReceiverValue receiverArgument = resolvedCall.getReceiverArgument();
            if (thisObject.exists()) {
                if (receiverArgument.exists()) {
                    if (callableMethod != null) {
@@ -1330,7 +1330,7 @@ public abstract class StackValue {
        }
        private void genReceiver(
-                InstructionAdapter v, ReceiverDescriptor receiverArgument, Type type,
+                InstructionAdapter v, ReceiverValue receiverArgument, Type type,
                @Nullable ReceiverParameterDescriptor receiverParameter, int depth
        ) {
            if (receiver == StackValue.none()) {
@@ -24,7 +24,6 @@ import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
 import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl;
 import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
 import org.jetbrains.jet.lang.types.*;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
@@ -20,7 +20,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.resolve.name.Name;
-import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.TypeSubstitutor;
@@ -40,8 +40,8 @@ import java.util.List;
    @NotNull
    @Override
-    public ReceiverDescriptor getValue() {
+    public ReceiverValue getValue() {
-        return ReceiverDescriptor.NO_RECEIVER;
+        return ReceiverValue.NO_RECEIVER;
    }
    @NotNull
@@ -18,7 +18,7 @@ package org.jetbrains.jet.lang.descriptors;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.TypeSubstitutor;
@@ -34,7 +34,7 @@ public interface ReceiverParameterDescriptor extends DeclarationDescriptor {
    JetType getType();
    @NotNull
-    ReceiverDescriptor getValue();
+    ReceiverValue getValue();
    @Override
    @NotNull
@@ -17,18 +17,18 @@
 package org.jetbrains.jet.lang.descriptors;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue;
 import org.jetbrains.jet.lang.types.JetType;
 public class ReceiverParameterDescriptorImpl extends AbstractReceiverParameterDescriptor {
    private final DeclarationDescriptor containingDeclaration;
    private final JetType type;
-    private final ReceiverDescriptor value;
+    private final ReceiverValue value;
    public ReceiverParameterDescriptorImpl(
            @NotNull DeclarationDescriptor containingDeclaration,
            @NotNull JetType type,
-            @NotNull ReceiverDescriptor value
+            @NotNull ReceiverValue value
    ) {
        this.containingDeclaration = containingDeclaration;
        this.type = type;
@@ -43,7 +43,7 @@ public class ReceiverParameterDescriptorImpl extends AbstractReceiverParameterDe
    @NotNull
    @Override
-    public ReceiverDescriptor getValue() {
+    public ReceiverValue getValue() {
        return value;
    }
@@ -20,7 +20,7 @@ import com.intellij.lang.ASTNode;
 import com.intellij.psi.PsiElement;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue;
 import java.util.List;
@@ -34,10 +34,10 @@ public interface Call {
    ASTNode getCallOperationNode();
    @NotNull
-    ReceiverDescriptor getExplicitReceiver();
+    ReceiverValue getExplicitReceiver();
    @NotNull
-    ReceiverDescriptor getThisObject();
+    ReceiverValue getThisObject();
    @Nullable
    JetExpression getCalleeExpression();
@@ -30,7 +30,7 @@ import org.jetbrains.jet.lang.resolve.calls.model.ResolvedValueArgument;
 import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo;
 import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
-import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue;
 import org.jetbrains.jet.lang.types.ErrorUtils;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices;
@@ -86,7 +86,7 @@ public class AnnotationResolver {
        OverloadResolutionResults<FunctionDescriptor> results = callResolver.resolveFunctionCall(
                                                                    trace,
                                                                    scope,
-                                                                    CallMaker.makeCall(ReceiverDescriptor.NO_RECEIVER, null, entryElement),
+                                                                    CallMaker.makeCall(ReceiverValue.NO_RECEIVER, null, entryElement),
                                                                    NO_EXPECTED_TYPE,
                                                                    DataFlowInfo.EMPTY);
        if (results.isSuccess()) {
@@ -32,7 +32,7 @@ import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.resolve.scopes.RedeclarationHandler;
 import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
 import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl;
-import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue;
 import org.jetbrains.jet.lang.types.*;
 import org.jetbrains.jet.lang.types.checker.JetTypeChecker;
 import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices;
@@ -221,7 +221,7 @@ public class BodyResolver {
                }
                OverloadResolutionResults<FunctionDescriptor> results = callResolver.resolveFunctionCall(
                        trace, scopeForConstructor,
-                        CallMaker.makeCall(ReceiverDescriptor.NO_RECEIVER, null, call), NO_EXPECTED_TYPE, DataFlowInfo.EMPTY);
+                        CallMaker.makeCall(ReceiverValue.NO_RECEIVER, null, call), NO_EXPECTED_TYPE, DataFlowInfo.EMPTY);
                if (results.isSuccess()) {
                    JetType supertype = results.getResultingDescriptor().getReturnType();
                    recordSupertype(typeReference, supertype);
@@ -33,7 +33,7 @@ import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
 import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl;
 import org.jetbrains.jet.lang.resolve.scopes.receivers.ClassReceiver;
 import org.jetbrains.jet.lang.resolve.scopes.receivers.ExtensionReceiver;
-import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue;
 import org.jetbrains.jet.lang.types.*;
 import org.jetbrains.jet.lang.types.checker.JetTypeChecker;
 import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices;
@@ -1301,7 +1301,7 @@ public class DescriptorResolver {
            @NotNull
            @Override
-            public ReceiverDescriptor getValue() {
+            public ReceiverValue getValue() {
                if (value == null) {
                    value = new ClassReceiver(classDescriptor);
                }
@@ -23,7 +23,7 @@ import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCallImpl;
 import org.jetbrains.jet.lang.resolve.calls.tasks.ResolutionTask;
 import org.jetbrains.jet.lang.resolve.calls.tasks.TracingStrategy;
-import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue;
 /**
 * @author svtk
@@ -31,7 +31,7 @@ import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
 public final class CallResolutionContext<D extends CallableDescriptor, F extends D> extends ResolutionContext {
    /*package*/ final ResolvedCallImpl<D> candidateCall;
    /*package*/ final TracingStrategy tracing;
-    /*package*/ ReceiverDescriptor receiverForVariableAsFunctionSecondCall = ReceiverDescriptor.NO_RECEIVER;
+    /*package*/ ReceiverValue receiverForVariableAsFunctionSecondCall = ReceiverValue.NO_RECEIVER;
    private CallResolutionContext(@NotNull ResolvedCallImpl<D> candidateCall, @NotNull ResolutionTask<D, F> task, @NotNull BindingTrace trace, @NotNull TracingStrategy tracing, @NotNull Call call) {
        super(trace, task.scope, call, task.expectedType, task.dataFlowInfo);
@@ -35,7 +35,7 @@ import org.jetbrains.jet.lang.resolve.calls.util.ExpressionAsFunctionDescriptor;
 import org.jetbrains.jet.lang.resolve.calls.util.JetFakeReference;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
-import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue;
 import org.jetbrains.jet.lang.types.*;
 import org.jetbrains.jet.lang.types.checker.JetTypeChecker;
 import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices;
@@ -51,7 +51,7 @@ import static org.jetbrains.jet.lang.descriptors.ReceiverParameterDescriptor.NO_
 import static org.jetbrains.jet.lang.diagnostics.Errors.*;
 import static org.jetbrains.jet.lang.resolve.BindingContext.*;
 import static org.jetbrains.jet.lang.resolve.calls.results.ResolutionStatus.*;
-import static org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor.NO_RECEIVER;
+import static org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue.NO_RECEIVER;
 import static org.jetbrains.jet.lang.types.TypeUtils.NO_EXPECTED_TYPE;
 /**
@@ -200,7 +200,7 @@ public class CallResolver {
                        context.trace.report(NO_CONSTRUCTOR.on(reportAbsenceOn));
                        return checkArgumentTypesAndFail(context);
                    }
-                    Collection<ResolutionCandidate<CallableDescriptor>> candidates = TaskPrioritizer.<CallableDescriptor>convertWithImpliedThis(context.scope, Collections.<ReceiverDescriptor>singletonList(NO_RECEIVER), constructors);
+                    Collection<ResolutionCandidate<CallableDescriptor>> candidates = TaskPrioritizer.<CallableDescriptor>convertWithImpliedThis(context.scope, Collections.<ReceiverValue>singletonList(NO_RECEIVER), constructors);
                    for (ResolutionCandidate<CallableDescriptor> candidate : candidates) {
                        candidate.setSafeCall(JetPsiUtil.isSafeCall(context.call));
                    }
@@ -531,7 +531,7 @@ public class CallResolver {
    @Deprecated // Creates wrong resolved calls, should be removed
    @NotNull
-    public OverloadResolutionResults<FunctionDescriptor> resolveExactSignature(@NotNull JetScope scope, @NotNull ReceiverDescriptor receiver, @NotNull Name name, @NotNull List<JetType> parameterTypes) {
+    public OverloadResolutionResults<FunctionDescriptor> resolveExactSignature(@NotNull JetScope scope, @NotNull ReceiverValue receiver, @NotNull Name name, @NotNull List<JetType> parameterTypes) {
        List<ResolutionCandidate<FunctionDescriptor>> candidates = findCandidatesByExactSignature(scope, receiver, name, parameterTypes);
        BindingTraceContext trace = new BindingTraceContext();
@@ -545,7 +545,7 @@ public class CallResolver {
                                                                     Collections.<ResolvedCallWithTrace<FunctionDescriptor>>emptySet());
    }
-    private List<ResolutionCandidate<FunctionDescriptor>> findCandidatesByExactSignature(JetScope scope, ReceiverDescriptor receiver,
+    private List<ResolutionCandidate<FunctionDescriptor>> findCandidatesByExactSignature(JetScope scope, ReceiverValue receiver,
                                                                                      Name name, List<JetType> parameterTypes) {
        List<ResolutionCandidate<FunctionDescriptor>> result = Lists.newArrayList();
        if (receiver.exists()) {
@@ -587,7 +587,7 @@ public class CallResolver {
        return found;
    }
-    private boolean findExtensionFunctions(Collection<ResolutionCandidate<FunctionDescriptor>> candidates, ReceiverDescriptor receiver,
+    private boolean findExtensionFunctions(Collection<ResolutionCandidate<FunctionDescriptor>> candidates, ReceiverValue receiver,
                                           List<JetType> parameterTypes, List<ResolutionCandidate<FunctionDescriptor>> result) {
        boolean found = false;
        for (ResolutionCandidate<FunctionDescriptor> candidate : candidates) {
@@ -37,7 +37,7 @@ import org.jetbrains.jet.lang.resolve.calls.tasks.ResolutionTask;
 import org.jetbrains.jet.lang.resolve.calls.util.DelegatingCall;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.scopes.receivers.ExpressionReceiver;
-import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue;
 import org.jetbrains.jet.lang.types.JetType;
 import java.util.Collection;
@@ -111,7 +111,7 @@ public class CallTransformer<D extends CallableDescriptor, F extends D> {
                    candidate, variableCall, candidateTrace, task);
            ResolutionCandidate<CallableDescriptor> candidateWithoutReceiver = ResolutionCandidate.create(
-                    candidate.getDescriptor(), candidate.getThisObject(), ReceiverDescriptor.NO_RECEIVER, ExplicitReceiverKind.NO_EXPLICIT_RECEIVER, false);
+                    candidate.getDescriptor(), candidate.getThisObject(), ReceiverValue.NO_RECEIVER, ExplicitReceiverKind.NO_EXPLICIT_RECEIVER, false);
            CallResolutionContext<CallableDescriptor, FunctionDescriptor> contextWithoutReceiver = createContextWithChainedTrace(
                    candidateWithoutReceiver, variableCallWithoutReceiver, candidateTrace, task);
@@ -165,8 +165,8 @@ public class CallTransformer<D extends CallableDescriptor, F extends D> {
            return new DelegatingCall(variableCall) {
                @NotNull
                @Override
-                public ReceiverDescriptor getExplicitReceiver() {
+                public ReceiverValue getExplicitReceiver() {
-                    return ReceiverDescriptor.NO_RECEIVER;
+                    return ReceiverValue.NO_RECEIVER;
                }
            };
        }
@@ -216,13 +216,13 @@ public class CallTransformer<D extends CallableDescriptor, F extends D> {
            return new CallForImplicitInvoke(task.call) {
                @NotNull
                @Override
-                public ReceiverDescriptor getExplicitReceiver() {
+                public ReceiverValue getExplicitReceiver() {
                    return context.receiverForVariableAsFunctionSecondCall;
                }
                @NotNull
                @Override
-                public ReceiverDescriptor getThisObject() {
+                public ReceiverValue getThisObject() {
                    return receiverFromVariable;
                }
@@ -38,7 +38,7 @@ import org.jetbrains.jet.lang.resolve.calls.results.ResolutionStatus;
 import org.jetbrains.jet.lang.resolve.calls.tasks.ResolutionTask;
 import org.jetbrains.jet.lang.resolve.calls.tasks.TaskPrioritizer;
 import org.jetbrains.jet.lang.resolve.calls.tasks.TracingStrategy;
-import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue;
 import org.jetbrains.jet.lang.types.*;
 import org.jetbrains.jet.lang.types.checker.JetTypeChecker;
 import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices;
@@ -314,7 +314,7 @@ public class CandidateResolver {
        // Receiver
        // Error is already reported if something is missing
-        ReceiverDescriptor receiverArgument = candidateCall.getReceiverArgument();
+        ReceiverValue receiverArgument = candidateCall.getReceiverArgument();
        ReceiverParameterDescriptor receiverParameter = candidateWithFreshVariables.getReceiverParameter();
        if (receiverArgument.exists() && receiverParameter.exists()) {
            constraintsSystem.addSubtypeConstraint(receiverParameter.getType(), receiverArgument.getType(),
@@ -467,7 +467,7 @@ public class CandidateResolver {
    }
    private <D extends CallableDescriptor, F extends D> ResolutionStatus checkReceiver(CallResolutionContext<D, F> context, ResolvedCall<D> candidateCall,
-            ReceiverParameterDescriptor receiverParameter, ReceiverDescriptor receiverArgument,
+            ReceiverParameterDescriptor receiverParameter, ReceiverValue receiverArgument,
            boolean isExplicitReceiver, boolean implicitInvokeCheck) {
        BindingContext bindingContext = context.candidateCall.getTrace().getBindingContext();
@@ -29,7 +29,7 @@ import org.jetbrains.jet.lang.resolve.calls.model.*;
 import org.jetbrains.jet.lang.resolve.calls.tasks.TracingStrategy;
 import org.jetbrains.jet.lang.resolve.calls.util.CallMaker;
 import org.jetbrains.jet.lang.resolve.name.Name;
-import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue;
 import java.util.List;
 import java.util.Map;
@@ -213,7 +213,7 @@ import static org.jetbrains.jet.lang.resolve.calls.ValueArgumentsToParametersMap
        }
        ReceiverParameterDescriptor receiverParameter = candidate.getReceiverParameter();
-        ReceiverDescriptor receiverArgument = candidateCall.getReceiverArgument();
+        ReceiverValue receiverArgument = candidateCall.getReceiverArgument();
        if (receiverParameter.exists() &&!receiverArgument.exists()) {
            tracing.missingReceiver(traceForCall, receiverParameter);
            status = ERROR;
@@ -17,19 +17,19 @@
 package org.jetbrains.jet.lang.resolve.calls.autocasts;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.resolve.scopes.receivers.AbstractReceiverDescriptor;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.AbstractReceiverValue;
-import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue;
-import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptorVisitor;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValueVisitor;
 import org.jetbrains.jet.lang.types.JetType;
 /**
 * @author abreslav
 */
-public class AutoCastReceiver extends AbstractReceiverDescriptor {
+public class AutoCastReceiver extends AbstractReceiverValue {
-    private final ReceiverDescriptor original;
+    private final ReceiverValue original;
    private final boolean canCast;
-    public AutoCastReceiver(@NotNull ReceiverDescriptor original, @NotNull JetType castTo, boolean canCast) {
+    public AutoCastReceiver(@NotNull ReceiverValue original, @NotNull JetType castTo, boolean canCast) {
        super(castTo);
        this.original = original;
        this.canCast = canCast;
@@ -40,12 +40,12 @@ public class AutoCastReceiver extends AbstractReceiverDescriptor {
    }
    @NotNull
-    public ReceiverDescriptor getOriginal() {
+    public ReceiverValue getOriginal() {
        return original;
    }
    @Override
-    public <R, D> R accept(@NotNull ReceiverDescriptorVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull ReceiverValueVisitor<R, D> visitor, D data) {
        return original.accept(visitor, data);
    }
@@ -17,7 +17,7 @@
 package org.jetbrains.jet.lang.resolve.calls.autocasts;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue;
 import java.util.Collections;
 import java.util.List;
@@ -34,22 +34,22 @@ public interface AutoCastService {
        }
        @Override
-        public boolean isNotNull(@NotNull ReceiverDescriptor receiver) {
+        public boolean isNotNull(@NotNull ReceiverValue receiver) {
            return !receiver.getType().isNullable();
        }
        @NotNull
        @Override
-        public List<ReceiverDescriptor> getVariantsForReceiver(@NotNull ReceiverDescriptor receiverDescriptor) {
+        public List<ReceiverValue> getVariantsForReceiver(@NotNull ReceiverValue receiverValue) {
-            return Collections.singletonList(receiverDescriptor);
+            return Collections.singletonList(receiverValue);
        }
    };
    @NotNull
-    List<ReceiverDescriptor> getVariantsForReceiver(@NotNull ReceiverDescriptor receiverDescriptor);
+    List<ReceiverValue> getVariantsForReceiver(@NotNull ReceiverValue receiverValue);
    @NotNull
    DataFlowInfo getDataFlowInfo();
-    boolean isNotNull(@NotNull ReceiverDescriptor receiver);
+    boolean isNotNull(@NotNull ReceiverValue receiver);
 }
@@ -19,7 +19,7 @@ package org.jetbrains.jet.lang.resolve.calls.autocasts;
 import com.google.common.collect.Lists;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.resolve.BindingContext;
-import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue;
 import java.util.List;
@@ -37,9 +37,9 @@ public class AutoCastServiceImpl implements AutoCastService {
    @NotNull
    @Override
-    public List<ReceiverDescriptor> getVariantsForReceiver(@NotNull ReceiverDescriptor receiverDescriptor) {
+    public List<ReceiverValue> getVariantsForReceiver(@NotNull ReceiverValue receiverValue) {
-        List<ReceiverDescriptor> variants = Lists.newArrayList(AutoCastUtils.getAutoCastVariants(bindingContext, dataFlowInfo, receiverDescriptor));
+        List<ReceiverValue> variants = Lists.newArrayList(AutoCastUtils.getAutoCastVariants(bindingContext, dataFlowInfo, receiverValue));
-        variants.add(receiverDescriptor);
+        variants.add(receiverValue);
        return variants;
    }
@@ -50,11 +50,11 @@ public class AutoCastServiceImpl implements AutoCastService {
    }
    @Override
-    public boolean isNotNull(@NotNull ReceiverDescriptor receiver) {
+    public boolean isNotNull(@NotNull ReceiverValue receiver) {
        if (!receiver.getType().isNullable()) return true;
-        List<ReceiverDescriptor> autoCastVariants = AutoCastUtils.getAutoCastVariants(bindingContext, dataFlowInfo, receiver);
+        List<ReceiverValue> autoCastVariants = AutoCastUtils.getAutoCastVariants(bindingContext, dataFlowInfo, receiver);
-        for (ReceiverDescriptor autoCastVariant : autoCastVariants) {
+        for (ReceiverValue autoCastVariant : autoCastVariants) {
            if (!autoCastVariant.getType().isNullable()) return true;
        }
        return false;
@@ -40,41 +40,41 @@ public class AutoCastUtils {
    /**
     * @return variants @param receiverToCast may be cast to according to @param dataFlowInfo, @param receiverToCast itself is NOT included
     */
-    public static List<ReceiverDescriptor> getAutoCastVariants(
+    public static List<ReceiverValue> getAutoCastVariants(
            @NotNull final BindingContext bindingContext,
-            @NotNull final DataFlowInfo dataFlowInfo, @NotNull ReceiverDescriptor receiverToCast
+            @NotNull final DataFlowInfo dataFlowInfo, @NotNull ReceiverValue receiverToCast
    ) {
-        return receiverToCast.accept(new ReceiverDescriptorVisitor<List<ReceiverDescriptor>, Object>() {
+        return receiverToCast.accept(new ReceiverValueVisitor<List<ReceiverValue>, Object>() {
            @Override
-            public List<ReceiverDescriptor> visitNoReceiver(ReceiverDescriptor noReceiver, Object data) {
+            public List<ReceiverValue> visitNoReceiver(ReceiverValue noReceiver, Object data) {
                return Collections.emptyList();
            }
            @Override
-            public List<ReceiverDescriptor> visitTransientReceiver(TransientReceiver receiver, Object data) {
+            public List<ReceiverValue> visitTransientReceiver(TransientReceiver receiver, Object data) {
                return Collections.emptyList();
            }
            @Override
-            public List<ReceiverDescriptor> visitExtensionReceiver(ExtensionReceiver receiver, Object data) {
+            public List<ReceiverValue> visitExtensionReceiver(ExtensionReceiver receiver, Object data) {
                return castThis(dataFlowInfo, receiver);
            }
            @Override
-            public List<ReceiverDescriptor> visitClassReceiver(ClassReceiver receiver, Object data) {
+            public List<ReceiverValue> visitClassReceiver(ClassReceiver receiver, Object data) {
                return castThis(dataFlowInfo, receiver);
            }
            @Override
-            public List<ReceiverDescriptor> visitScriptReceiver(ScriptReceiver receiver, Object data) {
+            public List<ReceiverValue> visitScriptReceiver(ScriptReceiver receiver, Object data) {
                return Collections.emptyList();
            }
            @Override
-            public List<ReceiverDescriptor> visitExpressionReceiver(ExpressionReceiver receiver, Object data) {
+            public List<ReceiverValue> visitExpressionReceiver(ExpressionReceiver receiver, Object data) {
                DataFlowValue dataFlowValue = DataFlowValueFactory.INSTANCE.createDataFlowValue(receiver.getExpression(), receiver.getType(),
                                                                                                bindingContext);
-                List<ReceiverDescriptor> result = Lists.newArrayList();
+                List<ReceiverValue> result = Lists.newArrayList();
                for (JetType possibleType : dataFlowInfo.getPossibleTypes(dataFlowValue)) {
                    result.add(new AutoCastReceiver(receiver, possibleType, dataFlowValue.isStableIdentifier()));
                }
@@ -83,19 +83,19 @@ public class AutoCastUtils {
        }, null);
    }
-    private static List<ReceiverDescriptor> castThis(@NotNull DataFlowInfo dataFlowInfo, @NotNull ThisReceiverDescriptor receiver) {
+    private static List<ReceiverValue> castThis(@NotNull DataFlowInfo dataFlowInfo, @NotNull ThisReceiver receiver) {
        assert receiver.exists();
-        List<ReceiverDescriptor> result = Lists.newArrayList();
+        List<ReceiverValue> result = Lists.newArrayList();
        for (JetType possibleType : dataFlowInfo.getPossibleTypes(DataFlowValueFactory.INSTANCE.createDataFlowValue(receiver))) {
            result.add(new AutoCastReceiver(receiver, possibleType, true));
        }
        return result;
    }
-    public static void recordAutoCastIfNecessary(ReceiverDescriptor receiver, @NotNull BindingTrace trace) {
+    public static void recordAutoCastIfNecessary(ReceiverValue receiver, @NotNull BindingTrace trace) {
        if (receiver instanceof AutoCastReceiver) {
            AutoCastReceiver autoCastReceiver = (AutoCastReceiver) receiver;
-            ReceiverDescriptor original = autoCastReceiver.getOriginal();
+            ReceiverValue original = autoCastReceiver.getOriginal();
            if (original instanceof ExpressionReceiver) {
                ExpressionReceiver expressionReceiver = (ExpressionReceiver) original;
                if (autoCastReceiver.canCast()) {
@@ -50,7 +50,7 @@ public class DataFlowValueFactory {
    }
    @NotNull
-    public DataFlowValue createDataFlowValue(@NotNull ThisReceiverDescriptor receiver) {
+    public DataFlowValue createDataFlowValue(@NotNull ThisReceiver receiver) {
        JetType type = receiver.getType();
        return new DataFlowValue(receiver, type, true, getImmanentNullability(type));
    }
@@ -62,11 +62,11 @@ public class DataFlowValueFactory {
    }
    @NotNull
-    public DataFlowValue createDataFlowValue(@NotNull ReceiverDescriptor receiverDescriptor, @NotNull BindingContext bindingContext) {
+    public DataFlowValue createDataFlowValue(@NotNull ReceiverValue receiverValue, @NotNull BindingContext bindingContext) {
-        return receiverDescriptor.accept(new ReceiverDescriptorVisitor<DataFlowValue, BindingContext>() {
+        return receiverValue.accept(new ReceiverValueVisitor<DataFlowValue, BindingContext>() {
            @Override
-            public DataFlowValue visitNoReceiver(ReceiverDescriptor noReceiver, BindingContext data) {
+            public DataFlowValue visitNoReceiver(ReceiverValue noReceiver, BindingContext data) {
-                throw new IllegalArgumentException("No DataFlowValue exists for ReceiverDescriptor.NO_RECEIVER");
+                throw new IllegalArgumentException("No DataFlowValue exists for ReceiverValue.NO_RECEIVER");
            }
            @Override
@@ -95,7 +95,7 @@ public class DataFlowValueFactory {
            }
            @NotNull
-            private DataFlowValue createTransientDataFlowValue(ReceiverDescriptor receiver) {
+            private DataFlowValue createTransientDataFlowValue(ReceiverValue receiver) {
                JetType type = receiver.getType();
                boolean nullable = type.isNullable() || TypeUtils.hasNullableSuperType(type);
                return new DataFlowValue(receiver, type, nullable, Nullability.NOT_NULL);
@@ -21,7 +21,7 @@ import org.jetbrains.jet.lang.descriptors.CallableDescriptor;
 import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor;
 import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor;
 import org.jetbrains.jet.lang.resolve.calls.tasks.ExplicitReceiverKind;
-import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue;
 import org.jetbrains.jet.lang.types.JetType;
 import java.util.List;
@@ -41,11 +41,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
-    ReceiverDescriptor getReceiverArgument();
+    ReceiverValue getReceiverArgument();
    /** If the target was a member of a class, this is the object of that class to call it on */
    @NotNull
-    ReceiverDescriptor getThisObject();
+    ReceiverValue getThisObject();
    /** Determines whether receiver argument or this object is substituted for explicit receiver */
    @NotNull
@@ -28,7 +28,7 @@ import org.jetbrains.jet.lang.resolve.calls.tasks.ExplicitReceiverKind;
 import org.jetbrains.jet.lang.resolve.calls.tasks.ResolutionCandidate;
 import org.jetbrains.jet.lang.resolve.calls.results.ResolutionStatus;
 import org.jetbrains.jet.lang.resolve.calls.inference.ConstraintSystem;
-import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.TypeSubstitutor;
@@ -64,8 +64,8 @@ public class ResolvedCallImpl<D extends CallableDescriptor> implements ResolvedC
    private final D candidateDescriptor;
    private D resultingDescriptor; // Probably substituted
-    private final ReceiverDescriptor thisObject; // receiver object of a method
+    private final ReceiverValue thisObject; // receiver object of a method
-    private final ReceiverDescriptor receiverArgument; // receiver of an extension function
+    private final ReceiverValue receiverArgument; // receiver of an extension function
    private final ExplicitReceiverKind explicitReceiverKind;
    private final boolean isSafeCall;
@@ -162,13 +162,13 @@ public class ResolvedCallImpl<D extends CallableDescriptor> implements ResolvedC
    @Override
    @NotNull
-    public ReceiverDescriptor getReceiverArgument() {
+    public ReceiverValue getReceiverArgument() {
        return receiverArgument;
    }
    @Override
    @NotNull
-    public ReceiverDescriptor getThisObject() {
+    public ReceiverValue getThisObject() {
        return thisObject;
    }
@@ -24,7 +24,7 @@ import org.jetbrains.jet.lang.descriptors.VariableDescriptor;
 import org.jetbrains.jet.lang.resolve.DelegatingBindingTrace;
 import org.jetbrains.jet.lang.resolve.calls.tasks.ExplicitReceiverKind;
 import org.jetbrains.jet.lang.resolve.calls.results.ResolutionStatus;
-import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue;
 import org.jetbrains.jet.lang.types.JetType;
 import java.util.List;
@@ -65,13 +65,13 @@ public class VariableAsFunctionResolvedCall implements ResolvedCallWithTrace<Fun
    @NotNull
    @Override
-    public ReceiverDescriptor getReceiverArgument() {
+    public ReceiverValue getReceiverArgument() {
        return variableCall.getReceiverArgument();
    }
    @NotNull
    @Override
-    public ReceiverDescriptor getThisObject() {
+    public ReceiverValue getThisObject() {
        return variableCall.getThisObject();
    }
@@ -20,24 +20,24 @@ import com.google.common.collect.Lists;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.CallableDescriptor;
-import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue;
 import java.util.Collection;
 import java.util.List;
-import static org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor.NO_RECEIVER;
+import static org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue.NO_RECEIVER;
 /**
 * @author svtk
 */
 public class ResolutionCandidate<D extends CallableDescriptor> {
    private final D candidateDescriptor;
-    private ReceiverDescriptor thisObject; // receiver object of a method
+    private ReceiverValue thisObject; // receiver object of a method
-    private ReceiverDescriptor receiverArgument; // receiver of an extension function
+    private ReceiverValue receiverArgument; // receiver of an extension function
    private ExplicitReceiverKind explicitReceiverKind;
    private Boolean isSafeCall;
-    private ResolutionCandidate(@NotNull D descriptor, @NotNull ReceiverDescriptor thisObject, @NotNull ReceiverDescriptor receiverArgument,
+    private ResolutionCandidate(@NotNull D descriptor, @NotNull ReceiverValue thisObject, @NotNull ReceiverValue receiverArgument,
            @NotNull ExplicitReceiverKind explicitReceiverKind, @Nullable Boolean isSafeCall) {
        this.candidateDescriptor = descriptor;
        this.thisObject = thisObject;
@@ -54,16 +54,16 @@ public class ResolutionCandidate<D extends CallableDescriptor> {
        return create(descriptor, NO_RECEIVER, NO_RECEIVER, ExplicitReceiverKind.NO_EXPLICIT_RECEIVER, isSafeCall);
    }
-    public static <D extends CallableDescriptor> ResolutionCandidate<D> create(@NotNull D descriptor, @NotNull ReceiverDescriptor thisObject,
+    public static <D extends CallableDescriptor> ResolutionCandidate<D> create(@NotNull D descriptor, @NotNull ReceiverValue thisObject,
-            @NotNull ReceiverDescriptor receiverArgument, @NotNull ExplicitReceiverKind explicitReceiverKind, boolean isSafeCall) {
+            @NotNull ReceiverValue receiverArgument, @NotNull ExplicitReceiverKind explicitReceiverKind, boolean isSafeCall) {
        return new ResolutionCandidate<D>(descriptor, thisObject, receiverArgument, explicitReceiverKind, isSafeCall);
    }
-    public void setThisObject(@NotNull ReceiverDescriptor thisObject) {
+    public void setThisObject(@NotNull ReceiverValue thisObject) {
        this.thisObject = thisObject;
    }
-    public void setReceiverArgument(@NotNull ReceiverDescriptor receiverArgument) {
+    public void setReceiverArgument(@NotNull ReceiverValue receiverArgument) {
        this.receiverArgument = receiverArgument;
    }
@@ -77,12 +77,12 @@ public class ResolutionCandidate<D extends CallableDescriptor> {
    }
    @NotNull
-    public ReceiverDescriptor getThisObject() {
+    public ReceiverValue getThisObject() {
        return thisObject;
    }
    @NotNull
-    public ReceiverDescriptor getReceiverArgument() {
+    public ReceiverValue getReceiverArgument() {
        return receiverArgument;
    }
@@ -34,7 +34,7 @@ import org.jetbrains.jet.lang.resolve.calls.model.VariableAsFunctionResolvedCall
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.resolve.scopes.receivers.ExpressionReceiver;
-import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue;
 import org.jetbrains.jet.lang.types.ErrorUtils;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.Variance;
@@ -154,7 +154,7 @@ public class ResolutionTask<D extends CallableDescriptor, F extends D> extends R
        }
        @Override
-        public void wrongReceiverType(@NotNull BindingTrace trace, @NotNull ReceiverParameterDescriptor receiverParameter, @NotNull ReceiverDescriptor receiverArgument) {
+        public void wrongReceiverType(@NotNull BindingTrace trace, @NotNull ReceiverParameterDescriptor receiverParameter, @NotNull ReceiverValue receiverArgument) {
            if (receiverArgument instanceof ExpressionReceiver) {
                ExpressionReceiver expressionReceiver = (ExpressionReceiver)receiverArgument;
                trace.report(TYPE_MISMATCH.on(expressionReceiver.getExpression(), receiverParameter.getType(), receiverArgument.getType()));
@@ -31,9 +31,8 @@ import org.jetbrains.jet.lang.resolve.calls.autocasts.AutoCastServiceImpl;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.resolve.scopes.JetScopeUtils;
 import org.jetbrains.jet.lang.resolve.scopes.receivers.ClassReceiver;
 import org.jetbrains.jet.lang.resolve.scopes.receivers.ExpressionReceiver;
-import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue;
 import org.jetbrains.jet.lang.types.ErrorUtils;
 import org.jetbrains.jet.lang.types.NamespaceType;
 import org.jetbrains.jet.lang.types.checker.JetTypeChecker;
@@ -43,7 +42,7 @@ import java.util.Collections;
 import java.util.List;
 import static org.jetbrains.jet.lang.resolve.DescriptorUtils.isClassObject;
-import static org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor.NO_RECEIVER;
+import static org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue.NO_RECEIVER;
 /**
 * @author abreslav
@@ -67,7 +66,7 @@ public abstract class TaskPrioritizer {
    }
    @Nullable
-    public static JetSuperExpression getReceiverSuper(@NotNull ReceiverDescriptor receiver) {
+    public static JetSuperExpression getReceiverSuper(@NotNull ReceiverValue receiver) {
        if (receiver instanceof ExpressionReceiver) {
            ExpressionReceiver expressionReceiver = (ExpressionReceiver) receiver;
            JetExpression expression = expressionReceiver.getExpression();
@@ -81,7 +80,7 @@ public abstract class TaskPrioritizer {
    @NotNull
    public static <D extends CallableDescriptor, F extends D> List<ResolutionTask<D, F>> computePrioritizedTasks(@NotNull BasicResolutionContext context, @NotNull Name name,
                                                           @NotNull JetReferenceExpression functionReference, @NotNull List<CallableDescriptorCollector<? extends D>> callableDescriptorCollectors) {
-        ReceiverDescriptor explicitReceiver = context.call.getExplicitReceiver();
+        ReceiverValue explicitReceiver = context.call.getExplicitReceiver();
        final JetScope scope;
        if (explicitReceiver.exists() && explicitReceiver.getType() instanceof NamespaceType) {
            // Receiver is a namespace
@@ -108,20 +107,20 @@ public abstract class TaskPrioritizer {
        return result.getTasks();
    }
-    private static <D extends CallableDescriptor, F extends D> void doComputeTasks(@NotNull JetScope scope, @NotNull ReceiverDescriptor receiver,
+    private static <D extends CallableDescriptor, F extends D> void doComputeTasks(@NotNull JetScope scope, @NotNull ReceiverValue receiver,
            @NotNull Name name, @NotNull ResolutionTaskHolder<D, F> result,
            @NotNull BasicResolutionContext context, @NotNull CallableDescriptorCollector<? extends D> callableDescriptorCollector) {
        ProgressIndicatorProvider.checkCanceled();
        AutoCastServiceImpl autoCastService = new AutoCastServiceImpl(context.dataFlowInfo, context.trace.getBindingContext());
-        List<ReceiverDescriptor> implicitReceivers = JetScopeUtils.getImplicitReceiversHierarchyValues(scope);
+        List<ReceiverValue> implicitReceivers = JetScopeUtils.getImplicitReceiversHierarchyValues(scope);
        boolean hasExplicitThisObject = context.call.getThisObject().exists();
        if (hasExplicitThisObject) {
            implicitReceivers.add(context.call.getThisObject());
        }
        if (receiver.exists()) {
-            List<ReceiverDescriptor> variantsForExplicitReceiver = autoCastService.getVariantsForReceiver(receiver);
+            List<ReceiverValue> variantsForExplicitReceiver = autoCastService.getVariantsForReceiver(receiver);
            Collection<ResolutionCandidate<D>> extensionFunctions = convertWithImpliedThis(scope, variantsForExplicitReceiver, callableDescriptorCollector.getNonMembersByName(scope, name));
            List<ResolutionCandidate<D>> nonlocals = Lists.newArrayList();
@@ -130,7 +129,7 @@ public abstract class TaskPrioritizer {
            TaskPrioritizer.<D>splitLexicallyLocalDescriptors(extensionFunctions, scope.getContainingDeclaration(), locals, nonlocals);
            Collection<ResolutionCandidate<D>> members = Lists.newArrayList();
-            for (ReceiverDescriptor variant : variantsForExplicitReceiver) {
+            for (ReceiverValue variant : variantsForExplicitReceiver) {
                Collection<? extends D> membersForThisVariant = callableDescriptorCollector.getMembersByName(variant.getType(), name);
                convertWithReceivers(membersForThisVariant, Collections.singletonList(variant), Collections.singletonList(NO_RECEIVER), members, hasExplicitThisObject);
            }
@@ -138,10 +137,10 @@ public abstract class TaskPrioritizer {
            result.addLocalExtensions(locals);
            result.addMembers(members);
-            for (ReceiverDescriptor implicitReceiver : implicitReceivers) {
+            for (ReceiverValue implicitReceiver : implicitReceivers) {
                Collection<? extends D> memberExtensions = callableDescriptorCollector.getNonMembersByName(
                        implicitReceiver.getType().getMemberScope(), name);
-                List<ReceiverDescriptor> variantsForImplicitReceiver = autoCastService.getVariantsForReceiver(implicitReceiver);
+                List<ReceiverValue> variantsForImplicitReceiver = autoCastService.getVariantsForReceiver(implicitReceiver);
                result.addNonLocalExtensions(convertWithReceivers(memberExtensions, variantsForImplicitReceiver, variantsForExplicitReceiver, hasExplicitThisObject));
            }
@@ -159,25 +158,25 @@ public abstract class TaskPrioritizer {
            result.addLocalExtensions(locals);
            result.addNonLocalExtensions(nonlocals);
-            for (ReceiverDescriptor implicitReceiver : implicitReceivers) {
+            for (ReceiverValue implicitReceiver : implicitReceivers) {
                doComputeTasks(scope, implicitReceiver, name, result, context, callableDescriptorCollector);
            }
        }
    }
-    private static <D extends CallableDescriptor> Collection<ResolutionCandidate<D>> convertWithReceivers(Collection<? extends D> descriptors, Iterable<ReceiverDescriptor> thisObjects,
+    private static <D extends CallableDescriptor> Collection<ResolutionCandidate<D>> convertWithReceivers(Collection<? extends D> descriptors, Iterable<ReceiverValue> thisObjects,
-            Iterable<ReceiverDescriptor> receiverParameters, boolean hasExplicitThisObject) {
+            Iterable<ReceiverValue> receiverParameters, boolean hasExplicitThisObject) {
        Collection<ResolutionCandidate<D>> result = Lists.newArrayList();
        convertWithReceivers(descriptors, thisObjects, receiverParameters, result, hasExplicitThisObject);
        return result;
    }
-    private static <D extends CallableDescriptor> void convertWithReceivers(Collection<? extends D> descriptors, Iterable<ReceiverDescriptor> thisObjects, Iterable<ReceiverDescriptor> receiverParameters,
+    private static <D extends CallableDescriptor> void convertWithReceivers(Collection<? extends D> descriptors, Iterable<ReceiverValue> thisObjects, Iterable<ReceiverValue> receiverParameters,
            Collection<ResolutionCandidate<D>> result, boolean hasExplicitThisObject) {
-        for (ReceiverDescriptor thisObject : thisObjects) {
+        for (ReceiverValue thisObject : thisObjects) {
-            for (ReceiverDescriptor receiverParameter : receiverParameters) {
+            for (ReceiverValue receiverParameter : receiverParameters) {
                for (D extension : descriptors) {
                    ResolutionCandidate<D> candidate = ResolutionCandidate.create(extension);
                    candidate.setThisObject(thisObject);
@@ -190,9 +189,9 @@ public abstract class TaskPrioritizer {
        }
    }
-    public static <D extends CallableDescriptor> Collection<ResolutionCandidate<D>> convertWithImpliedThis(JetScope scope, Collection<ReceiverDescriptor> receiverParameters, Collection<? extends D> descriptors) {
+    public static <D extends CallableDescriptor> Collection<ResolutionCandidate<D>> convertWithImpliedThis(JetScope scope, Collection<ReceiverValue> receiverParameters, Collection<? extends D> descriptors) {
        Collection<ResolutionCandidate<D>> result = Lists.newArrayList();
-        for (ReceiverDescriptor receiverParameter : receiverParameters) {
+        for (ReceiverValue receiverParameter : receiverParameters) {
            for (D descriptor : descriptors) {
                ResolutionCandidate<D> candidate = ResolutionCandidate.create(descriptor);
                candidate.setReceiverArgument(receiverParameter);
@@ -26,7 +26,7 @@ import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.calls.inference.ConstraintSystem;
 import org.jetbrains.jet.lang.resolve.calls.inference.InferenceErrorData;
 import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCallWithTrace;
-import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue;
 import org.jetbrains.jet.lang.types.JetType;
 import java.util.Collection;
@@ -56,7 +56,7 @@ public interface TracingStrategy {
        public void missingReceiver(@NotNull BindingTrace trace, @NotNull ReceiverParameterDescriptor expectedReceiver) {}
        @Override
-        public void wrongReceiverType(@NotNull BindingTrace trace, @NotNull ReceiverParameterDescriptor receiverParameter, @NotNull ReceiverDescriptor receiverArgument) {}
+        public void wrongReceiverType(@NotNull BindingTrace trace, @NotNull ReceiverParameterDescriptor receiverParameter, @NotNull ReceiverValue receiverArgument) {}
        @Override
        public void noReceiverAllowed(@NotNull BindingTrace trace) {}
@@ -106,7 +106,7 @@ public interface TracingStrategy {
    void missingReceiver(@NotNull BindingTrace trace, @NotNull ReceiverParameterDescriptor expectedReceiver);
-    void wrongReceiverType(@NotNull BindingTrace trace, @NotNull ReceiverParameterDescriptor receiverParameter, @NotNull ReceiverDescriptor receiverArgument);
+    void wrongReceiverType(@NotNull BindingTrace trace, @NotNull ReceiverParameterDescriptor receiverParameter, @NotNull ReceiverValue receiverArgument);
    void noReceiverAllowed(@NotNull BindingTrace trace);
@@ -23,7 +23,7 @@ import com.intellij.psi.impl.source.tree.LeafPsiElement;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.psi.*;
-import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue;
 import org.jetbrains.jet.lang.psi.Call.CallType;
 import java.util.Collections;
@@ -75,17 +75,17 @@ public class CallMaker {
    private static class CallImpl implements Call {
        private final PsiElement callElement;
-        private final ReceiverDescriptor explicitReceiver;
+        private final ReceiverValue explicitReceiver;
        private final ASTNode callOperationNode;
        private final JetExpression calleeExpression;
        private final List<? extends ValueArgument> valueArguments;
        private final Call.CallType callType;
-        protected CallImpl(@NotNull PsiElement callElement, @NotNull ReceiverDescriptor explicitReceiver, @Nullable ASTNode callOperationNode, @Nullable JetExpression calleeExpression, @NotNull List<? extends ValueArgument> valueArguments) {
+        protected CallImpl(@NotNull PsiElement callElement, @NotNull ReceiverValue explicitReceiver, @Nullable ASTNode callOperationNode, @Nullable JetExpression calleeExpression, @NotNull List<? extends ValueArgument> valueArguments) {
            this(callElement, explicitReceiver, callOperationNode, calleeExpression, valueArguments, CallType.DEFAULT);
        }
-        protected CallImpl(@NotNull PsiElement callElement, @NotNull ReceiverDescriptor explicitReceiver, @Nullable ASTNode callOperationNode,
+        protected CallImpl(@NotNull PsiElement callElement, @NotNull ReceiverValue explicitReceiver, @Nullable ASTNode callOperationNode,
                @Nullable JetExpression calleeExpression, @NotNull List<? extends ValueArgument> valueArguments, @NotNull CallType callType) {
            this.callElement = callElement;
            this.explicitReceiver = explicitReceiver;
@@ -102,14 +102,14 @@ public class CallMaker {
        @NotNull
        @Override
-        public ReceiverDescriptor getExplicitReceiver() {
+        public ReceiverValue getExplicitReceiver() {
            return explicitReceiver;
        }
        @NotNull
        @Override
-        public ReceiverDescriptor getThisObject() {
+        public ReceiverValue getThisObject() {
-            return ReceiverDescriptor.NO_RECEIVER;
+            return ReceiverValue.NO_RECEIVER;
        }
        @Override
@@ -162,13 +162,13 @@ public class CallMaker {
        }
    }
-    public static Call makeCallWithExpressions(@NotNull JetElement callElement, @NotNull ReceiverDescriptor explicitReceiver,
+    public static Call makeCallWithExpressions(@NotNull JetElement callElement, @NotNull ReceiverValue explicitReceiver,
                                               @Nullable ASTNode callOperationNode, @NotNull JetExpression calleeExpression,
                                               @NotNull List<JetExpression> argumentExpressions) {
        return makeCallWithExpressions(callElement, explicitReceiver, callOperationNode, calleeExpression, argumentExpressions, CallType.DEFAULT);
    }
-    public static Call makeCallWithExpressions(@NotNull JetElement callElement, @NotNull ReceiverDescriptor explicitReceiver,
+    public static Call makeCallWithExpressions(@NotNull JetElement callElement, @NotNull ReceiverValue explicitReceiver,
                                               @Nullable ASTNode callOperationNode, @NotNull JetExpression calleeExpression,
                                               @NotNull List<JetExpression> argumentExpressions, @NotNull CallType callType) {
        List<ValueArgument> arguments = Lists.newArrayList();
@@ -178,31 +178,31 @@ public class CallMaker {
        return makeCall(callElement, explicitReceiver, callOperationNode, calleeExpression, arguments, callType);
    }
-    public static Call makeCall(JetElement callElement, ReceiverDescriptor explicitReceiver, @Nullable ASTNode callOperationNode, JetExpression calleeExpression, List<? extends ValueArgument> arguments) {
+    public static Call makeCall(JetElement callElement, ReceiverValue explicitReceiver, @Nullable ASTNode callOperationNode, JetExpression calleeExpression, List<? extends ValueArgument> arguments) {
        return makeCall(callElement, explicitReceiver, callOperationNode, calleeExpression, arguments, CallType.DEFAULT);
    }
-    public static Call makeCall(JetElement callElement, ReceiverDescriptor explicitReceiver, @Nullable ASTNode callOperationNode,
+    public static Call makeCall(JetElement callElement, ReceiverValue explicitReceiver, @Nullable ASTNode callOperationNode,
            JetExpression calleeExpression, List<? extends ValueArgument> arguments, CallType callType) {
        return new CallImpl(callElement, explicitReceiver, callOperationNode, calleeExpression, arguments, callType);
    }
-    public static Call makeCall(@NotNull ReceiverDescriptor leftAsReceiver, JetBinaryExpression expression) {
+    public static Call makeCall(@NotNull ReceiverValue leftAsReceiver, JetBinaryExpression expression) {
        return makeCallWithExpressions(expression, leftAsReceiver, null, expression.getOperationReference(), Collections.singletonList(expression.getRight()));
    }
-    public static Call makeCall(@NotNull ReceiverDescriptor baseAsReceiver, JetUnaryExpression expression) {
+    public static Call makeCall(@NotNull ReceiverValue baseAsReceiver, JetUnaryExpression expression) {
        return makeCall(expression, baseAsReceiver, null, expression.getOperationReference(), Collections.<ValueArgument>emptyList());
    }
-    public static Call makeArraySetCall(@NotNull ReceiverDescriptor arrayAsReceiver, @NotNull JetArrayAccessExpression arrayAccessExpression,
+    public static Call makeArraySetCall(@NotNull ReceiverValue arrayAsReceiver, @NotNull JetArrayAccessExpression arrayAccessExpression,
            @NotNull JetExpression rightHandSide, @NotNull CallType callType) {
        List<JetExpression> arguments = Lists.newArrayList(arrayAccessExpression.getIndexExpressions());
        arguments.add(rightHandSide);
        return makeCallWithExpressions(arrayAccessExpression, arrayAsReceiver, null, arrayAccessExpression, arguments, callType);
    }
-    public static Call makeArrayGetCall(@NotNull ReceiverDescriptor arrayAsReceiver, @NotNull JetArrayAccessExpression arrayAccessExpression,
+    public static Call makeArrayGetCall(@NotNull ReceiverValue arrayAsReceiver, @NotNull JetArrayAccessExpression arrayAccessExpression,
            @NotNull CallType callType) {
        return makeCallWithExpressions(arrayAccessExpression, arrayAsReceiver, null, arrayAccessExpression, arrayAccessExpression.getIndexExpressions(), callType);
    }
@@ -215,11 +215,11 @@ public class CallMaker {
        return new ExpressionValueArgument(expression, reportErrorsOn);
    }
-    public static Call makePropertyCall(@NotNull ReceiverDescriptor explicitReceiver, @Nullable ASTNode callOperationNode, @NotNull JetSimpleNameExpression nameExpression) {
+    public static Call makePropertyCall(@NotNull ReceiverValue explicitReceiver, @Nullable ASTNode callOperationNode, @NotNull JetSimpleNameExpression nameExpression) {
        return makeCallWithExpressions(nameExpression, explicitReceiver, callOperationNode, nameExpression, Collections.<JetExpression>emptyList());
    }
-    public static Call makeCall(@NotNull final ReceiverDescriptor explicitReceiver, @Nullable final ASTNode callOperationNode, @NotNull final JetCallElement callElement) {
+    public static Call makeCall(@NotNull final ReceiverValue explicitReceiver, @Nullable final ASTNode callOperationNode, @NotNull final JetCallElement callElement) {
        return new Call() {
            @Override
            public ASTNode getCallOperationNode() {
@@ -228,14 +228,14 @@ public class CallMaker {
            @NotNull
            @Override
-            public ReceiverDescriptor getExplicitReceiver() {
+            public ReceiverValue getExplicitReceiver() {
                return explicitReceiver;
            }
            @NotNull
            @Override
-            public ReceiverDescriptor getThisObject() {
+            public ReceiverValue getThisObject() {
-                return ReceiverDescriptor.NO_RECEIVER;
+                return ReceiverValue.NO_RECEIVER;
            }
            @Override
@@ -293,7 +293,7 @@ public class CallMaker {
        };
    }
-    public static Call makeCall(@NotNull JetElement callElement, @NotNull ReceiverDescriptor explicitReceiver) {
+    public static Call makeCall(@NotNull JetElement callElement, @NotNull ReceiverValue explicitReceiver) {
        return new CallImpl(callElement, explicitReceiver, null, null, Collections.<ValueArgument>emptyList());
    }
 }
@@ -21,7 +21,7 @@ import com.intellij.psi.PsiElement;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.psi.*;
-import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue;
 import java.util.List;
@@ -44,13 +44,13 @@ public class DelegatingCall implements Call {
    @Override
    @NotNull
-    public ReceiverDescriptor getExplicitReceiver() {
+    public ReceiverValue getExplicitReceiver() {
        return delegate.getExplicitReceiver();
    }
    @NotNull
    @Override
-    public ReceiverDescriptor getThisObject() {
+    public ReceiverValue getThisObject() {
        return delegate.getThisObject();
    }
@@ -24,7 +24,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.CallableDescriptor;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
 import org.jetbrains.jet.lang.descriptors.ReceiverParameterDescriptor;
-import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue;
 import java.util.Collection;
 import java.util.List;
@@ -36,14 +36,14 @@ import java.util.Set;
 public final class JetScopeUtils {
    private JetScopeUtils() {}
-    public static List<ReceiverDescriptor> getImplicitReceiversHierarchyValues(@NotNull JetScope scope) {
+    public static List<ReceiverValue> getImplicitReceiversHierarchyValues(@NotNull JetScope scope) {
        Collection<ReceiverParameterDescriptor> hierarchy = scope.getImplicitReceiversHierarchy();
        return Lists.newArrayList(
                Collections2.transform(hierarchy,
-                       new Function<ReceiverParameterDescriptor, ReceiverDescriptor>() {
+                       new Function<ReceiverParameterDescriptor, ReceiverValue>() {
                           @Override
-                           public ReceiverDescriptor apply(ReceiverParameterDescriptor receiverParameterDescriptor) {
+                           public ReceiverValue apply(ReceiverParameterDescriptor receiverParameterDescriptor) {
                               return receiverParameterDescriptor.getValue();
                           }
                       })
@@ -22,10 +22,10 @@ import org.jetbrains.jet.lang.types.JetType;
 /**
 * @author abreslav
 */
-public abstract class AbstractReceiverDescriptor implements ReceiverDescriptor {
+public abstract class AbstractReceiverValue implements ReceiverValue {
    protected final JetType receiverType;
-    public AbstractReceiverDescriptor(@NotNull JetType receiverType) {
+    public AbstractReceiverValue(@NotNull JetType receiverType) {
        this.receiverType = receiverType;
    }
@@ -18,13 +18,12 @@ package org.jetbrains.jet.lang.resolve.scopes.receivers;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
 import org.jetbrains.jet.lang.types.JetType;
 /**
 * @author abreslav
 */
-public class ClassReceiver implements ThisReceiverDescriptor {
+public class ClassReceiver implements ThisReceiver {
    private final ClassDescriptor classDescriptor;
@@ -50,7 +49,7 @@ public class ClassReceiver implements ThisReceiverDescriptor {
    }
    @Override
-    public <R, D> R accept(@NotNull ReceiverDescriptorVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull ReceiverValueVisitor<R, D> visitor, D data) {
        return visitor.visitClassReceiver(this, data);
    }
@@ -23,7 +23,7 @@ import org.jetbrains.jet.lang.types.JetType;
 /**
 * @author abreslav
 */
-public class ExpressionReceiver extends AbstractReceiverDescriptor implements ReceiverDescriptor {
+public class ExpressionReceiver extends AbstractReceiverValue implements ReceiverValue {
    private final JetExpression expression;
@@ -38,7 +38,7 @@ public class ExpressionReceiver extends AbstractReceiverDescriptor implements Re
    }
    @Override
-    public <R, D> R accept(@NotNull ReceiverDescriptorVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull ReceiverValueVisitor<R, D> visitor, D data) {
        return visitor.visitExpressionReceiver(this, data);
    }
@@ -24,7 +24,7 @@ import org.jetbrains.jet.lang.types.JetType;
 /**
 * @author abreslav
 */
-public class ExtensionReceiver extends AbstractReceiverDescriptor implements ThisReceiverDescriptor {
+public class ExtensionReceiver extends AbstractReceiverValue implements ThisReceiver {
    private final CallableDescriptor descriptor;
@@ -40,7 +40,7 @@ public class ExtensionReceiver extends AbstractReceiverDescriptor implements Thi
    }
    @Override
-    public <R, D> R accept(@NotNull ReceiverDescriptorVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull ReceiverValueVisitor<R, D> visitor, D data) {
        return visitor.visitExtensionReceiver(this, data);
    }
@@ -22,9 +22,9 @@ import org.jetbrains.jet.lang.types.JetType;
 /**
 * @author abreslav
 */
-public interface ReceiverDescriptor {
+public interface ReceiverValue {
-    ReceiverDescriptor NO_RECEIVER = new ReceiverDescriptor() {
+    ReceiverValue NO_RECEIVER = new ReceiverValue() {
        @NotNull
        @Override
        public JetType getType() {
@@ -37,7 +37,7 @@ public interface ReceiverDescriptor {
        }
        @Override
-        public <R, D> R accept(@NotNull ReceiverDescriptorVisitor<R, D> visitor, D data) {
+        public <R, D> R accept(@NotNull ReceiverValueVisitor<R, D> visitor, D data) {
            return visitor.visitNoReceiver(this, data);
        }
@@ -52,5 +52,5 @@ public interface ReceiverDescriptor {
    boolean exists();
-    <R, D> R accept(@NotNull ReceiverDescriptorVisitor<R, D> visitor, D data);
+    <R, D> R accept(@NotNull ReceiverValueVisitor<R, D> visitor, D data);
 }
@@ -19,8 +19,8 @@ package org.jetbrains.jet.lang.resolve.scopes.receivers;
 /**
 * @author abreslav
 */
-public class ReceiverDescriptorVisitor<R, D> {
+public class ReceiverValueVisitor<R, D> {
-    public R visitNoReceiver(ReceiverDescriptor noReceiver, D data) {
+    public R visitNoReceiver(ReceiverValue noReceiver, D data) {
        return null;
    }
@@ -17,7 +17,6 @@
 package org.jetbrains.jet.lang.resolve.scopes.receivers;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
 import org.jetbrains.jet.lang.descriptors.ScriptDescriptor;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
@@ -25,7 +24,7 @@ import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
 /**
 * @author Stepan Koltsov
 */
-public class ScriptReceiver implements ThisReceiverDescriptor {
+public class ScriptReceiver implements ThisReceiver {
    @NotNull
    private final ScriptDescriptor scriptDescriptor;
@@ -54,7 +53,7 @@ public class ScriptReceiver implements ThisReceiverDescriptor {
    }
    @Override
-    public <R, D> R accept(@NotNull ReceiverDescriptorVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull ReceiverValueVisitor<R, D> visitor, D data) {
        return visitor.visitScriptReceiver(this, data);
    }
 }
@@ -24,7 +24,7 @@ import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
 *
 * @author abreslav
 */
-public interface ThisReceiverDescriptor extends ReceiverDescriptor {
+public interface ThisReceiver extends ReceiverValue {
    @NotNull
    DeclarationDescriptor getDeclarationDescriptor();
 }
@@ -25,13 +25,13 @@ import org.jetbrains.jet.lang.types.JetType;
 *
 * @author abreslav
 */
-public class TransientReceiver extends AbstractReceiverDescriptor {
+public class TransientReceiver extends AbstractReceiverValue {
    public TransientReceiver(@NotNull JetType type) {
        super(type);
    }
    @Override
-    public <R, D> R accept(@NotNull ReceiverDescriptorVisitor<R, D> visitor, D data) {
+    public <R, D> R accept(@NotNull ReceiverValueVisitor<R, D> visitor, D data) {
        return visitor.visitTransientReceiver(this, data);
    }
@@ -19,9 +19,7 @@ package org.jetbrains.jet.lang.types.expressions;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Multimap;
 import com.intellij.lang.ASTNode;
 import com.intellij.openapi.util.Pair;
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.impl.source.tree.LeafPsiElement;
 import com.intellij.psi.tree.IElementType;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -44,18 +42,17 @@ import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl;
 import org.jetbrains.jet.lang.resolve.scopes.receivers.ExpressionReceiver;
-import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue;
 import org.jetbrains.jet.lang.types.*;
 import org.jetbrains.jet.lang.types.checker.JetTypeChecker;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
 import org.jetbrains.jet.lexer.JetTokens;
 import org.jetbrains.jet.util.slicedmap.WritableSlice;
 import java.util.*;
 import static org.jetbrains.jet.lang.diagnostics.Errors.*;
 import static org.jetbrains.jet.lang.resolve.BindingContext.*;
-import static org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor.NO_RECEIVER;
+import static org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue.NO_RECEIVER;
 import static org.jetbrains.jet.lang.types.TypeUtils.NO_EXPECTED_TYPE;
 import static org.jetbrains.jet.lang.types.expressions.ExpressionTypingUtils.*;
 import static org.jetbrains.jet.lang.types.expressions.OperatorConventions.*;
@@ -618,7 +615,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
    }
    @Nullable
-    private FunctionDescriptor getFunctionDescriptor(@NotNull Call call, @NotNull JetExpression callExpression, @NotNull ReceiverDescriptor receiver,
+    private FunctionDescriptor getFunctionDescriptor(@NotNull Call call, @NotNull JetExpression callExpression, @NotNull ReceiverValue receiver,
            @NotNull ExpressionTypingContext context, @NotNull boolean[] result) {
        OverloadResolutionResults<FunctionDescriptor> results = context.resolveFunctionCall(call);
@@ -635,7 +632,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
    }
    @Nullable
-    private JetType getVariableType(@NotNull JetSimpleNameExpression nameExpression, @NotNull ReceiverDescriptor receiver,
+    private JetType getVariableType(@NotNull JetSimpleNameExpression nameExpression, @NotNull ReceiverValue receiver,
            @Nullable ASTNode callOperationNode, @NotNull ExpressionTypingContext context, @NotNull boolean[] result) {
        TemporaryBindingTrace traceForVariable = TemporaryBindingTrace.create(
@@ -670,7 +667,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
    }
    @NotNull
-    public JetTypeInfo getSelectorReturnTypeInfo(@NotNull ReceiverDescriptor receiver, @Nullable ASTNode callOperationNode, @NotNull JetExpression selectorExpression, @NotNull ExpressionTypingContext context) {
+    public JetTypeInfo getSelectorReturnTypeInfo(@NotNull ReceiverValue receiver, @Nullable ASTNode callOperationNode, @NotNull JetExpression selectorExpression, @NotNull ExpressionTypingContext context) {
        if (selectorExpression instanceof JetCallExpression) {
            return getCallExpressionTypeInfo((JetCallExpression) selectorExpression, receiver, callOperationNode, context);
        }
@@ -695,7 +692,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
    }
    @NotNull
-    private JetTypeInfo getSimpleNameExpressionTypeInfo(@NotNull JetSimpleNameExpression nameExpression, @NotNull ReceiverDescriptor receiver,
+    private JetTypeInfo getSimpleNameExpressionTypeInfo(@NotNull JetSimpleNameExpression nameExpression, @NotNull ReceiverValue receiver,
            @Nullable ASTNode callOperationNode, @NotNull ExpressionTypingContext context) {
        boolean[] result = new boolean[1];
@@ -723,7 +720,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
    }
    @NotNull
-    private JetTypeInfo getCallExpressionTypeInfo(@NotNull JetCallExpression callExpression, @NotNull ReceiverDescriptor receiver,
+    private JetTypeInfo getCallExpressionTypeInfo(@NotNull JetCallExpression callExpression, @NotNull ReceiverValue receiver,
            @Nullable ASTNode callOperationNode, @NotNull ExpressionTypingContext context) {
        boolean[] result = new boolean[1];
@@ -775,11 +772,11 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
        return JetTypeInfo.create(null, context.dataFlowInfo);
    }
-    private static void checkSuper(@NotNull ReceiverDescriptor receiverDescriptor, @NotNull OverloadResolutionResults<? extends CallableDescriptor> results,
+    private static void checkSuper(@NotNull ReceiverValue receiverValue, @NotNull OverloadResolutionResults<? extends CallableDescriptor> results,
            @NotNull BindingTrace trace, @NotNull JetExpression expression) {
        if (!results.isSingleResult()) return;
-        if (!(receiverDescriptor instanceof ExpressionReceiver)) return;
+        if (!(receiverValue instanceof ExpressionReceiver)) return;
-        JetExpression receiver = ((ExpressionReceiver) receiverDescriptor).getExpression();
+        JetExpression receiver = ((ExpressionReceiver) receiverValue).getExpression();
        CallableDescriptor descriptor = results.getResultingDescriptor();
        if (receiver instanceof JetSuperExpression && descriptor instanceof MemberDescriptor) {
            if (((MemberDescriptor) descriptor).getModality() == Modality.ABSTRACT) {
@@ -996,7 +993,8 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
                if (right != null) {
                    ExpressionReceiver receiver = ExpressionTypingUtils.safeGetExpressionReceiver(facade, left, context.replaceScope(context.scope));
-                    final JetReferenceExpression fakeArgument = JetPsiFactory.createSimpleName(context.expressionTypingServices.getProject(), "fakeArgument");
+                    final JetReferenceExpression fakeArgument = JetPsiFactory.createSimpleName(
                            context.expressionTypingServices.getProject(), "fakeArgument");
                    TemporaryBindingTrace traceWithFakeArgumentInfo = TemporaryBindingTrace.create(context.trace, "trace to store fake argument for", name);
                    traceWithFakeArgumentInfo.record(EXPRESSION_TYPE, fakeArgument, KotlinBuiltIns.getInstance().getNullableAnyType());
@@ -32,7 +32,7 @@ import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo;
 import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstantResolver;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
-import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.TypeUtils;
@@ -160,14 +160,14 @@ public class ExpressionTypingContext {
    }
    @NotNull
-    public OverloadResolutionResults<VariableDescriptor> resolveSimpleProperty(@NotNull ReceiverDescriptor receiver, @Nullable ASTNode callOperationNode, @NotNull JetSimpleNameExpression nameExpression) {
+    public OverloadResolutionResults<VariableDescriptor> resolveSimpleProperty(@NotNull ReceiverValue receiver, @Nullable ASTNode callOperationNode, @NotNull JetSimpleNameExpression nameExpression) {
        Call call = CallMaker.makePropertyCall(receiver, callOperationNode, nameExpression);
        return expressionTypingServices.getCallResolver().resolveSimpleProperty(makeResolutionContext(call));
    }
    @Deprecated // Builds wrong resolved calls, should be removed
    @NotNull
-    public OverloadResolutionResults<FunctionDescriptor> resolveExactSignature(@NotNull ReceiverDescriptor receiver, @NotNull Name name, @NotNull List<JetType> parameterTypes) {
+    public OverloadResolutionResults<FunctionDescriptor> resolveExactSignature(@NotNull ReceiverValue receiver, @NotNull Name name, @NotNull List<JetType> parameterTypes) {
        return expressionTypingServices.getCallResolver().resolveExactSignature(scope, receiver, name, parameterTypes);
    }
 }
@@ -22,7 +22,7 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.psi.JetElement;
 import org.jetbrains.jet.lang.psi.JetExpression;
 import org.jetbrains.jet.lang.psi.JetSimpleNameExpression;
-import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue;
 import org.jetbrains.jet.lang.types.JetTypeInfo;
 /**
@@ -31,7 +31,7 @@ import org.jetbrains.jet.lang.types.JetTypeInfo;
 /*package*/ interface ExpressionTypingInternals extends ExpressionTypingFacade {
    @NotNull
-    JetTypeInfo getSelectorReturnTypeInfo(@NotNull ReceiverDescriptor receiver, @Nullable ASTNode callOperationNode, @NotNull JetExpression selectorExpression, @NotNull ExpressionTypingContext context);
+    JetTypeInfo getSelectorReturnTypeInfo(@NotNull ReceiverValue receiver, @Nullable ASTNode callOperationNode, @NotNull JetExpression selectorExpression, @NotNull ExpressionTypingContext context);
    boolean checkInExpression(JetElement callElement, @NotNull JetSimpleNameExpression operationSign, @Nullable JetExpression left, @NotNull JetExpression right, ExpressionTypingContext context);
@@ -42,7 +42,7 @@ import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
 import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl;
 import org.jetbrains.jet.lang.resolve.scopes.receivers.ExpressionReceiver;
-import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue;
 import org.jetbrains.jet.lang.types.*;
 import org.jetbrains.jet.lang.types.checker.JetTypeChecker;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
@@ -190,13 +190,13 @@ public class ExpressionTypingUtils {
                .analyseImportReference(importDirective, scope, new BindingTraceContext(), moduleConfiguration);
        List<CallableDescriptor> callableExtensionDescriptors = new ArrayList<CallableDescriptor>();
-        ReceiverDescriptor receiverDescriptor = new ExpressionReceiver(receiverExpression, receiverType);
+        ReceiverValue receiverValue = new ExpressionReceiver(receiverExpression, receiverType);
        for (DeclarationDescriptor declarationDescriptor : declarationDescriptors) {
            if (declarationDescriptor instanceof CallableDescriptor) {
                CallableDescriptor callableDescriptor = (CallableDescriptor) declarationDescriptor;
-                if (checkIsExtensionCallable(receiverDescriptor, callableDescriptor)) {
+                if (checkIsExtensionCallable(receiverValue, callableDescriptor)) {
                    callableExtensionDescriptors.add(callableDescriptor);
                }
            }
@@ -209,7 +209,7 @@ public class ExpressionTypingUtils {
    * Checks if receiver declaration could be resolved to call expected receiver.
    */
    public static boolean checkIsExtensionCallable (
-            @NotNull ReceiverDescriptor receiverArgument,
+            @NotNull ReceiverValue receiverArgument,
            @NotNull CallableDescriptor callableDescriptor
    ) {
        JetType type = receiverArgument.getType();
@@ -228,7 +228,7 @@ public class ExpressionTypingUtils {
    }
    private static boolean checkReceiverResolution (
-            @NotNull ReceiverDescriptor receiverArgument,
+            @NotNull ReceiverValue receiverArgument,
            @NotNull JetType receiverType,
            @NotNull CallableDescriptor callableDescriptor
    ) {
@@ -273,7 +273,7 @@ public class ExpressionTypingUtils {
    @NotNull
    public static OverloadResolutionResults<FunctionDescriptor> resolveFakeCall(
-            @NotNull ReceiverDescriptor receiver,
+            @NotNull ReceiverValue receiver,
            @NotNull ExpressionTypingContext context,
            @NotNull List<JetExpression> valueArguments,
            @NotNull Name name
@@ -283,7 +283,7 @@ public class ExpressionTypingUtils {
    @NotNull
    public static Pair<Call, OverloadResolutionResults<FunctionDescriptor>> makeAndResolveFakeCall(
-            @NotNull ReceiverDescriptor receiver,
+            @NotNull ReceiverValue receiver,
            @NotNull ExpressionTypingContext context,
            @NotNull List<JetExpression> valueArguments,
            @NotNull Name name
@@ -309,7 +309,7 @@ public class ExpressionTypingUtils {
    public static void defineLocalVariablesFromMultiDeclaration(
            @NotNull WritableScope writableScope,
            @NotNull JetMultiDeclaration multiDeclaration,
-            @NotNull ReceiverDescriptor receiver,
+            @NotNull ReceiverValue receiver,
            @NotNull JetExpression reportErrorsOn,
            @NotNull ExpressionTypingContext context
    ) {
@@ -23,7 +23,7 @@ import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo;
 import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
-import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue;
 import org.jetbrains.jet.lang.types.DeferredType;
 import org.jetbrains.jet.lang.types.ErrorUtils;
 import org.jetbrains.jet.lang.types.JetTypeInfo;
@@ -68,7 +68,7 @@ public class ExpressionTypingVisitorDispatcher extends JetVisitor<JetTypeInfo, E
    }
    @Override
-    public JetTypeInfo getSelectorReturnTypeInfo(@NotNull ReceiverDescriptor receiver, @Nullable ASTNode callOperationNode, @NotNull JetExpression selectorExpression, @NotNull ExpressionTypingContext context) {
+    public JetTypeInfo getSelectorReturnTypeInfo(@NotNull ReceiverValue receiver, @Nullable ASTNode callOperationNode, @NotNull JetExpression selectorExpression, @NotNull ExpressionTypingContext context) {
        return basic.getSelectorReturnTypeInfo(receiver, callOperationNode, selectorExpression, context);
    }
@@ -38,7 +38,7 @@ import org.jetbrains.jet.lang.resolve.calls.results.OverloadResolutionResults;
 import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall;
 import org.jetbrains.jet.lang.resolve.java.PsiClassFinder;
 import org.jetbrains.jet.lang.resolve.name.Name;
-import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.TypeProjection;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
@@ -142,7 +142,7 @@ public class JetResolveTest extends ExtensibleResolveTestCase {
        CallResolver callResolver = new InjectorForTests(getProject()).getCallResolver();
        OverloadResolutionResults<FunctionDescriptor> functions = callResolver.resolveExactSignature(
-                classDescriptor.getMemberScope(typeArguments), ReceiverDescriptor.NO_RECEIVER, Name.identifier(name), parameterTypeList);
+                classDescriptor.getMemberScope(typeArguments), ReceiverValue.NO_RECEIVER, Name.identifier(name), parameterTypeList);
        for (ResolvedCall<? extends FunctionDescriptor> resolvedCall : functions.getResultingCalls()) {
            List<ValueParameterDescriptor> unsubstitutedValueParameters = resolvedCall.getResultingDescriptor().getValueParameters();
            for (int i = 0, unsubstitutedValueParametersSize = unsubstitutedValueParameters.size(); i < unsubstitutedValueParametersSize; i++) {
@@ -45,7 +45,7 @@ import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCallWithTrace;
 import org.jetbrains.jet.lang.resolve.calls.model.ResolvedValueArgument;
 import org.jetbrains.jet.lang.resolve.calls.results.ResolutionDebugInfo;
 import org.jetbrains.jet.lang.resolve.calls.tasks.ResolutionTask;
-import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.plugin.JetFileType;
 import org.jetbrains.jet.plugin.internal.Location;
@@ -273,8 +273,8 @@ public class ResolveToolwindow extends JPanel implements Disposable {
    private static String renderCall(StringBuilder builder, ResolvedCall<? extends CallableDescriptor> resolvedCall) {
        CallableDescriptor resultingDescriptor = resolvedCall.getResultingDescriptor();
-        ReceiverDescriptor receiverArgument = resolvedCall.getReceiverArgument();
+        ReceiverValue receiverArgument = resolvedCall.getReceiverArgument();
-        ReceiverDescriptor thisObject = resolvedCall.getThisObject();
+        ReceiverValue thisObject = resolvedCall.getThisObject();
        Map<TypeParameterDescriptor, JetType> typeArguments = resolvedCall.getTypeArguments();
        Map<ValueParameterDescriptor, ResolvedValueArgument> valueArguments = resolvedCall.getValueArguments();
@@ -344,7 +344,7 @@ public class ResolveToolwindow extends JPanel implements Disposable {
        builder.append(">");
    }
-    private static void renderReceiver(ReceiverDescriptor receiverArgument, ReceiverDescriptor thisObject, StringBuilder builder) {
+    private static void renderReceiver(ReceiverValue receiverArgument, ReceiverValue thisObject, StringBuilder builder) {
        if (receiverArgument.exists()) {
            builder.append("/").append(receiverArgument);
        }
@@ -28,10 +28,9 @@ import org.jetbrains.jet.lang.descriptors.ClassOrNamespaceDescriptor;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
 import org.jetbrains.jet.lang.psi.JetExpression;
 import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall;
-import org.jetbrains.jet.lang.resolve.scopes.receivers.ClassReceiver;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.*;
-import org.jetbrains.jet.lang.resolve.scopes.receivers.ExtensionReceiver;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue;
-import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ThisReceiver;
 import org.jetbrains.jet.lang.resolve.scopes.receivers.ThisReceiverDescriptor;
 import java.util.Map;
@@ -52,7 +51,7 @@ public class AliasingContext {
        @Nullable
        @Override
        public JsExpression get(@NotNull ResolvedCall<?> call) {
-            ReceiverDescriptor callThisObject = call.getThisObject();
+            ReceiverValue callThisObject = call.getThisObject();
            return callThisObject.exists() && (callThisObject instanceof ClassReceiver || callThisObject instanceof ExtensionReceiver)
                   ? JsLiteral.THIS
                   : null;
@@ -116,13 +115,13 @@ public class AliasingContext {
        @Nullable
        @Override
        public JsExpression get(@NotNull ResolvedCall<?> call) {
-            ReceiverDescriptor thisObject = call.getThisObject();
+            ReceiverValue thisObject = call.getThisObject();
            if (!thisObject.exists()) {
                return null;
            }
            if (thisObject instanceof ExtensionReceiver || thisObject instanceof ClassReceiver) {
-                JsNameRef ref = get(((ThisReceiverDescriptor) thisObject).getDeclarationDescriptor());
+                JsNameRef ref = get(((ThisReceiver) thisObject).getDeclarationDescriptor());
                if (ref != null) {
                    return ref;
                }
@@ -26,7 +26,7 @@ import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.scopes.receivers.ClassReceiver;
 import org.jetbrains.jet.lang.resolve.scopes.receivers.ExtensionReceiver;
-import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.expressions.OperatorConventions;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
@@ -100,7 +100,7 @@ public final class JsDescriptorUtils {
    @NotNull
    public static DeclarationDescriptor getDeclarationDescriptorForReceiver
-            (@NotNull ReceiverDescriptor receiverParameter) {
+            (@NotNull ReceiverValue receiverParameter) {
        DeclarationDescriptor declarationDescriptor =
                receiverParameter.getType().getConstructor().getDeclarationDescriptor();
        //TODO: WHY assert?
@@ -185,7 +185,7 @@ public final class JsDescriptorUtils {
    public static DeclarationDescriptor getDeclarationDescriptorForExtensionCallReceiver(
            @NotNull ResolvedCall<? extends CallableDescriptor> resolvedCall
    ) {
-        ReceiverDescriptor receiverArgument = resolvedCall.getReceiverArgument();
+        ReceiverValue receiverArgument = resolvedCall.getReceiverArgument();
        if (receiverArgument instanceof ExtensionReceiver) {
            return ((ExtensionReceiver) receiverArgument).getDeclarationDescriptor();
        }