Add CheckValueArgumentsMode to call resolver

Now it's ENABLED everywhere. DISABLED will be used for resolving callable reference expressions, since there won't be any arguments near the function call to check #KT-1183 In Progress
2013-04-17 15:41:10 +04:00
parent 1d07068c7c
commit 1db026aac5
10 changed files with 105 additions and 52 deletions
@@ -192,11 +192,12 @@ public class CallExpressionResolver {
    private ResolvedCallWithTrace<FunctionDescriptor> getResolvedCallForFunction(
            @NotNull Call call, @NotNull JetExpression callExpression,
            @NotNull ResolutionContext context, @NotNull ResolveMode resolveMode,
-            @NotNull ResolutionResultsCache resolutionResultsCache, @NotNull boolean[] result
+            @NotNull CheckValueArgumentsMode checkArguments, @NotNull ResolutionResultsCache resolutionResultsCache,
+            @NotNull boolean[] result
    ) {
        CallResolver callResolver = expressionTypingServices.getCallResolver();
        OverloadResolutionResultsImpl<FunctionDescriptor> results = callResolver.resolveFunctionCall(
-                BasicCallResolutionContext.create(context, call, resolveMode, resolutionResultsCache));
+                BasicCallResolutionContext.create(context, call, resolveMode, checkArguments, resolutionResultsCache));
        if (!results.isNothing()) {
            checkSuper(call.getExplicitReceiver(), results, context.trace, callExpression);
            result[0] = true;
@@ -220,7 +221,7 @@ public class CallExpressionResolver {
        Call call = CallMaker.makePropertyCall(receiver, callOperationNode, nameExpression);
        OverloadResolutionResults<VariableDescriptor> resolutionResult = callResolver.resolveSimpleProperty(
                BasicCallResolutionContext.create(context.replaceBindingTrace(traceForVariable), call, ResolveMode.TOP_LEVEL_CALL,
-                                                  ResolutionResultsCache.create()));
+                                                  CheckValueArgumentsMode.ENABLED, ResolutionResultsCache.create()));
        if (!resolutionResult.isNothing()) {
            traceForVariable.commit();
            checkSuper(receiver, resolutionResult, context.trace, nameExpression);
@@ -268,7 +269,8 @@ public class CallExpressionResolver {
        Call call = CallMaker.makeCall(nameExpression, receiver, callOperationNode, nameExpression, Collections.<ValueArgument>emptyList());
        TemporaryBindingTrace traceForFunction = TemporaryBindingTrace.create(context.trace, "trace to resolve as function", nameExpression);
        ResolvedCall<FunctionDescriptor> resolvedCall = getResolvedCallForFunction(
-                call, nameExpression, context, ResolveMode.TOP_LEVEL_CALL, ResolutionResultsCache.create(), result);
+                call, nameExpression, context, ResolveMode.TOP_LEVEL_CALL, CheckValueArgumentsMode.ENABLED,
+                ResolutionResultsCache.create(), result);
        if (result[0]) {
            FunctionDescriptor functionDescriptor = resolvedCall != null ? resolvedCall.getResultingDescriptor() : null;
            traceForFunction.commit();
@@ -307,7 +309,8 @@ public class CallExpressionResolver {

        TemporaryBindingTrace traceForFunction = TemporaryBindingTrace.create(context.trace, "trace to resolve as function call", callExpression);
        ResolvedCallWithTrace<FunctionDescriptor> resolvedCall = getResolvedCallForFunction(
-                call, callExpression, context.replaceBindingTrace(traceForFunction), resolveMode, resolutionResultsCache, result);
+                call, callExpression, context.replaceBindingTrace(traceForFunction), resolveMode, CheckValueArgumentsMode.ENABLED,
+                resolutionResultsCache, result);
        if (result[0]) {
            FunctionDescriptor functionDescriptor = resolvedCall != null ? resolvedCall.getResultingDescriptor() : null;
            traceForFunction.commit();
@@ -29,7 +29,10 @@ import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo;
 import org.jetbrains.jet.lang.resolve.calls.context.*;
 import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCallImpl;
 import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCallWithTrace;
-import org.jetbrains.jet.lang.resolve.calls.results.*;
+import org.jetbrains.jet.lang.resolve.calls.results.OverloadResolutionResults;
+import org.jetbrains.jet.lang.resolve.calls.results.OverloadResolutionResultsImpl;
+import org.jetbrains.jet.lang.resolve.calls.results.ResolutionDebugInfo;
+import org.jetbrains.jet.lang.resolve.calls.results.ResolutionResultsHandler;
 import org.jetbrains.jet.lang.resolve.calls.tasks.*;
 import org.jetbrains.jet.lang.resolve.calls.util.DelegatingCall;
 import org.jetbrains.jet.lang.resolve.calls.util.ExpressionAsFunctionDescriptor;
@@ -45,11 +48,15 @@ import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
 import org.jetbrains.jet.lexer.JetTokens;

 import javax.inject.Inject;
-import java.util.*;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.EnumSet;
+import java.util.List;

 import static org.jetbrains.jet.lang.descriptors.ReceiverParameterDescriptor.NO_RECEIVER_PARAMETER;
 import static org.jetbrains.jet.lang.diagnostics.Errors.*;
-import static org.jetbrains.jet.lang.resolve.BindingContext.*;
+import static org.jetbrains.jet.lang.resolve.BindingContext.NON_DEFAULT_EXPRESSION_DATA_FLOW;
+import static org.jetbrains.jet.lang.resolve.BindingContext.RESOLUTION_SCOPE;
 import static org.jetbrains.jet.lang.resolve.calls.CallResolverUtil.ResolveArgumentsMode.RESOLVE_FUNCTION_ARGUMENTS;
 import static org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue.NO_RECEIVER;
 import static org.jetbrains.jet.lang.types.TypeUtils.NO_EXPECTED_TYPE;
@@ -125,8 +132,8 @@ public class CallResolver {
            @NotNull DataFlowInfo dataFlowInfo
    ) {
        return resolveFunctionCall(BasicCallResolutionContext.create(
-                trace, scope, call, expectedType, dataFlowInfo, ResolveMode.TOP_LEVEL_CALL, ExpressionPosition.FREE,
-                ResolutionResultsCache.create()));
+                trace, scope, call, expectedType, dataFlowInfo, ResolveMode.TOP_LEVEL_CALL, CheckValueArgumentsMode.ENABLED,
+                ExpressionPosition.FREE, ResolutionResultsCache.create()));
    }

    @NotNull
@@ -482,7 +489,8 @@ public class CallResolver {
                            public List<JetExpression> getFunctionLiteralArguments() {
                                return Collections.emptyList();
                            }
-                        }, task.expectedType, task.dataFlowInfo, task.resolveMode, task.expressionPosition, task.resolutionResultsCache);
+                        }, task.expectedType, task.dataFlowInfo, task.resolveMode, task.checkArguments,
+                           task.expressionPosition, task.resolutionResultsCache);
            OverloadResolutionResultsImpl<F> resultsWithFunctionLiteralsStripped = performResolution(newTask, callTransformer, traceForResolutionCache);
            if (resultsWithFunctionLiteralsStripped.isSuccess() || resultsWithFunctionLiteralsStripped.isAmbiguity()) {
                task.tracing.danglingFunctionLiteralArgumentSuspected(task.trace, task.call.getFunctionLiteralArguments());
@@ -25,7 +25,9 @@ import org.jetbrains.jet.lang.descriptors.CallableDescriptor;
 import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
 import org.jetbrains.jet.lang.descriptors.VariableDescriptor;
 import org.jetbrains.jet.lang.psi.*;
-import org.jetbrains.jet.lang.resolve.*;
+import org.jetbrains.jet.lang.resolve.ChainedTemporaryBindingTrace;
+import org.jetbrains.jet.lang.resolve.DelegatingBindingTrace;
+import org.jetbrains.jet.lang.resolve.TemporaryBindingTrace;
 import org.jetbrains.jet.lang.resolve.calls.context.BasicCallResolutionContext;
 import org.jetbrains.jet.lang.resolve.calls.context.CallCandidateResolutionContext;
 import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCallImpl;
@@ -194,7 +196,7 @@ public class CallTransformer<D extends CallableDescriptor, F extends D> {
            DelegatingBindingTrace variableCallTrace = context.candidateCall.getTrace();
            BasicCallResolutionContext basicCallResolutionContext = BasicCallResolutionContext.create(
                    variableCallTrace, context.scope, functionCall, context.expectedType, context.dataFlowInfo,
-                    context.resolveMode, context.expressionPosition, context.resolutionResultsCache);
+                    context.resolveMode, context.checkArguments, context.expressionPosition, context.resolutionResultsCache);

            // 'invoke' call resolve
            OverloadResolutionResults<FunctionDescriptor> results = callResolver.resolveCallWithGivenName(basicCallResolutionContext, task.reference, Name.identifier("invoke"));
@@ -31,6 +31,7 @@ import org.jetbrains.jet.lang.resolve.*;
 import org.jetbrains.jet.lang.resolve.calls.autocasts.*;
 import org.jetbrains.jet.lang.resolve.calls.context.CallCandidateResolutionContext;
 import org.jetbrains.jet.lang.resolve.calls.context.CallResolutionContext;
+import org.jetbrains.jet.lang.resolve.calls.context.CheckValueArgumentsMode;
 import org.jetbrains.jet.lang.resolve.calls.context.ResolveMode;
 import org.jetbrains.jet.lang.resolve.calls.inference.*;
 import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall;
@@ -98,23 +99,25 @@ public class CandidateResolver {
            return;
        }

-        Set<ValueArgument> unmappedArguments = Sets.newLinkedHashSet();
-        ValueArgumentsToParametersMapper.Status
-                argumentMappingStatus = ValueArgumentsToParametersMapper.mapValueArgumentsToParameters(context.call, context.tracing,
-                                                                                                        candidateCall, unmappedArguments);
-        if (!argumentMappingStatus.isSuccess()) {
-            if (argumentMappingStatus == ValueArgumentsToParametersMapper.Status.STRONG_ERROR) {
-                candidateCall.addStatus(STRONG_ERROR);
+        if (task.checkArguments == CheckValueArgumentsMode.ENABLED) {
+            Set<ValueArgument> unmappedArguments = Sets.newLinkedHashSet();
+            ValueArgumentsToParametersMapper.Status
+                    argumentMappingStatus = ValueArgumentsToParametersMapper.mapValueArgumentsToParameters(context.call, context.tracing,
+                                                                                                            candidateCall, unmappedArguments);
+            if (!argumentMappingStatus.isSuccess()) {
+                if (argumentMappingStatus == ValueArgumentsToParametersMapper.Status.STRONG_ERROR) {
+                    candidateCall.addStatus(STRONG_ERROR);
+                }
+                else {
+                    candidateCall.addStatus(OTHER_ERROR);
+                }
+                if ((argumentMappingStatus == ValueArgumentsToParametersMapper.Status.ERROR && candidate.getTypeParameters().isEmpty()) ||
+                    argumentMappingStatus == ValueArgumentsToParametersMapper.Status.STRONG_ERROR) {
+                    argumentTypeResolver.checkTypesWithNoCallee(context.toBasic());
+                    return;
+                }
+                candidateCall.setUnmappedArguments(unmappedArguments);
            }
-            else {
-                candidateCall.addStatus(OTHER_ERROR);
-            }
-            if ((argumentMappingStatus == ValueArgumentsToParametersMapper.Status.ERROR && candidate.getTypeParameters().isEmpty()) ||
-                argumentMappingStatus == ValueArgumentsToParametersMapper.Status.STRONG_ERROR) {
-                argumentTypeResolver.checkTypesWithNoCallee(context.toBasic());
-                return;
-            }
-            candidateCall.setUnmappedArguments(unmappedArguments);
        }

        List<JetTypeProjection> jetTypeArguments = context.call.getTypeArguments();
@@ -32,23 +32,26 @@ public class BasicCallResolutionContext extends CallResolutionContext<BasicCallR
            @NotNull JetType expectedType,
            @NotNull DataFlowInfo dataFlowInfo,
            @NotNull ResolveMode resolveMode,
+            @NotNull CheckValueArgumentsMode checkArguments,
            @NotNull ExpressionPosition expressionPosition,
            @NotNull ResolutionResultsCache resolutionResultsCache
    ) {
-        return new BasicCallResolutionContext(trace, scope, call, expectedType, dataFlowInfo, resolveMode, expressionPosition, resolutionResultsCache);
+        return new BasicCallResolutionContext(trace, scope, call, expectedType, dataFlowInfo, resolveMode, checkArguments, expressionPosition, resolutionResultsCache);
    }
    @NotNull
    public static BasicCallResolutionContext create(
-            @NotNull ResolutionContext context, @NotNull Call call, @NotNull ResolveMode resolveMode, @NotNull ResolutionResultsCache resolutionResultsCache
+            @NotNull ResolutionContext context, @NotNull Call call, @NotNull ResolveMode resolveMode,
+            @NotNull CheckValueArgumentsMode checkArguments, @NotNull ResolutionResultsCache resolutionResultsCache
    ) {
-        return create(context.trace, context.scope, call, context.expectedType, context.dataFlowInfo, resolveMode, context.expressionPosition, resolutionResultsCache);
+        return create(context.trace, context.scope, call, context.expectedType, context.dataFlowInfo, resolveMode, checkArguments, context.expressionPosition, resolutionResultsCache);
    }

    private BasicCallResolutionContext(
            BindingTrace trace, JetScope scope, Call call, JetType expectedType,
-            DataFlowInfo dataFlowInfo, ResolveMode resolveMode, ExpressionPosition expressionPosition, ResolutionResultsCache resolutionResultsCache
+            DataFlowInfo dataFlowInfo, ResolveMode resolveMode, CheckValueArgumentsMode checkArguments,
+            ExpressionPosition expressionPosition, ResolutionResultsCache resolutionResultsCache
    ) {
-        super(trace, scope, call, expectedType, dataFlowInfo, resolveMode, expressionPosition, resolutionResultsCache);
+        super(trace, scope, call, expectedType, dataFlowInfo, resolveMode, checkArguments, expressionPosition, resolutionResultsCache);
    }

    @Override
@@ -59,7 +62,7 @@ public class BasicCallResolutionContext extends CallResolutionContext<BasicCallR
            @NotNull JetType expectedType,
            @NotNull ExpressionPosition expressionPosition
    ) {
-        return create(trace, scope, call, expectedType, dataFlowInfo, resolveMode, expressionPosition, resolutionResultsCache);
+        return create(trace, scope, call, expectedType, dataFlowInfo, resolveMode, checkArguments, expressionPosition, resolutionResultsCache);
    }

    @Override
@@ -41,10 +41,11 @@ public final class CallCandidateResolutionContext<D extends CallableDescriptor>
            @NotNull JetType expectedType,
            @NotNull DataFlowInfo dataFlowInfo,
            @NotNull ResolveMode resolveMode,
+            @NotNull CheckValueArgumentsMode checkArguments,
            @NotNull ExpressionPosition expressionPosition,
            @NotNull ResolutionResultsCache resolutionResultsCache
    ) {
-        super(trace, scope, call, expectedType, dataFlowInfo, resolveMode, expressionPosition, resolutionResultsCache);
+        super(trace, scope, call, expectedType, dataFlowInfo, resolveMode, checkArguments, expressionPosition, resolutionResultsCache);
        this.candidateCall = candidateCall;
        this.tracing = tracing;
    }
