Frontend: use AdditionalCheckerProvider instead of CallResolverExtensionProvider

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

@@ -41,13 +41,12 @@ import org.jetbrains.kotlin.resolve.annotations.hasIntrinsicAnnotation
 import org.jetbrains.kotlin.load.kotlin.nativeDeclarations.NativeFunChecker
 import org.jetbrains.kotlin.psi.JetPropertyAccessor
 import org.jetbrains.kotlin.descriptors.MemberDescriptor
+import org.jetbrains.kotlin.resolve.calls.checkers.NeedSyntheticChecker
 
-public object JavaDeclarationCheckerProvider : AdditionalCheckerProvider {
+public object JavaDeclarationCheckerProvider : AdditionalCheckerProvider(
-
+        annotationCheckers = listOf(PlatformStaticAnnotationChecker(), LocalFunInlineChecker(), ReifiedTypeParameterAnnotationChecker(), NativeFunChecker()),
-    override val annotationCheckers: List<AnnotationChecker> = listOf(
+        additionalCallCheckers = listOf(NeedSyntheticChecker())
-            PlatformStaticAnnotationChecker(), LocalFunInlineChecker(), ReifiedTypeParameterAnnotationChecker(), NativeFunChecker()
+)
-    )
-}
 
 public class LocalFunInlineChecker : AnnotationChecker {
 

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

@@ -16,12 +16,20 @@
 
 package org.jetbrains.kotlin.resolve
 
-public trait AdditionalCheckerProvider {
+import org.jetbrains.annotations.ReadOnly
 
-    public val annotationCheckers: List<AnnotationChecker>
+import java.util.Collections
+import kotlin.properties.Delegates
+import org.jetbrains.kotlin.resolve.calls.checkers.*
 
-    public object Empty : AdditionalCheckerProvider {
+private val DEFAULT_CALL_CHECKERS = listOf(CapturingInClosureChecker(), InlineCheckerWrapper(), ReifiedTypeParameterSubstitutionChecker())
 
-        override val annotationCheckers: List<AnnotationChecker> = listOf()
+public abstract class AdditionalCheckerProvider(
-    }
+        public val annotationCheckers: List<AnnotationChecker>,
+        additionalCallCheckers: List<CallChecker>
+) {
+
+    public val callCheckers: List<CallChecker> = DEFAULT_CALL_CHECKERS + additionalCallCheckers
+
+    public object Empty : AdditionalCheckerProvider(listOf(), listOf()) {}
 }

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

@@ -219,7 +219,7 @@ public class CallResolver {
         return resolveFunctionCall(
                 BasicCallResolutionContext.create(
                         trace, scope, call, expectedType, dataFlowInfo, ContextDependency.INDEPENDENT, CheckValueArgumentsMode.ENABLED,
-                        expressionTypingServices.createExtension(scope, isAnnotationContext), isAnnotationContext)
+                        expressionTypingServices.getCallChecker(), isAnnotationContext)
         );
     }
 

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

@@ -1,41 +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.annotations.Nullable;
-import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
-import org.jetbrains.kotlin.descriptors.SimpleFunctionDescriptor;
-
-import java.lang.ref.WeakReference;
-import java.util.*;
-
-public class CallResolverExtensionProvider {
-
-    private final static CompositeChecker DEFAULT =
-            new CompositeChecker(Arrays.asList(
-                    new NeedSyntheticChecker(),
-                    new ReifiedTypeParameterSubstitutionChecker(),
-                    new CapturingInClosureChecker(),
-                    new InlineCheckerWrapper()
-            ));
-
-    @NotNull
-    public CallChecker createExtension(@Nullable DeclarationDescriptor descriptor, boolean isAnnotationContext) {
-        return DEFAULT;
-    }
-}

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

@@ -40,7 +40,7 @@ public class ExpressionTypingContext extends ResolutionContext<ExpressionTypingC
     ) {
         return newContext(trace, scope, dataFlowInfo, expectedType,
                           ContextDependency.INDEPENDENT, new ResolutionResultsCacheImpl(),
-                          expressionTypingServices.createExtension(scope, false), false);
+                          expressionTypingServices.getCallChecker(), false);
     }
 
     @NotNull

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

@@ -34,10 +34,10 @@ import org.jetbrains.kotlin.psi.*;
 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.CompositeChecker;
 import org.jetbrains.kotlin.resolve.calls.context.ContextDependency;
 import org.jetbrains.kotlin.resolve.calls.context.ResolutionContext;
 import org.jetbrains.kotlin.resolve.calls.checkers.CallChecker;
-import org.jetbrains.kotlin.resolve.calls.checkers.CallResolverExtensionProvider;
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo;
 import org.jetbrains.kotlin.resolve.constants.evaluate.ConstantExpressionEvaluator;
 import org.jetbrains.kotlin.resolve.scopes.JetScope;
@@ -67,7 +67,6 @@ public class ExpressionTypingServices {
     private DescriptorResolver descriptorResolver;
     private TypeResolver typeResolver;
     private AnnotationResolver annotationResolver;
-    private CallResolverExtensionProvider extensionProvider;
     private PartialBodyResolveProvider partialBodyResolveProvider;
     private KotlinBuiltIns builtIns;
 
@@ -131,11 +130,6 @@ public class ExpressionTypingServices {
         this.annotationResolver = annotationResolver;
     }
 
-    @Inject
-    public void setExtensionProvider(@NotNull CallResolverExtensionProvider extensionProvider) {
-        this.extensionProvider = extensionProvider;
-    }
-
     @NotNull
     private PartialBodyResolveProvider getPartialBodyResolveProvider() {
         return partialBodyResolveProvider;
@@ -417,7 +411,8 @@ public class ExpressionTypingServices {
     }
 
     @NotNull
-    public CallChecker createExtension(@NotNull JetScope scope, boolean isAnnotationContext) {
+    public CallChecker getCallChecker() {
-        return extensionProvider.createExtension(scope == JetScope.Empty.INSTANCE$ ? null : scope.getContainingDeclaration(), isAnnotationContext);
+        List<CallChecker> checkers = expressionTypingComponents.additionalCheckerProvider.getCallCheckers();
+        return new CompositeChecker(checkers);
     }
 }

js/js.frontend/src/org/jetbrains/kotlin/js/resolve/KotlinJsDeclarationCheckerProvider.kt

@@ -31,10 +31,12 @@ import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.js.translate.utils.AnnotationsUtils
 import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.types.typeUtil.isSubtypeOf
+import org.jetbrains.kotlin.resolve.calls.checkers.CallChecker
 
-public object KotlinJsDeclarationCheckerProvider : AdditionalCheckerProvider {
+public object KotlinJsDeclarationCheckerProvider : AdditionalCheckerProvider(
-    override val annotationCheckers: List<AnnotationChecker> = listOf(NativeInvokeChecker(), NativeGetterChecker(), NativeSetterChecker())
+        annotationCheckers = listOf(NativeInvokeChecker(), NativeGetterChecker(), NativeSetterChecker()),
-}
+        additionalCallCheckers = listOf()
+)
 
 private abstract class AbstractNativeAnnotationsChecker(private val requiredAnnotation: PredefinedAnnotation) : AnnotationChecker {