Update test data for tower resolution algorithm

- locals win
- unary calls to plus/minus are not supported in favor of unaryPlus/unaryMinus
- unqualified nested classes are temporarily reported as unresolved
- function without receiver win against extension function
- explicit import win against star import

compiler/testData/diagnostics/tests/DeprecatedUnaryOperatorConventions.kt

@@ -15,7 +15,7 @@ operator fun String.unaryPlus(): Int = 0
 fun test() {
     requireInt(+ "")
     requireInt(+ Example())
-    requireString(<!DEPRECATED_UNARY_PLUS_MINUS!>+ ExampleDeprecated()<!>)
+    requireString(<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>+<!> ExampleDeprecated())
 }
 
 fun requireInt(n: Int) {}
@@ -26,7 +26,7 @@ class Example2 {
     <!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun minus() = this
 
     fun test() {
-        <!DEPRECATED_UNARY_PLUS_MINUS!>+this<!>
-        <!DEPRECATED_UNARY_PLUS_MINUS!>-this<!>
+        <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>+<!>this
+        <!UNRESOLVED_REFERENCE!>-<!>this
     }
 }

compiler/testData/diagnostics/tests/FreeFunctionCalledAsExtension.kt

@@ -1,13 +1,13 @@
-fun foo(a: (String) -> Unit) {
-    "".<!INVOKE_EXTENSION_ON_NOT_EXTENSION_FUNCTION!>a<!>()
+fun foo(<!UNUSED_PARAMETER!>a<!>: (String) -> Unit) {
+    "".<!UNRESOLVED_REFERENCE!>a<!>()
 }
 
 
 
 interface A : (String) -> Unit {}
 
-fun foo(a: @Extension A) {
+fun foo(<!UNUSED_PARAMETER!>a<!>: @Extension A) {
     // @Extension annotation on an unrelated type shouldn't have any effect on this diagnostic.
     // Only kotlin.Function{n} type annotated with @Extension should
-    "".<!INVOKE_EXTENSION_ON_NOT_EXTENSION_FUNCTION!>a<!>()
+    "".<!UNRESOLVED_REFERENCE!>a<!>()
 }

compiler/testData/diagnostics/tests/Operators.kt

@@ -38,7 +38,7 @@ class Example2 {
     public operator fun invoke() {}
 }
 
-fun a() {
+fun test() {
     var a = Example()
     var b = Example()
     var c = Example2()
@@ -107,7 +107,7 @@ open class Anc : Base() {
 
 class Anc2 : Anc()
 
-fun b() {
+fun test2() {
     Anc() + Anc()
     Anc() <!OPERATOR_MODIFIER_REQUIRED!>-<!> Anc()
     Anc2() + Anc2()

compiler/testData/diagnostics/tests/Operators.txt

@@ -1,7 +1,7 @@
 package
 
-public fun a(): kotlin.Unit
-public fun b(): kotlin.Unit
+public fun test(): kotlin.Unit
+public fun test2(): kotlin.Unit
 
 public open class Anc : Base {
     public constructor Anc()

compiler/testData/diagnostics/tests/RecursiveResolve.kt

@@ -32,7 +32,7 @@ class Test2<A, B, C>(foo: Any?, bar: Any?) {
 class Test3<in A, B, C>(foo: Any?, bar: Any?) {
     val foo = foo ?: this
     private val bar = bar ?: this
-    private val bas = bas()
+    private val bas = <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!><!DEBUG_INFO_MISSING_UNRESOLVED!>bas<!>()<!>
     val bas2 = bas2()
 
     private fun bas(): Int = null!!
@@ -47,7 +47,7 @@ class Test3<in A, B, C>(foo: Any?, bar: Any?) {
 class Test4<A, out B, C>(foo: Any?, bar: Any?) {
     val foo = foo ?: this
     private val bar = bar ?: this
-    private val bas = bas()
+    private val bas = <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!><!DEBUG_INFO_MISSING_UNRESOLVED!>bas<!>()<!>
     val bas2 = bas2()
 
     private fun bas(): Int = null!!

compiler/testData/diagnostics/tests/RecursiveResolve.txt

@@ -37,7 +37,7 @@ public final class Test2</*0*/ A, /*1*/ B, /*2*/ C> {
 public final class Test3</*0*/ in A, /*1*/ B, /*2*/ C> {
     public constructor Test3</*0*/ in A, /*1*/ B, /*2*/ C>(/*0*/ foo: kotlin.Any?, /*1*/ bar: kotlin.Any?)
     private final val bar: kotlin.Any
-    private final val bas: kotlin.Int
+    private final val bas: [ERROR : Type for bas()]
     public final val bas2: kotlin.Int
     public final val foo: kotlin.Any
     public final fun bar(): kotlin.Int
@@ -54,7 +54,7 @@ public final class Test3</*0*/ in A, /*1*/ B, /*2*/ C> {
 public final class Test4</*0*/ A, /*1*/ out B, /*2*/ C> {
     public constructor Test4</*0*/ A, /*1*/ out B, /*2*/ C>(/*0*/ foo: kotlin.Any?, /*1*/ bar: kotlin.Any?)
     private final val bar: kotlin.Any
-    private final val bas: kotlin.Int
+    private final val bas: [ERROR : Type for bas()]
     public final val bas2: kotlin.Int
     public final val foo: kotlin.Any
     public final fun bar(): kotlin.Int

compiler/testData/diagnostics/tests/StarsInFunctionCalls.kt

@@ -5,7 +5,7 @@ fun foo(<!UNUSED_PARAMETER!>a<!> : Any?) {}
 
 public fun main() {
     getT<<!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>*<!>>()
-    <!UNRESOLVED_REFERENCE!>ggetT<!><<!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT, PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>*<!>>()
+    <!UNRESOLVED_REFERENCE!>ggetT<!><<!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>*<!>>()
     getTT<<!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>*<!>, <!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>*<!>>()
     getTT<<!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>*<!>, Int>()
     getTT<Int, <!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>*<!>>()

compiler/testData/diagnostics/tests/callableReference/function/extensionInClassDisallowed.kt

@@ -10,6 +10,6 @@ class A {
 }
 
 fun main() {
-    A::<!MISSING_RECEIVER, EXTENSION_IN_CLASS_REFERENCE_NOT_ALLOWED!>extInt<!>
-    A::<!MISSING_RECEIVER, EXTENSION_IN_CLASS_REFERENCE_NOT_ALLOWED!>extA<!>
+    A::<!UNRESOLVED_REFERENCE!>extInt<!>
+    A::<!UNRESOLVED_REFERENCE!>extA<!>
 }

compiler/testData/diagnostics/tests/callableReference/function/nestedConstructorFromExtension.kt

@@ -7,7 +7,7 @@ class A {
 }
     
 fun A.main() {
-    ::<!NESTED_CLASS_SHOULD_BE_QUALIFIED!>Nested<!>
+    ::<!UNRESOLVED_REFERENCE!>Nested<!>
     val y = A::Nested
     
     checkSubtype<KFunction0<A.Nested>>(y)

compiler/testData/diagnostics/tests/callableReference/function/unresolved.kt

@@ -8,5 +8,5 @@ fun main() {
     
     A::<!UNRESOLVED_REFERENCE!>bar<!>
     
-    <!UNRESOLVED_REFERENCE!>B<!>::<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>bar<!>
+    <!UNRESOLVED_REFERENCE!>B<!>::<!OVERLOAD_RESOLUTION_AMBIGUITY!>bar<!>
 }

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

@@ -14,15 +14,14 @@ class A {
 
 fun A.foo(): String = "A"
 
-val x0 = A::foo // function A::foo wins by default
-val userOfX0 = x0(A())
+val x0 = A::<!OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!>
 
 val x1 = ofType<(A) -> Unit>(A::foo)
 val x2 = ofType<KProperty1<A, Int>>(A::foo)
 val x3: KProperty1<A, Int> = A::foo
 val x4: (A) -> String = A::foo
 
-val y0 = A::bar
+val y0 = A::<!OVERLOAD_RESOLUTION_AMBIGUITY!>bar<!>
 val y1 = ofType<(A) -> Unit>(A::bar)
 val y2 = ofType<KProperty1<A, Int>>(A::bar)
 val y3: KProperty1<A, Int> = A::bar

compiler/testData/diagnostics/tests/callableReference/resolve/withExtFun.txt

@@ -1,12 +1,11 @@
 package
 
-public val userOfX0: kotlin.Unit
-public val x0: kotlin.reflect.KFunction1<A, kotlin.Unit>
+public val x0: [ERROR : Type for A::foo]
 public val x1: (A) -> kotlin.Unit
 public val x2: kotlin.reflect.KProperty1<A, kotlin.Int>
 public val x3: kotlin.reflect.KProperty1<A, kotlin.Int>
 public val x4: (A) -> kotlin.String
-public val y0: kotlin.reflect.KFunction1<A, kotlin.Unit>
+public val y0: [ERROR : Type for A::bar]
 public val y1: (A) -> kotlin.Unit
 public val y2: kotlin.reflect.KProperty1<A, kotlin.Int>
 public val y3: kotlin.reflect.KProperty1<A, kotlin.Int>

compiler/testData/diagnostics/tests/classObjects/InnerClassAccessThroughEnum.kt

@@ -14,12 +14,11 @@ enum class C {
 
     E4 {
         fun c() {
-            //TODO: this is a bug
-            this.<!UNRESOLVED_REFERENCE!>B<!>()
+            this.B()
 
             C.A()
             A()
-            //TODO: this is a bug
+            //TODO: should be resolved with error
             this.<!UNRESOLVED_REFERENCE!>A<!>()
         }
     };
@@ -33,7 +32,7 @@ enum class C {
 
 fun f() {
     C.E1.<!UNRESOLVED_REFERENCE!>A<!>
-    C.E1.<!NESTED_CLASS_ACCESSED_VIA_INSTANCE_REFERENCE!>A<!>()
+    C.E1.<!UNRESOLVED_REFERENCE!>A<!>()
     C.E2.B()
 
     C.E2.<!UNRESOLVED_REFERENCE!>O<!>

compiler/testData/diagnostics/tests/dynamicTypes/withInvisibleSynthesized.dynamic.txt

@@ -1 +1,2 @@
 public final fun sam(/*0*/ p0: dynamic): dynamic
+public final fun sam(/*0*/ name: dynamic, /*1*/ name: dynamic): dynamic

compiler/testData/diagnostics/tests/dynamicTypes/withInvisibleSynthesized.kt

@@ -22,9 +22,9 @@ import p.*
 class K: J.C() {
     fun <!UNSUPPORTED!>dynamic<!>.test() {
         <!DEBUG_INFO_DYNAMIC!>sam<!>(null)
-        <!INVISIBLE_MEMBER!>sam<!>(
-            <!NAMED_ARGUMENTS_NOT_ALLOWED, NAMED_PARAMETER_NOT_FOUND!>name<!> = null,
-            <!NAMED_ARGUMENTS_NOT_ALLOWED, NAMED_PARAMETER_NOT_FOUND!>name<!> = null
+        <!DEBUG_INFO_DYNAMIC!>sam<!>(
+            name = null,
+            <!ARGUMENT_PASSED_TWICE!>name<!> = null
         <!NO_VALUE_FOR_PARAMETER!>)<!>
     }
 

compiler/testData/diagnostics/tests/extensions/extensionMemberInClassObject.kt

@@ -9,9 +9,12 @@ class Foo {
 }
 
 fun main(args: Array<String>) {
-    <!TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR!>with<!>("", <!TYPE_MISMATCH!>{
-        Foo.<!MISSING_RECEIVER, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>findByName<!>("")
-    }<!>)
+    with("", {
+        Foo.<!UNRESOLVED_REFERENCE!>findByName<!>("")
+    })
+    with(Foo) {
+        findByName("")
+    }
 }
 
 fun <T> with(t: T, f: T.() -> Unit) {}

compiler/testData/diagnostics/tests/extensions/kt1875.kt

@@ -2,7 +2,7 @@
 
 package kt1875
 
-fun f(a : Int?, b : Int.(Int)->Int) = a?.b(1) //unnecessary safe call warning
+fun foo(a : Int?, b : Int.(Int)->Int) = a?.b(1) //unnecessary safe call warning
 
 interface T {
     val f : ((i: Int) -> Unit)?
@@ -14,7 +14,7 @@ fun test(t: T) {
 }
 
 fun test1(t: T?) {
-    t<!UNSAFE_CALL!>.<!><!UNSAFE_CALL!>f<!>(1)
+    t<!UNSAFE_CALL!>.<!><!FUNCTION_EXPECTED!>f<!>(1) // todo resolve f as value and report UNSAFE_CALL
     t?.<!UNSAFE_CALL!>f<!>(1)
     t<!UNSAFE_CALL!>.<!>f?.invoke(1)
     t?.f?.invoke(1)

compiler/testData/diagnostics/tests/extensions/kt1875.txt

@@ -1,7 +1,7 @@
 package
 
 package kt1875 {
-    public fun f(/*0*/ a: kotlin.Int?, /*1*/ b: kotlin.Int.(kotlin.Int) -> kotlin.Int): kotlin.Int?
+    public fun foo(/*0*/ a: kotlin.Int?, /*1*/ b: kotlin.Int.(kotlin.Int) -> kotlin.Int): kotlin.Int?
     public fun test(/*0*/ t: kt1875.T): kotlin.Unit
     public fun test1(/*0*/ t: kt1875.T?): kotlin.Unit
 

compiler/testData/diagnostics/tests/imports/AllUnderImportsSamePriorityForProperty.kt

@@ -15,5 +15,5 @@ import a.X
 import b.*
 
 fun foo() {
-    <!OVERLOAD_RESOLUTION_AMBIGUITY!>X<!> = 1
+    X = 1
 }

compiler/testData/diagnostics/tests/imports/importFunctionWithAllUnderImportAfterNamedImport.kt

@@ -5,8 +5,8 @@ package test
 import testing.other.*
 import testing.TestFun
 
-// Resolve should be ambiguous
-val a = <!OVERLOAD_RESOLUTION_AMBIGUITY!>TestFun<!>()
+// Resolve shouldn't be ambiguous
+val a = TestFun()
 
 
 //FILE:testing.kt

compiler/testData/diagnostics/tests/imports/importFunctionWithAllUnderImportAfterNamedImport.txt

@@ -1,7 +1,7 @@
 package
 
 package test {
-    public val a: [ERROR : Type for TestFun()]
+    public val a: testing.TestFun
 }
 
 package testing {

compiler/testData/diagnostics/tests/inner/accessingToJavaNestedClass.kt

@@ -48,17 +48,17 @@ fun test() {
     val ii: I.NI? = null
 
     val bc: B.<!UNRESOLVED_REFERENCE!>NC<!> = B.<!UNRESOLVED_REFERENCE!>NC<!>()
-    val bic: B.<!UNRESOLVED_REFERENCE!>IC<!> = B().<!UNRESOLVED_REFERENCE!>IC<!>()
+    val bic: B.<!UNRESOLVED_REFERENCE!>IC<!> = B().IC()
     val bi: B.<!UNRESOLVED_REFERENCE!>NI<!>? = null
 
     val cc: C.<!UNRESOLVED_REFERENCE!>NC<!> = C.<!UNRESOLVED_REFERENCE!>NC<!>()
     val ci: C.<!UNRESOLVED_REFERENCE!>NI<!>? = null
 
     val dc: D.<!UNRESOLVED_REFERENCE!>NC<!> = D.<!UNRESOLVED_REFERENCE!>NC<!>()
-    val dic: D.<!UNRESOLVED_REFERENCE!>IC<!> = D().<!UNRESOLVED_REFERENCE!>IC<!>()
+    val dic: D.<!UNRESOLVED_REFERENCE!>IC<!> = D().IC()
     val di: D.<!UNRESOLVED_REFERENCE!>NI<!>? = null
 
     val kc: K.<!UNRESOLVED_REFERENCE!>NC<!> = K.<!UNRESOLVED_REFERENCE!>NC<!>()
-    val kic: K.<!UNRESOLVED_REFERENCE!>IC<!> = K().<!UNRESOLVED_REFERENCE!>IC<!>()
+    val kic: K.<!UNRESOLVED_REFERENCE!>IC<!> = K().IC()
     val ki: K.<!UNRESOLVED_REFERENCE!>NI<!>? = null
 }

compiler/testData/diagnostics/tests/inner/accessingToKotlinNestedClass.kt

@@ -32,13 +32,13 @@ fun test() {
     val ii: I.NI? = null
 
     val bc: B.<!UNRESOLVED_REFERENCE!>NC<!> = B.<!UNRESOLVED_REFERENCE!>NC<!>()
-    val bic: B.<!UNRESOLVED_REFERENCE!>IC<!> = B().<!UNRESOLVED_REFERENCE!>IC<!>()
+    val bic: B.<!UNRESOLVED_REFERENCE!>IC<!> = B().IC()
     val bi: B.<!UNRESOLVED_REFERENCE!>NI<!>? = null
 
     val cc: C.<!UNRESOLVED_REFERENCE!>NC<!> = C.<!UNRESOLVED_REFERENCE!>NC<!>()
     val ci: C.<!UNRESOLVED_REFERENCE!>NI<!>? = null
 
     val dc: D.<!UNRESOLVED_REFERENCE!>NC<!> = D.<!UNRESOLVED_REFERENCE!>NC<!>()
-    val dic: D.<!UNRESOLVED_REFERENCE!>IC<!> = D().<!UNRESOLVED_REFERENCE!>IC<!>()
+    val dic: D.<!UNRESOLVED_REFERENCE!>IC<!> = D().IC()
     val di: D.<!UNRESOLVED_REFERENCE!>NI<!>? = null
 }

compiler/testData/diagnostics/tests/inner/extensionFun.kt

@@ -23,6 +23,6 @@ class Outer {
 
 fun Outer.foo() {
     Outer()
-    <!NESTED_CLASS_SHOULD_BE_QUALIFIED!>Nested<!>()
+    <!UNRESOLVED_REFERENCE!>Nested<!>()
     Inner()
 }

compiler/testData/diagnostics/tests/inner/nestedClassAccessedViaInstanceReference.kt

@@ -24,30 +24,30 @@ object Obj {
 }
 
 fun test(with: WithClassObject, without: WithoutClassObject, obj: Obj) {
-    with.<!NESTED_CLASS_ACCESSED_VIA_INSTANCE_REFERENCE!>Nested<!>()
-    with.<!NESTED_CLASS_ACCESSED_VIA_INSTANCE_REFERENCE!>NestedWithClassObject<!>
-    with.<!NESTED_CLASS_ACCESSED_VIA_INSTANCE_REFERENCE!>NestedWithClassObject<!>()
-    with.<!NESTED_CLASS_ACCESSED_VIA_INSTANCE_REFERENCE!>NestedWithClassObject<!>.foo()
+    with.<!UNRESOLVED_REFERENCE!>Nested<!>()
+    with.<!NO_COMPANION_OBJECT, NESTED_CLASS_ACCESSED_VIA_INSTANCE_REFERENCE!>NestedWithClassObject<!>
+    with.<!UNRESOLVED_REFERENCE!>NestedWithClassObject<!>()
+    with.<!NO_COMPANION_OBJECT, NESTED_CLASS_ACCESSED_VIA_INSTANCE_REFERENCE!>NestedWithClassObject<!>.foo()
     with.<!NO_COMPANION_OBJECT, NESTED_CLASS_ACCESSED_VIA_INSTANCE_REFERENCE!>NestedEnum<!>.A
     with.<!NESTED_CLASS_ACCESSED_VIA_INSTANCE_REFERENCE!>NestedObj<!>
-    with.<!NESTED_CLASS_ACCESSED_VIA_INSTANCE_REFERENCE!>NestedObj<!>()
+    with.<!UNRESOLVED_REFERENCE!>NestedObj<!>()
     with.<!NESTED_CLASS_ACCESSED_VIA_INSTANCE_REFERENCE!>NestedObj<!>.foo()
 
-    without.<!NESTED_CLASS_ACCESSED_VIA_INSTANCE_REFERENCE!>Nested<!>()
-    without.<!NESTED_CLASS_ACCESSED_VIA_INSTANCE_REFERENCE!>NestedWithClassObject<!>
-    without.<!NESTED_CLASS_ACCESSED_VIA_INSTANCE_REFERENCE!>NestedWithClassObject<!>()
-    without.<!NESTED_CLASS_ACCESSED_VIA_INSTANCE_REFERENCE!>NestedWithClassObject<!>.foo()
+    without.<!UNRESOLVED_REFERENCE!>Nested<!>()
+    without.<!NO_COMPANION_OBJECT, NESTED_CLASS_ACCESSED_VIA_INSTANCE_REFERENCE!>NestedWithClassObject<!>
+    without.<!UNRESOLVED_REFERENCE!>NestedWithClassObject<!>()
+    without.<!NO_COMPANION_OBJECT, NESTED_CLASS_ACCESSED_VIA_INSTANCE_REFERENCE!>NestedWithClassObject<!>.foo()
     without.<!NO_COMPANION_OBJECT, NESTED_CLASS_ACCESSED_VIA_INSTANCE_REFERENCE!>NestedEnum<!>.A
     without.<!NESTED_CLASS_ACCESSED_VIA_INSTANCE_REFERENCE!>NestedObj<!>
-    without.<!NESTED_CLASS_ACCESSED_VIA_INSTANCE_REFERENCE!>NestedObj<!>()
+    without.<!UNRESOLVED_REFERENCE!>NestedObj<!>()
     without.<!NESTED_CLASS_ACCESSED_VIA_INSTANCE_REFERENCE!>NestedObj<!>.foo()
 
-    obj.<!NESTED_CLASS_ACCESSED_VIA_INSTANCE_REFERENCE!>Nested<!>()
-    obj.<!NESTED_CLASS_ACCESSED_VIA_INSTANCE_REFERENCE!>NestedWithClassObject<!>
-    obj.<!NESTED_CLASS_ACCESSED_VIA_INSTANCE_REFERENCE!>NestedWithClassObject<!>()
-    obj.<!NESTED_CLASS_ACCESSED_VIA_INSTANCE_REFERENCE!>NestedWithClassObject<!>.foo()
+    obj.<!UNRESOLVED_REFERENCE!>Nested<!>()
+    obj.<!NO_COMPANION_OBJECT, NESTED_CLASS_ACCESSED_VIA_INSTANCE_REFERENCE!>NestedWithClassObject<!>
+    obj.<!UNRESOLVED_REFERENCE!>NestedWithClassObject<!>()
+    obj.<!NO_COMPANION_OBJECT, NESTED_CLASS_ACCESSED_VIA_INSTANCE_REFERENCE!>NestedWithClassObject<!>.foo()
     obj.<!NO_COMPANION_OBJECT, NESTED_CLASS_ACCESSED_VIA_INSTANCE_REFERENCE!>NestedEnum<!>.A
     obj.<!NESTED_CLASS_ACCESSED_VIA_INSTANCE_REFERENCE!>NestedObj<!>
-    obj.<!NESTED_CLASS_ACCESSED_VIA_INSTANCE_REFERENCE!>NestedObj<!>()
+    obj.<!UNRESOLVED_REFERENCE!>NestedObj<!>()
     obj.<!NESTED_CLASS_ACCESSED_VIA_INSTANCE_REFERENCE!>NestedObj<!>.foo()
 }

compiler/testData/diagnostics/tests/modifiers/operatorInfix/LocalFunctions.kt

@@ -26,11 +26,11 @@ fun a() {
             consumeString(a plus b)
             consumeInt(a minus b)
 
-            a <!OVERLOAD_RESOLUTION_AMBIGUITY!>*<!> b
-            a <!OVERLOAD_RESOLUTION_AMBIGUITY!>/<!> b
+            a * b
+            a <!OPERATOR_MODIFIER_REQUIRED!>/<!> b
 
-            a <!OVERLOAD_RESOLUTION_AMBIGUITY!>times<!> b
-            a <!OVERLOAD_RESOLUTION_AMBIGUITY!>div<!> b
+            a times b
+            a <!INFIX_MODIFIER_REQUIRED!>div<!> b
         }
     }
 }

compiler/testData/diagnostics/tests/modifiers/operatorInfix/Simple.kt

@@ -24,7 +24,7 @@ operator fun Example.inc() = Example2()
 
 infix fun Example.plus(o: Example) = ""
 
-fun a() {
+fun test() {
     var a = Example()
     val b = Example()
 

compiler/testData/diagnostics/tests/modifiers/operatorInfix/Simple.txt

@@ -1,9 +1,9 @@
 package
 
-public fun a(): kotlin.Unit
 public fun consumeExample2(/*0*/ e: Example2): kotlin.Unit
 public fun consumeInt(/*0*/ i: kotlin.Int): kotlin.Unit
 public fun consumeString(/*0*/ s: kotlin.String): kotlin.Unit
+public fun test(): kotlin.Unit
 public operator fun Example.component1(): kotlin.String
 public operator fun Example.component2(): kotlin.String
 public operator fun Example.get(/*0*/ i: kotlin.Int): kotlin.String

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

@@ -31,6 +31,6 @@ import p.*
 
 fun B.test() {
     if (this is C) {
-        "".getParent()
+        "".<!DEBUG_INFO_IMPLICIT_RECEIVER_SMARTCAST!>getParent<!>()
     }
 }

compiler/testData/diagnostics/tests/platformTypes/intVsIntegerAmbiguity.kt

@@ -24,10 +24,12 @@ class C
 fun foo(i: Int?) : C = null!!
 
 fun test(i: Int, ni: Int?) {
-    checkSubtype<J.A>(foo(2))
-    checkSubtype<J.A>(foo(i))
+    checkSubtype<C>(foo(2))
+    checkSubtype<J.A>(J.foo(2))
+    checkSubtype<J.A>(J.foo(i))
+    checkSubtype<J.B>(J.foo(ni))
+    checkSubtype<C>(foo(ni))
     checkSubtype<J.B>(J.foo(ni))
-    <!OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!>(ni)
 
     foo(J.getInteger())
     J.foo(J.getInteger())

compiler/testData/diagnostics/tests/resolve/invoke/errors/receiverPresenceErrorForInvoke.kt

@@ -5,7 +5,7 @@ fun test1(f: String.() -> Unit) {
 }
 
 fun test2(f: (Int) -> Int) {
-    1.<!INVOKE_EXTENSION_ON_NOT_EXTENSION_FUNCTION!>f<!>(<!TOO_MANY_ARGUMENTS!>2<!>)
+    1.<!UNRESOLVED_REFERENCE!>f<!>(2)
 
-    2.<!INVOKE_EXTENSION_ON_NOT_EXTENSION_FUNCTION!>(f)<!>(<!TOO_MANY_ARGUMENTS!>2<!>)
+    2.<!NO_RECEIVER_ALLOWED!>(f)<!>(2)
 }

compiler/testData/diagnostics/tests/resolve/invoke/invokeAsMemberExtensionToExplicitReceiver.kt

@@ -3,8 +3,8 @@ interface Foo {
     operator fun A.invoke()
 }
 
-fun test(a: A, foo: Foo) {
-    a.<!INVOKE_EXTENSION_ON_NOT_EXTENSION_FUNCTION!>foo<!>()
+fun test(a: A, <!UNUSED_PARAMETER!>foo<!>: Foo) {
+    a.<!UNRESOLVED_REFERENCE!>foo<!>()
 }
 
 fun test(a: Int, foo: Int.()->Unit) {

compiler/testData/diagnostics/tests/resolve/invoke/invokeOnVariableWithExtensionFunctionType.kt

@@ -12,7 +12,7 @@ fun test(a: A, b: B) {
     a.foo(b)
 
     with(a) {
-        b.<!MISSING_RECEIVER!>foo<!>() // todo
+        b.foo()
 
         b.(foo)()
 
@@ -23,7 +23,7 @@ fun test(a: A, b: B) {
     }
 
     with(b) {
-        a.<!INVOKE_ON_EXTENSION_FUNCTION_WITH_EXPLICIT_DISPATCH_RECEIVER!>foo<!>()
+        a.foo(<!NO_VALUE_FOR_PARAMETER!>)<!>
         a.<!FUNCTION_EXPECTED!>(<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>foo<!>)<!>()
 
         (a.foo)()
@@ -68,7 +68,7 @@ fun test(a: A, b: B) {
     }
 
     with(b) {
-        a.<!INVOKE_ON_EXTENSION_FUNCTION_WITH_EXPLICIT_DISPATCH_RECEIVER!>foo<!>()
+        a.foo(<!NO_VALUE_FOR_PARAMETER!>)<!>
         a.<!FUNCTION_EXPECTED!>(<!UNRESOLVED_REFERENCE!>foo<!>)<!>()
 
         (a.foo)()

compiler/testData/diagnostics/tests/resolve/invoke/kt9805.kt

@@ -6,7 +6,7 @@ class B
 
 fun test(a: A, b: B) {
     with(b) {
-        a.<!INVOKE_ON_EXTENSION_FUNCTION_WITH_EXPLICIT_DISPATCH_RECEIVER!>foo<!>() // here must be error, because a is not extension receiver
+        a.foo(<!NO_VALUE_FOR_PARAMETER!>)<!> // here must be error, because a is not extension receiver
 
         a.foo(this)
 

compiler/testData/diagnostics/tests/resolve/invoke/wrongInvokeExtension.kt

@@ -9,11 +9,11 @@ val B.a: () -> Int  get() = { 5 }
 fun test(a: A, b: B) {
     val <!UNUSED_VARIABLE!>x<!>: Int = b.a()
 
-    b.<!INVOKE_EXTENSION_ON_NOT_EXTENSION_FUNCTION!>(a)<!>()
+    b.<!FUNCTION_EXPECTED!>(a)<!>()
 
     with(b) {
         val <!UNUSED_VARIABLE!>y<!>: Int = a()
-        <!MISSING_RECEIVER!>(a)<!>()
+        <!FUNCTION_EXPECTED!>(a)<!>()
     }
 }
 

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

@@ -1,5 +1,5 @@
 // FILE: root.kt
-fun testFun() = 12
+fun testFun() = "239"
 
 // FILE: otherPackage.kt
 package test
@@ -9,4 +9,4 @@ fun testFun() = 12
 // FILE: using.kt
 import test.*
 
-val t = <!OVERLOAD_RESOLUTION_AMBIGUITY!>testFun<!>()
+val t: String = testFun()

compiler/testData/diagnostics/tests/scopes/AmbiguityBetweenRootAndPackage.txt

@@ -1,7 +1,7 @@
 package
 
-public val t: [ERROR : Type for testFun()]
-public fun testFun(): kotlin.Int
+public val t: kotlin.String
+public fun testFun(): kotlin.String
 
 package test {
     public fun testFun(): kotlin.Int

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

@@ -15,12 +15,12 @@ class A<T> {
 
     inner class I {
         init {
-            <!NESTED_CLASS_SHOULD_BE_QUALIFIED!>T<!>() // todo: fix error message
+            T() // todo: https://jetbrains.quip.com/hPM5AJcc1nca
         }
     }
 
     init {
-        <!NESTED_CLASS_SHOULD_BE_QUALIFIED!>T<!>()
+        T()
     }
 }
 
@@ -47,11 +47,11 @@ class B<T> {
 
     inner class I {
         init {
-            <!NESTED_CLASS_SHOULD_BE_QUALIFIED!>T<!>()
+            T()
         }
     }
 
     init {
-        <!NESTED_CLASS_SHOULD_BE_QUALIFIED!>T<!>()
+        T()
     }
 }

compiler/testData/diagnostics/tests/scopes/inheritance/innerClasses.kt

@@ -33,8 +33,8 @@ class E: A() {
 
     object Z {
         init {
-            <!NESTED_CLASS_SHOULD_BE_QUALIFIED!>B<!>().<!UNRESOLVED_REFERENCE!>foo<!>() // todo: some resolve hacks
-            <!NESTED_CLASS_SHOULD_BE_QUALIFIED!>B<!>().bar()
+            <!UNRESOLVED_REFERENCE!>B<!>().<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>foo<!>()
+            <!UNRESOLVED_REFERENCE!>B<!>().<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>bar<!>()
 
             <!UNRESOLVED_REFERENCE!>D<!>()
             C()

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

@@ -31,6 +31,6 @@ public class X extends B {
 // FILE: 2.kt
 class Y: X() {
     init {
-        val a: Double = <!TYPE_MISMATCH!>foo()<!> // todo
+        val a: Double = foo()
     }
 }

compiler/testData/diagnostics/tests/secondaryConstructors/companionObjectScope.kt

@@ -13,5 +13,5 @@ class A {
     }
 
     constructor(x: Int)
-    constructor() : this(foo() + prop + B.bar() + B.prop + C)
+    constructor() : this(foo() + prop + B.bar() + B.prop <!NONE_APPLICABLE!>+<!> C)
 }

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

@@ -3,11 +3,15 @@ package foo
 
 fun <T> f(<!UNUSED_PARAMETER!>l<!>: List<T>) {}
 
+// FILE: bar.kt
+package bar
+
+fun <T> f(<!UNUSED_PARAMETER!>l<!>: List<T>) {}
+
 // FILE: main.kt
 
 import foo.*
-
-fun <T> f(<!UNUSED_PARAMETER!>l<!>: List<T>) {}
+import bar.*
 
 fun <T> test(l: List<T>) {
     <!CANNOT_COMPLETE_RESOLVE!>f<!>(l)

compiler/testData/diagnostics/tests/substitutions/upperBoundsSubstitutionForOverloadResolutionWithAmbiguity.txt

@@ -1,8 +1,11 @@
 package
 
-public fun </*0*/ T> f(/*0*/ l: kotlin.List<T>): kotlin.Unit
 public fun </*0*/ T> test(/*0*/ l: kotlin.List<T>): kotlin.Unit
 
+package bar {
+    public fun </*0*/ T> f(/*0*/ l: kotlin.List<T>): kotlin.Unit
+}
+
 package foo {
     public fun </*0*/ T> f(/*0*/ l: kotlin.List<T>): kotlin.Unit
 }