@@ -55,7 +56,8 @@ public final class CallCandidateResolutionContext<D extends CallableDescriptor>
        candidateCall.setInitialDataFlowInfo(context.dataFlowInfo);
        return new CallCandidateResolutionContext<D>(
                candidateCall, tracing, trace, context.scope, call, context.expectedType,
-                context.dataFlowInfo, context.resolveMode, context.expressionPosition, context.resolutionResultsCache);
+                context.dataFlowInfo, context.resolveMode, context.checkArguments,
+                context.expressionPosition, context.resolutionResultsCache);
    }

    public static <D extends CallableDescriptor> CallCandidateResolutionContext<D> create(
@@ -67,16 +69,18 @@ public final class CallCandidateResolutionContext<D extends CallableDescriptor>
    public static <D extends CallableDescriptor> CallCandidateResolutionContext<D> createForCallBeingAnalyzed(
            @NotNull ResolvedCallImpl<D> candidateCall, @NotNull BasicCallResolutionContext context, @NotNull TracingStrategy tracing
    ) {
-        return createForCallBeingAnalyzed(candidateCall, context, context.call, context.resolveMode, tracing, context.resolutionResultsCache);
+        return createForCallBeingAnalyzed(candidateCall, context, context.call, context.resolveMode,
+                                          context.checkArguments, tracing, context.resolutionResultsCache);
    }

    public static <D extends CallableDescriptor> CallCandidateResolutionContext<D> createForCallBeingAnalyzed(
            @NotNull ResolvedCallImpl<D> candidateCall, @NotNull ResolutionContext context, @NotNull Call call,
-            @NotNull ResolveMode resolveMode, @NotNull TracingStrategy tracing, @NotNull ResolutionResultsCache resolutionResultsCache
+            @NotNull ResolveMode resolveMode, @NotNull CheckValueArgumentsMode checkArguments, @NotNull TracingStrategy tracing,
+            @NotNull ResolutionResultsCache resolutionResultsCache
    ) {
        return new CallCandidateResolutionContext<D>(
                candidateCall, tracing, context.trace, context.scope, call, context.expectedType,
-                context.dataFlowInfo, resolveMode, context.expressionPosition, resolutionResultsCache);
+                context.dataFlowInfo, resolveMode, checkArguments, context.expressionPosition, resolutionResultsCache);
    }

    @Override
