Drop SymbolUsageValidator#validateCall in favor of CallChecker#check

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<CallChecker> callCheckers;
-    private final Iterable<SymbolUsageValidator> symbolUsageValidators;
 
     public DelegatedPropertyResolver(
             @NotNull KotlinBuiltIns builtIns,
             @NotNull FakeCallResolver fakeCallResolver,
             @NotNull ExpressionTypingServices expressionTypingServices,
             @NotNull LanguageFeatureSettings languageFeatureSettings,
-            @NotNull Iterable<CallChecker> callCheckers,
+            @NotNull Iterable<CallChecker> callCheckers
-            @NotNull Iterable<SymbolUsageValidator> symbolUsageValidators
     ) {
         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);

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
 )

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<CallChecker>,
-        private val symbolUsageValidators: Iterable<SymbolUsageValidator>,
         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)
         }
 

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<KtBinaryExpression>(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<KtReferenceExpression>(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) }
+    }
+}

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

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 org.jetbrains.kotlin.descriptors.ClassifierDescriptor
-import com.intellij.psi.util.PsiTreeUtil
+import org.jetbrains.kotlin.descriptors.PropertyAccessorDescriptor
-import org.jetbrains.kotlin.descriptors.*
+import org.jetbrains.kotlin.psi.KtAnnotationEntry
-import org.jetbrains.kotlin.diagnostics.Diagnostic
+import org.jetbrains.kotlin.psi.KtStubbedPsiUtil
-import org.jetbrains.kotlin.diagnostics.Errors
+import org.jetbrains.kotlin.psi.KtSuperTypeCallEntry
-import org.jetbrains.kotlin.lexer.KtTokens
-import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.resolve.BindingTrace
-import org.jetbrains.kotlin.resolve.Deprecation
+import org.jetbrains.kotlin.resolve.calls.checkers.DeprecatedCallChecker
-import org.jetbrains.kotlin.resolve.DeprecationLevelValue
+import org.jetbrains.kotlin.resolve.createDeprecationDiagnostic
-import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
 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)
+        DeprecatedCallChecker.check(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)
-        }
     }
 
     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<KtBinaryExpression>(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<KtReferenceExpression>(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) }
-    }
 }

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)
 }

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) {

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<CallChecker>,
+        private val callCheckers: Iterable<CallChecker>
-        private val symbolUsageValidators: Iterable<SymbolUsageValidator>
 ) {
     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)

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<CallChecker> callCheckers;
-    private final Iterable<SymbolUsageValidator> symbolUsageValidators;
 
     public ForLoopConventionsChecker(
             @NotNull KotlinBuiltIns builtIns,
             @NotNull FakeCallResolver fakeCallResolver,
             @NotNull LanguageFeatureSettings languageFeatureSettings,
-            @NotNull Iterable<CallChecker> callCheckers,
+            @NotNull Iterable<CallChecker> callCheckers
-            @NotNull Iterable<SymbolUsageValidator> symbolUsageValidators
     ) {
         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<FunctionDescriptor> 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();