Fix presence of Deprecated hidden annotation for reference arguments

#KT-40234 Fixed

compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/components/CallableReferenceResolution.kt

@@ -186,7 +186,8 @@ class CallableReferencesCandidateFactory(
     val scopeTower: ImplicitScopeTower,
     val compatibilityChecker: ((ConstraintSystemOperation) -> Unit) -> Unit,
     val expectedType: UnwrappedType?,
-    private val csBuilder: ConstraintSystemOperation
+    private val csBuilder: ConstraintSystemOperation,
+    private val resolutionCallbacks: KotlinResolutionCallbacks
 ) : CandidateFactory<CallableReferenceCandidate> {
 
     fun createCallableProcessor(explicitReceiver: DetailedReceiver?) =
@@ -212,6 +213,17 @@ class CallableReferencesCandidateFactory(
             callComponents.builtIns
         )
 
+        fun createReferenceCandidate(): CallableReferenceCandidate =
+            CallableReferenceCandidate(
+                candidateDescriptor, dispatchCallableReceiver, extensionCallableReceiver,
+                explicitReceiverKind, reflectionCandidateType, callableReferenceAdaptation, diagnostics
+            )
+
+        if (callComponents.statelessCallbacks.isHiddenInResolution(candidateDescriptor, argument, resolutionCallbacks)) {
+            diagnostics.add(HiddenDescriptor)
+            return createReferenceCandidate()
+        }
+
         if (needCompatibilityResolveForCallableReference(callableReferenceAdaptation, candidateDescriptor)) {
             markCandidateForCompatibilityResolve(diagnostics)
         }
@@ -254,10 +266,7 @@ class CallableReferencesCandidateFactory(
             )
         }
 
-        return CallableReferenceCandidate(
-            candidateDescriptor, dispatchCallableReceiver, extensionCallableReceiver,
-            explicitReceiverKind, reflectionCandidateType, callableReferenceAdaptation, diagnostics
-        )
+        return createReferenceCandidate()
     }
 
     private fun needCompatibilityResolveForCallableReference(

compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/components/CallableReferenceResolver.kt

@@ -23,7 +23,6 @@ import org.jetbrains.kotlin.resolve.calls.inference.ConstraintSystemBuilder
 import org.jetbrains.kotlin.resolve.calls.inference.ConstraintSystemOperation
 import org.jetbrains.kotlin.resolve.calls.inference.components.ConstraintInjector
 import org.jetbrains.kotlin.resolve.calls.inference.components.NewTypeSubstitutor
-import org.jetbrains.kotlin.resolve.calls.inference.model.LowerPriorityToPreserveCompatibility
 import org.jetbrains.kotlin.resolve.calls.model.*
 import org.jetbrains.kotlin.resolve.calls.results.FlatSignature
 import org.jetbrains.kotlin.resolve.calls.results.OverloadingConflictResolver
@@ -76,13 +75,14 @@ class CallableReferenceResolver(
     fun processCallableReferenceArgument(
         csBuilder: ConstraintSystemBuilder,
         resolvedAtom: ResolvedCallableReferenceAtom,
-        diagnosticsHolder: KotlinDiagnosticsHolder
+        diagnosticsHolder: KotlinDiagnosticsHolder,
+        resolutionCallbacks: KotlinResolutionCallbacks
     ) {
         val argument = resolvedAtom.atom
         val expectedType = resolvedAtom.expectedType?.let { (csBuilder.buildCurrentSubstitutor() as NewTypeSubstitutor).safeSubstitute(it) }
 
         val scopeTower = callComponents.statelessCallbacks.getScopeTowerForCallableReferenceArgument(argument)
-        val candidates = runRHSResolution(scopeTower, argument, expectedType, csBuilder) { checkCallableReference ->
+        val candidates = runRHSResolution(scopeTower, argument, expectedType, csBuilder, resolutionCallbacks) { checkCallableReference ->
             csBuilder.runTransaction { checkCallableReference(this); false }
         }
 
@@ -144,10 +144,11 @@ class CallableReferenceResolver(
         callableReference: CallableReferenceKotlinCallArgument,
         expectedType: UnwrappedType?, // this type can have not fixed type variable inside
         csBuilder: ConstraintSystemBuilder,
+        resolutionCallbacks: KotlinResolutionCallbacks,
         compatibilityChecker: ((ConstraintSystemOperation) -> Unit) -> Unit // you can run anything throw this operation and all this operation will be rolled back
     ): Set<CallableReferenceCandidate> {
         val factory = CallableReferencesCandidateFactory(
-            callableReference, callComponents, scopeTower, compatibilityChecker, expectedType, csBuilder
+            callableReference, callComponents, scopeTower, compatibilityChecker, expectedType, csBuilder, resolutionCallbacks
         )
         val processor = createCallableReferenceProcessor(factory)
         val candidates = towerResolver.runResolve(scopeTower, processor, useOrder = true, name = callableReference.rhsName)

compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/components/ExternalComponents.kt

@@ -27,6 +27,10 @@ interface KotlinResolutionStatelessCallbacks {
     fun isInfixCall(kotlinCall: KotlinCall): Boolean
     fun isOperatorCall(kotlinCall: KotlinCall): Boolean
     fun isSuperOrDelegatingConstructorCall(kotlinCall: KotlinCall): Boolean
+    fun isHiddenInResolution(
+        descriptor: DeclarationDescriptor, kotlinCallArgument: KotlinCallArgument, resolutionCallbacks: KotlinResolutionCallbacks
+    ): Boolean
+
     fun isHiddenInResolution(
         descriptor: DeclarationDescriptor, kotlinCall: KotlinCall, resolutionCallbacks: KotlinResolutionCallbacks
     ): Boolean

compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/components/PostponedArgumentsAnalyzer.kt

@@ -58,7 +58,7 @@ class PostponedArgumentsAnalyzer(
                 )
 
             is ResolvedCallableReferenceAtom ->
-                callableReferenceResolver.processCallableReferenceArgument(c.getBuilder(), argument, diagnosticsHolder)
+                callableReferenceResolver.processCallableReferenceArgument(c.getBuilder(), argument, diagnosticsHolder, resolutionCallbacks)
 
             is ResolvedCollectionLiteralAtom -> TODO("Not supported")
 

compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/components/ResolutionParts.kt

@@ -638,7 +638,7 @@ internal object EagerResolveOfCallableReferences : ResolutionPart() {
         getSubResolvedAtoms()
             .filterIsInstance<EagerCallableReferenceAtom>()
             .forEach {
-                callableReferenceResolver.processCallableReferenceArgument(csBuilder, it, this)
+                callableReferenceResolver.processCallableReferenceArgument(csBuilder, it, this, resolutionCallbacks)
             }
     }
 }