@@ -88,8 +92,8 @@ public final class CallCandidateResolutionContext<D extends CallableDescriptor>
            @NotNull ExpressionPosition expressionPosition
    ) {
        return new CallCandidateResolutionContext<D>(
-                candidateCall, tracing, trace, scope, call, expectedType, dataFlowInfo, resolveMode, expressionPosition,
-                resolutionResultsCache);
+                candidateCall, tracing, trace, scope, call, expectedType, dataFlowInfo, resolveMode,
+                checkArguments, expressionPosition, resolutionResultsCache);
    }

    @Override
@@ -101,7 +105,7 @@ public final class CallCandidateResolutionContext<D extends CallableDescriptor>
    public CallCandidateResolutionContext<D> replaceResolveMode(@NotNull ResolveMode newResolveMode) {
        if (newResolveMode == resolveMode) return this;
        return new CallCandidateResolutionContext<D>(
-                candidateCall, tracing, trace, scope, call, expectedType, dataFlowInfo, newResolveMode, expressionPosition,
-                resolutionResultsCache);
+                candidateCall, tracing, trace, scope, call, expectedType, dataFlowInfo, newResolveMode,
+                checkArguments, expressionPosition, resolutionResultsCache);
    }
 }
@@ -26,6 +26,7 @@ import org.jetbrains.jet.lang.types.JetType;
 public abstract class CallResolutionContext<Context extends CallResolutionContext> extends ResolutionContext<Context> {
    public final Call call;
    public final ResolveMode resolveMode;
+    public final CheckValueArgumentsMode checkArguments;
    public final ResolutionResultsCache resolutionResultsCache;

    protected CallResolutionContext(
@@ -35,16 +36,18 @@ public abstract class CallResolutionContext<Context extends CallResolutionContex
            @NotNull JetType expectedType,
            @NotNull DataFlowInfo dataFlowInfo,
            @NotNull ResolveMode resolveMode,
+            @NotNull CheckValueArgumentsMode checkArguments,
            @NotNull ExpressionPosition expressionPosition,
            @NotNull ResolutionResultsCache resolutionResultsCache
    ) {
        super(trace, scope, expectedType, dataFlowInfo, expressionPosition);
        this.call = call;
        this.resolveMode = resolveMode;
+        this.checkArguments = checkArguments;
        this.resolutionResultsCache = resolutionResultsCache;
    }

    public BasicCallResolutionContext toBasic() {
-        return BasicCallResolutionContext.create(this, call, resolveMode, resolutionResultsCache);
+        return BasicCallResolutionContext.create(this, call, resolveMode, checkArguments, resolutionResultsCache);
    }
 }
