From d599d87978056dcf468e2d927ee97f9ce634463d Mon Sep 17 00:00:00 2001 From: Alexander Udalov Date: Mon, 27 Jun 2016 19:10:12 +0300 Subject: [PATCH] Drop SymbolUsageValidator#validateCall in favor of CallChecker#check --- .../resolve/DelegatedPropertyResolver.java | 9 +- .../kotlin/resolve/TargetPlatform.kt | 3 +- .../kotlin/resolve/calls/CallCompleter.kt | 6 -- .../calls/checkers/DeprecatedCallChecker.kt | 83 +++++++++++++++++++ .../kotlin/resolve/deprecationUtil.kt | 12 +++ .../validation/DeprecatedSymbolValidator.kt | 81 ++---------------- .../validation/SymbolUsageValidator.kt | 4 - .../BasicExpressionTypingVisitor.java | 3 - .../DestructuringDeclarationResolver.kt | 7 +- .../ForLoopConventionsChecker.java | 14 +--- 10 files changed, 109 insertions(+), 113 deletions(-) create mode 100644 compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/DeprecatedCallChecker.kt diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DelegatedPropertyResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DelegatedPropertyResolver.java index abe5ef6d4a5..540c9d271c6 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DelegatedPropertyResolver.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DelegatedPropertyResolver.java @@ -42,7 +42,6 @@ import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo; import org.jetbrains.kotlin.resolve.scopes.LexicalScope; import org.jetbrains.kotlin.resolve.scopes.ScopeUtils; import org.jetbrains.kotlin.resolve.scopes.receivers.ExpressionReceiver; -import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator; import org.jetbrains.kotlin.types.*; import org.jetbrains.kotlin.types.checker.KotlinTypeChecker; import org.jetbrains.kotlin.types.expressions.ExpressionTypingContext; @@ -70,22 +69,19 @@ public class DelegatedPropertyResolver { private final ExpressionTypingServices expressionTypingServices; private final LanguageFeatureSettings languageFeatureSettings; private final Iterable callCheckers; - private final Iterable symbolUsageValidators; public DelegatedPropertyResolver( @NotNull KotlinBuiltIns builtIns, @NotNull FakeCallResolver fakeCallResolver, @NotNull ExpressionTypingServices expressionTypingServices, @NotNull LanguageFeatureSettings languageFeatureSettings, - @NotNull Iterable callCheckers, - @NotNull Iterable symbolUsageValidators + @NotNull Iterable callCheckers ) { this.builtIns = builtIns; this.fakeCallResolver = fakeCallResolver; this.expressionTypingServices = expressionTypingServices; this.languageFeatureSettings = languageFeatureSettings; this.callCheckers = callCheckers; - this.symbolUsageValidators = symbolUsageValidators; } public void resolvePropertyDelegate( @@ -288,9 +284,6 @@ public class DelegatedPropertyResolver { for (CallChecker checker : callCheckers) { checker.check(resultingCall, byKeyword, callCheckerContext); } - for (SymbolUsageValidator validator : symbolUsageValidators) { - validator.validateCall(resultingCall, trace, byKeyword); - } } } trace.record(DELEGATED_PROPERTY_RESOLVED_CALL, accessor, resultingCall); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/TargetPlatform.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/TargetPlatform.kt index 9fbd5ffeb3a..cb59e23bcec 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/TargetPlatform.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/TargetPlatform.kt @@ -26,6 +26,7 @@ import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.resolve.calls.checkers.* import org.jetbrains.kotlin.resolve.calls.results.TypeSpecificityComparator import org.jetbrains.kotlin.resolve.scopes.SyntheticScopes +import org.jetbrains.kotlin.resolve.calls.checkers.DeprecatedCallChecker import org.jetbrains.kotlin.resolve.validation.DeprecatedSymbolValidator import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator import org.jetbrains.kotlin.storage.StorageManager @@ -66,7 +67,7 @@ private val DEFAULT_DECLARATION_CHECKERS = listOf( private val DEFAULT_CALL_CHECKERS = listOf( CapturingInClosureChecker(), InlineCheckerWrapper(), ReifiedTypeParameterSubstitutionChecker(), SafeCallChecker(), - CallReturnsArrayOfNothingChecker(), InfixCallChecker(), OperatorCallChecker(), + DeprecatedCallChecker, CallReturnsArrayOfNothingChecker(), InfixCallChecker(), OperatorCallChecker(), ConstructorHeaderCallChecker, ProtectedConstructorCallChecker, CoroutineSuspendCallChecker, BuilderFunctionsCallChecker ) 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 0e7a82cbbc0..627d4360f92 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallCompleter.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallCompleter.kt @@ -44,7 +44,6 @@ import org.jetbrains.kotlin.resolve.calls.results.OverloadResolutionResultsImpl import org.jetbrains.kotlin.resolve.calls.results.ResolutionStatus import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo import org.jetbrains.kotlin.resolve.calls.tasks.TracingStrategy -import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator import org.jetbrains.kotlin.types.ErrorUtils import org.jetbrains.kotlin.types.KotlinType import org.jetbrains.kotlin.types.TypeUtils @@ -58,7 +57,6 @@ class CallCompleter( private val candidateResolver: CandidateResolver, private val dataFlowAnalyzer: DataFlowAnalyzer, private val callCheckers: Iterable, - private val symbolUsageValidators: Iterable, private val builtIns: KotlinBuiltIns, private val fakeCallResolver: FakeCallResolver, private val languageFeatureSettings: LanguageFeatureSettings @@ -95,10 +93,6 @@ class CallCompleter( callChecker.check(resolvedCall, reportOn, callCheckerContext) } - for (validator in symbolUsageValidators) { - validator.validateCall(resolvedCall, context.trace, element!!) - } - resolveHandleResultCallForCoroutineLambdaExpressions(context, resolvedCall) } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/DeprecatedCallChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/DeprecatedCallChecker.kt new file mode 100644 index 00000000000..66a7b36436a --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/DeprecatedCallChecker.kt @@ -0,0 +1,83 @@ +/* + * Copyright 2010-2016 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 com.intellij.psi.PsiElement +import com.intellij.psi.tree.TokenSet +import com.intellij.psi.util.PsiTreeUtil +import org.jetbrains.kotlin.descriptors.CallableDescriptor +import org.jetbrains.kotlin.descriptors.PropertyDescriptor +import org.jetbrains.kotlin.descriptors.PropertySetterDescriptor +import org.jetbrains.kotlin.lexer.KtTokens +import org.jetbrains.kotlin.psi.KtBinaryExpression +import org.jetbrains.kotlin.psi.KtCallableReferenceExpression +import org.jetbrains.kotlin.psi.KtReferenceExpression +import org.jetbrains.kotlin.psi.KtUnaryExpression +import org.jetbrains.kotlin.resolve.BindingTrace +import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall +import org.jetbrains.kotlin.resolve.createDeprecationDiagnostic +import org.jetbrains.kotlin.resolve.getDeprecation + +object DeprecatedCallChecker : CallChecker { + override fun check(resolvedCall: ResolvedCall<*>, reportOn: PsiElement, context: CallCheckerContext) { + check(resolvedCall.resultingDescriptor, context.trace, reportOn) + } + + internal fun check(targetDescriptor: CallableDescriptor, trace: BindingTrace, element: PsiElement) { + val deprecation = targetDescriptor.getDeprecation() + + // avoid duplicating diagnostic when deprecation for property effectively deprecates setter + if (targetDescriptor is PropertySetterDescriptor && targetDescriptor.correspondingProperty.getDeprecation() == deprecation) return + + if (deprecation != null) { + trace.report(createDeprecationDiagnostic(element, deprecation)) + } + else if (targetDescriptor is PropertyDescriptor) { + propertyGetterWorkaround(targetDescriptor, trace, element) + } + } + + private val PROPERTY_SET_OPERATIONS = TokenSet.create(KtTokens.EQ, KtTokens.PLUSEQ, KtTokens.MINUSEQ, KtTokens.MULTEQ, + KtTokens.DIVEQ, KtTokens.PERCEQ, KtTokens.PLUSPLUS, KtTokens.MINUSMINUS) + + private fun propertyGetterWorkaround(propertyDescriptor: PropertyDescriptor, trace: BindingTrace, expression: PsiElement) { + // property getters do not come as callable yet, so we analyse surroundings to check for deprecation annotation on getter + val binaryExpression = PsiTreeUtil.getParentOfType(expression, KtBinaryExpression::class.java) + if (binaryExpression != null) { + val left = binaryExpression.left + if (left == expression && binaryExpression.operationToken in PROPERTY_SET_OPERATIONS) return + + val referenceExpressions = PsiTreeUtil.getChildrenOfType(left, KtReferenceExpression::class.java) + if (referenceExpressions != null) { + for (expr in referenceExpressions) { + // skip binary set operations + if (expr == expression && binaryExpression.operationToken in PROPERTY_SET_OPERATIONS) return + } + } + } + + val unaryExpression = PsiTreeUtil.getParentOfType(expression, KtUnaryExpression::class.java) + // skip unary set operations + if (unaryExpression?.operationReference?.getReferencedNameElementType() in PROPERTY_SET_OPERATIONS) return + + val callableExpression = PsiTreeUtil.getParentOfType(expression, KtCallableReferenceExpression::class.java) + // skip Type::property + if (callableExpression != null && callableExpression.callableReference == expression) return + + propertyDescriptor.getter?.let { check(it, trace, expression) } + } +} diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/deprecationUtil.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/deprecationUtil.kt index 6285c01cabf..50dea404ea0 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/deprecationUtil.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/deprecationUtil.kt @@ -16,11 +16,14 @@ package org.jetbrains.kotlin.resolve +import com.intellij.psi.PsiElement import org.jetbrains.kotlin.builtins.KotlinBuiltIns import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget import org.jetbrains.kotlin.descriptors.annotations.Annotations +import org.jetbrains.kotlin.diagnostics.Diagnostic +import org.jetbrains.kotlin.diagnostics.Errors import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.resolve.annotations.argumentValue import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe @@ -173,6 +176,15 @@ private fun DeclarationDescriptor.getDeclaredDeprecatedAnnotation( return null } +internal fun createDeprecationDiagnostic(element: PsiElement, deprecation: Deprecation): Diagnostic { + val targetOriginal = deprecation.target.original + if (deprecation.deprecationLevel == DeprecationLevelValue.ERROR) { + return Errors.DEPRECATION_ERROR.on(element, targetOriginal, deprecation.message) + } + + return Errors.DEPRECATION.on(element, targetOriginal, deprecation.message) +} + // values from kotlin.DeprecationLevel enum class DeprecationLevelValue { WARNING, ERROR, HIDDEN diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/validation/DeprecatedSymbolValidator.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/validation/DeprecatedSymbolValidator.kt index 1327f0f2661..1ded6b05c9c 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/validation/DeprecatedSymbolValidator.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/validation/DeprecatedSymbolValidator.kt @@ -17,41 +17,19 @@ package org.jetbrains.kotlin.resolve.validation import com.intellij.psi.PsiElement -import com.intellij.psi.tree.TokenSet -import com.intellij.psi.util.PsiTreeUtil -import org.jetbrains.kotlin.descriptors.* -import org.jetbrains.kotlin.diagnostics.Diagnostic -import org.jetbrains.kotlin.diagnostics.Errors -import org.jetbrains.kotlin.lexer.KtTokens -import org.jetbrains.kotlin.psi.* +import org.jetbrains.kotlin.descriptors.ClassifierDescriptor +import org.jetbrains.kotlin.descriptors.PropertyAccessorDescriptor +import org.jetbrains.kotlin.psi.KtAnnotationEntry +import org.jetbrains.kotlin.psi.KtStubbedPsiUtil +import org.jetbrains.kotlin.psi.KtSuperTypeCallEntry import org.jetbrains.kotlin.resolve.BindingTrace -import org.jetbrains.kotlin.resolve.Deprecation -import org.jetbrains.kotlin.resolve.DeprecationLevelValue -import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall +import org.jetbrains.kotlin.resolve.calls.checkers.DeprecatedCallChecker +import org.jetbrains.kotlin.resolve.createDeprecationDiagnostic import org.jetbrains.kotlin.resolve.getDeprecation class DeprecatedSymbolValidator : SymbolUsageValidator { - - override fun validateCall(resolvedCall: ResolvedCall<*>, trace: BindingTrace, element: PsiElement) { - validate(resolvedCall.resultingDescriptor, trace, element) - } - override fun validatePropertyCall(targetDescriptor: PropertyAccessorDescriptor, trace: BindingTrace, element: PsiElement) { - validate(targetDescriptor, trace, element) - } - - private fun validate(targetDescriptor: CallableDescriptor, trace: BindingTrace, element: PsiElement) { - val deprecation = targetDescriptor.getDeprecation() - - // avoid duplicating diagnostic when deprecation for property effectively deprecates setter - if (targetDescriptor is PropertySetterDescriptor && targetDescriptor.correspondingProperty.getDeprecation() == deprecation) return - - if (deprecation != null) { - trace.report(createDeprecationDiagnostic(element, deprecation)) - } - else if (targetDescriptor is PropertyDescriptor) { - propertyGetterWorkaround(targetDescriptor, trace, element) - } + DeprecatedCallChecker.check(targetDescriptor, trace, element) } override fun validateTypeUsage(targetDescriptor: ClassifierDescriptor, trace: BindingTrace, element: PsiElement) { @@ -68,47 +46,4 @@ class DeprecatedSymbolValidator : SymbolUsageValidator { trace.report(createDeprecationDiagnostic(element, deprecation)) } } - - private fun createDeprecationDiagnostic(element: PsiElement, deprecation: Deprecation): Diagnostic { - val targetOriginal = deprecation.target.original - if (deprecation.deprecationLevel == DeprecationLevelValue.ERROR) { - return Errors.DEPRECATION_ERROR.on(element, targetOriginal, deprecation.message) - } - - return Errors.DEPRECATION.on(element, targetOriginal, deprecation.message) - } - - private val PROPERTY_SET_OPERATIONS = TokenSet.create(KtTokens.EQ, KtTokens.PLUSEQ, KtTokens.MINUSEQ, KtTokens.MULTEQ, - KtTokens.DIVEQ, KtTokens.PERCEQ, KtTokens.PLUSPLUS, KtTokens.MINUSMINUS) - - fun propertyGetterWorkaround( - propertyDescriptor: PropertyDescriptor, - trace: BindingTrace, - expression: PsiElement - ) { - // property getters do not come as callable yet, so we analyse surroundings to check for deprecation annotation on getter - val binaryExpression = PsiTreeUtil.getParentOfType(expression, KtBinaryExpression::class.java) - if (binaryExpression != null) { - val left = binaryExpression.left - if (left == expression && binaryExpression.operationToken in PROPERTY_SET_OPERATIONS) return - - val referenceExpressions = PsiTreeUtil.getChildrenOfType(left, KtReferenceExpression::class.java) - if (referenceExpressions != null) { - for (expr in referenceExpressions) { - // skip binary set operations - if (expr == expression && binaryExpression.operationToken in PROPERTY_SET_OPERATIONS) return - } - } - } - - val unaryExpression = PsiTreeUtil.getParentOfType(expression, KtUnaryExpression::class.java) - // skip unary set operations - if (unaryExpression?.operationReference?.getReferencedNameElementType() in PROPERTY_SET_OPERATIONS) return - - val callableExpression = PsiTreeUtil.getParentOfType(expression, KtCallableReferenceExpression::class.java) - // skip Type::property - if (callableExpression != null && callableExpression.callableReference == expression) return - - propertyDescriptor.getter?.let { validatePropertyCall(it, trace, expression) } - } } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/validation/SymbolUsageValidator.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/validation/SymbolUsageValidator.kt index c9b047fd1de..59627f752b2 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/validation/SymbolUsageValidator.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/validation/SymbolUsageValidator.kt @@ -17,16 +17,12 @@ package org.jetbrains.kotlin.resolve.validation import com.intellij.psi.PsiElement -import org.jetbrains.kotlin.descriptors.CallableDescriptor import org.jetbrains.kotlin.descriptors.ClassifierDescriptor import org.jetbrains.kotlin.descriptors.PropertyAccessorDescriptor import org.jetbrains.kotlin.resolve.BindingTrace -import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall interface SymbolUsageValidator { fun validateTypeUsage(targetDescriptor: ClassifierDescriptor, trace: BindingTrace, element: PsiElement) - fun validateCall(resolvedCall: ResolvedCall<*>, trace: BindingTrace, element: PsiElement) - fun validatePropertyCall(targetDescriptor: PropertyAccessorDescriptor, trace: BindingTrace, element: PsiElement) } 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 106319eb77a..a2dd495b00c 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java @@ -589,9 +589,6 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { for (CallChecker checker : components.callCheckers) { checker.check(resolvedCall, expression, callCheckerContext); } - for (SymbolUsageValidator validator : components.symbolUsageValidators) { - validator.validateCall(resolvedCall, trace, expression); - } } private static boolean isDeclaredInClass(ReceiverParameterDescriptor receiver) { diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/DestructuringDeclarationResolver.kt b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/DestructuringDeclarationResolver.kt index 88e0fa39b9f..2b559b79586 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/DestructuringDeclarationResolver.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/DestructuringDeclarationResolver.kt @@ -30,7 +30,6 @@ import org.jetbrains.kotlin.resolve.calls.checkers.CallCheckerContext import org.jetbrains.kotlin.resolve.dataClassUtils.createComponentName import org.jetbrains.kotlin.resolve.scopes.LexicalWritableScope import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue -import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator import org.jetbrains.kotlin.types.ErrorUtils import org.jetbrains.kotlin.types.KotlinType import org.jetbrains.kotlin.types.TypeUtils @@ -41,8 +40,7 @@ class DestructuringDeclarationResolver( private val localVariableResolver: LocalVariableResolver, private val typeResolver: TypeResolver, private val languageFeatureSettings: LanguageFeatureSettings, - private val callCheckers: Iterable, - private val symbolUsageValidators: Iterable + private val callCheckers: Iterable ) { fun defineLocalVariablesFromMultiDeclaration( writableScope: LexicalWritableScope, @@ -90,9 +88,6 @@ class DestructuringDeclarationResolver( for (checker in callCheckers) { checker.check(results.resultingCall, entry, callCheckerContext) } - for (validator in symbolUsageValidators) { - validator.validateCall(results.resultingCall, context.trace, entry) - } val functionReturnType = results.resultingDescriptor.returnType if (functionReturnType != null && !TypeUtils.noExpectedType(expectedType) diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ForLoopConventionsChecker.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ForLoopConventionsChecker.java index 7f5a418cc70..e1922d554c9 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ForLoopConventionsChecker.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ForLoopConventionsChecker.java @@ -35,7 +35,6 @@ import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall; import org.jetbrains.kotlin.resolve.calls.results.OverloadResolutionResults; import org.jetbrains.kotlin.resolve.scopes.receivers.ExpressionReceiver; import org.jetbrains.kotlin.resolve.scopes.receivers.TransientReceiver; -import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator; import org.jetbrains.kotlin.types.DynamicTypesKt; import org.jetbrains.kotlin.types.ErrorUtils; import org.jetbrains.kotlin.types.KotlinType; @@ -52,20 +51,17 @@ public class ForLoopConventionsChecker { private final FakeCallResolver fakeCallResolver; private final LanguageFeatureSettings languageFeatureSettings; private final Iterable callCheckers; - private final Iterable symbolUsageValidators; public ForLoopConventionsChecker( @NotNull KotlinBuiltIns builtIns, @NotNull FakeCallResolver fakeCallResolver, @NotNull LanguageFeatureSettings languageFeatureSettings, - @NotNull Iterable callCheckers, - @NotNull Iterable symbolUsageValidators + @NotNull Iterable callCheckers ) { this.builtIns = builtIns; this.fakeCallResolver = fakeCallResolver; this.languageFeatureSettings = languageFeatureSettings; this.callCheckers = callCheckers; - this.symbolUsageValidators = symbolUsageValidators; } @Nullable @@ -90,9 +86,6 @@ public class ForLoopConventionsChecker { for (CallChecker checker : callCheckers) { checker.check(iteratorResolvedCall, loopRangeExpression, callCheckerContext); } - for (SymbolUsageValidator validator : symbolUsageValidators) { - validator.validateCall(iteratorResolvedCall, context.trace, loopRangeExpression); - } KotlinType iteratorType = iteratorFunction.getReturnType(); //noinspection ConstantConditions @@ -148,16 +141,13 @@ public class ForLoopConventionsChecker { assert nextResolutionResults.isSuccess(); ResolvedCall resolvedCall = nextResolutionResults.getResultingCall(); context.trace.record(resolvedCallKey, loopRangeExpression, resolvedCall); - FunctionDescriptor functionDescriptor = resolvedCall.getResultingDescriptor(); CallCheckerContext callCheckerContext = new CallCheckerContext(context, languageFeatureSettings); for (CallChecker checker : callCheckers) { checker.check(resolvedCall, loopRangeExpression, callCheckerContext); } - for (SymbolUsageValidator validator : symbolUsageValidators) { - validator.validateCall(resolvedCall, context.trace, loopRangeExpression); - } + FunctionDescriptor functionDescriptor = resolvedCall.getResultingDescriptor(); checkIfOperatorModifierPresent(loopRangeExpression, functionDescriptor, context.trace); return functionDescriptor.getReturnType();