Minor. introduce method ExpressionReceiver.create and replace almost all usages of constructor ExpressionReceiver.

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

@@ -145,7 +145,7 @@ public class DelegatedPropertyResolver {
 
         KtPsiFactory psiFactory = KtPsiFactory(delegateExpression);
         List<KtExpression> arguments = Collections.singletonList(createExpressionForProperty(psiFactory));
-        ExpressionReceiver receiver = new ExpressionReceiver(delegateExpression, delegateType);
+        ExpressionReceiver receiver = ExpressionReceiver.create(delegateExpression, delegateType, trace.getBindingContext());
 
         Pair<Call, OverloadResolutionResults<FunctionDescriptor>> resolutionResult =
                 fakeCallResolver.makeAndResolveFakeCallInContext(receiver, context, arguments, PROPERTY_DELEGATED_FUNCTION_NAME, delegateExpression);
@@ -261,7 +261,7 @@ public class DelegatedPropertyResolver {
         }
 
         Name functionName = isGet ? GETTER_NAME : SETTER_NAME;
-        ExpressionReceiver receiver = new ExpressionReceiver(delegateExpression, delegateType);
+        ExpressionReceiver receiver = ExpressionReceiver.create(delegateExpression, delegateType, trace.getBindingContext());
 
         Pair<Call, OverloadResolutionResults<FunctionDescriptor>> resolutionResult =
                 fakeCallResolver.makeAndResolveFakeCallInContext(receiver, context, arguments, functionName, delegateExpression);

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallExpressionResolver.java

@@ -348,7 +348,9 @@ public class CallExpressionResolver {
             }
             QualifierReceiver qualifierReceiver = (QualifierReceiver) context.trace.get(BindingContext.QUALIFIER, element.getReceiver());
 
-            ReceiverValue receiver = qualifierReceiver == null ? new ExpressionReceiver(element.getReceiver(), receiverType) : qualifierReceiver;
+            ReceiverValue receiver = qualifierReceiver == null ?
+                                     ExpressionReceiver.create(element.getReceiver(), receiverType, context.trace.getBindingContext()) :
+                                     qualifierReceiver;
 
             boolean lastStage = element.getQualified() == expression;
             assert lastStage == (element == elementChain.getLast());

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolver.java

@@ -315,7 +315,7 @@ public class CallResolver {
         }
         KotlinType calleeType = expressionTypingServices.safeGetType(
                 context.scope, calleeExpression, expectedType, context.dataFlowInfo, context.trace);
-        ExpressionReceiver expressionReceiver = new ExpressionReceiver(calleeExpression, calleeType);
+        ExpressionReceiver expressionReceiver = ExpressionReceiver.create(calleeExpression, calleeType, context.trace.getBindingContext());
 
         Call call = new CallTransformer.CallForImplicitInvoke(context.call.getExplicitReceiver(), expressionReceiver, context.call);
         TracingStrategyForInvoke tracingForInvoke = new TracingStrategyForInvoke(calleeExpression, call, calleeType);

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallTransformer.java

@@ -235,7 +235,8 @@ public class CallTransformer<D extends CallableDescriptor, F extends D> {
             KtExpression calleeExpression = task.call.getCalleeExpression();
             if (calleeExpression == null) return Collections.emptyList();
 
-            ExpressionReceiver variableReceiver = new ExpressionReceiver(calleeExpression, variableResolvedCall.getResultingDescriptor().getType());
+            ExpressionReceiver variableReceiver = ExpressionReceiver.create(
+                    calleeExpression, variableResolvedCall.getResultingDescriptor().getType(), context.trace.getBindingContext());
             Call functionCall = new CallForImplicitInvoke(context.explicitExtensionReceiverForInvoke, variableReceiver, task.call);
 
             DelegatingBindingTrace variableCallTrace = context.candidateCall.getTrace();

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CandidateResolver.kt

@@ -364,7 +364,7 @@ public class CandidateResolver(
             expectedType: KotlinType,
             actualType: KotlinType,
             context: ResolutionContext<*>): KotlinType? {
-        val receiverToCast = ExpressionReceiver(KtPsiUtil.safeDeparenthesize(expression), actualType)
+        val receiverToCast = ExpressionReceiver.create(KtPsiUtil.safeDeparenthesize(expression), actualType, context.trace.bindingContext)
         val variants = smartCastManager.getSmartCastVariantsExcludingReceiver(context, receiverToCast)
         for (possibleType in variants) {
             if (KotlinTypeChecker.DEFAULT.isSubtypeOf(possibleType, expectedType)) {

compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/receivers/ExpressionReceiver.java

@@ -18,10 +18,19 @@ package org.jetbrains.kotlin.resolve.scopes.receivers;
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.psi.KtExpression;
+import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.types.KotlinType;
 
 public class ExpressionReceiver extends AbstractReceiverValue implements ReceiverValue {
 
+    public static ExpressionReceiver create(
+            @NotNull KtExpression expression,
+            @NotNull KotlinType type,
+            @NotNull BindingContext bindingContext
+    ) {
+        return new ExpressionReceiver(expression, type);
+    }
+
     private final KtExpression expression;
 
     public ExpressionReceiver(@NotNull KtExpression expression, @NotNull KotlinType type) {

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

@@ -760,7 +760,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
         // Type check the base expression
         KotlinTypeInfo typeInfo = facade.safeGetTypeInfo(baseExpression, context);
         KotlinType type = ExpressionTypingUtils.safeGetType(typeInfo);
-        ExpressionReceiver receiver = new ExpressionReceiver(baseExpression, type);
+        ExpressionReceiver receiver = ExpressionReceiver.create(baseExpression, type, context.trace.getBindingContext());
 
         Call call = CallMaker.makeCall(receiver, expression);
 
@@ -1495,7 +1495,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
         KotlinType arrayType = ExpressionTypingUtils.safeGetType(arrayTypeInfo);
 
         ExpressionTypingContext context = oldContext.replaceDataFlowInfo(arrayTypeInfo.getDataFlowInfo());
-        ExpressionReceiver receiver = new ExpressionReceiver(arrayExpression, arrayType);
+        ExpressionReceiver receiver = ExpressionReceiver.create(arrayExpression, arrayType, context.trace.getBindingContext());
         if (!isGet) assert rightHandSide != null;
 
         Call call = isGet

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

@@ -71,19 +71,15 @@ public class ExpressionTypingUtils {
         return receiverValue;
     }
 
-    @Nullable
-    public static ExpressionReceiver getExpressionReceiver(@NotNull KtExpression expression, @Nullable KotlinType type) {
-        if (type == null) return null;
-        return new ExpressionReceiver(expression, type);
-    }
-
     @Nullable
     public static ExpressionReceiver getExpressionReceiver(
             @NotNull ExpressionTypingFacade facade,
             @NotNull KtExpression expression,
             ExpressionTypingContext context
     ) {
-        return getExpressionReceiver(expression, facade.getTypeInfo(expression, context).getType());
+        KotlinType type = facade.getTypeInfo(expression, context).getType();
+        if (type == null) return null;
+        return ExpressionReceiver.create(expression, type, context.trace.getBindingContext());
     }
 
     @NotNull
@@ -93,7 +89,7 @@ public class ExpressionTypingUtils {
             ExpressionTypingContext context
     ) {
         KotlinType type = safeGetType(facade.safeGetTypeInfo(expression, context));
-        return new ExpressionReceiver(expression, type);
+        return ExpressionReceiver.create(expression, type, context.trace.getBindingContext());
     }
 
     @NotNull

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

@@ -250,7 +250,7 @@ public class ExpressionTypingVisitorForStatements extends ExpressionTypingVisito
             temporary.commit();
             return rightInfo.clearType();
         }
-        ExpressionReceiver receiver = new ExpressionReceiver(left, leftType);
+        ExpressionReceiver receiver = ExpressionReceiver.create(left, leftType, context.trace.getBindingContext());
 
         // We check that defined only one of '+=' and '+' operations, and call it (in the case '+' we then also assign)
         // Check for '+='