@@ -0,0 +1,22 @@
+/*
+ * Copyright 2010-2013 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.jet.lang.resolve.calls.context;
+
+public enum CheckValueArgumentsMode {
+    ENABLED,
+    DISABLED
+}
@@ -44,9 +44,10 @@ public class ResolutionTask<D extends CallableDescriptor, F extends D> extends C
    public ResolutionTask(
            @NotNull Collection<ResolutionCandidate<D>> candidates, @NotNull JetReferenceExpression reference,
            @NotNull TracingStrategy tracing, BindingTrace trace, JetScope scope, Call call, JetType expectedType,
-            DataFlowInfo dataFlowInfo, ResolveMode resolveMode, ExpressionPosition expressionPosition, ResolutionResultsCache resolutionResultsCache
+            DataFlowInfo dataFlowInfo, ResolveMode resolveMode, CheckValueArgumentsMode checkArguments,
+            ExpressionPosition expressionPosition, ResolutionResultsCache resolutionResultsCache
    ) {
-        super(trace, scope, call, expectedType, dataFlowInfo, resolveMode, expressionPosition, resolutionResultsCache);
+        super(trace, scope, call, expectedType, dataFlowInfo, resolveMode, checkArguments, expressionPosition, resolutionResultsCache);
        this.candidates = candidates;
        this.reference = reference;
        this.tracing = tracing;
@@ -54,7 +55,8 @@ public class ResolutionTask<D extends CallableDescriptor, F extends D> extends C

    public ResolutionTask(@NotNull Collection<ResolutionCandidate<D>> candidates, @NotNull JetReferenceExpression reference, @NotNull BasicCallResolutionContext context) {
        this(candidates, reference, TracingStrategyImpl.create(reference, context.call), context.trace, context.scope, context.call,
-             context.expectedType, context.dataFlowInfo, context.resolveMode, context.expressionPosition, context.resolutionResultsCache);
+             context.expectedType, context.dataFlowInfo, context.resolveMode, context.checkArguments,
+             context.expressionPosition, context.resolutionResultsCache);
    }

    @NotNull
@@ -87,8 +89,8 @@ public class ResolutionTask<D extends CallableDescriptor, F extends D> extends C
            @NotNull ExpressionPosition expressionPosition
    ) {
        ResolutionTask<D, F> newTask = new ResolutionTask<D, F>(
-                candidates, reference, tracing, trace, scope, call, expectedType, dataFlowInfo, resolveMode, expressionPosition,
-                resolutionResultsCache);
+                candidates, reference, tracing, trace, scope, call, expectedType, dataFlowInfo, resolveMode, checkArguments,
+                expressionPosition, resolutionResultsCache);
        newTask.setCheckingStrategy(checkingStrategy);
        return newTask;
    }
@@ -21,7 +21,6 @@ import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
 import org.jetbrains.jet.lang.psi.Call;
 import org.jetbrains.jet.lang.psi.JetReferenceExpression;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
-import org.jetbrains.jet.lang.resolve.TraceUtil;
 import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo;
 import org.jetbrains.jet.lang.resolve.calls.context.*;
 import org.jetbrains.jet.lang.resolve.calls.results.OverloadResolutionResults;
@@ -105,6 +104,10 @@ public class ExpressionTypingContext extends ResolutionContext<ExpressionTypingC
    @NotNull
    public OverloadResolutionResults<FunctionDescriptor> resolveCallWithGivenName(@NotNull Call call, @NotNull JetReferenceExpression functionReference, @NotNull Name name) {
        return expressionTypingServices.getCallResolver().resolveCallWithGivenName(
-                BasicCallResolutionContext.create(this, call, ResolveMode.TOP_LEVEL_CALL, ResolutionResultsCache.create()), functionReference, name);
+                BasicCallResolutionContext.create(this, call, ResolveMode.TOP_LEVEL_CALL,
+                                                  CheckValueArgumentsMode.ENABLED, ResolutionResultsCache.create()),
+                functionReference,
+                name
+        );
    }
 }