diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/JavaAnnotationCallChecker.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/JavaAnnotationCallChecker.kt index 085b10421f3..2819fd3b0f2 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/JavaAnnotationCallChecker.kt +++ b/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 check(resolvedCall: ResolvedCall, context: BasicCallResolutionContext) { + override fun check(resolvedCall: ResolvedCall, context: BasicCallResolutionContext) { val resultingDescriptor = resolvedCall.getResultingDescriptor().getOriginal() if (resultingDescriptor !is JavaConstructorDescriptor || resultingDescriptor.getContainingDeclaration().getKind() != ClassKind.ANNOTATION_CLASS) return diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/JavaAnnotationMethodCallChecker.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/JavaAnnotationMethodCallChecker.kt index 64993940525..7a3feef6aa5 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/JavaAnnotationMethodCallChecker.kt +++ b/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 check(resolvedCall: ResolvedCall, context: BasicCallResolutionContext) { + override fun check(resolvedCall: ResolvedCall, context: BasicCallResolutionContext) { val descriptor = resolvedCall.getCandidateDescriptor().getOriginal() val containingDeclaration = descriptor.getContainingDeclaration() diff --git a/compiler/frontend/src/org/jetbrains/kotlin/frontend/di/injection.kt b/compiler/frontend/src/org/jetbrains/kotlin/frontend/di/injection.kt index 439a6106186..2d109a7f6fd 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/frontend/di/injection.kt +++ b/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( diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/AdditionalCheckerProvider.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/AdditionalCheckerProvider.kt index a690cbf0226..de3a4b0a4b8 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/AdditionalCheckerProvider.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/AdditionalCheckerProvider.kt @@ -33,7 +33,7 @@ public abstract class AdditionalCheckerProvider( ) { public val declarationCheckers: List = DEFAULT_DECLARATION_CHECKERS + additionalDeclarationCheckers - public val callChecker: CallChecker = CompositeChecker(DEFAULT_CALL_CHECKERS + additionalCallCheckers) + public val callCheckers: List = DEFAULT_CALL_CHECKERS + additionalCallCheckers public val typeCheckers: List = DEFAULT_TYPE_CHECKERS + additionalTypeCheckers public val symbolUsageValidator: SymbolUsageValidator = SymbolUsageValidator.Composite(DEFAULT_VALIDATORS + additionalSymbolUsageValidators) diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolver.java index 6977e132e80..ec539daa7bc 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolver.java +++ b/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() { @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 beforeBlockBody, - @Nullable CallChecker callChecker + @NotNull CallChecker callChecker ) { JetScope innerScope = FunctionDescriptorUtil.getFunctionInnerScope(scope, functionDescriptor, trace); List 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; diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/ConstructorHeaderCallChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/ConstructorHeaderCallChecker.kt index d3aa09c8926..53b2ca2ede4 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/ConstructorHeaderCallChecker.kt +++ b/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 check(resolvedCall: ResolvedCall, context: BasicCallResolutionContext) { + override fun check(resolvedCall: ResolvedCall, 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<*>) { diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DelegatedPropertyResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DelegatedPropertyResolver.java index e33c5ad9155..e5c82f7b597 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DelegatedPropertyResolver.java +++ b/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 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; diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/ScriptBodyResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/ScriptBodyResolver.java index 86e06a64666..1f20050fd3c 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/ScriptBodyResolver.java +++ b/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, diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallCompleter.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallCompleter.kt index 19a0de7c7c6..43496741dcd 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallCompleter.kt +++ b/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, private val builtIns: KotlinBuiltIns ) { fun 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 diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolver.java index 739357e7e26..d9abdcd23a8 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolver.java +++ b/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 ) ); } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/CallChecker.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/CallChecker.kt similarity index 59% rename from compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/CallChecker.java rename to compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/CallChecker.kt index 86f91fa9b51..7e3caa190ad 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/CallChecker.java +++ b/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 { - void check(@NotNull ResolvedCall resolvedCall, @NotNull BasicCallResolutionContext context); + public fun check(resolvedCall: ResolvedCall, context: BasicCallResolutionContext) + + public object DoNothing : CallChecker { + override fun check(resolvedCall: ResolvedCall, context: BasicCallResolutionContext) { + } + } } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/CompositeChecker.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/CompositeChecker.java deleted file mode 100644 index 2cb326c4a57..00000000000 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/CompositeChecker.java +++ /dev/null @@ -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 extensions; - - public CompositeChecker(@NotNull List extensions) { - this.extensions = extensions; - } - - @Override - public void check( - @NotNull ResolvedCall resolvedCall, - @NotNull BasicCallResolutionContext context - ) { - for (CallChecker resolverExtension : extensions) { - resolverExtension.check(resolvedCall, context); - } - } -} diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/InlineCheckerWrapper.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/InlineCheckerWrapper.kt index 54cf17f2bc7..d4ba50bbf5e 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/InlineCheckerWrapper.kt +++ b/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>? = null - override fun check(resolvedCall: ResolvedCall, context: BasicCallResolutionContext) { + override fun check(resolvedCall: ResolvedCall, context: BasicCallResolutionContext) { if (context.isAnnotationContext) return var parentDescriptor: DeclarationDescriptor? = context.scope.getContainingDeclaration() diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/context/BasicCallResolutionContext.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/context/BasicCallResolutionContext.java index 7592bb7daf0..e213aaa15ea 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/context/BasicCallResolutionContext.java +++ b/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 resolvedCall) { + callChecker.check(resolvedCall, this); + } } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/context/ResolutionContext.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/context/ResolutionContext.java index c55a31c0398..1de5bf5d12c 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/context/ResolutionContext.java +++ b/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; diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java index ccf61c3a6bb..dced3c69a77 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java +++ b/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); } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingComponents.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingComponents.java index 5cea9eeeca1..d19db25ce5f 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingComponents.java +++ b/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 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 callCheckers) { + this.callCheckers = callCheckers; + } } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingContext.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingContext.java index 32bb12fa987..7cafa87c602 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingContext.java +++ b/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 functions = container.getFakeCallResolver().resolveFakeCall( diff --git a/idea/ide-common/src/org/jetbrains/kotlin/idea/util/ShadowedDeclarationsFilter.kt b/idea/ide-common/src/org/jetbrains/kotlin/idea/util/ShadowedDeclarationsFilter.kt index 62e1b932da0..a0c90ad30df 100644 --- a/idea/ide-common/src/org/jetbrains/kotlin/idea/util/ShadowedDeclarationsFilter.kt +++ b/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() } diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/ExpectedInfos.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/ExpectedInfos.kt index f2755866007..b6aee3a8fda 100644 --- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/ExpectedInfos.kt +++ b/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 = callResolver.resolveFunctionCall(callResolutionContext) diff --git a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/IterableTypesDetector.kt b/idea/idea-core/src/org/jetbrains/kotlin/idea/core/IterableTypesDetector.kt index 15c1d162bb7..3a3a8e0a361 100644 --- a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/IterableTypesDetector.kt +++ b/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) } } diff --git a/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/diagnostics/JsCallChecker.kt b/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/diagnostics/JsCallChecker.kt index e1ab616f0e3..54107641d08 100644 --- a/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/diagnostics/JsCallChecker.kt +++ b/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/diagnostics/JsCallChecker.kt @@ -63,7 +63,7 @@ public class JsCallChecker : CallChecker { } } - override fun check(resolvedCall: ResolvedCall, context: BasicCallResolutionContext) { + override fun check(resolvedCall: ResolvedCall, context: BasicCallResolutionContext) { if (context.isAnnotationContext || !resolvedCall.isJsCall()) return val expression = resolvedCall.getCall().getCallElement()