Converted CallResolverUtil to kotlin

compiler/backend-common/src/org/jetbrains/kotlin/backend/common/CodegenUtil.java

@@ -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)) {

compiler/backend-common/src/org/jetbrains/kotlin/backend/common/bridges/impl.kt

@@ -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

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

@@ -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())) {

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

@@ -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,

compiler/backend/src/org/jetbrains/kotlin/codegen/ImplementationBodyCodegen.java

@@ -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;
             }
 

compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/calls/checkers/TraitDefaultMethodCallChecker.kt

@@ -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 (getSuperCallExpression(resolvedCall.getCall()) == null) return
-        if (jetSuperExpression == null) return
 
         val targetDescriptor = resolvedCall.getResultingDescriptor().getOriginal()
         val containerDescriptor = targetDescriptor.getContainingDeclaration()

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

@@ -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);
                 }

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

@@ -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.RESOLVE_FUNCTION_ARGUMENTS;
+import static org.jetbrains.kotlin.resolve.calls.callResolverUtil.ResolveArgumentsMode.SHAPE_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;

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

@@ -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.ResolveArgumentsMode.RESOLVE_FUNCTION_ARGUMENTS
-import org.jetbrains.kotlin.resolve.calls.CallResolverUtil.getEffectiveExpectedType
+import org.jetbrains.kotlin.resolve.calls.callResolverUtil.getEffectiveExpectedType
-import org.jetbrains.kotlin.resolve.calls.callUtil.getCall
+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")
 

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

@@ -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.RESOLVE_FUNCTION_ARGUMENTS;
-import static org.jetbrains.kotlin.resolve.calls.CallResolverUtil.ResolveArgumentsMode.SHAPE_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);

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

@@ -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.google.common.collect.Lists
-import com.intellij.util.SmartList;
+import com.intellij.util.containers.ContainerUtil
-import com.intellij.util.containers.ContainerUtil;
+import org.jetbrains.kotlin.builtins.KotlinBuiltIns
-import org.jetbrains.annotations.NotNull;
+import org.jetbrains.kotlin.descriptors.CallableDescriptor
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
+import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
-import org.jetbrains.kotlin.descriptors.*;
+import org.jetbrains.kotlin.descriptors.ReceiverParameterDescriptor
-import org.jetbrains.kotlin.psi.*;
+import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
-import org.jetbrains.kotlin.resolve.calls.inference.ConstraintSystem;
+import org.jetbrains.kotlin.psi.Call
-import org.jetbrains.kotlin.resolve.scopes.receivers.ExpressionReceiver;
+import org.jetbrains.kotlin.psi.JetSimpleNameExpression
-import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue;
+import org.jetbrains.kotlin.psi.JetSuperExpression
-import org.jetbrains.kotlin.types.*;
+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;
+public enum class ResolveArgumentsMode {
-import java.util.List;
+    RESOLVE_FUNCTION_ARGUMENTS,
-
+    SHAPE_FUNCTION_ARGUMENTS
-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 static boolean hasUnknownFunctionParameter(@NotNull JetType type) {
+public fun hasUnknownFunctionParameter(type: JetType): Boolean {
-        assert KotlinBuiltIns.isFunctionOrExtensionFunctionType(type);
+    assert(KotlinBuiltIns.isFunctionOrExtensionFunctionType(type))
-        List<TypeProjection> arguments = type.getArguments();
+    val arguments = type.getArguments()
-        // last argument is return type of function type
+    // last argument is return type of function type
-        List<TypeProjection> functionParameters = arguments.subList(0, arguments.size() - 1);
+    val functionParameters = arguments.subList(0, arguments.size() - 1)
-        for (TypeProjection functionParameter : functionParameters) {
+    return functionParameters.any {
-            if (TypeUtils.containsSpecialType(functionParameter.getType(), DONT_CARE)
+        TypeUtils.containsSpecialType(it.getType(), DONT_CARE) || ErrorUtils.containsUninferredParameter(it.getType())
-                || 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 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()
+}

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

@@ -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) {

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

@@ -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.*
-import org.jetbrains.kotlin.resolve.calls.CallResolverUtil.ResolveArgumentsMode.SHAPE_FUNCTION_ARGUMENTS
+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.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

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

@@ -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;

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/TaskPrioritizer.kt

@@ -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

idea/src/org/jetbrains/kotlin/idea/codeInsight/OverrideMethodsHandler.java

@@ -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);
                 }
             }

js/js.translator/src/org/jetbrains/kotlin/js/translate/callTranslator/CallTranslator.kt

@@ -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)
     }