Simplify and fix createReflectionTypeForCallableDescriptor

Previously its call sites needed to determine if the receiver type should be
ignored (e.g. if the reference is to static member or nested class constructor,
or if it's a bound reference), and 3 of 4 callers did it incorrectly. Simplify
this by passing the DoubleColonLHS instance everywhere.

Also rename it to createKCallableTypeForReference

 #KT-12738 Fixed
 #KT-12751 Fixed
 #KT-12799 Fixed

compiler/frontend/src/org/jetbrains/kotlin/resolve/callableReferences/CallableReferencesResolutionUtils.kt

@@ -22,7 +22,6 @@ import org.jetbrains.kotlin.descriptors.annotations.Annotations
 import org.jetbrains.kotlin.diagnostics.Errors.CALLABLE_REFERENCE_LHS_NOT_A_CLASS
 import org.jetbrains.kotlin.psi.KtCallableReferenceExpression
 import org.jetbrains.kotlin.psi.KtSimpleNameExpression
-import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.calls.CallResolver
 import org.jetbrains.kotlin.resolve.calls.callResolverUtil.ResolveArgumentsMode
 import org.jetbrains.kotlin.resolve.calls.context.BasicCallResolutionContext
@@ -151,24 +150,15 @@ fun resolvePossiblyAmbiguousCallableReference(
     return null
 }
 
-fun createReflectionTypeForCallableDescriptor(
+fun createKCallableTypeForReference(
         descriptor: CallableDescriptor,
-        lhsType: KotlinType?,
+        lhs: DoubleColonLHS?,
         reflectionTypes: ReflectionTypes,
-        ignoreReceiver: Boolean,
         scopeOwnerDescriptor: DeclarationDescriptor
 ): KotlinType? {
-    val extensionReceiver = descriptor.extensionReceiverParameter
-    val dispatchReceiver = descriptor.dispatchReceiverParameter?.let { dispatchReceiver ->
-        // See CallableDescriptor#getOwnerForEffectiveDispatchReceiverParameter
-        if ((descriptor as? CallableMemberDescriptor)?.kind == CallableMemberDescriptor.Kind.FAKE_OVERRIDE)
-            DescriptorUtils.getDispatchReceiverParameterIfNeeded(descriptor.containingDeclaration)
-        else dispatchReceiver
-    }
-
     val receiverType =
-            if ((extensionReceiver != null || dispatchReceiver != null) && !ignoreReceiver)
-                lhsType ?: extensionReceiver?.type ?: dispatchReceiver?.type
+            if (descriptor.extensionReceiverParameter != null || descriptor.dispatchReceiverParameter != null)
+                (lhs as? DoubleColonLHS.Type)?.type
             else null
 
     return when (descriptor) {

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

@@ -261,9 +261,8 @@ public class ArgumentTypeResolver {
                     OverloadResolutionResultsUtil.getResultingCall(overloadResolutionResults, context.contextDependency);
             if (resolvedCall == null) return null;
 
-            return CallableReferencesResolutionUtilsKt.createReflectionTypeForCallableDescriptor(
-                    resolvedCall.getResultingDescriptor(), lhs != null ? lhs.getType() : null, reflectionTypes,
-                    callableReferenceExpression.isEmptyLHS(), context.scope.getOwnerDescriptor()
+            return CallableReferencesResolutionUtilsKt.createKCallableTypeForReference(
+                    resolvedCall.getResultingDescriptor(), lhs, reflectionTypes, context.scope.getOwnerDescriptor()
             );
         }
 

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

@@ -27,7 +27,7 @@ import org.jetbrains.kotlin.diagnostics.Errors.*
 import org.jetbrains.kotlin.progress.ProgressIndicatorAndCompilationCanceledStatus
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.resolve.*
-import org.jetbrains.kotlin.resolve.callableReferences.createReflectionTypeForCallableDescriptor
+import org.jetbrains.kotlin.resolve.callableReferences.createKCallableTypeForReference
 import org.jetbrains.kotlin.resolve.calls.CallTransformer.CallForImplicitInvoke
 import org.jetbrains.kotlin.resolve.calls.callResolverUtil.ResolveArgumentsMode
 import org.jetbrains.kotlin.resolve.calls.callResolverUtil.ResolveArgumentsMode.SHAPE_FUNCTION_ARGUMENTS
@@ -158,12 +158,14 @@ class CandidateResolver(
     private fun <D : CallableDescriptor> CallCandidateResolutionContext<D>.checkExpectedCallableType()
             = check {
                 if (!noExpectedType(expectedType)) {
-                    val callableReferenceExpression = call.callElement.parent as? KtCallableReferenceExpression
-                    val candidateReflectionType = createReflectionTypeForCallableDescriptor(
-                            candidateCall.candidateDescriptor, null, reflectionTypes,
-                            callableReferenceExpression?.isEmptyLHS == true, scope.ownerDescriptor
+                    val candidateKCallableType = createKCallableTypeForReference(
+                            candidateCall.candidateDescriptor,
+                            (call.callElement.parent as? KtCallableReferenceExpression)?.receiverExpression?.let {
+                                trace.bindingContext.get(BindingContext.DOUBLE_COLON_LHS, it)
+                            },
+                            reflectionTypes, scope.ownerDescriptor
                     )
-                    if (candidateReflectionType == null || !KotlinTypeChecker.DEFAULT.isSubtypeOf(candidateReflectionType, expectedType)) {
+                    if (candidateKCallableType == null || !KotlinTypeChecker.DEFAULT.isSubtypeOf(candidateKCallableType, expectedType)) {
                         candidateCall.addStatus(OTHER_ERROR)
                     }
                 }

compiler/frontend/src/org/jetbrains/kotlin/types/expressions/DoubleColonExpressionResolver.kt

@@ -30,7 +30,7 @@ import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.codeFragmentUtil.suppressDiagnosticsInDebugMode
 import org.jetbrains.kotlin.psi.psiUtil.getQualifiedElementSelector
 import org.jetbrains.kotlin.resolve.*
-import org.jetbrains.kotlin.resolve.callableReferences.createReflectionTypeForCallableDescriptor
+import org.jetbrains.kotlin.resolve.callableReferences.createKCallableTypeForReference
 import org.jetbrains.kotlin.resolve.callableReferences.resolvePossiblyAmbiguousCallableReference
 import org.jetbrains.kotlin.resolve.calls.CallResolver
 import org.jetbrains.kotlin.resolve.calls.callResolverUtil.ResolveArgumentsMode
@@ -286,10 +286,7 @@ class DoubleColonExpressionResolver(
 
         checkReferenceIsToAllowedMember(descriptor, context.trace, expression)
 
-        val ignoreReceiver = lhs is DoubleColonLHS.Expression || expression.isEmptyLHS
-        val type = createReflectionTypeForCallableDescriptor(
-                descriptor, lhs?.type, reflectionTypes, ignoreReceiver, context.scope.ownerDescriptor
-        ) ?: return null
+        val type = createKCallableTypeForReference(descriptor, lhs, reflectionTypes, context.scope.ownerDescriptor) ?: return null
 
         when (descriptor) {
             is FunctionDescriptor -> bindFunctionReference(expression, type, context)