FIR checker: introduce DECLARATION_SIGNATURE_OR_DEFAULT positioning strategy

and fix CONFLICTING_OVERLOADS to use it

compiler/fir/analysis-tests/testData/resolve/diagnostics/conflictingOverloads.kt

-<!CONFLICTING_OVERLOADS!>fun test(x: Int) {}<!>
+<!CONFLICTING_OVERLOADS{LT}!><!CONFLICTING_OVERLOADS{PSI}!>fun test(x: Int)<!> {}<!>
 
-<!CONFLICTING_OVERLOADS!>fun test(y: Int) {}<!>
+<!CONFLICTING_OVERLOADS{LT}!><!CONFLICTING_OVERLOADS{PSI}!>fun test(y: Int)<!> {}<!>
 
 fun test() {}
 
@@ -17,9 +17,9 @@ fun test(z: Int, c: Char) {}
 }<!>
 
 <!REDECLARATION!>class B : A {
-    <!CONFLICTING_OVERLOADS!>override fun rest(s: String) {}<!>
+    <!CONFLICTING_OVERLOADS{LT}!><!CONFLICTING_OVERLOADS{PSI}!>override fun rest(s: String)<!> {}<!>
 
-    <!CONFLICTING_OVERLOADS!>fun rest(s: String) {}<!>
+    <!CONFLICTING_OVERLOADS{LT}!><!CONFLICTING_OVERLOADS{PSI}!>fun rest(s: String)<!> {}<!>
 
     fun rest(l: Long) {}
 
@@ -45,8 +45,8 @@ fun <T : Int> kek(t: T) {}
 fun lol(a: Array<Int>) {}
 fun lol(a: Array<Boolean>) {}
 
-<!CONFLICTING_OVERLOADS!>fun <T> mem(t: T) where T : () -> Boolean, T : String {}<!>
-<!CONFLICTING_OVERLOADS!>fun <T> mem(t: T) where T : String, T : () -> Boolean {}<!>
+<!CONFLICTING_OVERLOADS{LT}!><!CONFLICTING_OVERLOADS{PSI}!>fun <T> mem(t: T)<!> where T : () -> Boolean, T : String {}<!>
+<!CONFLICTING_OVERLOADS{LT}!><!CONFLICTING_OVERLOADS{PSI}!>fun <T> mem(t: T)<!> where T : String, T : () -> Boolean {}<!>
 
 class M {
     <!REDECLARATION{LT}!>companion <!REDECLARATION{PSI}!>object<!> {}<!>

compiler/fir/analysis-tests/testData/resolve/smartcasts/receivers/mixingImplicitAndExplicitReceivers.kt

-<!CONFLICTING_OVERLOADS!>fun takeString(s: String) {}<!>
+<!CONFLICTING_OVERLOADS{LT}!><!CONFLICTING_OVERLOADS{PSI}!>fun takeString(s: String)<!> {}<!>
 
 class Wrapper(val s: String?) {
     fun withThis() {
@@ -11,4 +11,4 @@ class Wrapper(val s: String?) {
     }
 }
 
-<!CONFLICTING_OVERLOADS!>fun takeString(s: String) {}<!>
+<!CONFLICTING_OVERLOADS{LT}!><!CONFLICTING_OVERLOADS{PSI}!>fun takeString(s: String)<!> {}<!>

compiler/fir/analysis-tests/testData/resolve/smartcasts/safeCalls/assignSafeCall.kt

@@ -23,7 +23,7 @@ fun test_2(a: A?) {
     }
 }
 
-<!CONFLICTING_OVERLOADS!>fun test_3(x: Any?) {
+<!CONFLICTING_OVERLOADS{LT}!><!CONFLICTING_OVERLOADS{PSI}!>fun test_3(x: Any?)<!> {
     val a = x as? A ?: return
     a.foo() // Should be OK
     x.foo() // Should be OK
@@ -53,7 +53,7 @@ fun test_2(a: B?) {
     }
 }
 
-<!CONFLICTING_OVERLOADS!>fun test_3(x: Any?) {
+<!CONFLICTING_OVERLOADS{LT}!><!CONFLICTING_OVERLOADS{PSI}!>fun test_3(x: Any?)<!> {
     val a = x as? B ?: return
     a.foo() // Should be OK
     x.foo() // Should be OK

compiler/fir/analysis-tests/testData/resolve/whenElse.kt

@@ -13,7 +13,7 @@ class B()
 class C(val b : B)
 fun get(f: Boolean) = if (f) {A.A1} else {""}
 
-<!CONFLICTING_OVERLOADS!>fun case2() {
+<!CONFLICTING_OVERLOADS{LT}!><!CONFLICTING_OVERLOADS{PSI}!>fun case2()<!> {
 
     val flag: Any = get(false) //string
     val l1 = when (flag!!) { // should be NO_ELSE_IN_WHEN
@@ -27,7 +27,7 @@ fun get(f: Boolean) = if (f) {A.A1} else {""}
     }
 }<!>
 
-<!CONFLICTING_OVERLOADS!>fun case2() {
+<!CONFLICTING_OVERLOADS{LT}!><!CONFLICTING_OVERLOADS{PSI}!>fun case2()<!> {
 
     val flag: Any = get(true)  //A
     val l1 = when (flag!!) {// should be NO_ELSE_IN_WHEN

compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/beyoundCalls.kt

-<!CONFLICTING_OVERLOADS!>fun bar(x: String): Int = 1<!>
-<!CONFLICTING_OVERLOADS!>fun bar(x: String): Double = 1<!>
+<!CONFLICTING_OVERLOADS{LT}!><!CONFLICTING_OVERLOADS!>fun bar(x: String): Int<!> = 1<!>
+<!CONFLICTING_OVERLOADS{LT}!><!CONFLICTING_OVERLOADS!>fun bar(x: String): Double<!> = 1<!>
 
 fun baz(x: String): Int = 1
 fun <T, R> foobaz(x: T): R = TODO()

compiler/fir/analysis-tests/testData/resolveWithStdlib/lowPriorityInResolution.kt

-<!CONFLICTING_OVERLOADS!>@Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
+<!CONFLICTING_OVERLOADS{LT}!><!CONFLICTING_OVERLOADS!>@Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
 <!HIDDEN!>@kotlin.internal.LowPriorityInOverloadResolution<!>
-fun foo(): Int = 1<!>
+fun foo(): Int<!> = 1<!>
 
-<!CONFLICTING_OVERLOADS!>fun foo(): String = ""<!>
+<!CONFLICTING_OVERLOADS{LT}!><!CONFLICTING_OVERLOADS!>fun foo(): String<!> = ""<!>
 
 fun test() {
     val s = foo()

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrors.kt

@@ -139,7 +139,7 @@ object FirErrors {
 
     // Redeclarations
     val MANY_COMPANION_OBJECTS by error0<FirSourceElement, PsiElement>()
-    val CONFLICTING_OVERLOADS by error1<FirSourceElement, PsiElement, String>()
+    val CONFLICTING_OVERLOADS by error1<FirSourceElement, PsiElement, String>(SourceElementPositioningStrategies.DECLARATION_SIGNATURE_OR_DEFAULT)
     val REDECLARATION by error1<FirSourceElement, PsiElement, String>()
     val ANY_METHOD_IMPLEMENTED_IN_INTERFACE by error0<FirSourceElement, PsiElement>()
 

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/LightTreePositioningStrategies.kt

@@ -145,6 +145,30 @@ object LightTreePositioningStrategies {
         }
     }
 
+    val DECLARATION_SIGNATURE_OR_DEFAULT: LightTreePositioningStrategy = object : LightTreePositioningStrategy() {
+        override fun mark(node: LighterASTNode, tree: FlyweightCapableTreeStructure<LighterASTNode>): List<TextRange> =
+            if (node.isDeclaration) {
+                DECLARATION_SIGNATURE.mark(node, tree)
+            } else {
+                DEFAULT.mark(node, tree)
+            }
+
+        private val LighterASTNode.isDeclaration: Boolean
+            get() =
+                when (tokenType) {
+                    KtNodeTypes.PRIMARY_CONSTRUCTOR, KtNodeTypes.SECONDARY_CONSTRUCTOR,
+                    KtNodeTypes.FUN, KtNodeTypes.FUNCTION_LITERAL,
+                    KtNodeTypes.PROPERTY,
+                    KtNodeTypes.PROPERTY_ACCESSOR,
+                    KtNodeTypes.CLASS,
+                    KtNodeTypes.OBJECT_DECLARATION,
+                    KtNodeTypes.CLASS_INITIALIZER ->
+                        true
+                    else ->
+                        false
+                }
+    }
+
     private class ModifierSetBasedLightTreePositioningStrategy(private val modifierSet: TokenSet) : LightTreePositioningStrategy() {
         override fun mark(node: LighterASTNode, tree: FlyweightCapableTreeStructure<LighterASTNode>): List<TextRange> {
             tree.findChildByType(node, modifierSet)?.let { return markElement(it, tree) }

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/SourceElementPositioningStrategies.kt

@@ -33,6 +33,11 @@ object SourceElementPositioningStrategies {
         PositioningStrategies.DECLARATION_SIGNATURE
     )
 
+    val DECLARATION_SIGNATURE_OR_DEFAULT = SourceElementPositioningStrategy(
+        LightTreePositioningStrategies.DECLARATION_SIGNATURE_OR_DEFAULT,
+        PositioningStrategies.DECLARATION_SIGNATURE_OR_DEFAULT
+    )
+
     val VISIBILITY_MODIFIER = SourceElementPositioningStrategy(
         LightTreePositioningStrategies.VISIBILITY_MODIFIER,
         PositioningStrategies.VISIBILITY_MODIFIER

compiler/testData/diagnostics/tests/dataClasses/conflictingCopyOverloads.fir.kt

 // !DIAGNOSTICS: -UNUSED_PARAMETER
 
 data class A(val x: Int, val y: String) {
-    <!CONFLICTING_OVERLOADS!>fun copy(x: Int, y: String) = x<!>
-    <!CONFLICTING_OVERLOADS!>fun copy(x: Int, y: String) = A(x, y)<!>
+    <!CONFLICTING_OVERLOADS!>fun copy(x: Int, y: String)<!> = x
+    <!CONFLICTING_OVERLOADS!>fun copy(x: Int, y: String)<!> = A(x, y)
 }
\ No newline at end of file

compiler/testData/diagnostics/tests/declarationChecks/MultiDeclarationErrors.fir.kt

@@ -7,8 +7,8 @@ class MyClass {
 
 class MyClass2 {}
 
-<!CONFLICTING_OVERLOADS!>fun MyClass2.component1() = 1.2<!>
-<!CONFLICTING_OVERLOADS!>fun MyClass2.component1() = 1.3<!>
+<!CONFLICTING_OVERLOADS!>fun MyClass2.component1()<!> = 1.2
+<!CONFLICTING_OVERLOADS!>fun MyClass2.component1()<!> = 1.3
 
 fun test(mc1: MyClass, mc2: MyClass2) {
     val (<!INAPPLICABLE_CANDIDATE!>a<!>, <!UNRESOLVED_REFERENCE!>b<!>) = mc1

compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/ForLoopComponentFunctionAmbiguity.fir.kt

 class A {
-    <!CONFLICTING_OVERLOADS!>operator fun component1() = 1<!>
-    <!CONFLICTING_OVERLOADS!>operator fun component1() = 1<!>
+    <!CONFLICTING_OVERLOADS!>operator fun component1()<!> = 1
+    <!CONFLICTING_OVERLOADS!>operator fun component1()<!> = 1
     operator fun component2() = 1
 }
 

compiler/testData/diagnostics/tests/multiplatform/topLevelFun/conflictingImplDeclarations.fir.kt

@@ -7,11 +7,11 @@ expect fun foo()
 // MODULE: m2-jvm(m1-common)
 // FILE: jvm.kt
 
-<!CONFLICTING_OVERLOADS!>actual fun foo() {}<!>
-<!CONFLICTING_OVERLOADS!>actual fun foo() {}<!>
+<!CONFLICTING_OVERLOADS!>actual fun foo()<!> {}
+<!CONFLICTING_OVERLOADS!>actual fun foo()<!> {}
 
 // MODULE: m3-js(m1-common)
 // FILE: js.kt
 
-<!CONFLICTING_OVERLOADS!>actual fun foo() {}<!>
-<!CONFLICTING_OVERLOADS!>actual fun foo() {}<!>
+<!CONFLICTING_OVERLOADS!>actual fun foo()<!> {}
+<!CONFLICTING_OVERLOADS!>actual fun foo()<!> {}

compiler/testData/diagnostics/tests/multiplatform/topLevelFun/headerDeclarationWithBody.fir.kt

@@ -4,6 +4,6 @@
 
 <!CONFLICTING_OVERLOADS!>expect fun foo()<!>
 
-<!CONFLICTING_OVERLOADS!>expect fun foo() {}<!>
+<!CONFLICTING_OVERLOADS!>expect fun foo()<!> {}
 
 expect fun bar() {}

compiler/testData/diagnostics/tests/overload/ConflictingOverloadsFunsDifferentReturnInClass.fir.kt

 class A {
-    <!CONFLICTING_OVERLOADS!>fun a(a: Int): Int = 0<!>
+    <!CONFLICTING_OVERLOADS!>fun a(a: Int): Int<!> = 0
 
-    <!CONFLICTING_OVERLOADS!>fun a(a: Int) {
-    }<!>
+    <!CONFLICTING_OVERLOADS!>fun a(a: Int)<!> {
+    }
 }

compiler/testData/diagnostics/tests/overload/ConflictingOverloadsFunsDifferentReturnInPackage.fir.kt

 package qwertyuiop
 
-<!CONFLICTING_OVERLOADS!>fun c(s: String) {
-}<!>
+<!CONFLICTING_OVERLOADS!>fun c(s: String)<!> {
+}
 
-<!CONFLICTING_OVERLOADS!>fun c(s: String) {
-}<!>
+<!CONFLICTING_OVERLOADS!>fun c(s: String)<!> {
+}

compiler/testData/diagnostics/tests/overload/ConflictingOverloadsIdenticalExtFunsInPackage.fir.kt

 package extensionFunctions
 
-<!CONFLICTING_OVERLOADS!>fun Int.qwe(a: Float) = 1<!>
+<!CONFLICTING_OVERLOADS!>fun Int.qwe(a: Float)<!> = 1
 
-<!CONFLICTING_OVERLOADS!>fun Int.qwe(a: Float) = 2<!>
+<!CONFLICTING_OVERLOADS!>fun Int.qwe(a: Float)<!> = 2

compiler/testData/diagnostics/tests/overload/ConflictingOverloadsIdenticalFunsInClass.fir.kt

-class A() {
-    <!CONFLICTING_OVERLOADS!>fun b() {
-    }<!>
-
-    <!CONFLICTING_OVERLOADS!>fun b() {
-    }<!>
-}

compiler/testData/diagnostics/tests/overload/ConflictingOverloadsIdenticalFunsInClass.kt

+// FIR_IDENTICAL
 class A() {
     <!CONFLICTING_OVERLOADS!>fun b()<!> {
     }

compiler/testData/diagnostics/tests/overload/TypeParameterMultipleBounds.fir.kt

-import java.io.Serializable
-
-interface Test1 {
-    <!CONFLICTING_OVERLOADS!>fun <T> foo(t: T) where T : Cloneable, T : Serializable<!>
-    <!CONFLICTING_OVERLOADS!>fun <T> foo(t: T) where T : Serializable, T : Cloneable<!>
-}
-
-
-interface I1
-interface I2 : I1
-
-interface Test2 {
-    <!CONFLICTING_OVERLOADS!>fun <T> foo(t: T) where T : I1, T : I2<!>
-    <!CONFLICTING_OVERLOADS!>fun <T> foo(t: T) where T : I2, T : I1<!>
-}

compiler/testData/diagnostics/tests/overload/TypeParameterMultipleBounds.kt

+// FIR_IDENTICAL
 import java.io.Serializable
 
 interface Test1 {

compiler/testData/diagnostics/tests/override/DuplicateMethod.fir.kt

-interface Some {
-    fun test()
-}
-
-class SomeImpl : Some  {
-    <!CONFLICTING_OVERLOADS!>override fun test() {}<!>
-    <!CONFLICTING_OVERLOADS!>override fun test() {}<!>
-}
\ No newline at end of file

compiler/testData/diagnostics/tests/override/DuplicateMethod.kt

+// FIR_IDENTICAL
 interface Some {
     fun test()
 }

compiler/testData/diagnostics/tests/redeclarations/RedeclarationMainInFile.fir.kt

-// !DIAGNOSTICS: -UNUSED_PARAMETER
-// KT-9733 No error shown for 2 "main" functions in the same file
-
-<!CONFLICTING_OVERLOADS!>fun main(args: Array<String>) {}<!>
-<!CONFLICTING_OVERLOADS!>fun main(args: Array<String>) {}<!>
\ No newline at end of file

compiler/testData/diagnostics/tests/redeclarations/RedeclarationMainInFile.kt

+// FIR_IDENTICAL
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 // KT-9733 No error shown for 2 "main" functions in the same file
 

compiler/testData/diagnostics/tests/redeclarations/RedeclaringPrivateToFile.fir.kt

@@ -14,16 +14,16 @@ private val invalidProp0 = 1
 fun useInvalidFun0() = invalidFun0()
 fun useInvalidProp0() = invalidProp0
 
-<!CONFLICTING_OVERLOADS!>private fun invalidFun1() {}<!>
-<!CONFLICTING_OVERLOADS!>private fun invalidFun1() {}<!>
+<!CONFLICTING_OVERLOADS!>private fun invalidFun1()<!> {}
+<!CONFLICTING_OVERLOADS!>private fun invalidFun1()<!> {}
 
-<!CONFLICTING_OVERLOADS!>private fun invalidFun2() {}<!>
-<!CONFLICTING_OVERLOADS!>public fun invalidFun2() {}<!>
+<!CONFLICTING_OVERLOADS!>private fun invalidFun2()<!> {}
+<!CONFLICTING_OVERLOADS!>public fun invalidFun2()<!> {}
 
 public fun invalidFun3() {}
 
-<!CONFLICTING_OVERLOADS!>private fun invalidFun4() {}<!>
-<!CONFLICTING_OVERLOADS!>public fun invalidFun4() {}<!>
+<!CONFLICTING_OVERLOADS!>private fun invalidFun4()<!> {}
+<!CONFLICTING_OVERLOADS!>public fun invalidFun4()<!> {}
 
 public fun validFun2(a: A) = a
 public fun validFun2(b: B) = b

compiler/testData/diagnostics/tests/redeclarations/kt470.fir.kt

@@ -7,14 +7,14 @@
 <!REDECLARATION!>val b : Int = 1<!>
 <!REDECLARATION!>val b : Int = 1<!>
 
-<!CONFLICTING_OVERLOADS!>fun foo() {}<!> // and here too
-<!CONFLICTING_OVERLOADS!>fun foo() {}<!> // and here
-<!CONFLICTING_OVERLOADS!>fun foo() {}<!> // and here
-<!CONFLICTING_OVERLOADS!>fun foo() {}<!> // and here
+<!CONFLICTING_OVERLOADS!>fun foo()<!> {} // and here too
+<!CONFLICTING_OVERLOADS!>fun foo()<!> {} // and here
+<!CONFLICTING_OVERLOADS!>fun foo()<!> {} // and here
+<!CONFLICTING_OVERLOADS!>fun foo()<!> {} // and here
 
-<!CONFLICTING_OVERLOADS!>fun bar() {}<!> // and here
-<!CONFLICTING_OVERLOADS!>fun bar() {}<!> // and here
-<!CONFLICTING_OVERLOADS!>fun bar() {}<!> // and here
+<!CONFLICTING_OVERLOADS!>fun bar()<!> {} // and here
+<!CONFLICTING_OVERLOADS!>fun bar()<!> {} // and here
+<!CONFLICTING_OVERLOADS!>fun bar()<!> {} // and here
 
 class A {
     <!REDECLARATION!>val a : Int = 1<!>
@@ -26,12 +26,12 @@ class A {
     <!REDECLARATION!>val b : Int = 1<!>
     <!REDECLARATION!>val b : Int = 1<!>
 
-    <!CONFLICTING_OVERLOADS!>fun foo() {}<!> // and here too
-    <!CONFLICTING_OVERLOADS!>fun foo() {}<!> // and here
-    <!CONFLICTING_OVERLOADS!>fun foo() {}<!> // and here
-    <!CONFLICTING_OVERLOADS!>fun foo() {}<!> // and here
+    <!CONFLICTING_OVERLOADS!>fun foo()<!> {} // and here too
+    <!CONFLICTING_OVERLOADS!>fun foo()<!> {} // and here
+    <!CONFLICTING_OVERLOADS!>fun foo()<!> {} // and here
+    <!CONFLICTING_OVERLOADS!>fun foo()<!> {} // and here
 
-    <!CONFLICTING_OVERLOADS!>fun bar() {}<!> // and here
-    <!CONFLICTING_OVERLOADS!>fun bar() {}<!> // and here
-    <!CONFLICTING_OVERLOADS!>fun bar() {}<!> // and here
+    <!CONFLICTING_OVERLOADS!>fun bar()<!> {} // and here
+    <!CONFLICTING_OVERLOADS!>fun bar()<!> {} // and here
+    <!CONFLICTING_OVERLOADS!>fun bar()<!> {} // and here
 }

compiler/testData/diagnostics/tests/resolve/resolveWithRedeclarationError.fir.kt

@@ -3,32 +3,32 @@ package c
 
 fun z(view: () -> Unit) {}
 
-<!CONFLICTING_OVERLOADS!>fun x() = z { z { z { z { z { z { z { z { } } } } } } } }<!>
-<!CONFLICTING_OVERLOADS!>fun x() = z { z { z { z { z { z { z { z { } } } } } } } }<!>
-<!CONFLICTING_OVERLOADS!>fun x() = z { z { z { z { z { z { z { z { } } } } } } } }<!>
-<!CONFLICTING_OVERLOADS!>fun x() = z { z { z { z { z { z { z { z { } } } } } } } }<!>
-<!CONFLICTING_OVERLOADS!>fun x() = z { z { z { z { z { z { z { z { } } } } } } } }<!>
-<!CONFLICTING_OVERLOADS!>fun x() = z { z { z { z { z { z { z { z { } } } } } } } }<!>
-<!CONFLICTING_OVERLOADS!>fun x() = z { z { z { z { z { z { z { z { } } } } } } } }<!>
-<!CONFLICTING_OVERLOADS!>fun x() = z { z { z { z { z { z { z { z { } } } } } } } }<!>
-<!CONFLICTING_OVERLOADS!>fun x() = z { z { z { z { z { z { z { z { } } } } } } } }<!>
-<!CONFLICTING_OVERLOADS!>fun x() = z { z { z { z { z { z { z { z { } } } } } } } }<!>
-<!CONFLICTING_OVERLOADS!>fun x() = z { z { z { z { z { z { z { z { } } } } } } } }<!>
-<!CONFLICTING_OVERLOADS!>fun x() = z { z { z { z { z { z { z { z { } } } } } } } }<!>
-<!CONFLICTING_OVERLOADS!>fun x() = z { z { z { z { z { z { z { z { } } } } } } } }<!>
-<!CONFLICTING_OVERLOADS!>fun x() = z { z { z { z { z { z { z { z { } } } } } } } }<!>
-<!CONFLICTING_OVERLOADS!>fun x() = z { z { z { z { z { z { z { z { } } } } } } } }<!>
-<!CONFLICTING_OVERLOADS!>fun x() = z { z { z { z { z { z { z { z { } } } } } } } }<!>
-<!CONFLICTING_OVERLOADS!>fun x() = z { z { z { z { z { z { z { z { } } } } } } } }<!>
-<!CONFLICTING_OVERLOADS!>fun x() = z { z { z { z { z { z { z { z { } } } } } } } }<!>
-<!CONFLICTING_OVERLOADS!>fun x() = z { z { z { z { z { z { z { z { } } } } } } } }<!>
-<!CONFLICTING_OVERLOADS!>fun x() = z { z { z { z { z { z { z { z { } } } } } } } }<!>
-<!CONFLICTING_OVERLOADS!>fun x() = z { z { z { z { z { z { z { z { } } } } } } } }<!>
-<!CONFLICTING_OVERLOADS!>fun x() = z { z { z { z { z { z { z { z { } } } } } } } }<!>
-<!CONFLICTING_OVERLOADS!>fun x() = z { z { z { z { z { z { z { z { } } } } } } } }<!>
-<!CONFLICTING_OVERLOADS!>fun x() = z { z { z { z { z { z { z { z { } } } } } } } }<!>
-<!CONFLICTING_OVERLOADS!>fun x() = z { z { z { z { z { z { z { z { } } } } } } } }<!>
-<!CONFLICTING_OVERLOADS!>fun x() = z { z { z { z { z { z { z { z { } } } } } } } }<!>
-<!CONFLICTING_OVERLOADS!>fun x() = z { z { z { z { z { z { z { z { } } } } } } } }<!>
+<!CONFLICTING_OVERLOADS!>fun x()<!> = z { z { z { z { z { z { z { z { } } } } } } } }
+<!CONFLICTING_OVERLOADS!>fun x()<!> = z { z { z { z { z { z { z { z { } } } } } } } }
+<!CONFLICTING_OVERLOADS!>fun x()<!> = z { z { z { z { z { z { z { z { } } } } } } } }
+<!CONFLICTING_OVERLOADS!>fun x()<!> = z { z { z { z { z { z { z { z { } } } } } } } }
+<!CONFLICTING_OVERLOADS!>fun x()<!> = z { z { z { z { z { z { z { z { } } } } } } } }
+<!CONFLICTING_OVERLOADS!>fun x()<!> = z { z { z { z { z { z { z { z { } } } } } } } }
+<!CONFLICTING_OVERLOADS!>fun x()<!> = z { z { z { z { z { z { z { z { } } } } } } } }
+<!CONFLICTING_OVERLOADS!>fun x()<!> = z { z { z { z { z { z { z { z { } } } } } } } }
+<!CONFLICTING_OVERLOADS!>fun x()<!> = z { z { z { z { z { z { z { z { } } } } } } } }
+<!CONFLICTING_OVERLOADS!>fun x()<!> = z { z { z { z { z { z { z { z { } } } } } } } }
+<!CONFLICTING_OVERLOADS!>fun x()<!> = z { z { z { z { z { z { z { z { } } } } } } } }
+<!CONFLICTING_OVERLOADS!>fun x()<!> = z { z { z { z { z { z { z { z { } } } } } } } }
+<!CONFLICTING_OVERLOADS!>fun x()<!> = z { z { z { z { z { z { z { z { } } } } } } } }
+<!CONFLICTING_OVERLOADS!>fun x()<!> = z { z { z { z { z { z { z { z { } } } } } } } }
+<!CONFLICTING_OVERLOADS!>fun x()<!> = z { z { z { z { z { z { z { z { } } } } } } } }
+<!CONFLICTING_OVERLOADS!>fun x()<!> = z { z { z { z { z { z { z { z { } } } } } } } }
+<!CONFLICTING_OVERLOADS!>fun x()<!> = z { z { z { z { z { z { z { z { } } } } } } } }
+<!CONFLICTING_OVERLOADS!>fun x()<!> = z { z { z { z { z { z { z { z { } } } } } } } }
+<!CONFLICTING_OVERLOADS!>fun x()<!> = z { z { z { z { z { z { z { z { } } } } } } } }
+<!CONFLICTING_OVERLOADS!>fun x()<!> = z { z { z { z { z { z { z { z { } } } } } } } }
+<!CONFLICTING_OVERLOADS!>fun x()<!> = z { z { z { z { z { z { z { z { } } } } } } } }
+<!CONFLICTING_OVERLOADS!>fun x()<!> = z { z { z { z { z { z { z { z { } } } } } } } }
+<!CONFLICTING_OVERLOADS!>fun x()<!> = z { z { z { z { z { z { z { z { } } } } } } } }
+<!CONFLICTING_OVERLOADS!>fun x()<!> = z { z { z { z { z { z { z { z { } } } } } } } }
+<!CONFLICTING_OVERLOADS!>fun x()<!> = z { z { z { z { z { z { z { z { } } } } } } } }
+<!CONFLICTING_OVERLOADS!>fun x()<!> = z { z { z { z { z { z { z { z { } } } } } } } }
+<!CONFLICTING_OVERLOADS!>fun x()<!> = z { z { z { z { z { z { z { z { } } } } } } } }
 
 class x() {}
\ No newline at end of file

compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendConflictsWithNoSuspend.fir.kt

@@ -5,11 +5,11 @@ interface A {
 }
 
 interface B : A {
-    <!CONFLICTING_OVERLOADS!>suspend override fun foo() {
+    <!CONFLICTING_OVERLOADS!>suspend override fun foo()<!> {
 
-    }<!>
+    }
 
-    <!CONFLICTING_OVERLOADS!>override fun foo() {
+    <!CONFLICTING_OVERLOADS!>override fun foo()<!> {
 
-    }<!>
+    }
 }

compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/noInferAndLowPriority.fir.kt

@@ -4,10 +4,10 @@
 <!CONFLICTING_OVERLOADS!>@Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
 @kotlin.jvm.JvmName("containsAny")
 <!HIDDEN!>@kotlin.internal.LowPriorityInOverloadResolution<!>
-public fun <T> Iterable<T>.contains1(element: T): Int = null!!<!>
+public fun <T> Iterable<T>.contains1(element: T): Int<!> = null!!
 
 <!CONFLICTING_OVERLOADS!>@Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
-public fun <T> Iterable<T>.contains1(element: @kotlin.internal.NoInfer T): Boolean = null!!<!>
+public fun <T> Iterable<T>.contains1(element: @kotlin.internal.NoInfer T): Boolean<!> = null!!
 
 
 fun test() {

compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesAndLowPriority.fir.kt

@@ -5,10 +5,10 @@
 <!CONFLICTING_OVERLOADS!>@Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
 @kotlin.jvm.JvmName("containsAny")
 <!HIDDEN!>@kotlin.internal.LowPriorityInOverloadResolution<!>
-public fun <T> Iterable<T>.contains1(element: T): Int = null!!<!>
+public fun <T> Iterable<T>.contains1(element: T): Int<!> = null!!
 
 <!CONFLICTING_OVERLOADS!>@Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
-public fun <<!HIDDEN!>@kotlin.internal.OnlyInputTypes<!> T> Iterable<T>.contains1(element: T): Boolean = null!!<!>
+public fun <<!HIDDEN!>@kotlin.internal.OnlyInputTypes<!> T> Iterable<T>.contains1(element: T): Boolean<!> = null!!
 
 @Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
 @JvmName("getAny")