Inject non-context dependent CallCheckers instead of getting them from context

compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/JavaAnnotationCallChecker.kt

@@ -42,7 +42,7 @@ import org.jetbrains.kotlin.types.TypeUtils
 import java.lang.annotation.Target
 
 public class JavaAnnotationCallChecker : CallChecker {
-    override fun <F : CallableDescriptor?> check(resolvedCall: ResolvedCall<F>, context: BasicCallResolutionContext) {
+    override fun <F : CallableDescriptor> check(resolvedCall: ResolvedCall<F>, context: BasicCallResolutionContext) {
         val resultingDescriptor = resolvedCall.getResultingDescriptor().getOriginal()
         if (resultingDescriptor !is JavaConstructorDescriptor ||
             resultingDescriptor.getContainingDeclaration().getKind() != ClassKind.ANNOTATION_CLASS) return

compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/JavaAnnotationMethodCallChecker.kt

@@ -25,7 +25,7 @@ import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.ErrorsJvm
 
 public class JavaAnnotationMethodCallChecker : CallChecker {
-    override fun <F : CallableDescriptor?> check(resolvedCall: ResolvedCall<F>, context: BasicCallResolutionContext) {
+    override fun <F : CallableDescriptor> check(resolvedCall: ResolvedCall<F>, context: BasicCallResolutionContext) {
         val descriptor = resolvedCall.getCandidateDescriptor().getOriginal()
         val containingDeclaration = descriptor.getContainingDeclaration()
 

compiler/frontend/src/org/jetbrains/kotlin/frontend/di/injection.kt

@@ -50,6 +50,9 @@ public fun StorageComponentContainer.configureModule(
     additionalCheckerProvider.typeCheckers.forEach {
         useInstance(it)
     }
+    additionalCheckerProvider.callCheckers.forEach {
+        useInstance(it)
+    }
 }
 
 public fun StorageComponentContainer.configureModule(

compiler/frontend/src/org/jetbrains/kotlin/resolve/AdditionalCheckerProvider.kt

@@ -33,7 +33,7 @@ public abstract class AdditionalCheckerProvider(
 ) {
 
     public val declarationCheckers: List<DeclarationChecker> = DEFAULT_DECLARATION_CHECKERS + additionalDeclarationCheckers
-    public val callChecker: CallChecker = CompositeChecker(DEFAULT_CALL_CHECKERS + additionalCallCheckers)
+    public val callCheckers: List<CallChecker> = DEFAULT_CALL_CHECKERS + additionalCallCheckers
     public val typeCheckers: List<AdditionalTypeChecker> = DEFAULT_TYPE_CHECKERS + additionalTypeCheckers
     public val symbolUsageValidator: SymbolUsageValidator = SymbolUsageValidator.Composite(DEFAULT_VALIDATORS + additionalSymbolUsageValidators)
 

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

@@ -63,12 +63,10 @@ public class BodyResolver {
     @NotNull private final AnnotationResolver annotationResolver;
     @NotNull private final DelegatedPropertyResolver delegatedPropertyResolver;
     @NotNull private final FunctionAnalyzerExtension functionAnalyzerExtension;
-    @NotNull private final AdditionalCheckerProvider additionalCheckerProvider;
     @NotNull private final ValueParameterResolver valueParameterResolver;
     @NotNull private final BodyResolveCache bodyResolveCache;
 
     public BodyResolver(
-            @NotNull AdditionalCheckerProvider additionalCheckerProvider,
             @NotNull AnnotationResolver annotationResolver,
             @NotNull BodyResolveCache bodyResolveCache,
             @NotNull CallResolver callResolver,
@@ -82,7 +80,6 @@ public class BodyResolver {
             @NotNull ValueParameterResolver valueParameterResolver,
             @NotNull ModifiersChecker modifiersChecker
     ) {
-        this.additionalCheckerProvider = additionalCheckerProvider;
         this.annotationResolver = annotationResolver;
         this.bodyResolveCache = bodyResolveCache;
         this.callResolver = callResolver;
@@ -138,7 +135,7 @@ public class BodyResolver {
     ) {
         ForceResolveUtil.forceResolveAllContents(descriptor.getAnnotations());
 
-        final CallChecker callChecker = new ConstructorHeaderCallChecker(descriptor, additionalCheckerProvider.getCallChecker());
+        final CallChecker callChecker = new ConstructorHeaderCallChecker(descriptor);
         resolveFunctionBody(outerDataFlowInfo, trace, constructor, descriptor, declaringScope,
                             new Function1<JetScope, DataFlowInfo>() {
                                 @Override
@@ -741,7 +738,7 @@ public class BodyResolver {
     ) {
         computeDeferredType(functionDescriptor.getReturnType());
 
-        resolveFunctionBody(outerDataFlowInfo, trace, function, functionDescriptor, declaringScope, null, null);
+        resolveFunctionBody(outerDataFlowInfo, trace, function, functionDescriptor, declaringScope, null, CallChecker.DoNothing.INSTANCE$);
 
         assert functionDescriptor.getReturnType() != null;
     }
@@ -753,7 +750,7 @@ public class BodyResolver {
             @NotNull FunctionDescriptor functionDescriptor,
             @NotNull JetScope scope,
             @Nullable Function1<JetScope, DataFlowInfo> beforeBlockBody,
-            @Nullable CallChecker callChecker
+            @NotNull CallChecker callChecker
     ) {
         JetScope innerScope = FunctionDescriptorUtil.getFunctionInnerScope(scope, functionDescriptor, trace);
         List<JetParameter> valueParameters = function.getValueParameters();
@@ -762,7 +759,7 @@ public class BodyResolver {
         valueParameterResolver.resolveValueParameters(
                 valueParameters, valueParameterDescriptors,
                 ExpressionTypingContext.newContext(
-                        additionalCheckerProvider, trace, innerScope, outerDataFlowInfo, NO_EXPECTED_TYPE, callChecker)
+                        trace, innerScope, outerDataFlowInfo, NO_EXPECTED_TYPE, callChecker)
         );
 
         DataFlowInfo dataFlowInfo = null;

compiler/frontend/src/org/jetbrains/kotlin/resolve/ConstructorHeaderCallChecker.kt

@@ -30,10 +30,10 @@ import org.jetbrains.kotlin.resolve.calls.resolvedCallUtil.hasImplicitThisOrSupe
 import org.jetbrains.kotlin.resolve.descriptorUtil.getOwnerForEffectiveDispatchReceiverParameter
 
 
-public class ConstructorHeaderCallChecker(constructor: ConstructorDescriptor, private val wrapped: CallChecker) : CallChecker {
+public class ConstructorHeaderCallChecker(constructor: ConstructorDescriptor) : CallChecker {
     private val containingClass = constructor.getContainingDeclaration()
 
-    override fun <F : CallableDescriptor?> check(resolvedCall: ResolvedCall<F>, context: BasicCallResolutionContext) {
+    override fun <F : CallableDescriptor> check(resolvedCall: ResolvedCall<F>, context: BasicCallResolutionContext) {
         if (resolvedCall.getStatus().isSuccess() &&
             resolvedCall.hasImplicitThisOrSuperDispatchReceiver(context.trace.getBindingContext()) &&
             containingClass == resolvedCall.getResultingDescriptor().getOwnerForEffectiveDispatchReceiverParameter()
@@ -49,8 +49,6 @@ public class ConstructorHeaderCallChecker(constructor: ConstructorDescriptor, pr
                 }
             }
         }
-
-        wrapped.check(resolvedCall, context)
     }
 
     private fun reportError(context: BasicCallResolutionContext, resolvedCall: ResolvedCall<*>) {

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

@@ -139,7 +139,7 @@ public class DelegatedPropertyResolver {
     ) {
         TemporaryBindingTrace traceToResolvePDMethod = TemporaryBindingTrace.create(trace, "Trace to resolve propertyDelegated method in delegated property");
         ExpressionTypingContext context = ExpressionTypingContext.newContext(
-                additionalCheckerProvider, traceToResolvePDMethod, scope,
+                traceToResolvePDMethod, scope,
                 DataFlowInfo.EMPTY, TypeUtils.NO_EXPECTED_TYPE);
 
         List<JetExpression> arguments = Lists.newArrayList();
@@ -236,7 +236,7 @@ public class DelegatedPropertyResolver {
                                ? propertyDescriptor.getType() : TypeUtils.NO_EXPECTED_TYPE;
 
         ExpressionTypingContext context = ExpressionTypingContext.newContext(
-                additionalCheckerProvider, trace, scope,
+                trace, scope,
                 DataFlowInfo.EMPTY, expectedType);
 
         boolean hasThis = propertyDescriptor.getExtensionReceiverParameter() != null || propertyDescriptor.getDispatchReceiverParameter() != null;

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

@@ -61,7 +61,6 @@ public class ScriptBodyResolver {
     ) {
         // Resolve all contents of the script
         ExpressionTypingContext context = ExpressionTypingContext.newContext(
-                additionalCheckerProvider,
                 trace,
                 scriptDescriptor.getScopeForBodyResolution(),
                 DataFlowInfo.EMPTY,

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

@@ -26,6 +26,7 @@ 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.callResolverUtil.isInvokeCallOnVariable
+import org.jetbrains.kotlin.resolve.calls.checkers.CallChecker
 import org.jetbrains.kotlin.resolve.calls.context.BasicCallResolutionContext
 import org.jetbrains.kotlin.resolve.calls.context.CallCandidateResolutionContext
 import org.jetbrains.kotlin.resolve.calls.context.CheckArgumentTypesMode
@@ -49,6 +50,7 @@ public class CallCompleter(
         private val candidateResolver: CandidateResolver,
         private val symbolUsageValidator: SymbolUsageValidator,
         private val dataFlowAnalyzer: DataFlowAnalyzer,
+        private val callCheckers: Iterable<CallChecker>,
         private val builtIns: KotlinBuiltIns
 ) {
     fun <D : CallableDescriptor> completeCall(
@@ -73,7 +75,11 @@ public class CallCompleter(
         }
 
         if (resolvedCall != null) {
-            context.callChecker.check(resolvedCall, context)
+            context.performContextDependentCallChecks(resolvedCall)
+            for (callChecker in callCheckers) {
+                callChecker.check(resolvedCall, context)
+            }
+
             val element = if (resolvedCall is VariableAsFunctionResolvedCall)
                 resolvedCall.variableCall.getCall().getCalleeExpression()
             else

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

@@ -79,17 +79,14 @@ public class CallResolver {
     private GenericCandidateResolver genericCandidateResolver;
     private CallCompleter callCompleter;
     @NotNull private final TaskPrioritizer taskPrioritizer;
-    @NotNull private final AdditionalCheckerProvider additionalCheckerProvider;
-    
+
     private static final PerformanceCounter callResolvePerfCounter = PerformanceCounter.Companion.create("Call resolve", ExpressionTypingVisitorDispatcher.typeInfoPerfCounter);
     private static final PerformanceCounter candidatePerfCounter = PerformanceCounter.Companion.create("Call resolve candidate analysis", true);
 
     public CallResolver(
-            @NotNull TaskPrioritizer taskPrioritizer,
-            @NotNull AdditionalCheckerProvider additionalCheckerProvider
+            @NotNull TaskPrioritizer taskPrioritizer
     ) {
         this.taskPrioritizer = taskPrioritizer;
-        this.additionalCheckerProvider = additionalCheckerProvider;
     }
 
     // component dependency cycle
@@ -264,7 +261,7 @@ public class CallResolver {
         return resolveFunctionCall(
                 BasicCallResolutionContext.create(
                         trace, scope, call, expectedType, dataFlowInfo, ContextDependency.INDEPENDENT, CheckArgumentTypesMode.CHECK_VALUE_ARGUMENTS,
-                        additionalCheckerProvider.getCallChecker(), isAnnotationContext
+                        CallChecker.DoNothing.INSTANCE$, isAnnotationContext
                 )
         );
     }

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/CallChecker.kt

@@ -14,13 +14,17 @@
  * limitations under the License.
  */
 
-package org.jetbrains.kotlin.resolve.calls.checkers;
+package org.jetbrains.kotlin.resolve.calls.checkers
 
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.descriptors.CallableDescriptor;
-import org.jetbrains.kotlin.resolve.calls.context.BasicCallResolutionContext;
-import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
+import org.jetbrains.kotlin.descriptors.CallableDescriptor
+import org.jetbrains.kotlin.resolve.calls.context.BasicCallResolutionContext
+import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
 
 public interface CallChecker {
-    <F extends CallableDescriptor> void check(@NotNull ResolvedCall<F> resolvedCall, @NotNull BasicCallResolutionContext context);
+    public fun <F : CallableDescriptor> check(resolvedCall: ResolvedCall<F>, context: BasicCallResolutionContext)
+
+    public object DoNothing : CallChecker {
+        override fun <F : CallableDescriptor> check(resolvedCall: ResolvedCall<F>, context: BasicCallResolutionContext) {
+        }
+    }
 }

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/CompositeChecker.java

@@ -1,43 +0,0 @@
-/*
- * Copyright 2010-2015 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.kotlin.resolve.calls.checkers;
-
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.descriptors.CallableDescriptor;
-import org.jetbrains.kotlin.resolve.calls.context.BasicCallResolutionContext;
-import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
-
-import java.util.List;
-
-public class CompositeChecker implements CallChecker {
-
-    private final List<CallChecker> extensions;
-
-    public CompositeChecker(@NotNull List<CallChecker> extensions) {
-        this.extensions = extensions;
-    }
-
-    @Override
-    public <F extends CallableDescriptor> void check(
-            @NotNull ResolvedCall<F> resolvedCall,
-            @NotNull BasicCallResolutionContext context
-    ) {
-        for (CallChecker resolverExtension : extensions) {
-            resolverExtension.check(resolvedCall, context);
-        }
-    }
-}

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/InlineCheckerWrapper.kt

@@ -27,7 +27,7 @@ import java.lang.ref.WeakReference
 public class InlineCheckerWrapper : CallChecker {
     private var checkersCache: WeakReference<MutableMap<DeclarationDescriptor, CallChecker>>? = null
 
-    override fun <F : CallableDescriptor?> check(resolvedCall: ResolvedCall<F>, context: BasicCallResolutionContext) {
+    override fun <F : CallableDescriptor> check(resolvedCall: ResolvedCall<F>, context: BasicCallResolutionContext) {
         if (context.isAnnotationContext) return
 
         var parentDescriptor: DeclarationDescriptor? = context.scope.getContainingDeclaration()

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/context/BasicCallResolutionContext.java

@@ -23,6 +23,7 @@ import org.jetbrains.kotlin.resolve.BindingTrace;
 import org.jetbrains.kotlin.resolve.StatementFilter;
 import org.jetbrains.kotlin.resolve.calls.checkers.CallChecker;
 import org.jetbrains.kotlin.resolve.calls.model.MutableDataFlowInfoForArguments;
+import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo;
 import org.jetbrains.kotlin.resolve.scopes.JetScope;
 import org.jetbrains.kotlin.types.JetType;
@@ -107,4 +108,8 @@ public class BasicCallResolutionContext extends CallResolutionContext<BasicCallR
                 trace, scope, newCall, expectedType, dataFlowInfo, contextDependency, checkArguments, resolutionResultsCache,
                 dataFlowInfoForArguments, callChecker, statementFilter, isAnnotationContext, collectAllCandidates, insideCallChain);
     }
+
+    public void performContextDependentCallChecks(@NotNull ResolvedCall<?> resolvedCall) {
+        callChecker.check(resolvedCall, this);
+    }
 }

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/context/ResolutionContext.java

@@ -21,6 +21,7 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.resolve.BindingTrace;
 import org.jetbrains.kotlin.resolve.StatementFilter;
 import org.jetbrains.kotlin.resolve.calls.checkers.CallChecker;
+import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo;
 import org.jetbrains.kotlin.resolve.scopes.JetScope;
 import org.jetbrains.kotlin.types.JetType;

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

@@ -31,12 +31,14 @@ import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.descriptors.annotations.Annotations;
 import org.jetbrains.kotlin.diagnostics.Diagnostic;
+import org.jetbrains.kotlin.diagnostics.DiagnosticFactory;
 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.callableReferences.CallableReferencesPackage;
 import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
+import org.jetbrains.kotlin.resolve.calls.checkers.CallChecker;
 import org.jetbrains.kotlin.resolve.calls.context.BasicCallResolutionContext;
 import org.jetbrains.kotlin.resolve.calls.context.CheckArgumentTypesMode;
 import org.jetbrains.kotlin.resolve.calls.model.DataFlowInfoForArgumentsImpl;
@@ -492,7 +494,11 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
         trace.record(CALL, expression, call);
 
         BasicCallResolutionContext resolutionContext = BasicCallResolutionContext.create(context, call, CheckArgumentTypesMode.CHECK_CALLABLE_TYPE);
-        context.callChecker.check(resolvedCall, resolutionContext);
+        resolutionContext.performContextDependentCallChecks(resolvedCall);
+        for (CallChecker checker : components.callCheckers) {
+            checker.check(resolvedCall, resolutionContext);
+        }
+
         components.symbolUsageValidator.validateCall(descriptor, trace, expression);
     }
 

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

@@ -23,6 +23,7 @@ import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap;
 import org.jetbrains.kotlin.resolve.*;
 import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
 import org.jetbrains.kotlin.resolve.calls.CallResolver;
+import org.jetbrains.kotlin.resolve.calls.checkers.CallChecker;
 import org.jetbrains.kotlin.resolve.constants.evaluate.ConstantExpressionEvaluator;
 import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator;
 import org.jetbrains.kotlin.types.DynamicTypesSettings;
@@ -53,6 +54,7 @@ public class ExpressionTypingComponents {
     /*package*/ ConstantExpressionEvaluator constantExpressionEvaluator;
     /*package*/ ModifiersChecker modifiersChecker;
     /*package*/ DataFlowAnalyzer dataFlowAnalyzer;
+    /*package*/ Iterable<? extends CallChecker> callCheckers;
 
     @Inject
     public void setGlobalContext(@NotNull GlobalContext globalContext) {
@@ -173,4 +175,9 @@ public class ExpressionTypingComponents {
     public void setDataFlowAnalyzer(@NotNull DataFlowAnalyzer dataFlowAnalyzer) {
         this.dataFlowAnalyzer = dataFlowAnalyzer;
     }
+
+    @Inject
+    public void setCallCheckers(@NotNull Iterable<? extends CallChecker> callCheckers) {
+        this.callCheckers = callCheckers;
+    }
 }

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

@@ -17,7 +17,6 @@
 package org.jetbrains.kotlin.types.expressions;
 
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider;
 import org.jetbrains.kotlin.resolve.BindingTrace;
 import org.jetbrains.kotlin.resolve.StatementFilter;
@@ -35,27 +34,25 @@ public class ExpressionTypingContext extends ResolutionContext<ExpressionTypingC
 
     @NotNull
     public static ExpressionTypingContext newContext(
-            @NotNull AdditionalCheckerProvider additionalCheckerProvider,
             @NotNull BindingTrace trace,
             @NotNull JetScope scope,
             @NotNull DataFlowInfo dataFlowInfo,
             @NotNull JetType expectedType
     ) {
-        return newContext(additionalCheckerProvider, trace, scope, dataFlowInfo, expectedType, null);
+        return newContext(trace, scope, dataFlowInfo, expectedType, CallChecker.DoNothing.INSTANCE$);
     }
 
     @NotNull
     public static ExpressionTypingContext newContext(
-            @NotNull AdditionalCheckerProvider additionalCheckerProvider,
             @NotNull BindingTrace trace,
             @NotNull JetScope scope,
             @NotNull DataFlowInfo dataFlowInfo,
             @NotNull JetType expectedType,
-            @Nullable CallChecker callChecker
+            @NotNull CallChecker callChecker
     ) {
         return newContext(trace, scope, dataFlowInfo, expectedType,
                           ContextDependency.INDEPENDENT, new ResolutionResultsCacheImpl(),
-                          callChecker != null ? callChecker : additionalCheckerProvider.getCallChecker(),
+                          callChecker,
                           StatementFilter.NONE, false);
     }
 

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

@@ -86,7 +86,7 @@ public class ExpressionTypingServices {
             @NotNull BindingTrace trace
     ) {
         ExpressionTypingContext context = ExpressionTypingContext.newContext(
-                expressionTypingComponents.additionalCheckerProvider, trace, scope, dataFlowInfo, expectedType
+                trace, scope, dataFlowInfo, expectedType
         );
         return expressionTypingFacade.getTypeInfo(expression, context);
     }
@@ -124,7 +124,7 @@ public class ExpressionTypingServices {
             }
         }
         checkFunctionReturnType(function, ExpressionTypingContext.newContext(
-                expressionTypingComponents.additionalCheckerProvider, trace,
+                trace,
                 functionInnerScope, dataFlowInfo, expectedReturnType != null ? expectedReturnType : NO_EXPECTED_TYPE
         ));
     }
@@ -199,7 +199,7 @@ public class ExpressionTypingServices {
         JetScope functionInnerScope = FunctionDescriptorUtil.getFunctionInnerScope(outerScope, functionDescriptor, trace);
 
         ExpressionTypingContext context = ExpressionTypingContext.newContext(
-                expressionTypingComponents.additionalCheckerProvider, trace, functionInnerScope, dataFlowInfo, NO_EXPECTED_TYPE
+                trace, functionInnerScope, dataFlowInfo, NO_EXPECTED_TYPE
         );
         JetTypeInfo typeInfo = expressionTypingFacade.getTypeInfo(bodyExpression, context, function.hasBlockBody());
 

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

@@ -42,8 +42,7 @@ public class ValueParameterResolver(
             trace: BindingTrace
     ) {
         resolveValueParameters(valueParameters, valueParameterDescriptors,
-                               ExpressionTypingContext.newContext(additionalCheckerProvider, trace, declaringScope,
-                                                                  dataFlowInfo, TypeUtils.NO_EXPECTED_TYPE)
+                               ExpressionTypingContext.newContext(trace, declaringScope, dataFlowInfo, TypeUtils.NO_EXPECTED_TYPE)
         )
     }
 

compiler/tests/org/jetbrains/kotlin/resolve/JetExpectedResolveDataUtil.java

@@ -133,7 +133,7 @@ public class JetExpectedResolveDataUtil {
         emptyModule.initialize(PackageFragmentProvider.Empty.INSTANCE$);
 
         ExpressionTypingContext context = ExpressionTypingContext.newContext(
-                container.getAdditionalCheckerProvider(), new BindingTraceContext(), classDescriptor.getDefaultType().getMemberScope(),
+                new BindingTraceContext(), classDescriptor.getDefaultType().getMemberScope(),
                 DataFlowInfo.EMPTY, TypeUtils.NO_EXPECTED_TYPE);
 
         OverloadResolutionResults<FunctionDescriptor> functions = container.getFakeCallResolver().resolveFakeCall(

idea/ide-common/src/org/jetbrains/kotlin/idea/util/ShadowedDeclarationsFilter.kt

@@ -25,7 +25,7 @@ import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.DelegatingBindingTrace
 import org.jetbrains.kotlin.resolve.bindingContextUtil.getDataFlowInfo
 import org.jetbrains.kotlin.resolve.calls.callUtil.getCall
-import org.jetbrains.kotlin.resolve.calls.checkers.CompositeChecker
+import org.jetbrains.kotlin.resolve.calls.checkers.CallChecker
 import org.jetbrains.kotlin.resolve.calls.context.BasicCallResolutionContext
 import org.jetbrains.kotlin.resolve.calls.context.CheckArgumentTypesMode
 import org.jetbrains.kotlin.resolve.calls.context.ContextDependency
@@ -164,7 +164,7 @@ public class ShadowedDeclarationsFilter(
         val dataFlowInfo = bindingContext.getDataFlowInfo(calleeExpression)
         val context = BasicCallResolutionContext.create(bindingTrace, resolutionScope, newCall, TypeUtils.NO_EXPECTED_TYPE, dataFlowInfo,
                                                         ContextDependency.INDEPENDENT, CheckArgumentTypesMode.CHECK_VALUE_ARGUMENTS,
-                                                        CompositeChecker(listOf()), false)
+                                                        CallChecker.DoNothing, false)
         val callResolver = createContainerForMacros(project, moduleDescriptor).callResolver
         val results = if (isFunction) callResolver.resolveFunctionCall(context) else callResolver.resolveSimpleProperty(context)
         val resultingDescriptors = results.getResultingCalls().map { it.getResultingDescriptor() }

idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/ExpectedInfos.kt

@@ -35,7 +35,7 @@ import org.jetbrains.kotlin.resolve.bindingContextUtil.getDataFlowInfo
 import org.jetbrains.kotlin.resolve.bindingContextUtil.getTargetFunctionDescriptor
 import org.jetbrains.kotlin.resolve.calls.callUtil.getCall
 import org.jetbrains.kotlin.resolve.calls.callUtil.noErrorsInValueArguments
-import org.jetbrains.kotlin.resolve.calls.checkers.CompositeChecker
+import org.jetbrains.kotlin.resolve.calls.checkers.CallChecker
 import org.jetbrains.kotlin.resolve.calls.context.BasicCallResolutionContext
 import org.jetbrains.kotlin.resolve.calls.context.CheckArgumentTypesMode
 import org.jetbrains.kotlin.resolve.calls.context.ContextDependency
@@ -179,7 +179,7 @@ class ExpectedInfos(
         val bindingTrace = DelegatingBindingTrace(bindingContext, "Temporary trace for completion")
         val context = BasicCallResolutionContext.create(bindingTrace, resolutionScope, truncatedCall, callExpectedType, dataFlowInfo,
                                                         ContextDependency.INDEPENDENT, CheckArgumentTypesMode.CHECK_VALUE_ARGUMENTS,
-                                                        CompositeChecker(listOf()), false)
+                                                        CallChecker.DoNothing, false)
         val callResolutionContext = context.replaceCollectAllCandidates(true)
         val callResolver = createContainerForMacros(project, moduleDescriptor).callResolver
         val results: OverloadResolutionResults<FunctionDescriptor> = callResolver.resolveFunctionCall(callResolutionContext)

idea/idea-core/src/org/jetbrains/kotlin/idea/core/IterableTypesDetector.kt

@@ -68,8 +68,7 @@ public class IterableTypesDetector(
         val expression = JetPsiFactory(project).createExpression("fake")
         val expressionReceiver = ExpressionReceiver(expression, type.type)
         val expressionTypingComponents = container.expressionTypingComponents
-        val context = ExpressionTypingContext.newContext(expressionTypingComponents.getAdditionalCheckerProvider(),
-                                                         BindingTraceContext(), scope, DataFlowInfo.EMPTY, TypeUtils.NO_EXPECTED_TYPE)
+        val context = ExpressionTypingContext.newContext(BindingTraceContext(), scope, DataFlowInfo.EMPTY, TypeUtils.NO_EXPECTED_TYPE)
         val elementType = expressionTypingComponents.getForLoopConventionsChecker().checkIterableConvention(expressionReceiver, context)
         return elementType?.let { FuzzyType(it, type.freeParameters) }
     }

js/js.frontend/src/org/jetbrains/kotlin/js/resolve/diagnostics/JsCallChecker.kt

@@ -63,7 +63,7 @@ public class JsCallChecker : CallChecker {
         }
     }
 
-    override fun <F : CallableDescriptor?> check(resolvedCall: ResolvedCall<F>, context: BasicCallResolutionContext) {
+    override fun <F : CallableDescriptor> check(resolvedCall: ResolvedCall<F>, context: BasicCallResolutionContext) {
         if (context.isAnnotationContext || !resolvedCall.isJsCall()) return
 
         val expression = resolvedCall.getCall().getCallElement()