Converted CallResolverUtil to kotlin

2015-07-01 22:08:27 +03:00
parent 517c2b3520
commit a714de783f
17 changed files with 176 additions and 217 deletions
@@ -17,7 +17,6 @@
 package org.jetbrains.kotlin.backend.common;

 import com.intellij.openapi.editor.Document;
-import com.intellij.openapi.util.TextRange;
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.PsiFile;
 import org.jetbrains.annotations.NotNull;
@@ -29,7 +28,7 @@ import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
-import org.jetbrains.kotlin.resolve.calls.CallResolverUtil;
+import org.jetbrains.kotlin.resolve.calls.callResolverUtil.CallResolverUtilPackage;
 import org.jetbrains.kotlin.resolve.calls.callUtil.CallUtilPackage;
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
 import org.jetbrains.kotlin.types.JetType;
@@ -62,7 +61,7 @@ public class CodegenUtil {
    ) {
        Collection<FunctionDescriptor> functions = owner.getDefaultType().getMemberScope().getFunctions(name);
        for (FunctionDescriptor function : functions) {
-            if (!CallResolverUtil.isOrOverridesSynthesized(function)
+            if (!CallResolverUtilPackage.isOrOverridesSynthesized(function)
                && function.getTypeParameters().isEmpty()
                && valueParameterClassesMatch(function.getValueParameters(), Arrays.asList(valueParameterClassifiers))
                && rawTypeMatches(function.getReturnType(), returnedClassifier)) {
@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.OverrideResolver
-import org.jetbrains.kotlin.resolve.calls.CallResolverUtil
+import org.jetbrains.kotlin.resolve.calls.callResolverUtil.isOrOverridesSynthesized

 public fun <Signature> generateBridgesForFunctionDescriptor(
        descriptor: FunctionDescriptor,
@@ -69,7 +69,7 @@ private data class DescriptorBasedFunctionHandle(val descriptor: FunctionDescrip
 */
 public fun findTraitImplementation(descriptor: CallableMemberDescriptor): CallableMemberDescriptor? {
    if (descriptor.getKind().isReal()) return null
-    if (CallResolverUtil.isOrOverridesSynthesized(descriptor)) return null
+    if (isOrOverridesSynthesized(descriptor)) return null

    val implementation = findImplementationFromInterface(descriptor) ?: return null
    val immediateConcreteSuper = firstSuperMethodFromKotlin(descriptor, implementation) ?: return null
@@ -60,7 +60,7 @@ import org.jetbrains.kotlin.resolve.BindingContextUtils;
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
 import org.jetbrains.kotlin.resolve.annotations.AnnotationsPackage;
-import org.jetbrains.kotlin.resolve.calls.CallResolverUtil;
+import org.jetbrains.kotlin.resolve.calls.callResolverUtil.CallResolverUtilPackage;
 import org.jetbrains.kotlin.resolve.calls.model.*;
 import org.jetbrains.kotlin.resolve.calls.util.CallMaker;
 import org.jetbrains.kotlin.resolve.calls.util.FakeCallableDescriptorForObject;
@@ -2330,7 +2330,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
    @NotNull
    public StackValue invokeFunction(@NotNull Call call, @NotNull ResolvedCall<?> resolvedCall, @NotNull StackValue receiver) {
        FunctionDescriptor fd = accessibleFunctionDescriptor(resolvedCall);
-        JetSuperExpression superCallExpression = CallResolverUtil.getSuperCallExpression(call);
+        JetSuperExpression superCallExpression = CallResolverUtilPackage.getSuperCallExpression(call);
        boolean superCall = superCallExpression != null;

        if (superCall && !isInterface(fd.getContainingDeclaration())) {
@@ -42,7 +42,7 @@ import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
 import org.jetbrains.kotlin.resolve.annotations.AnnotationsPackage;
-import org.jetbrains.kotlin.resolve.calls.CallResolverUtil;
+import org.jetbrains.kotlin.resolve.calls.callResolverUtil.CallResolverUtilPackage;
 import org.jetbrains.kotlin.resolve.constants.ArrayValue;
 import org.jetbrains.kotlin.resolve.constants.CompileTimeConstant;
 import org.jetbrains.kotlin.resolve.constants.KClassValue;
@@ -502,7 +502,7 @@ public class FunctionCodegen {
        if (isMethodOfAny(descriptor)) return;

        // If the function doesn't have a physical declaration among super-functions, it's a SAM adapter or alike and doesn't need bridges
-        if (CallResolverUtil.isOrOverridesSynthesized(descriptor)) return;
+        if (CallResolverUtilPackage.isOrOverridesSynthesized(descriptor)) return;

        Set<Bridge<Method>> bridgesToGenerate = BridgesPackage.generateBridgesForFunctionDescriptor(
                descriptor,
@@ -49,7 +49,7 @@ import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
 import org.jetbrains.kotlin.resolve.annotations.AnnotationsPackage;
-import org.jetbrains.kotlin.resolve.calls.CallResolverUtil;
+import org.jetbrains.kotlin.resolve.calls.callResolverUtil.CallResolverUtilPackage;
 import org.jetbrains.kotlin.resolve.calls.callUtil.CallUtilPackage;
 import org.jetbrains.kotlin.resolve.calls.model.DefaultValueArgument;
 import org.jetbrains.kotlin.resolve.calls.model.ExpressionValueArgument;
@@ -403,7 +403,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
    private boolean isGenericToArrayPresent() {
        Collection<FunctionDescriptor> functions = descriptor.getDefaultType().getMemberScope().getFunctions(Name.identifier("toArray"));
        for (FunctionDescriptor function : functions) {
-            if (CallResolverUtil.isOrOverridesSynthesized(function)) {
+            if (CallResolverUtilPackage.isOrOverridesSynthesized(function)) {
                continue;
            }

@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.descriptors.ClassifierDescriptor
 import org.jetbrains.kotlin.load.java.descriptors.JavaClassDescriptor
 import org.jetbrains.kotlin.psi.JetExpression
 import org.jetbrains.kotlin.resolve.DescriptorUtils
-import org.jetbrains.kotlin.resolve.calls.CallResolverUtil
+import org.jetbrains.kotlin.resolve.calls.callResolverUtil.getSuperCallExpression
 import org.jetbrains.kotlin.resolve.calls.checkers.CallChecker
 import org.jetbrains.kotlin.resolve.calls.context.BasicCallResolutionContext
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
@@ -31,8 +31,7 @@ import org.jetbrains.kotlin.resolve.jvm.diagnostics.ErrorsJvm
 public class TraitDefaultMethodCallChecker : CallChecker {

    override fun <F : CallableDescriptor> check(resolvedCall: ResolvedCall<F>, context: BasicCallResolutionContext) {
-        val jetSuperExpression = CallResolverUtil.getSuperCallExpression(resolvedCall.getCall())
-        if (jetSuperExpression == null) return
+        if (getSuperCallExpression(resolvedCall.getCall()) == null) return

        val targetDescriptor = resolvedCall.getResultingDescriptor().getOriginal()
        val containerDescriptor = targetDescriptor.getContainingDeclaration()
@@ -35,7 +35,7 @@ import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.kotlin.lexer.JetTokens;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.psi.*;
-import org.jetbrains.kotlin.resolve.calls.CallResolverUtil;
+import org.jetbrains.kotlin.resolve.calls.callResolverUtil.CallResolverUtilPackage;
 import org.jetbrains.kotlin.resolve.dataClassUtils.DataClassUtilsPackage;
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue;
 import org.jetbrains.kotlin.types.*;
@@ -361,7 +361,7 @@ public class OverrideResolver {
            @NotNull List<CallableMemberDescriptor> concreteOverridden
    ) {
        for (CallableMemberDescriptor overridden : allOverriddenDeclarations) {
-            if (!CallResolverUtil.isOrOverridesSynthesized(overridden)) {
+            if (!CallResolverUtilPackage.isOrOverridesSynthesized(overridden)) {
                if (overridden.getModality() == Modality.ABSTRACT) {
                    abstractOverridden.add(overridden);
                }
@@ -24,6 +24,7 @@ import org.jetbrains.kotlin.descriptors.annotations.Annotations;
 import org.jetbrains.kotlin.diagnostics.Errors;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.resolve.*;
+import org.jetbrains.kotlin.resolve.calls.callResolverUtil.ResolveArgumentsMode;
 import org.jetbrains.kotlin.resolve.calls.callUtil.CallUtilPackage;
 import org.jetbrains.kotlin.resolve.calls.context.CallResolutionContext;
 import org.jetbrains.kotlin.resolve.calls.context.CheckValueArgumentsMode;
@@ -50,9 +51,8 @@ import java.util.Collections;
 import java.util.List;

 import static org.jetbrains.kotlin.resolve.BindingContextUtils.getRecordedTypeInfo;
-import static org.jetbrains.kotlin.resolve.calls.CallResolverUtil.ResolveArgumentsMode;
-import static org.jetbrains.kotlin.resolve.calls.CallResolverUtil.ResolveArgumentsMode.RESOLVE_FUNCTION_ARGUMENTS;
-import static org.jetbrains.kotlin.resolve.calls.CallResolverUtil.ResolveArgumentsMode.SHAPE_FUNCTION_ARGUMENTS;
+import static org.jetbrains.kotlin.resolve.calls.callResolverUtil.ResolveArgumentsMode.RESOLVE_FUNCTION_ARGUMENTS;
+import static org.jetbrains.kotlin.resolve.calls.callResolverUtil.ResolveArgumentsMode.SHAPE_FUNCTION_ARGUMENTS;
 import static org.jetbrains.kotlin.resolve.calls.context.ContextDependency.DEPENDENT;
 import static org.jetbrains.kotlin.resolve.calls.context.ContextDependency.INDEPENDENT;
 import static org.jetbrains.kotlin.resolve.calls.inference.InferencePackage.createTypeForFunctionPlaceholder;
@@ -23,13 +23,12 @@ import org.jetbrains.kotlin.resolve.BindingContext.CONSTRAINT_SYSTEM_COMPLETER
 import org.jetbrains.kotlin.resolve.BindingContextUtils
 import org.jetbrains.kotlin.resolve.BindingTrace
 import org.jetbrains.kotlin.resolve.TemporaryBindingTrace
-import org.jetbrains.kotlin.resolve.calls.CallResolverUtil.ResolveArgumentsMode.RESOLVE_FUNCTION_ARGUMENTS
-import org.jetbrains.kotlin.resolve.calls.CallResolverUtil.getEffectiveExpectedType
-import org.jetbrains.kotlin.resolve.calls.callUtil.getCall
+import org.jetbrains.kotlin.resolve.calls.callResolverUtil.ResolveArgumentsMode.RESOLVE_FUNCTION_ARGUMENTS
+import org.jetbrains.kotlin.resolve.calls.callResolverUtil.getEffectiveExpectedType
+import org.jetbrains.kotlin.resolve.calls.callResolverUtil.isInvokeCallOnVariable
 import org.jetbrains.kotlin.resolve.calls.context.BasicCallResolutionContext
 import org.jetbrains.kotlin.resolve.calls.context.CallCandidateResolutionContext
 import org.jetbrains.kotlin.resolve.calls.context.CheckValueArgumentsMode
-import org.jetbrains.kotlin.resolve.calls.inference.ConstraintSystem
 import org.jetbrains.kotlin.resolve.calls.inference.ConstraintSystemImpl
 import org.jetbrains.kotlin.resolve.calls.inference.InferenceErrorData
 import org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.ConstraintPositionKind.*
@@ -38,14 +37,11 @@ import org.jetbrains.kotlin.resolve.calls.results.OverloadResolutionResultsImpl
 import org.jetbrains.kotlin.resolve.calls.results.ResolutionStatus
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo
 import org.jetbrains.kotlin.resolve.calls.tasks.TracingStrategy
+import org.jetbrains.kotlin.types.ErrorUtils
 import org.jetbrains.kotlin.types.JetType
 import org.jetbrains.kotlin.types.TypeUtils
 import org.jetbrains.kotlin.types.expressions.DataFlowUtils
-import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils
 import java.util.ArrayList
-import org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.ConstraintPositionKind.*
-import org.jetbrains.kotlin.resolve.calls.model.*
-import org.jetbrains.kotlin.types.ErrorUtils

 public class CallCompleter(
        val argumentTypeResolver: ArgumentTypeResolver,
@@ -61,7 +57,7 @@ public class CallCompleter(

        // for the case 'foo(a)' where 'foo' is a variable, the call 'foo.invoke(a)' shouldn't be completed separately,
        // it's completed when the outer (variable as function call) is completed
-        if (!CallResolverUtil.isInvokeCallOnVariable(context.call)) {
+        if (!isInvokeCallOnVariable(context.call)) {

            val temporaryTrace = TemporaryBindingTrace.create(context.trace, "Trace to complete a resulting call")

@@ -27,6 +27,7 @@ import org.jetbrains.kotlin.lexer.JetTokens;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.resolve.*;
+import org.jetbrains.kotlin.resolve.calls.callResolverUtil.CallResolverUtilPackage;
 import org.jetbrains.kotlin.resolve.calls.callUtil.CallUtilPackage;
 import org.jetbrains.kotlin.resolve.calls.checkers.CallChecker;
 import org.jetbrains.kotlin.resolve.calls.context.*;
@@ -59,8 +60,8 @@ import java.util.List;

 import static org.jetbrains.kotlin.diagnostics.Errors.*;
 import static org.jetbrains.kotlin.resolve.bindingContextUtil.BindingContextUtilPackage.recordScopeAndDataFlowInfo;
-import static org.jetbrains.kotlin.resolve.calls.CallResolverUtil.ResolveArgumentsMode.RESOLVE_FUNCTION_ARGUMENTS;
-import static org.jetbrains.kotlin.resolve.calls.CallResolverUtil.ResolveArgumentsMode.SHAPE_FUNCTION_ARGUMENTS;
+import static org.jetbrains.kotlin.resolve.calls.callResolverUtil.ResolveArgumentsMode.RESOLVE_FUNCTION_ARGUMENTS;
+import static org.jetbrains.kotlin.resolve.calls.callResolverUtil.ResolveArgumentsMode.SHAPE_FUNCTION_ARGUMENTS;
 import static org.jetbrains.kotlin.resolve.calls.results.OverloadResolutionResults.Code.CANDIDATES_WITH_WRONG_RECEIVER;
 import static org.jetbrains.kotlin.resolve.calls.results.OverloadResolutionResults.Code.INCOMPLETE_TYPE_INFERENCE;
 import static org.jetbrains.kotlin.types.TypeUtils.NO_EXPECTED_TYPE;
@@ -465,7 +466,7 @@ public class CallResolver {
            @NotNull OverloadResolutionResultsImpl<D> results,
            @NotNull TracingStrategy tracing
    ) {
-        if (CallResolverUtil.isInvokeCallOnVariable(context.call)) return;
+        if (CallResolverUtilPackage.isInvokeCallOnVariable(context.call)) return;
        if (!results.isSingleResult()) {
            if (results.getResultCode() == INCOMPLETE_TYPE_INFERENCE) {
                argumentTypeResolver.checkTypesWithNoCallee(context, RESOLVE_FUNCTION_ARGUMENTS);
@@ -485,7 +486,7 @@ public class CallResolver {
            @NotNull TracingStrategy tracing
    ) {
        Call call = context.call;
-        if (CallResolverUtil.isInvokeCallOnVariable(call)) return;
+        if (CallResolverUtilPackage.isInvokeCallOnVariable(call)) return;

        DelegatingBindingTrace deltasTraceToCacheResolve = new DelegatingBindingTrace(
                BindingContext.EMPTY, "delta trace for caching resolve of", context.call);
@@ -14,170 +14,134 @@
 * limitations under the License.
 */

-package org.jetbrains.kotlin.resolve.calls;
+package org.jetbrains.kotlin.resolve.calls.callResolverUtil

-import com.google.common.collect.Lists;
-import com.intellij.util.SmartList;
-import com.intellij.util.containers.ContainerUtil;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
-import org.jetbrains.kotlin.descriptors.*;
-import org.jetbrains.kotlin.psi.*;
-import org.jetbrains.kotlin.resolve.calls.inference.ConstraintSystem;
-import org.jetbrains.kotlin.resolve.scopes.receivers.ExpressionReceiver;
-import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue;
-import org.jetbrains.kotlin.types.*;
+import com.google.common.collect.Lists
+import com.intellij.util.containers.ContainerUtil
+import org.jetbrains.kotlin.builtins.KotlinBuiltIns
+import org.jetbrains.kotlin.descriptors.CallableDescriptor
+import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
+import org.jetbrains.kotlin.descriptors.ReceiverParameterDescriptor
+import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
+import org.jetbrains.kotlin.psi.Call
+import org.jetbrains.kotlin.psi.JetSimpleNameExpression
+import org.jetbrains.kotlin.psi.JetSuperExpression
+import org.jetbrains.kotlin.psi.ValueArgument
+import org.jetbrains.kotlin.resolve.calls.inference.ConstraintSystem
+import org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.ConstraintPositionKind.EXPECTED_TYPE_POSITION
+import org.jetbrains.kotlin.resolve.scopes.receivers.ExpressionReceiver
+import org.jetbrains.kotlin.types.*
+import org.jetbrains.kotlin.types.TypeUtils.DONT_CARE

-import java.util.Collections;
-import java.util.List;
-
-import static org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.ConstraintPositionKind.EXPECTED_TYPE_POSITION;
-import static org.jetbrains.kotlin.types.TypeUtils.DONT_CARE;
-
-public class CallResolverUtil {
-    public static enum ResolveArgumentsMode {
-        RESOLVE_FUNCTION_ARGUMENTS,
-        SHAPE_FUNCTION_ARGUMENTS
-    }
-
-    private CallResolverUtil() {}
+public enum class ResolveArgumentsMode {
+    RESOLVE_FUNCTION_ARGUMENTS,
+    SHAPE_FUNCTION_ARGUMENTS
+}


-    public static boolean hasUnknownFunctionParameter(@NotNull JetType type) {
-        assert KotlinBuiltIns.isFunctionOrExtensionFunctionType(type);
-        List<TypeProjection> arguments = type.getArguments();
-        // last argument is return type of function type
-        List<TypeProjection> functionParameters = arguments.subList(0, arguments.size() - 1);
-        for (TypeProjection functionParameter : functionParameters) {
-            if (TypeUtils.containsSpecialType(functionParameter.getType(), DONT_CARE)
-                || ErrorUtils.containsUninferredParameter(functionParameter.getType())) {
-                return true;
-            }
-        }
-        return false;
-    }
-
-    public static boolean hasUnknownReturnType(@NotNull JetType type) {
-        assert KotlinBuiltIns.isFunctionOrExtensionFunctionType(type);
-        JetType returnTypeFromFunctionType = KotlinBuiltIns.getReturnTypeFromFunctionType(type);
-        return ErrorUtils.containsErrorType(returnTypeFromFunctionType);
-    }
-
-    public static JetType replaceReturnTypeByUnknown(@NotNull JetType type) {
-        assert KotlinBuiltIns.isFunctionOrExtensionFunctionType(type);
-        List<TypeProjection> arguments = type.getArguments();
-        List<TypeProjection> newArguments = Lists.newArrayList();
-        newArguments.addAll(arguments.subList(0, arguments.size() - 1));
-        newArguments.add(new TypeProjectionImpl(Variance.INVARIANT, DONT_CARE));
-        return new JetTypeImpl(type.getAnnotations(), type.getConstructor(), type.isMarkedNullable(), newArguments, type.getMemberScope());
-    }
-
-    private static boolean hasReturnTypeDependentOnUninferredParams(
-            @NotNull CallableDescriptor candidateDescriptor,
-            @NotNull ConstraintSystem constraintSystem
-    ) {
-        JetType returnType = candidateDescriptor.getReturnType();
-        if (returnType == null) return false;
-
-        for (TypeParameterDescriptor typeVariable : constraintSystem.getTypeVariables()) {
-            JetType inferredValueForTypeVariable = constraintSystem.getTypeBounds(typeVariable).getValue();
-            if (inferredValueForTypeVariable == null) {
-                if (TypeUtils.dependsOnTypeParameters(returnType, Collections.singleton(typeVariable))) {
-                    return true;
-                }
-            }
-        }
-        return false;
-    }
-
-    public static boolean hasInferredReturnType(
-            @NotNull CallableDescriptor candidateDescriptor,
-            @NotNull ConstraintSystem constraintSystem
-    ) {
-        if (hasReturnTypeDependentOnUninferredParams(candidateDescriptor, constraintSystem)) return false;
-
-        // Expected type mismatch was reported before as 'TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH'
-        if (constraintSystem.getStatus().hasOnlyErrorsFromPosition(EXPECTED_TYPE_POSITION.position())) return false;
-        return true;
-    }
-
-    @NotNull
-    public static JetType getErasedReceiverType(
-            @NotNull ReceiverParameterDescriptor receiverParameterDescriptor,
-            @NotNull CallableDescriptor descriptor
-    ) {
-        JetType receiverType = receiverParameterDescriptor.getType();
-        for (TypeParameterDescriptor typeParameter : descriptor.getTypeParameters()) {
-            if (typeParameter.getTypeConstructor().equals(receiverType.getConstructor())) {
-                receiverType = typeParameter.getUpperBoundsAsType();
-            }
-        }
-        List<TypeProjection> fakeTypeArguments = ContainerUtil.newSmartList();
-        for (TypeProjection typeProjection : receiverType.getArguments()) {
-            fakeTypeArguments.add(new TypeProjectionImpl(typeProjection.getProjectionKind(), DONT_CARE));
-        }
-        return new JetTypeImpl(
-                receiverType.getAnnotations(), receiverType.getConstructor(), receiverType.isMarkedNullable(),
-                fakeTypeArguments, ErrorUtils.createErrorScope("Error scope for erased receiver type", /*throwExceptions=*/true));
-    }
-
-    public static boolean isOrOverridesSynthesized(@NotNull CallableMemberDescriptor descriptor) {
-        if (descriptor.getKind() == CallableMemberDescriptor.Kind.SYNTHESIZED) {
-            return true;
-        }
-        if (descriptor.getKind() == CallableMemberDescriptor.Kind.FAKE_OVERRIDE) {
-            for (CallableMemberDescriptor overridden : descriptor.getOverriddenDescriptors()) {
-                if (!isOrOverridesSynthesized(overridden)) {
-                    return false;
-                }
-            }
-            return true;
-        }
-        return false;
-    }
-
-    public static boolean isInvokeCallOnVariable(@NotNull Call call) {
-        if (call.getCallType() != Call.CallType.INVOKE) return false;
-        ReceiverValue dispatchReceiver = call.getDispatchReceiver();
-        //calleeExpressionAsDispatchReceiver for invoke is always ExpressionReceiver, see CallForImplicitInvoke
-        JetExpression expression = ((ExpressionReceiver) dispatchReceiver).getExpression();
-        return expression instanceof JetSimpleNameExpression;
-    }
-
-    public static boolean isInvokeCallOnExpressionWithBothReceivers(@NotNull Call call) {
-        if (call.getCallType() != Call.CallType.INVOKE || isInvokeCallOnVariable(call)) return false;
-        return call.getExplicitReceiver().exists() && call.getDispatchReceiver().exists();
-    }
-
-    public static JetSuperExpression getSuperCallExpression(@NotNull Call call) {
-        ReceiverValue explicitReceiver = call.getExplicitReceiver();
-        if (explicitReceiver instanceof ExpressionReceiver) {
-            JetExpression receiverExpression = ((ExpressionReceiver) explicitReceiver).getExpression();
-            if (receiverExpression instanceof JetSuperExpression) {
-                return (JetSuperExpression) receiverExpression;
-            }
-        }
-        return null;
-    }
-
-    @NotNull
-    public static JetType getEffectiveExpectedType(@NotNull ValueParameterDescriptor parameterDescriptor, @NotNull ValueArgument argument) {
-        if (argument.getSpreadElement() != null) {
-            if (parameterDescriptor.getVarargElementType() == null) {
-                // Spread argument passed to a non-vararg parameter, an error is already reported by ValueArgumentsToParametersMapper
-                return DONT_CARE;
-            }
-            else {
-                return parameterDescriptor.getType();
-            }
-        }
-        else {
-            JetType varargElementType = parameterDescriptor.getVarargElementType();
-            if (varargElementType != null) {
-                return varargElementType;
-            }
-
-            return parameterDescriptor.getType();
-        }
+public fun hasUnknownFunctionParameter(type: JetType): Boolean {
+    assert(KotlinBuiltIns.isFunctionOrExtensionFunctionType(type))
+    val arguments = type.getArguments()
+    // last argument is return type of function type
+    val functionParameters = arguments.subList(0, arguments.size() - 1)
+    return functionParameters.any {
+        TypeUtils.containsSpecialType(it.getType(), DONT_CARE) || ErrorUtils.containsUninferredParameter(it.getType())
    }
 }
+
+public fun hasUnknownReturnType(type: JetType): Boolean {
+    assert(KotlinBuiltIns.isFunctionOrExtensionFunctionType(type))
+    val returnTypeFromFunctionType = KotlinBuiltIns.getReturnTypeFromFunctionType(type)
+    return ErrorUtils.containsErrorType(returnTypeFromFunctionType)
+}
+
+public fun replaceReturnTypeByUnknown(type: JetType): JetType {
+    assert(KotlinBuiltIns.isFunctionOrExtensionFunctionType(type))
+    val arguments = type.getArguments()
+    val newArguments = Lists.newArrayList<TypeProjection>()
+    newArguments.addAll(arguments.subList(0, arguments.size() - 1))
+    newArguments.add(TypeProjectionImpl(Variance.INVARIANT, DONT_CARE))
+    return JetTypeImpl(type.getAnnotations(), type.getConstructor(), type.isMarkedNullable(), newArguments, type.getMemberScope())
+}
+
+private fun hasReturnTypeDependentOnUninferredParams(candidateDescriptor: CallableDescriptor, constraintSystem: ConstraintSystem): Boolean {
+    val returnType = candidateDescriptor.getReturnType() ?: return false
+
+    for (typeVariable in constraintSystem.getTypeVariables()) {
+        val inferredValueForTypeVariable = constraintSystem.getTypeBounds(typeVariable).value
+        if (inferredValueForTypeVariable == null) {
+            if (TypeUtils.dependsOnTypeParameters(returnType, setOf(typeVariable))) {
+                return true
+            }
+        }
+    }
+    return false
+}
+
+public fun hasInferredReturnType(candidateDescriptor: CallableDescriptor, constraintSystem: ConstraintSystem): Boolean {
+    if (hasReturnTypeDependentOnUninferredParams(candidateDescriptor, constraintSystem)) return false
+
+    // Expected type mismatch was reported before as 'TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH'
+    if (constraintSystem.getStatus().hasOnlyErrorsFromPosition(EXPECTED_TYPE_POSITION.position())) return false
+    return true
+}
+
+public fun getErasedReceiverType(receiverParameterDescriptor: ReceiverParameterDescriptor, descriptor: CallableDescriptor): JetType {
+    var receiverType = receiverParameterDescriptor.getType()
+    for (typeParameter in descriptor.getTypeParameters()) {
+        if (typeParameter.getTypeConstructor() == receiverType.getConstructor()) {
+            receiverType = typeParameter.getUpperBoundsAsType()
+        }
+    }
+    val fakeTypeArguments = ContainerUtil.newSmartList<TypeProjection>()
+    for (typeProjection in receiverType.getArguments()) {
+        fakeTypeArguments.add(TypeProjectionImpl(typeProjection.getProjectionKind(), DONT_CARE))
+    }
+    return JetTypeImpl(receiverType.getAnnotations(), receiverType.getConstructor(), receiverType.isMarkedNullable(), fakeTypeArguments,
+                       ErrorUtils.createErrorScope("Error scope for erased receiver type", /*throwExceptions=*/true))
+}
+
+public fun isOrOverridesSynthesized(descriptor: CallableMemberDescriptor): Boolean {
+    if (descriptor.getKind() == CallableMemberDescriptor.Kind.SYNTHESIZED) {
+        return true
+    }
+    if (descriptor.getKind() == CallableMemberDescriptor.Kind.FAKE_OVERRIDE) {
+        return descriptor.getOverriddenDescriptors().all {
+            isOrOverridesSynthesized(it)
+        }
+    }
+    return false
+}
+
+public fun isInvokeCallOnVariable(call: Call): Boolean {
+    if (call.getCallType() !== Call.CallType.INVOKE) return false
+    val dispatchReceiver = call.getDispatchReceiver()
+    //calleeExpressionAsDispatchReceiver for invoke is always ExpressionReceiver, see CallForImplicitInvoke
+    val expression = (dispatchReceiver as ExpressionReceiver).getExpression()
+    return expression is JetSimpleNameExpression
+}
+
+public fun isInvokeCallOnExpressionWithBothReceivers(call: Call): Boolean {
+    if (call.getCallType() !== Call.CallType.INVOKE || isInvokeCallOnVariable(call)) return false
+    return call.getExplicitReceiver().exists() && call.getDispatchReceiver().exists()
+}
+
+public fun getSuperCallExpression(call: Call): JetSuperExpression? {
+    return (call.getExplicitReceiver() as? ExpressionReceiver)?.getExpression() as? JetSuperExpression
+}
+
+public fun getEffectiveExpectedType(parameterDescriptor: ValueParameterDescriptor, argument: ValueArgument): JetType {
+    if (argument.getSpreadElement() != null) {
+        if (parameterDescriptor.getVarargElementType() == null) {
+            // Spread argument passed to a non-vararg parameter, an error is already reported by ValueArgumentsToParametersMapper
+            return DONT_CARE
+        }
+        return parameterDescriptor.getType()
+    }
+    val varargElementType = parameterDescriptor.getVarargElementType()
+    if (varargElementType != null) {
+        return varargElementType
+    }
+
+    return parameterDescriptor.getType()
+}
@@ -18,7 +18,6 @@ package org.jetbrains.kotlin.resolve.calls;

 import com.google.common.collect.Lists;
 import com.google.common.collect.Sets;
-import kotlin.jvm.functions.Function1;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
@@ -26,6 +25,8 @@ import org.jetbrains.kotlin.progress.ProgressIndicatorAndCompilationCanceledStat
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.resolve.*;
+import org.jetbrains.kotlin.resolve.calls.callResolverUtil.CallResolverUtilPackage;
+import org.jetbrains.kotlin.resolve.calls.callResolverUtil.ResolveArgumentsMode;
 import org.jetbrains.kotlin.resolve.calls.callUtil.CallUtilPackage;
 import org.jetbrains.kotlin.resolve.calls.context.CallCandidateResolutionContext;
 import org.jetbrains.kotlin.resolve.calls.context.CallResolutionContext;
@@ -55,9 +56,9 @@ import java.util.Map;

 import static org.jetbrains.kotlin.diagnostics.Errors.PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT;
 import static org.jetbrains.kotlin.diagnostics.Errors.SUPER_CANT_BE_EXTENSION_RECEIVER;
-import static org.jetbrains.kotlin.resolve.calls.CallResolverUtil.ResolveArgumentsMode.SHAPE_FUNCTION_ARGUMENTS;
-import static org.jetbrains.kotlin.resolve.calls.CallResolverUtil.getEffectiveExpectedType;
 import static org.jetbrains.kotlin.resolve.calls.CallTransformer.CallForImplicitInvoke;
+import static org.jetbrains.kotlin.resolve.calls.callResolverUtil.CallResolverUtilPackage.getEffectiveExpectedType;
+import static org.jetbrains.kotlin.resolve.calls.callResolverUtil.ResolveArgumentsMode.SHAPE_FUNCTION_ARGUMENTS;
 import static org.jetbrains.kotlin.resolve.calls.results.ResolutionStatus.*;
 import static org.jetbrains.kotlin.types.TypeUtils.noExpectedType;

@@ -295,7 +296,7 @@ public class CandidateResolver {
    @NotNull
    private <D extends CallableDescriptor> ValueArgumentsCheckingResult checkAllValueArguments(
            @NotNull CallCandidateResolutionContext<D> context,
-            @NotNull CallResolverUtil.ResolveArgumentsMode resolveFunctionArgumentBodies) {
+            @NotNull ResolveArgumentsMode resolveFunctionArgumentBodies) {
        return checkAllValueArguments(context, context.candidateCall.getTrace(), resolveFunctionArgumentBodies);
    }

@@ -303,7 +304,7 @@ public class CandidateResolver {
    public <D extends CallableDescriptor> ValueArgumentsCheckingResult checkAllValueArguments(
            @NotNull CallCandidateResolutionContext<D> context,
            @NotNull BindingTrace trace,
-            @NotNull CallResolverUtil.ResolveArgumentsMode resolveFunctionArgumentBodies
+            @NotNull ResolveArgumentsMode resolveFunctionArgumentBodies
    ) {
        ValueArgumentsCheckingResult checkingResult = checkValueArgumentTypes(
                context, context.candidateCall, trace, resolveFunctionArgumentBodies);
@@ -346,7 +347,7 @@ public class CandidateResolver {
            @NotNull CallResolutionContext<C> context,
            @NotNull MutableResolvedCall<D> candidateCall,
            @NotNull BindingTrace trace,
-            @NotNull CallResolverUtil.ResolveArgumentsMode resolveFunctionArgumentBodies) {
+            @NotNull ResolveArgumentsMode resolveFunctionArgumentBodies) {
        ResolutionStatus resultStatus = SUCCESS;
        List<JetType> argumentTypes = Lists.newArrayList();
        MutableDataFlowInfoForArguments infoForArguments = candidateCall.getDataFlowInfoForArguments();
@@ -423,7 +424,7 @@ public class CandidateResolver {
        ResolutionStatus status = SUCCESS;
        // For the expressions like '42.(f)()' where f: String.() -> Unit we'd like to generate a type mismatch error on '1',
        // not to throw away the candidate, so the following check is skipped.
-        if (!CallResolverUtil.isInvokeCallOnExpressionWithBothReceivers(context.call)) {
+        if (!CallResolverUtilPackage.isInvokeCallOnExpressionWithBothReceivers(context.call)) {
            status = status.combine(checkReceiverTypeError(context, extensionReceiver, candidateCall.getExtensionReceiver()));
        }
        status = status.combine(checkReceiverTypeError(context, dispatchReceiver, candidateCall.getDispatchReceiver()));
@@ -439,7 +440,7 @@ public class CandidateResolver {

        D candidateDescriptor = context.candidateCall.getCandidateDescriptor();

-        JetType erasedReceiverType = CallResolverUtil.getErasedReceiverType(receiverParameterDescriptor, candidateDescriptor);
+        JetType erasedReceiverType = CallResolverUtilPackage.getErasedReceiverType(receiverParameterDescriptor, candidateDescriptor);

        boolean isSubtypeBySmartCast = SmartCastUtils.isSubTypeBySmartCastIgnoringNullability(receiverArgument, erasedReceiverType, context);
        if (!isSubtypeBySmartCast) {
@@ -16,19 +16,17 @@

 package org.jetbrains.kotlin.resolve.calls

-import com.google.common.collect.Maps
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.descriptors.CallableDescriptor
-import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
 import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
 import org.jetbrains.kotlin.psi.JetExpression
 import org.jetbrains.kotlin.psi.JetPsiUtil
 import org.jetbrains.kotlin.psi.ValueArgument
 import org.jetbrains.kotlin.resolve.FunctionDescriptorUtil
 import org.jetbrains.kotlin.resolve.calls.ArgumentTypeResolver.getLastElementDeparenthesized
-import org.jetbrains.kotlin.resolve.calls.CallResolverUtil.ResolveArgumentsMode.RESOLVE_FUNCTION_ARGUMENTS
-import org.jetbrains.kotlin.resolve.calls.CallResolverUtil.ResolveArgumentsMode.SHAPE_FUNCTION_ARGUMENTS
-import org.jetbrains.kotlin.resolve.calls.CallResolverUtil.getEffectiveExpectedType
+import org.jetbrains.kotlin.resolve.calls.callResolverUtil.*
+import org.jetbrains.kotlin.resolve.calls.callResolverUtil.ResolveArgumentsMode.RESOLVE_FUNCTION_ARGUMENTS
+import org.jetbrains.kotlin.resolve.calls.callResolverUtil.ResolveArgumentsMode.SHAPE_FUNCTION_ARGUMENTS
 import org.jetbrains.kotlin.resolve.calls.callUtil.getCall
 import org.jetbrains.kotlin.resolve.calls.context.CallCandidateResolutionContext
 import org.jetbrains.kotlin.resolve.calls.context.ContextDependency.INDEPENDENT
@@ -130,7 +128,7 @@ class GenericCandidateResolver(
            substitutor: TypeSubstitutor,
            constraintSystem: ConstraintSystem,
            context: CallCandidateResolutionContext<*>,
-            resolveFunctionArgumentBodies: CallResolverUtil.ResolveArgumentsMode
+            resolveFunctionArgumentBodies: ResolveArgumentsMode
    ) {

        val effectiveExpectedType = getEffectiveExpectedType(valueParameterDescriptor, valueArgument)
@@ -239,14 +237,14 @@ class GenericCandidateResolver(
            expectedType = argumentTypeResolver.getShapeTypeOfFunctionLiteral(functionLiteral, context.scope, context.trace, false)
        }
        if (expectedType == null || !KotlinBuiltIns.isFunctionOrExtensionFunctionType(expectedType)
-            || CallResolverUtil.hasUnknownFunctionParameter(expectedType)) {
+            || hasUnknownFunctionParameter(expectedType)) {
            return
        }
        val dataFlowInfoForArguments = context.candidateCall.getDataFlowInfoForArguments()
        val dataFlowInfoForArgument = dataFlowInfoForArguments.getInfo(valueArgument)

        //todo analyze function literal body once in 'dependent' mode, then complete it with respect to expected type
-        val hasExpectedReturnType = !CallResolverUtil.hasUnknownReturnType(expectedType)
+        val hasExpectedReturnType = !hasUnknownReturnType(expectedType)
        val position = VALUE_PARAMETER_POSITION.position(valueParameterDescriptor.getIndex())
        if (hasExpectedReturnType) {
            val temporaryToResolveFunctionLiteral = TemporaryTraceAndCache.create(
@@ -267,7 +265,7 @@ class GenericCandidateResolver(
                return
            }
        }
-        val expectedTypeWithoutReturnType = if (hasExpectedReturnType) CallResolverUtil.replaceReturnTypeByUnknown(expectedType) else expectedType
+        val expectedTypeWithoutReturnType = if (hasExpectedReturnType) replaceReturnTypeByUnknown(expectedType) else expectedType
        val newContext = context.replaceExpectedType(expectedTypeWithoutReturnType).replaceDataFlowInfo(dataFlowInfoForArgument)
                .replaceContextDependency(INDEPENDENT)
        val type = argumentTypeResolver.getFunctionLiteralTypeInfo(argumentExpression, functionLiteral, newContext, RESOLVE_FUNCTION_ARGUMENTS).type
@@ -26,7 +26,7 @@ import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor;
 import org.jetbrains.kotlin.psi.Call;
 import org.jetbrains.kotlin.psi.ValueArgument;
 import org.jetbrains.kotlin.resolve.DelegatingBindingTrace;
-import org.jetbrains.kotlin.resolve.calls.CallResolverUtil;
+import org.jetbrains.kotlin.resolve.calls.callResolverUtil.CallResolverUtilPackage;
 import org.jetbrains.kotlin.resolve.calls.callUtil.CallUtilPackage;
 import org.jetbrains.kotlin.resolve.calls.inference.ConstraintSystem;
 import org.jetbrains.kotlin.resolve.calls.results.ResolutionStatus;
@@ -300,7 +300,8 @@ public class ResolvedCallImpl<D extends CallableDescriptor> implements MutableRe
    @Override
    public boolean hasInferredReturnType() {
        if (!completed) {
-            hasInferredReturnType = constraintSystem == null || CallResolverUtil.hasInferredReturnType(candidateDescriptor, constraintSystem);
+            hasInferredReturnType = constraintSystem == null ||
+                                    CallResolverUtilPackage.hasInferredReturnType(candidateDescriptor, constraintSystem);
        }
        assert hasInferredReturnType != null : "The property 'hasInferredReturnType' was not set when the call was completed.";
        return hasInferredReturnType;
@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.Call
 import org.jetbrains.kotlin.resolve.DescriptorUtils
-import org.jetbrains.kotlin.resolve.calls.CallResolverUtil.isOrOverridesSynthesized
+import org.jetbrains.kotlin.resolve.calls.callResolverUtil.isOrOverridesSynthesized
 import org.jetbrains.kotlin.resolve.calls.context.BasicCallResolutionContext
 import org.jetbrains.kotlin.resolve.calls.smartcasts.SmartCastUtils
 import org.jetbrains.kotlin.resolve.calls.tasks.ExplicitReceiverKind.BOTH_RECEIVERS
@@ -25,7 +25,7 @@ import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
 import org.jetbrains.kotlin.idea.core.codeInsight.OverrideImplementMethodsHandler;
 import org.jetbrains.kotlin.resolve.OverrideResolver;
 import org.jetbrains.kotlin.resolve.OverridingUtil;
-import org.jetbrains.kotlin.resolve.calls.CallResolverUtil;
+import org.jetbrains.kotlin.resolve.calls.callResolverUtil.CallResolverUtilPackage;
 import org.jetbrains.kotlin.types.JetType;

 import java.util.HashSet;
@@ -49,7 +49,7 @@ public class OverrideMethodsHandler extends OverrideImplementMethodsHandler {
        Set<CallableMemberDescriptor> result = new HashSet<CallableMemberDescriptor>();
        for (CallableMemberDescriptor superMethod : superMethods) {
            if (superMethod.getModality().isOverridable()) {
-                if (!CallResolverUtil.isOrOverridesSynthesized(superMethod)) {
+                if (!CallResolverUtilPackage.isOrOverridesSynthesized(superMethod)) {
                    result.add(superMethod);
                }
            }
@@ -25,7 +25,7 @@ import org.jetbrains.kotlin.js.translate.general.Translation
 import org.jetbrains.kotlin.js.translate.reference.CallArgumentTranslator
 import org.jetbrains.kotlin.js.translate.utils.AnnotationsUtils
 import org.jetbrains.kotlin.psi.Call.CallType
-import org.jetbrains.kotlin.resolve.calls.CallResolverUtil
+import org.jetbrains.kotlin.resolve.calls.callResolverUtil.isInvokeCallOnVariable
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
 import org.jetbrains.kotlin.resolve.calls.model.VariableAsFunctionResolvedCall
 import org.jetbrains.kotlin.resolve.calls.tasks.ExplicitReceiverKind
@@ -102,7 +102,7 @@ private fun translateCall(context: TranslationContext,
    }

    val call = resolvedCall.getCall()
-    if (call.getCallType() == CallType.INVOKE && !CallResolverUtil.isInvokeCallOnVariable(call)) {
+    if (call.getCallType() == CallType.INVOKE && !isInvokeCallOnVariable(call)) {
        val explicitReceiversForInvoke = computeExplicitReceiversForInvoke(context, resolvedCall, explicitReceivers)
        return translateFunctionCall(context, resolvedCall, explicitReceiversForInvoke)
    }