FIR: rename AMBIGUITY to OVERLOAD_RESOLUTION_AMBIGUITY to match FE 1.0

compiler/fir/analysis-tests/testData/resolve/arrays/arraySetWithOperation.kt

@@ -28,7 +28,7 @@ fun test_2(a: A<C>) {
 }
 
 fun test_3(a: A<D>) {
-    a[0] <!AMBIGUITY!>+=<!> D() // ambiguity
+    a[0] <!OVERLOAD_RESOLUTION_AMBIGUITY!>+=<!> D() // ambiguity
 }
 
 fun test_4(b: B) {

compiler/fir/analysis-tests/testData/resolve/callResolution/errorCandidates.kt

@@ -12,7 +12,7 @@ fun test(c: C) {
     <!INAPPLICABLE_CANDIDATE!>foo<!>("")
 
     // Ambiguity
-    <!AMBIGUITY!>bar<!>(c)
+    <!OVERLOAD_RESOLUTION_AMBIGUITY!>bar<!>(c)
 
     // Unresolved reference
     <!UNRESOLVED_REFERENCE!>baz<!>()

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

@@ -10,7 +10,7 @@ open class A3(x: String, y: String = "") {
     constructor(x: String, b: Boolean = true) : this(x, x)
 }
 
-class B3_1 : <!AMBIGUITY!>A3<!>("")
+class B3_1 : <!OVERLOAD_RESOLUTION_AMBIGUITY!>A3<!>("")
 class B3_2 : A3("", "asas")
 class B3_3 : A3("", true)
 class B3_4 : <!NONE_APPLICABLE!>A3<!>("", Unit)

compiler/fir/analysis-tests/testData/resolve/properties/javaAccessorConversion.kt

@@ -65,7 +65,7 @@ fun test_2(x: B) {
 }
 
 fun test_3(x: C) {
-    val error = x.<!AMBIGUITY!>vmParameters<!> // should be error
+    val error = x.<!OVERLOAD_RESOLUTION_AMBIGUITY!>vmParameters<!> // should be error
     val int = x.<!UNRESOLVED_REFERENCE!>vMParameters<!> // should be error
 }
 

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

@@ -31,7 +31,7 @@ fun main() {
     foo1(KotlinClass::baz)
     foo2(KotlinClass::baz)
     // Ambiguity (companion/class)
-    <!AMBIGUITY!>foo3<!>(KotlinClass::baz)
+    <!OVERLOAD_RESOLUTION_AMBIGUITY!>foo3<!>(KotlinClass::baz)
 
     // Type mismatch
     <!INAPPLICABLE_CANDIDATE!>foo1<!>(KotlinClass::<!UNRESOLVED_REFERENCE!>bar<!>)

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

@@ -16,5 +16,5 @@ fun foo3(x: (String) -> Int) {}
 fun main() {
     foo1(JavaClass::bar)
     foo2(JavaClass::bar)
-    <!AMBIGUITY!>foo3<!>(JavaClass::bar)
+    <!OVERLOAD_RESOLUTION_AMBIGUITY!>foo3<!>(JavaClass::bar)
 }

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

@@ -6,5 +6,5 @@ fun bar(): Int = 1
 fun bar(x: String): Int = 1
 
 fun main() {
-    <!AMBIGUITY!>foo<!>(::<!UNRESOLVED_REFERENCE!>bar<!>)
+    <!OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!>(::<!UNRESOLVED_REFERENCE!>bar<!>)
 }

compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/diagnostics/FirDiagnosticsList.kt

@@ -236,7 +236,7 @@ object DIAGNOSTICS_LIST : DiagnosticList() {
     }
 
     val AMBIGUITY by object : DiagnosticGroup("Ambiguity") {
-        val AMBIGUITY by error<FirSourceElement, PsiElement>(PositioningStrategy.REFERENCE_BY_QUALIFIED) {
+        val OVERLOAD_RESOLUTION_AMBIGUITY by error<FirSourceElement, PsiElement>(PositioningStrategy.REFERENCE_BY_QUALIFIED) {
             parameter<Collection<AbstractFirBasedSymbol<*>>>("candidates")
         }
         val ASSIGN_OPERATOR_AMBIGUITY by error<FirSourceElement, PsiElement> {

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

@@ -189,7 +189,7 @@ object FirErrors {
     val NO_VALUE_FOR_PARAMETER by error1<FirSourceElement, KtElement, FirValueParameter>(SourceElementPositioningStrategies.VALUE_ARGUMENTS)
 
     // Ambiguity
-    val AMBIGUITY by error1<FirSourceElement, PsiElement, Collection<AbstractFirBasedSymbol<*>>>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
+    val OVERLOAD_RESOLUTION_AMBIGUITY by error1<FirSourceElement, PsiElement, Collection<AbstractFirBasedSymbol<*>>>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
     val ASSIGN_OPERATOR_AMBIGUITY by error1<FirSourceElement, PsiElement, Collection<AbstractFirBasedSymbol<*>>>()
 
     // Types & type parameters

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

@@ -33,7 +33,6 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ABSTRACT_PROPERTY
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ABSTRACT_PROPERTY_WITH_INITIALIZER
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ABSTRACT_PROPERTY_WITH_SETTER
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ABSTRACT_SUPER_CALL
-import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.AMBIGUITY
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ANNOTATION_ARGUMENT_MUST_BE_CONST
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ANNOTATION_CLASS_MEMBER
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ANNOTATION_PARAMETER_DEFAULT_VALUE_MUST_BE_CONSTANT
@@ -153,6 +152,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.NO_VALUE_FOR_PARA
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.NULLABLE_TYPE_IN_CLASS_LITERAL_LHS
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.NULLABLE_TYPE_OF_ANNOTATION_MEMBER
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.OTHER_ERROR
+import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.OVERLOAD_RESOLUTION_AMBIGUITY
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.OVERRIDING_FINAL_MEMBER
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.PRIMARY_CONSTRUCTOR_DELEGATION_CALL_EXPECTED
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.PRIMARY_CONSTRUCTOR_REQUIRED_FOR_DATA_CLASS
@@ -396,7 +396,7 @@ class FirDefaultErrorMessages : DefaultErrorMessages.Extension {
             map.put(NO_VALUE_FOR_PARAMETER, "No value passed for parameter ''{0}''", NAME)
 
             // Ambiguity
-            map.put(AMBIGUITY, "Ambiguity between candidates: {0}", SYMBOLS)
+            map.put(OVERLOAD_RESOLUTION_AMBIGUITY, "Overload resolution ambiguity between candidates: {0}", SYMBOLS)
             map.put(ASSIGN_OPERATOR_AMBIGUITY, "Ambiguity between assign operator candidates: {0}", SYMBOLS)
 
             // Types & type parameters

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

@@ -33,7 +33,7 @@ private fun ConeDiagnostic.toFirDiagnostic(
     is ConeAmbiguityError -> if (!this.applicability.isSuccess) {
         FirErrors.NONE_APPLICABLE.on(source, this.candidates)
     } else {
-        FirErrors.AMBIGUITY.on(source, this.candidates)
+        FirErrors.OVERLOAD_RESOLUTION_AMBIGUITY.on(source, this.candidates)
     }
     is ConeOperatorAmbiguityError -> FirErrors.ASSIGN_OPERATOR_AMBIGUITY.on(source, this.candidates)
     is ConeVariableExpectedError -> FirErrors.VARIABLE_EXPECTED.on(source)

compiler/testData/diagnostics/tests/callableReference/resolve/overloadAmbiguityForSimpleLastExpressionOfBlock.fir.kt

@@ -1,25 +0,0 @@
-// !DIAGNOSTICS: -UNUSED_PARAMETER
-
-interface A
-interface B
-object C : A, B
-
-fun foo(a: A): Int = 0
-fun foo(b: B): Double = 0.0
-
-fun bar(a: A): Int = 0
-
-val l0: Int
-    get() =
-        if (1 < 2) {
-            <!AMBIGUITY!>foo<!>(C)
-        } else {
-            bar(C)
-        }
-
-val l1: Int
-    get() = when {
-        true -> <!AMBIGUITY!>foo<!>(C)
-        false -> { <!AMBIGUITY!>foo<!>(C) }
-        else -> bar(C)
-    }

compiler/testData/diagnostics/tests/callableReference/resolve/overloadAmbiguityForSimpleLastExpressionOfBlock.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 
 interface A

compiler/testData/diagnostics/tests/callableReference/resolve/withPlaceholderTypes.fir.kt

@@ -22,7 +22,7 @@ val x1 = fn1(1, ::foo, ::foo)
 val x2 = fn1(1, ::foo, ::bar)
 
 val x3 = fn2(::bar, ::foo)
-val x4 = <!AMBIGUITY!>fn2<!>(::<!UNRESOLVED_REFERENCE!>foo<!>, ::bar)
-val x5 = <!AMBIGUITY!>fn2<!>(::<!UNRESOLVED_REFERENCE!>foo<!>, ::<!UNRESOLVED_REFERENCE!>foo<!>)
+val x4 = <!OVERLOAD_RESOLUTION_AMBIGUITY!>fn2<!>(::<!UNRESOLVED_REFERENCE!>foo<!>, ::bar)
+val x5 = <!OVERLOAD_RESOLUTION_AMBIGUITY!>fn2<!>(::<!UNRESOLVED_REFERENCE!>foo<!>, ::<!UNRESOLVED_REFERENCE!>foo<!>)
 
 val x6 = fn3(1, ::qux)

compiler/testData/diagnostics/tests/dataFlowInfoTraversal/IfThenElseBothInvalid.fir.kt

@@ -6,11 +6,11 @@ fun foo() {
     <!INAPPLICABLE_CANDIDATE!>bar<!>(x)
     if (x != 2) {
         if (x == null) return
-        2<!AMBIGUITY!>+<!><!SYNTAX!><!>
+        2<!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!><!SYNTAX!><!>
     }
     else {
         if (x == null) return
-        2<!AMBIGUITY!>+<!><!SYNTAX!><!>
+        2<!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!><!SYNTAX!><!>
     }
     bar(x)
 }

compiler/testData/diagnostics/tests/delegatedProperty/inference/manyIncompleteCandidates.fir.kt

@@ -5,7 +5,7 @@ package test
 import first.*
 import second.*
 
-val a12 by <!AMBIGUITY!>A<!>()
+val a12 by <!OVERLOAD_RESOLUTION_AMBIGUITY!>A<!>()
 
 // FILE: first.kt
 package first

compiler/testData/diagnostics/tests/functionLiterals/LabeledFunctionLiterals.fir.kt

@@ -10,7 +10,7 @@ fun <T> foo(a: A, f: () -> T): T = f()
 fun <T> foo(b: B, f: () -> T): T = f()
 
 fun test(c: C) {
-    <!AMBIGUITY!>foo<!>(c) f@ {
+    <!OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!>(c) f@ {
         c!!
     }
 }

compiler/testData/diagnostics/tests/imports/RenameOnImport.fir.kt

@@ -18,5 +18,5 @@ import b.*
 import a.y as AY
 
 val v1: Int = AX
-val v2: String = <!AMBIGUITY!>x<!>
+val v2: String = <!OVERLOAD_RESOLUTION_AMBIGUITY!>x<!>
 val v3 = y

compiler/testData/diagnostics/tests/incompleteCode/unresolvedArguments.fir.kt

@@ -8,6 +8,6 @@ fun bar(i: Int) {}
 fun bar(s: String) {}
 
 fun test() {
-    <!AMBIGUITY!>foo<!>(<!UNRESOLVED_REFERENCE!>rrr<!>, 1)
-    <!AMBIGUITY!>bar<!>(<!UNRESOLVED_REFERENCE!>rrr<!>)
+    <!OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!>(<!UNRESOLVED_REFERENCE!>rrr<!>, 1)
+    <!OVERLOAD_RESOLUTION_AMBIGUITY!>bar<!>(<!UNRESOLVED_REFERENCE!>rrr<!>)
 }

compiler/testData/diagnostics/tests/inference/cannotCompleteResolveAmbiguity.fir.kt

@@ -5,5 +5,5 @@ fun <T> g(i: Int, a: Any): List<T> {throw Exception()}
 fun <T> g(a: Any, i: Int): Collection<T> {throw Exception()}
 
 fun <T> test() {
-    val c: List<T> = <!AMBIGUITY!>g<!>(1, 1)
+    val c: List<T> = <!OVERLOAD_RESOLUTION_AMBIGUITY!>g<!>(1, 1)
 }

compiler/testData/diagnostics/tests/inference/cannotCompleteResolveFunctionLiteralsNoUse.fir.kt

@@ -4,4 +4,4 @@ package f
 fun <R> h(i: Int, a: Any, r: R, f: (Boolean) -> Int) = 1
 fun <R> h(a: Any, i: Int, r: R, f: (Boolean) -> Int) = 1
 
-fun test() = <!AMBIGUITY!>h<!>(1, 1, 1, { b -> 42 })
+fun test() = <!OVERLOAD_RESOLUTION_AMBIGUITY!>h<!>(1, 1, 1, { b -> 42 })

compiler/testData/diagnostics/tests/inference/cannotCompleteResolveNoInfoForParameter.fir.kt

@@ -5,7 +5,7 @@ fun <T> f(i: Int, c: Collection<T>): List<T> {throw Exception()}
 fun <T> f(a: Any, l: List<T>): Collection<T> {throw Exception()}
 
 fun <T> test(l: List<T>) {
-    <!AMBIGUITY!>f<!>(1, emptyList())
+    <!OVERLOAD_RESOLUTION_AMBIGUITY!>f<!>(1, emptyList())
 }
 
 fun <T> emptyList(): List<T> {throw Exception()}

compiler/testData/diagnostics/tests/inference/cannotCompleteResolveWithFunctionLiterals.fir.kt

@@ -5,7 +5,7 @@ package f
 fun <R> h(f: (Boolean) -> R) = 1
 fun <R> h(f: (String) -> R) = 2
 
-fun test() = <!AMBIGUITY!>h<!>{ i -> getAnswer() }
+fun test() = <!OVERLOAD_RESOLUTION_AMBIGUITY!>h<!>{ i -> getAnswer() }
 
 fun getAnswer() = 42
 

compiler/testData/diagnostics/tests/inference/intersectionTypesWithContravariantTypes.fir.kt

@@ -8,6 +8,6 @@ fun <T : Comparable<T>, S : T> greater(x: Bar<in S>, t: T): Int = 0
 fun <T : Comparable<T>, S : T> greater(x: Bar<in S>, other: Foo<T>): String = ""
 
 fun test(b: Bar<Long>) {
-    val result = <!AMBIGUITY!>greater<!>(b, b)
+    val result = <!OVERLOAD_RESOLUTION_AMBIGUITY!>greater<!>(b, b)
     <!DEBUG_INFO_EXPRESSION_TYPE("ERROR CLASS: Ambiguity: greater, [/greater, /greater]")!>result<!>
 }

compiler/testData/diagnostics/tests/inference/recursiveLocalFuns/selfCall.fir.kt

@@ -2,7 +2,7 @@
 fun foo() {
     fun bar1() = bar1()
 
-    fun bar2() = 1 <!AMBIGUITY!>+<!> bar2()
+    fun bar2() = 1 <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> bar2()
     fun bar3() = <!INAPPLICABLE_CANDIDATE!>id<!>(bar3())
 }
 

compiler/testData/diagnostics/tests/j+k/ambiguousSamAdapters.fir.kt

@@ -1,17 +0,0 @@
-// FILE: A.java
-import java.io.Closeable;
-
-public class A {
-    public static void foo(Runnable r) {
-    }
-
-    public static void foo(Closeable c) {
-    }
-}
-
-// FILE: test.kt
-
-fun main() {
-    A.<!AMBIGUITY!>foo<!> { "Hello!" }
-    A.foo(Runnable { "Hello!" })
-}

compiler/testData/diagnostics/tests/j+k/ambiguousSamAdapters.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // FILE: A.java
 import java.io.Closeable;
 

compiler/testData/diagnostics/tests/j+k/brokenCode/fieldDuplicates.fir.kt

@@ -9,5 +9,5 @@ public class A {
 
 fun foo() {
     // no exception is thrown (see KT-3898)
-    A().<!AMBIGUITY!>foo<!>
+    A().<!OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!>
 }

compiler/testData/diagnostics/tests/j+k/collectionOverrides/collectionStringImpl.fir.kt

@@ -80,6 +80,6 @@ public class CollectionStringImpl implements Collection<String> {
 // FILE: main.kt
 
 fun test(x: CollectionStringImpl) {
-    x.<!AMBIGUITY!>contains<!>("")
+    x.<!OVERLOAD_RESOLUTION_AMBIGUITY!>contains<!>("")
     (x as Collection<String>).contains("")
 }

compiler/testData/diagnostics/tests/j+k/collectionOverrides/containsAndOverload.fir.kt

@@ -12,9 +12,9 @@ abstract class KA : A() {
 }
 
 fun foo(a: A, ka: KA) {
-    a.<!AMBIGUITY!>contains<!>("")
+    a.<!OVERLOAD_RESOLUTION_AMBIGUITY!>contains<!>("")
     a.<!NONE_APPLICABLE!>contains<!>(1)
-    "" <!AMBIGUITY!>in<!> a
+    "" <!OVERLOAD_RESOLUTION_AMBIGUITY!>in<!> a
     1 <!NONE_APPLICABLE!>in<!> a
 
     ka.contains("")

compiler/testData/diagnostics/tests/j+k/collectionOverrides/overridesBuiltinNoMagic.fir.kt

@@ -150,14 +150,14 @@ class Y2 : X() {
 
 fun main() {
     X().remove("")
-    X().<!AMBIGUITY!>removeAt<!>(1)
+    X().<!OVERLOAD_RESOLUTION_AMBIGUITY!>removeAt<!>(1)
 
     val y: MutableList<String> = Y()
     y.removeAt(1)
 
     Y().remove("")
-    Y().<!AMBIGUITY!>removeAt<!>(1)
+    Y().<!OVERLOAD_RESOLUTION_AMBIGUITY!>removeAt<!>(1)
 
     X().remove("")
-    X().<!AMBIGUITY!>removeAt<!>(1)
+    X().<!OVERLOAD_RESOLUTION_AMBIGUITY!>removeAt<!>(1)
 }

compiler/testData/diagnostics/tests/j+k/collectionOverrides/removeAtInt.fir.kt

@@ -24,7 +24,7 @@ abstract class D : AbstractList<Int>() {
 
 fun main(a: A, b: B, c: ArrayList<Int>) {
     a.remove(1)
-    a.<!AMBIGUITY!>removeAt<!>(0)
+    a.<!OVERLOAD_RESOLUTION_AMBIGUITY!>removeAt<!>(0)
     b.remove(1)
     b.removeAt(0)
     c.remove(1)

compiler/testData/diagnostics/tests/j+k/fieldOverridesNothing.fir.kt

@@ -17,5 +17,5 @@ class C : B() {
 }
 
 fun foo() {
-    C().<!AMBIGUITY!>size<!>
+    C().<!OVERLOAD_RESOLUTION_AMBIGUITY!>size<!>
 }

compiler/testData/diagnostics/tests/j+k/primitiveOverrides/specializedMap.fir.kt

@@ -102,10 +102,10 @@ fun foo(x: SpecializedMap) {
     x.containsKey(1)
     x.<!INAPPLICABLE_CANDIDATE!>containsKey<!>(null)
 
-    x.<!AMBIGUITY!>get<!>(2)
+    x.<!OVERLOAD_RESOLUTION_AMBIGUITY!>get<!>(2)
     x.<!NONE_APPLICABLE!>get<!>(null)
 
-    x.<!AMBIGUITY!>remove<!>(3)
+    x.<!OVERLOAD_RESOLUTION_AMBIGUITY!>remove<!>(3)
     x.<!NONE_APPLICABLE!>remove<!>(null)
 
     x.put(4, 5.0)

compiler/testData/diagnostics/tests/j+k/properties/fieldPropertyOverloads.fir.kt

@@ -19,8 +19,8 @@ public abstract class CollectionWithSize implements java.util.Collection<String>
 // FILE: main.kt
 
 fun main(c: CollectionWithSize) {
-    CompressionType.ZIP.<!AMBIGUITY!>name<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Double>() }
-    c.<!AMBIGUITY!>size<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
+    CompressionType.ZIP.<!OVERLOAD_RESOLUTION_AMBIGUITY!>name<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Double>() }
+    c.<!OVERLOAD_RESOLUTION_AMBIGUITY!>size<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
 
     CompressionType.ZIP::<!UNRESOLVED_REFERENCE!>name<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><kotlin.reflect.KProperty0<Double>>() }
     c::<!UNRESOLVED_REFERENCE!>size<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><kotlin.reflect.KProperty0<String>>() }

compiler/testData/diagnostics/tests/j+k/properties/fieldPropertyOverloadsDisabled.fir.kt

@@ -20,8 +20,8 @@ public abstract class CollectionWithSize implements java.util.Collection<String>
 // FILE: main.kt
 
 fun main(c: CollectionWithSize) {
-    CompressionType.ZIP.<!AMBIGUITY!>name<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Double>() }
-    c.<!AMBIGUITY!>size<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
+    CompressionType.ZIP.<!OVERLOAD_RESOLUTION_AMBIGUITY!>name<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Double>() }
+    c.<!OVERLOAD_RESOLUTION_AMBIGUITY!>size<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
 
     CompressionType.ZIP::<!UNRESOLVED_REFERENCE!>name<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><kotlin.reflect.KProperty0<Double>>() }
     c::<!UNRESOLVED_REFERENCE!>size<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><kotlin.reflect.KProperty0<String>>() }

compiler/testData/diagnostics/tests/j+k/properties/fieldPropertyOverloadsNI.fir.kt

@@ -19,8 +19,8 @@ public abstract class CollectionWithSize implements java.util.Collection<String>
 // FILE: main.kt
 
 fun main(c: CollectionWithSize) {
-    CompressionType.ZIP.<!AMBIGUITY!>name<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Double>() }
-    c.<!AMBIGUITY!>size<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
+    CompressionType.ZIP.<!OVERLOAD_RESOLUTION_AMBIGUITY!>name<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Double>() }
+    c.<!OVERLOAD_RESOLUTION_AMBIGUITY!>size<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
 
     CompressionType.ZIP::<!UNRESOLVED_REFERENCE!>name<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><kotlin.reflect.KProperty0<Double>>() }
     c::<!UNRESOLVED_REFERENCE!>size<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><kotlin.reflect.KProperty0<String>>() }

compiler/testData/diagnostics/tests/j+k/properties/staticFieldPropertyOverloads.fir.kt

@@ -1,16 +0,0 @@
-// SKIP_TXT
-// !LANGUAGE: +PreferJavaFieldOverload
-// FILE: a/JClass.java
-package a;
-public class JClass {
-    public static int foo = 42;
-}
-// FILE: a.kt
-package b
-val foo = 42
-
-// FILE: b.kt
-
-import a.JClass.foo
-import b.foo
-fun test() { <!AMBIGUITY!>foo<!> }

compiler/testData/diagnostics/tests/j+k/properties/staticFieldPropertyOverloads.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // SKIP_TXT
 // !LANGUAGE: +PreferJavaFieldOverload
 // FILE: a/JClass.java

compiler/testData/diagnostics/tests/j+k/selectMoreSpecific.fir.kt

@@ -11,6 +11,6 @@ public class A {
 // FILE: main.kt
 
 fun foo(a: A) {
-    a.<!AMBIGUITY!>foo<!>() <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
-    A.<!AMBIGUITY!>bar<!>() <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
+    a.<!OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!>() <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
+    A.<!OVERLOAD_RESOLUTION_AMBIGUITY!>bar<!>() <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
 }

compiler/testData/diagnostics/tests/multimodule/duplicateMethod/classGenericsInParamsIndexMismatch.fir.kt

@@ -29,6 +29,6 @@ import p.*
 
 fun <Y, Z> test(b: B<Y, Z>?) {
     if (b is C<Y, Z>) {
-        b?.<!AMBIGUITY!>foo<!>(null)
+        b?.<!OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!>(null)
     }
 }

compiler/testData/diagnostics/tests/multimodule/duplicateMethod/classVsFunctionGenericsInParamsMismatch.fir.kt

@@ -30,8 +30,8 @@ import p.*
 
 fun test(b: B?, c: C) {
     b?.foo(1, 1)
-    c.<!AMBIGUITY!>foo<!>(1, 1)
+    c.<!OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!>(1, 1)
     if (b is C) {
-        b?.<!AMBIGUITY!>foo<!>(1, 1)
+        b?.<!OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!>(1, 1)
     }
 }

compiler/testData/diagnostics/tests/multimodule/duplicateMethod/differentGenericsInParams.fir.kt

@@ -1,43 +0,0 @@
-// !DIAGNOSTICS: -UNNECESSARY_SAFE_CALL
-
-// MODULE: m0
-// FILE: a.kt
-package p
-
-public interface G1<T>
-public interface G2<A, B>
-
-// MODULE: m1(m0)
-// FILE: a.kt
-package p
-
-public interface B {
-    public fun foo(a: G1<Int>?, b: G2<B, String>?)
-}
-
-// MODULE: m2(m1, m0)
-// FILE: b.kt
-package p
-
-public interface C : B {
-    override fun foo(a: G1<Int>?, b: G2<B, String>?)
-
-}
-
-// MODULE: m3(m0)
-// FILE: b.kt
-package p
-
-public interface B {
-    public fun foo(a: G1<out Any?>?, b: G2<Int, out Any?>?)
-}
-
-// MODULE: m4(m3, m2, m0)
-// FILE: c.kt
-import p.*
-
-fun test(b: B?) {
-    if (b is C) {
-        b?.<!AMBIGUITY!>foo<!>(null, null)
-    }
-}

compiler/testData/diagnostics/tests/multimodule/duplicateMethod/differentGenericsInParams.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !DIAGNOSTICS: -UNNECESSARY_SAFE_CALL
 
 // MODULE: m0

compiler/testData/diagnostics/tests/multimodule/duplicateMethod/sinceKotlin.fir.kt

@@ -20,7 +20,7 @@ import p1.*
 import p2.*
 
 fun test1(): Int {
-    val r = <!AMBIGUITY!>foo<!>(42)
+    val r = <!OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!>(42)
     return r
 }
 

compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/funcLiteralArgsInsideAmbiguity.fir.kt

@@ -4,7 +4,7 @@ package d
 fun bar() {
     val i: Int? = 42
     if (i != null) {
-        <!AMBIGUITY!>doSmth1<!> {
+        <!OVERLOAD_RESOLUTION_AMBIGUITY!>doSmth1<!> {
         val x = i + 1
     }
 }

compiler/testData/diagnostics/tests/operatorsOverloading/IteratorAmbiguity.fir.kt

@@ -21,7 +21,7 @@ class MyIterator {
 class MyElement
 
 fun test1(collection: MyCollection) {
-    collection.<!AMBIGUITY!>iterator<!>()
-    <!AMBIGUITY, UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE!>for (element in collection) {
+    collection.<!OVERLOAD_RESOLUTION_AMBIGUITY!>iterator<!>()
+    <!OVERLOAD_RESOLUTION_AMBIGUITY, UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE!>for (element in collection) {
     }<!>
 }

compiler/testData/diagnostics/tests/operatorsOverloading/plusAssignOnArray.fir.kt

@@ -16,5 +16,5 @@ fun test() {
     val c = C()
     c[0] += ""
     var c1 = C1()
-    c1[0] <!AMBIGUITY!>+=<!> ""
+    c1[0] <!OVERLOAD_RESOLUTION_AMBIGUITY!>+=<!> ""
 }

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

@@ -4,5 +4,5 @@ fun foo(g: () -> Int) {}
 fun foo(f: (Int) -> Int) {}
 
 fun test() {
-    <!AMBIGUITY!>foo<!> { -> 42 }
+    <!OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!> { -> 42 }
 }

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

@@ -55,5 +55,5 @@ fun test() {
 
     withGenericDefaults("")
 
-    <!AMBIGUITY!>wrong<!>(null!!)
+    <!OVERLOAD_RESOLUTION_AMBIGUITY!>wrong<!>(null!!)
 }

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

@@ -1,34 +0,0 @@
-// !WITH_NEW_IFERENCE
-// !LANGUAGE: +NewInference
-// !DIAGNOSTICS: -UNUSED_PARAMETER
-
-// FILE: packageA.kt
-
-package a
-
-abstract class Cls
-abstract class Cls2
-
-// FILE: packageB.kt
-
-package b
-
-fun Cls() {}
-class Cls2
-
-// FILE: test.kt
-
-package c
-
-import a.*
-import b.*
-
-fun take(arg: Any) {}
-
-fun test() {
-    <!AMBIGUITY!>Cls<!>()
-    take(<!AMBIGUITY!>Cls<!>())
-
-    <!UNRESOLVED_REFERENCE!>Cls2<!>()
-    take(<!UNRESOLVED_REFERENCE!>Cls2<!>())
-}

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

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !WITH_NEW_IFERENCE
 // !LANGUAGE: +NewInference
 // !DIAGNOSTICS: -UNUSED_PARAMETER

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

@@ -16,5 +16,5 @@ class C: A, B
 fun main() {
     AImpl().f()
     BImpl().f()
-    C().<!AMBIGUITY!>f<!>()
+    C().<!OVERLOAD_RESOLUTION_AMBIGUITY!>f<!>()
 }

compiler/testData/diagnostics/tests/recovery/absentLeftHandSide.fir.kt

@@ -4,7 +4,7 @@ fun import() {
 }
 
 fun composite() {
-    val s = 13<!AMBIGUITY!>+<!><!SYNTAX!>~<!><!UNRESOLVED_REFERENCE!>/<!>12
+    val s = 13<!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!><!SYNTAX!>~<!><!UNRESOLVED_REFERENCE!>/<!>12
 }
 
 fun html() {

compiler/testData/diagnostics/tests/regressions/kt26303.fir.kt

@@ -14,5 +14,5 @@ import foo.foo as invoke
 import foo.invoke
 
 fun main(args: Array<String>) {
-    <!AMBIGUITY!>42<!>()
+    <!OVERLOAD_RESOLUTION_AMBIGUITY!>42<!>()
 }

compiler/testData/diagnostics/tests/regressions/kt30245.fir.kt

@@ -83,8 +83,8 @@ fun test2() { // to extension lambda 1
     val i27: E1 = when (e) { E.VALUE ->  { s: String -> <!NO_THIS!>this<!> + s.length } } // oi+ ni+
     val i27a: E1 = when (e) { E.VALUE ->  { s -> <!NO_THIS!>this<!> + s.<!UNRESOLVED_REFERENCE!>length<!> } } // oi+ ni+
 
-    val w28 = <!INAPPLICABLE_CANDIDATE!>W2<!> { i: Int, s -> i <!AMBIGUITY!>+<!> s.<!UNRESOLVED_REFERENCE!>length<!> } // oi- ni-
-    val i28: E1 = id { i: Int, s -> i <!AMBIGUITY!>+<!> s.<!UNRESOLVED_REFERENCE!>length<!> } // oi- ni-
+    val w28 = <!INAPPLICABLE_CANDIDATE!>W2<!> { i: Int, s -> i <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> s.<!UNRESOLVED_REFERENCE!>length<!> } // oi- ni-
+    val i28: E1 = id { i: Int, s -> i <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> s.<!UNRESOLVED_REFERENCE!>length<!> } // oi- ni-
     val w29 = <!INAPPLICABLE_CANDIDATE!>W2<!> { i: Int, s: String -> i + s.length } // oi- ni-
     val i29: E1 = id { i: Int, s: String -> i + s.length } // oi+ ni+
 
@@ -130,7 +130,7 @@ fun test4() { // to non-extension lambda 2
 }
 
 open class A(a: () -> Unit) {
-    constructor(f: (String) -> Unit) : <!AMBIGUITY!>this<!>({ -> f("") })
+    constructor(f: (String) -> Unit) : <!OVERLOAD_RESOLUTION_AMBIGUITY!>this<!>({ -> f("") })
 }
 
 class B: A({ s -> "1" })

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

@@ -1,30 +0,0 @@
-// FILE: a.kt
-package a
-
-class A
-
-// FILE: b.kt
-package b
-
-import a.A
-
-val A.d: Int get() = 1
-
-// FILE: c.kt
-package c
-
-import a.A
-
-val A.d: Int get() = 2
-
-// FILE: d.kt
-
-package d
-
-import a.A
-import b.d
-import c.d
-
-fun A.test() {
-    <!AMBIGUITY!>d<!>
-}

compiler/testData/diagnostics/tests/resolve/ambiguityOnPropertiesWithTheSamePackageName.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // FILE: a.kt
 package a
 

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

@@ -1,11 +0,0 @@
-// !DIAGNOSTICS: -UNUSED_PARAMETER
-
-fun foo(a: Any, f: ()->Int) = f()
-fun foo(a: Any, f: (Any)->Int) = f(a)
-fun foo(i: Int, f: Int.()->Int) = i.f()
-
-fun test1() {
-    <!AMBIGUITY!>foo<!>(1) { ->
-        <!NO_THIS!>this<!>
-    }
-}

compiler/testData/diagnostics/tests/resolve/ambiguityWithTwoCorrespondingFunctionTypes.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 
 fun foo(a: Any, f: ()->Int) = f()

compiler/testData/diagnostics/tests/resolve/invoke/errors/ambiguityForInvoke.fir.kt

@@ -5,7 +5,7 @@ fun Int.invoke(i: Int, a: Any) {}
 fun Int.invoke(a: Any, i: Int) {}
 
 fun foo(i: Int) {
-    <!AMBIGUITY!>i<!>(1, 1)
+    <!OVERLOAD_RESOLUTION_AMBIGUITY!>i<!>(1, 1)
 
-    <!AMBIGUITY!>5<!>(1, 2)
+    <!OVERLOAD_RESOLUTION_AMBIGUITY!>5<!>(1, 2)
 }

compiler/testData/diagnostics/tests/resolve/overloadConflicts/genericClash.fir.kt

@@ -13,8 +13,8 @@ fun <E> baz(x: E, y: String) {}
 fun <E> baz(x: String, y: E) {}
 
 fun bar(x: A<String>) {
-    x.<!AMBIGUITY!>foo<!>("")
+    x.<!OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!>("")
 
-    x.<!AMBIGUITY!>baz<!>("", "")
-    <!AMBIGUITY!>baz<!>("", "")
+    x.<!OVERLOAD_RESOLUTION_AMBIGUITY!>baz<!>("", "")
+    <!OVERLOAD_RESOLUTION_AMBIGUITY!>baz<!>("", "")
 }

compiler/testData/diagnostics/tests/resolve/overloadConflicts/kt31670.fir.kt

@@ -12,5 +12,5 @@ fun <T> B<T>.foo(block: (T) -> Unit) {
 }
 
 fun main() {
-    B("string").<!AMBIGUITY!>foo<!> {  }
+    B("string").<!OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!> {  }
 }

compiler/testData/diagnostics/tests/resolve/overloadConflicts/kt31670_compat.fir.kt

@@ -12,5 +12,5 @@ fun <T> B<T>.foo(block: (T) -> Unit) {
 }
 
 fun main() {
-    B("string").<!AMBIGUITY!>foo<!> {  }
+    B("string").<!OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!> {  }
 }

compiler/testData/diagnostics/tests/resolve/overloadConflicts/kt31758.fir.kt

@@ -22,5 +22,5 @@ import a.*
 import b.*
 
 fun test() {
-    <!AMBIGUITY!>foo<!><A> { }
+    <!OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!><A> { }
 }

compiler/testData/diagnostics/tests/resolve/overloadConflicts/kt31758_compat.fir.kt

@@ -22,5 +22,5 @@ import a.*
 import b.*
 
 fun test() {
-    <!AMBIGUITY!>foo<!><A> { }
+    <!OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!><A> { }
 }

compiler/testData/diagnostics/tests/resolve/overloadConflicts/kt37692.fir.kt

@@ -10,5 +10,5 @@ infix fun <T : Comparable<T>, S : T?> Bar<in S>.test(t: T) { }
 infix fun <T : Comparable<T>, S : T?> Bar<in S>.test(other: Bar<in S>) {}
 
 fun checkFunctions(exp1: Foo<Int?>, exp2: Foo<Int>) {
-    exp1.<!AMBIGUITY!>test<!>(exp2)
+    exp1.<!OVERLOAD_RESOLUTION_AMBIGUITY!>test<!>(exp2)
 }

compiler/testData/diagnostics/tests/resolve/overloadConflicts/withVariance.fir.kt

@@ -7,4 +7,4 @@ class A<T>
 fun <T1> A<T1>.foo() = X1
 fun <T2> A<out T2>.foo() = X2
 
-fun <T> A<out T>.test() = <!AMBIGUITY!>foo<!>() // TODO fix constraint system
+fun <T> A<out T>.test() = <!OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!>() // TODO fix constraint system

compiler/testData/diagnostics/tests/samConversions/OverloadPriority.fir.kt

@@ -22,9 +22,9 @@ public interface J {
 
 // FILE: 1.kt
 fun test(j: J) {
-    j.<!AMBIGUITY!>foo<!>({ <!UNRESOLVED_REFERENCE!>it<!> checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Any>() }; "" }, "") <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
+    j.<!OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!>({ <!UNRESOLVED_REFERENCE!>it<!> checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Any>() }; "" }, "") <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
 
-    j.<!AMBIGUITY!>bas<!>({ <!UNRESOLVED_REFERENCE!>it<!> checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Any>() }; "" }, "") <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
+    j.<!OVERLOAD_RESOLUTION_AMBIGUITY!>bas<!>({ <!UNRESOLVED_REFERENCE!>it<!> checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Any>() }; "" }, "") <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
 
     // NI: TODO
     j.bar { it checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Any>() }; "" } checkType { _<Int>() }

compiler/testData/diagnostics/tests/samConversions/OverloadPriorityKT.fir.kt

@@ -21,9 +21,9 @@ interface K {
 }
 
 fun test(k: K) {
-    k.<!AMBIGUITY!>foo<!> { <!UNRESOLVED_REFERENCE!>it<!> checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Any>() }; "" } <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
+    k.<!OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!> { <!UNRESOLVED_REFERENCE!>it<!> checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Any>() }; "" } <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
 
-    k.<!AMBIGUITY!>bas<!> { <!UNRESOLVED_REFERENCE!>it<!> checkType { _<Any?>() }; "" } <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
+    k.<!OVERLOAD_RESOLUTION_AMBIGUITY!>bas<!> { <!UNRESOLVED_REFERENCE!>it<!> checkType { _<Any?>() }; "" } <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
 
     // NI: TODO
     k.bar { it checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Any>() }; "" } checkType { _<Int>() }

compiler/testData/diagnostics/tests/scopes/AmbiguousNonExtensions.fir.kt

@@ -1,18 +0,0 @@
-// FILE: a.kt
-package a
-
-val v = 1
-fun f() = 1
-
-// FILE: b.kt
-package b
-
-val v = 1
-fun f() = 1
-
-// FILE: main.kt
-import a.*
-import b.*
-
-val vv = <!AMBIGUITY!>v<!>
-val ff = <!AMBIGUITY!>f<!>()

compiler/testData/diagnostics/tests/scopes/AmbiguousNonExtensions.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // FILE: a.kt
 package a
 

compiler/testData/diagnostics/tests/scopes/inheritance/statics/nameClash0.fir.kt

@@ -1,32 +0,0 @@
-// FILE: A.java
-
-public interface A {
-    int field = 1;
-}
-
-// FILE: B.java
-
-public interface B {
-    String field = 1;
-}
-
-// FILE: E.java
-
-public class E implements A, B {
-}
-
-// FILE: O.java
-
-public class O implements A, B {
-    public static double field = 1;
-}
-
-// FILE: test.kt
-
-fun test() {
-    A.field
-    B.field
-
-    E.<!AMBIGUITY!>field<!>
-    O.field
-}

compiler/testData/diagnostics/tests/scopes/inheritance/statics/nameClash0.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // FILE: A.java
 
 public interface A {

compiler/testData/diagnostics/tests/scopes/inheritance/statics/nameClash1.fir.kt

@@ -1,32 +0,0 @@
-// FILE: A.java
-
-public interface A {
-    int field = 1;
-}
-
-// FILE: B.java
-
-public interface B extends A {
-    String field = 1;
-}
-
-// FILE: E.java
-
-public class E implements A, B {
-}
-
-// FILE: O.java
-
-public class O implements A, B {
-    public static double field = 1;
-}
-
-// FILE: test.kt
-
-fun test() {
-    A.field
-    B.field
-
-    E.<!AMBIGUITY!>field<!>
-    O.field
-}

compiler/testData/diagnostics/tests/scopes/inheritance/statics/nameClash1.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // FILE: A.java
 
 public interface A {

compiler/testData/diagnostics/tests/scopes/inheritance/statics/nameClash2.fir.kt

@@ -1,66 +0,0 @@
-// FILE: A.java
-
-public interface A {
-    int field = 1;
-}
-
-// FILE: B.java
-
-public interface B {
-    String field = 1;
-}
-
-// FILE: C.java
-
-public interface C extends A {
-}
-
-// FILE: D.java
-
-public interface D extends B {
-}
-
-// FILE: E.java
-
-public class E implements C, D {
-}
-
-// FILE: EE.java
-
-public class EE extends E {
-}
-
-// FILE: EO.java
-
-public class EO extends E {
-    public static double field = 1;
-}
-
-// FILE: O.java
-
-public class O implements C, D {
-    public static double field = 1;
-}
-
-// FILE: OO.java
-
-public class OO extends O {
-}
-
-// FILE: test.kt
-
-fun test() {
-    A.field
-    B.field
-
-    C.field
-    D.field
-
-    E.<!AMBIGUITY!>field<!>
-    O.field
-
-    EE.<!AMBIGUITY!>field<!>
-    EO.field
-
-    OO.field
-}

compiler/testData/diagnostics/tests/scopes/inheritance/statics/nameClash2.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // FILE: A.java
 
 public interface A {

compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/innerInstanceCreation.fir.kt

@@ -6,6 +6,6 @@ class Outer {
     }
 
     constructor(x: Int)
-    constructor(x: Int, y: Int, z: Int = x + Inner().prop <!AMBIGUITY!>+<!> <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>Inner<!>().prop) :
-        this(x + Inner().prop <!AMBIGUITY!>+<!> <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>Inner<!>().prop)
+    constructor(x: Int, y: Int, z: Int = x + Inner().prop <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>Inner<!>().prop) :
+        this(x + Inner().prop <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>Inner<!>().prop)
 }

compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/memberFunAccess.fir.kt

@@ -2,6 +2,6 @@
 class A {
     fun foo() = 1
     constructor(x: Int)
-    constructor(x: Int, y: Int, z: Int = x <!AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>foo<!>() + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>foo<!>()) :
-        <!INAPPLICABLE_CANDIDATE!>this<!>(x <!AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>foo<!>() + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>foo<!>())
+    constructor(x: Int, y: Int, z: Int = x <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>foo<!>() + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>foo<!>()) :
+        <!INAPPLICABLE_CANDIDATE!>this<!>(x <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>foo<!>() + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>foo<!>())
 }

compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/propertyAccess.fir.kt

@@ -2,6 +2,6 @@
 class A {
     val prop = 1
     constructor(x: Int)
-    constructor(x: Int, y: Int, z: Int = x <!AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>prop<!> + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>prop<!>) :
-        <!INAPPLICABLE_CANDIDATE!>this<!>(x <!AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>prop<!> + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>prop<!>)
+    constructor(x: Int, y: Int, z: Int = x <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>prop<!> + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>prop<!>) :
+        <!INAPPLICABLE_CANDIDATE!>this<!>(x <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>prop<!> + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>prop<!>)
 }

compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/propertyAccessUnitialized.fir.kt

@@ -2,6 +2,6 @@
 open class B(x: Int)
 class A : B {
     val prop = 1
-    constructor(x: Int, y: Int = x <!AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>prop<!> + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>prop<!>) :
-        <!INAPPLICABLE_CANDIDATE!>super<!>(x <!AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>prop<!> + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>prop<!>)
+    constructor(x: Int, y: Int = x <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>prop<!> + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>prop<!>) :
+        <!INAPPLICABLE_CANDIDATE!>super<!>(x <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>prop<!> + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>prop<!>)
 }

compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/superFunAccess.fir.kt

@@ -3,6 +3,6 @@ open class B(x: Int) {
     fun foo() = 1
 }
 class A : B {
-    constructor(x: Int, y: Int = x <!AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>foo<!>() + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>foo<!>() + super.<!UNRESOLVED_REFERENCE!>foo<!>()) :
-        <!INAPPLICABLE_CANDIDATE!>super<!>(x <!AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>foo<!>() + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>foo<!>() + super.<!UNRESOLVED_REFERENCE!>foo<!>())
+    constructor(x: Int, y: Int = x <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>foo<!>() + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>foo<!>() + super.<!UNRESOLVED_REFERENCE!>foo<!>()) :
+        <!INAPPLICABLE_CANDIDATE!>super<!>(x <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>foo<!>() + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>foo<!>() + super.<!UNRESOLVED_REFERENCE!>foo<!>())
 }

compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/superFunAccessOverriden.fir.kt

@@ -4,6 +4,6 @@ open class B(x: Int) {
 }
 class A : B {
     override fun foo() = 2
-    constructor(x: Int, y: Int = x <!AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>foo<!>() + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>foo<!>() + super.<!UNRESOLVED_REFERENCE!>foo<!>()) :
-        <!INAPPLICABLE_CANDIDATE!>super<!>(x <!AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>foo<!>() + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>foo<!>() + super.<!UNRESOLVED_REFERENCE!>foo<!>())
+    constructor(x: Int, y: Int = x <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>foo<!>() + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>foo<!>() + super.<!UNRESOLVED_REFERENCE!>foo<!>()) :
+        <!INAPPLICABLE_CANDIDATE!>super<!>(x <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>foo<!>() + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>foo<!>() + super.<!UNRESOLVED_REFERENCE!>foo<!>())
 }

compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/superPropertyAccess.fir.kt

@@ -1,6 +1,6 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 open class B(val prop: Int)
 class A : B {
-    constructor(x: Int, y: Int = x <!AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>prop<!> + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>prop<!> + super.<!UNRESOLVED_REFERENCE!>prop<!>) :
-        <!INAPPLICABLE_CANDIDATE!>super<!>(x <!AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>prop<!> + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>prop<!> + super.<!UNRESOLVED_REFERENCE!>prop<!>)
+    constructor(x: Int, y: Int = x <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>prop<!> + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>prop<!> + super.<!UNRESOLVED_REFERENCE!>prop<!>) :
+        <!INAPPLICABLE_CANDIDATE!>super<!>(x <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>prop<!> + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>prop<!> + super.<!UNRESOLVED_REFERENCE!>prop<!>)
 }

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

@@ -1,9 +1,9 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 
 class A(x: String = "", y: String = "") {
-    constructor(x: String, y: String): <!AMBIGUITY!>this<!>(x, y)
-    constructor(): <!AMBIGUITY!>this<!>("", "")
-    constructor(): <!AMBIGUITY!>this<!>("", "")
+    constructor(x: String, y: String): <!OVERLOAD_RESOLUTION_AMBIGUITY!>this<!>(x, y)
+    constructor(): <!OVERLOAD_RESOLUTION_AMBIGUITY!>this<!>("", "")
+    constructor(): <!OVERLOAD_RESOLUTION_AMBIGUITY!>this<!>("", "")
 }
 
 class B {
@@ -14,9 +14,9 @@ fun B(x: Int) {}
 
 class Outer {
     class A(x: String = "", y: String = "") {
-        constructor(x: String, y: String): <!AMBIGUITY!>this<!>(x, y)
-        constructor(): <!AMBIGUITY!>this<!>("", "")
-        constructor(): <!AMBIGUITY!>this<!>("", "")
+        constructor(x: String, y: String): <!OVERLOAD_RESOLUTION_AMBIGUITY!>this<!>(x, y)
+        constructor(): <!OVERLOAD_RESOLUTION_AMBIGUITY!>this<!>("", "")
+        constructor(): <!OVERLOAD_RESOLUTION_AMBIGUITY!>this<!>("", "")
     }
 
     class B {

compiler/testData/diagnostics/tests/smartCasts/smartcastToNothingAfterCheckingForNull.fir.kt

@@ -23,7 +23,7 @@ fun g(x: B<Int>) {
     }
 
     if (y is Nothing?) {
-        <!AMBIGUITY!>f<!>(y)
-        <!AMBIGUITY!>g<!>(y)
+        <!OVERLOAD_RESOLUTION_AMBIGUITY!>f<!>(y)
+        <!OVERLOAD_RESOLUTION_AMBIGUITY!>g<!>(y)
     }
 }

compiler/testData/diagnostics/tests/substitutions/upperBoundsSubstitutionForOverloadResolutionWithAmbiguity.fir.kt

@@ -15,5 +15,5 @@ import foo.*
 import bar.*
 
 fun <T> test(l: List<T>) {
-    <!AMBIGUITY!>f<!>(l)
+    <!OVERLOAD_RESOLUTION_AMBIGUITY!>f<!>(l)
 }

compiler/testData/diagnostics/tests/suspendConversion/overloadResolutionBySuspendModifier.fir.kt

@@ -8,8 +8,8 @@ suspend fun suspendCall(): Int = 42
 
 // it's important to have ambiguity in these cases to introduce overload resolution by suspend modifier in future
 fun test1() {
-    <!AMBIGUITY!>foo<!> { usualCall() }
-    <!AMBIGUITY!>foo<!> { suspendCall() }
+    <!OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!> { usualCall() }
+    <!OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!> { suspendCall() }
 }
 
 // candidate without suspend conversions is more specific

compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/overloadResolution.fir.kt

@@ -1,36 +0,0 @@
-// !CHECK_TYPE
-// FILE: A.java
-public class A {
-    public int foo(Runnable r) { return 0; }
-    public String foo(Object r) { return null;}
-
-    public int bar(Runnable r) { return 1; }
-    public String bar(CharSequence r) { return null; }
-}
-
-// FILE: 1.kt
-fun fn() {}
-fun x(a: A, r: Runnable) {
-    a.foo(::fn) checkType { _<Int>() }
-    a.foo {} checkType { _<Int>() }
-
-    a.foo(null) checkType { _<Int>() }
-    a.foo(Runnable { }) checkType { _<Int>() }
-    a.foo(r) checkType { _<Int>() }
-
-    a.foo(123) checkType { _<String>() }
-    a.foo("") checkType { _<String>() }
-
-    a.bar(::fn) checkType { _<Int>() }
-    a.bar {} checkType { _<Int>() }
-
-    a.bar(r) checkType { _<Int>() }
-
-    a.<!AMBIGUITY!>bar<!>(null)
-
-    a.bar(null as Runnable?) checkType { _<Int>() }
-    a.bar(null as CharSequence?) checkType { _<String>() }
-
-    a.bar("") checkType { _<String>() }
-    a.<!NONE_APPLICABLE!>bar<!>(123)
-}

compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/overloadResolution.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !CHECK_TYPE
 // FILE: A.java
 public class A {

compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/overloadResolutionStatic.fir.kt

@@ -1,36 +0,0 @@
-// !CHECK_TYPE
-// FILE: A.java
-public class A {
-    public static int foo(Runnable r) { return 0; }
-    public static String foo(Object r) { return null;}
-
-    public static int bar(Runnable r) { return 1; }
-    public static String bar(CharSequence r) { return null; }
-}
-
-// FILE: 1.kt
-fun fn() {}
-fun x(r: Runnable) {
-    A.foo(::fn) checkType { _<Int>() }
-    A.foo {} checkType { _<Int>() }
-
-    A.foo(null) checkType { _<Int>() }
-    A.foo(Runnable { }) checkType { _<Int>() }
-    A.foo(r) checkType { _<Int>() }
-
-    A.foo(123) checkType { _<String>() }
-    A.foo("") checkType { _<String>() }
-
-    A.bar(::fn) checkType { _<Int>() }
-    A.bar {} checkType { _<Int>() }
-
-    A.bar(r) checkType { _<Int>() }
-
-    A.<!AMBIGUITY!>bar<!>(null)
-
-    A.bar(null as Runnable?) checkType { _<Int>() }
-    A.bar(null as CharSequence?) checkType { _<String>() }
-
-    A.bar("") checkType { _<String>() }
-    A.<!NONE_APPLICABLE!>bar<!>(123)
-}

compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/overloadResolutionStatic.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !CHECK_TYPE
 // FILE: A.java
 public class A {

compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/overloadResolutionStaticWithoutRefinedSams.fir.kt

@@ -27,7 +27,7 @@ fun x(r: Runnable) {
 
     A.bar(r) checkType { _<Int>() }
 
-    A.<!AMBIGUITY!>bar<!>(null)
+    A.<!OVERLOAD_RESOLUTION_AMBIGUITY!>bar<!>(null)
 
     A.bar(null as Runnable?) checkType { _<Int>() }
     A.bar(null as CharSequence?) checkType { _<String>() }

compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/overloadResolutionWithoutRefinedSams.fir.kt

@@ -27,7 +27,7 @@ fun x(a: A, r: Runnable) {
 
     a.bar(r) checkType { _<Int>() }
 
-    a.<!AMBIGUITY!>bar<!>(null)
+    a.<!OVERLOAD_RESOLUTION_AMBIGUITY!>bar<!>(null)
 
     a.bar(null as Runnable?) checkType { _<Int>() }
     a.bar(null as CharSequence?) checkType { _<String>() }

compiler/testData/diagnostics/tests/varargs/MostSepcificVarargsWithJava.fir.kt

@@ -1,19 +0,0 @@
-// FILE: kotlin.kt
-fun main(j : C, s : Array<String?>) {
-    j.from()
-    j.from("")
-    j.from("", "")
-    j.<!AMBIGUITY!>from<!>("", "", "")
-
-    j.<!AMBIGUITY!>from<!>("", *s) // This should not be an ambiguity, see KT-1842
-    j.from(*s)
-}
-
-// FILE: C.java
-public class C {
-    void from() {}
-    void from(String s) {}
-    void from(String s, String s1) {}
-    void from(String... s) {}
-    void from(String s1, String... s) {}
-}

compiler/testData/diagnostics/tests/varargs/MostSepcificVarargsWithJava.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // FILE: kotlin.kt
 fun main(j : C, s : Array<String?>) {
     j.from()

compiler/testData/diagnostics/tests/when/When.fir.kt

@@ -25,7 +25,7 @@ fun foo() : Int {
       is Any -> 1
       s -> 1
       1 -> 1
-      1 <!AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>a<!> -> 1
+      1 <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>a<!> -> 1
       in 1..<!UNRESOLVED_REFERENCE!>a<!> -> 1
       !in 1..<!UNRESOLVED_REFERENCE!>a<!> -> 1
       else -> 1

compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctionType/functionVsSuspendFunction.fir.kt

@@ -16,4 +16,4 @@ fun test5() = useSuspendFn {}
 
 fun test5(sfn: suspend () -> Unit) = ambiguous(sfn)
 fun test6(fn: () -> Unit) = ambiguous(fn)
-fun test7(): () -> Unit = <!AMBIGUITY!>ambiguous<!> {}
+fun test7(): () -> Unit = <!OVERLOAD_RESOLUTION_AMBIGUITY!>ambiguous<!> {}

compiler/testData/diagnostics/testsWithStdLib/factoryPattern/overloadByLambdaReturnType_enabled_no_annotation.fir.kt

@@ -9,28 +9,28 @@ fun takeString(s: String) {}
 fun takeInt(s: Int) {}
 
 fun test_1() {
-    val x = <!AMBIGUITY!>create<!> { "" }
+    val x = <!OVERLOAD_RESOLUTION_AMBIGUITY!>create<!> { "" }
     takeString(x)
 }
 
 fun test_2() {
-    val x = <!AMBIGUITY!>create<!> { 1 }
+    val x = <!OVERLOAD_RESOLUTION_AMBIGUITY!>create<!> { 1 }
     takeInt(x)
 }
 
 fun test_3() {
-    val x = <!AMBIGUITY!>create<!> { 1.0 }
+    val x = <!OVERLOAD_RESOLUTION_AMBIGUITY!>create<!> { 1.0 }
 }
 
 fun <K> create(x: K, f: (K) -> Int): Int = 1
 fun <T> create(x: T, f: (T) -> String): String = ""
 
 fun test_4() {
-    val x = <!AMBIGUITY!>create<!>("") { "" }
+    val x = <!OVERLOAD_RESOLUTION_AMBIGUITY!>create<!>("") { "" }
     takeString(x)
 }
 
 fun test_5() {
-    val x = <!AMBIGUITY!>create<!>("") { 1 }
+    val x = <!OVERLOAD_RESOLUTION_AMBIGUITY!>create<!>("") { 1 }
     takeInt(x)
 }