[ObjCInterop] Implement @ObjCSignatureOverride

This annotation leads to conflicting overloads error supression,
in case where several function with the same argument types,
but different argument names are inherited from ObjC class.

We need to implement it in both K1 and K2 to make the IDE experience
better.
But the annotation itself wouldn't be available in K1.

    ^KT-61323

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

@@ -16,9 +16,12 @@
 
 package org.jetbrains.kotlin.resolve
 
+import com.intellij.psi.PsiElement
 import com.intellij.util.containers.MultiMap
 import org.jetbrains.kotlin.config.LanguageVersionSettings
+import org.jetbrains.kotlin.container.DefaultImplementation
 import org.jetbrains.kotlin.descriptors.*
+import org.jetbrains.kotlin.diagnostics.DiagnosticFactory1
 import org.jetbrains.kotlin.diagnostics.Errors
 import org.jetbrains.kotlin.diagnostics.reportOnDeclaration
 import org.jetbrains.kotlin.idea.MainFunctionDetector
@@ -30,11 +33,35 @@ import org.jetbrains.kotlin.resolve.descriptorUtil.platform
 import org.jetbrains.kotlin.resolve.scopes.MemberScope
 import java.util.*
 
+@DefaultImplementation(impl = ConflictingOverloadsDispatcher.Default::class)
+interface ConflictingOverloadsDispatcher {
+    fun getDiagnostic(
+        languageVersionSettings: LanguageVersionSettings,
+        declaration: DeclarationDescriptor,
+        redeclarations: Collection<DeclarationDescriptor>
+    ): DiagnosticFactory1<PsiElement, Collection<DeclarationDescriptor>>?
+
+    object Default : ConflictingOverloadsDispatcher {
+        override fun getDiagnostic(
+            languageVersionSettings: LanguageVersionSettings,
+            declaration: DeclarationDescriptor,
+            redeclarations: Collection<DeclarationDescriptor>
+        ): DiagnosticFactory1<PsiElement, Collection<DeclarationDescriptor>>? {
+            return when (declaration) {
+                is PropertyDescriptor, is ClassifierDescriptor -> Errors.REDECLARATION
+                is FunctionDescriptor -> Errors.CONFLICTING_OVERLOADS
+                else -> null
+            }
+        }
+    }
+}
+
 class OverloadResolver(
     private val trace: BindingTrace,
     private val overloadFilter: OverloadFilter,
     private val overloadChecker: OverloadChecker,
-    languageVersionSettings: LanguageVersionSettings,
+    private val errorDispatcher: ConflictingOverloadsDispatcher,
+    private val languageVersionSettings: LanguageVersionSettings,
     mainFunctionDetectorFactory: MainFunctionDetector.Factory
 ) {
 
@@ -299,12 +326,9 @@ class OverloadResolver(
         if (redeclarations.isEmpty()) return
 
         for (memberDescriptor in redeclarations) {
-            when (memberDescriptor) {
-                is PropertyDescriptor,
-                is ClassifierDescriptor ->
-                    reportOnDeclaration(trace, memberDescriptor) { Errors.REDECLARATION.on(it, redeclarations) }
-                is FunctionDescriptor ->
-                    reportOnDeclaration(trace, memberDescriptor) { Errors.CONFLICTING_OVERLOADS.on(it, redeclarations) }
+            val diagnostic = errorDispatcher.getDiagnostic(languageVersionSettings, memberDescriptor, redeclarations) ?: continue
+            reportOnDeclaration(trace, memberDescriptor) {
+                diagnostic.on(it, redeclarations)
             }
         }
     }