[Spec tests] Add overload resolution tests for plus assign operator call

2020-07-28 11:14:26 +03:00
parent 1d83c59e80
commit d5ddb26180
59 changed files with 3756 additions and 8 deletions
@@ -0,0 +1,47 @@
+// !LANGUAGE: +NewInference
+// !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION
+// SKIP_TXT
+
+
+// FILE: TestCase1.kt
+/*
+ * TESTCASE NUMBER: 1
+ */
+package testPackCase1
+
+class C
+@JvmName("bb1")
+fun C?.boo( c: ()->Any) {} //(1)
+
+@JvmName("aa1")
+fun C?.boo( c: ()->C) : String { //(2)
+    val x = {1}
+    this.<!DEBUG_INFO_CALL("fqName: testPackCase1.boo; typeCall: extension function")!>boo( x )<!>// ok to (1)
+    this.boo( x )
+
+    this.<!DEBUG_INFO_CALL("fqName: testPackCase1.boo; typeCall: extension function")!>boo( {1})<!> //to (2); {1} is ()->C
+    this.boo( {1})
+
+    return ""
+}
+// FILE: TestCase2.kt
+/*
+ * TESTCASE NUMBER: 2
+ */
+package testPackCase2
+
+class C
+@JvmName("bb1")
+fun C?.boo( c: ()->Any) {} //(1)
+
+@JvmName("aa1")
+fun C?.boo( c: ()->C, x : Int = 1) : String { //(2)
+    val x = {1}
+    this.<!DEBUG_INFO_CALL("fqName: testPackCase2.boo; typeCall: extension function")!>boo( x )<!>// ok to (1)
+    this.boo( x )
+
+    this.<!DEBUG_INFO_CALL("fqName: testPackCase2.boo; typeCall: extension function")!>boo( {1})<!> //to (2); {1} is ()->C
+    this.boo( {1})
+
+    return ""
+}
@@ -0,0 +1,56 @@
+// !LANGUAGE: +NewInference
+// !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION
+// SKIP_TXT
+
+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
+ *
+ * SPEC VERSION: 0.1-448
+ * MAIN LINK: overload-resolution, building-the-overload-candidate-set-ocs, operator-call -> paragraph 1 -> sentence 2
+ * PRIMARY LINKS: overload-resolution, choosing-the-most-specific-candidate-from-the-overload-candidate-set, algorithm-of-msc-selection -> paragraph 3 -> sentence 1
+ * NUMBER: 1
+ * DESCRIPTION: call with lambda as argument
+ */
+
+// FILE: TestCase1.kt
+/*
+ * TESTCASE NUMBER: 1
+ */
+package testPackCase1
+
+class C
+@JvmName("bb1")
+fun C?.boo( c: ()->Any) {} //(1)
+
+@JvmName("aa1")
+fun C?.boo( c: ()->C) : String { //(2)
+    val x = {1}
+    this.<!DEBUG_INFO_CALL("fqName: testPackCase1.boo; typeCall: extension function")!>boo( x )<!>// ok to (1)
+    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit")!>this.boo( x )<!>
+
+    this.<!DEBUG_INFO_CALL("fqName: testPackCase1.boo; typeCall: extension function")!>boo( {<!CONSTANT_EXPECTED_TYPE_MISMATCH, CONSTANT_EXPECTED_TYPE_MISMATCH, CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>})<!> //to (2); {1} is ()->C
+    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String")!>this.boo( {<!CONSTANT_EXPECTED_TYPE_MISMATCH, CONSTANT_EXPECTED_TYPE_MISMATCH, CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>})<!>
+
+    return ""
+}
+// FILE: TestCase2.kt
+/*
+ * TESTCASE NUMBER: 2
+ */
+package testPackCase2
+
+class C
+@JvmName("bb1")
+fun C?.boo( c: ()->Any) {} //(1)
+
+@JvmName("aa1")
+fun C?.boo( c: ()->C, x : Int = 1) : String { //(2)
+    val <!NAME_SHADOWING!>x<!> = {1}
+    this.<!DEBUG_INFO_CALL("fqName: testPackCase2.boo; typeCall: extension function")!>boo( x )<!>// ok to (1)
+    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit")!>this.boo( x )<!>
+
+    this.<!DEBUG_INFO_CALL("fqName: testPackCase2.boo; typeCall: extension function")!>boo( {<!CONSTANT_EXPECTED_TYPE_MISMATCH, CONSTANT_EXPECTED_TYPE_MISMATCH, CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>})<!> //to (2); {1} is ()->C
+    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String")!>this.boo( {<!CONSTANT_EXPECTED_TYPE_MISMATCH, CONSTANT_EXPECTED_TYPE_MISMATCH, CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>})<!>
+
+    return ""
+}
@@ -0,0 +1,27 @@
+// !LANGUAGE: +NewInference
+// !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION
+// SKIP_TXT
+
+
+// FILE: TestCase1.kt
+/*
+ * TESTCASE NUMBER: 1
+ */
+package testPackCase1
+
+class B {
+    inline operator fun plusAssign(crossinline c: ()->C) {}
+
+    inline operator fun plus(crossinline c: ()->C): C = C()
+}
+
+@JvmName("bb")
+inline operator fun B?.plusAssign( c: ()->Any) { } //(1)
+@JvmName("aa")
+inline  operator fun B?.plusAssign( c: ()->C) { //(2)
+
+    this += {1}
+    <!DEBUG_INFO_CALL("fqName: testPackCase1.plusAssign; typeCall: inline operator extension function")!>this += {1}<!>
+}
+
+class C
@@ -0,0 +1,36 @@
+// !LANGUAGE: +NewInference
+// !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION
+// SKIP_TXT
+
+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
+ *
+ * SPEC VERSION: 0.1-448
+ * MAIN LINK: overload-resolution, building-the-overload-candidate-set-ocs, operator-call -> paragraph 1 -> sentence 2
+ * PRIMARY LINKS: overload-resolution, choosing-the-most-specific-candidate-from-the-overload-candidate-set, algorithm-of-msc-selection -> paragraph 3 -> sentence 1
+ * NUMBER: 2
+ * DESCRIPTION: plusAssign as inline function
+ */
+
+// FILE: TestCase1.kt
+/*
+ * TESTCASE NUMBER: 1
+ */
+package testPackCase1
+
+class B {
+    inline operator fun plusAssign(crossinline c: ()->C) {}
+
+    inline operator fun plus(crossinline c: ()->C): C = C()
+}
+
+@JvmName("bb")
+inline operator fun B?.plusAssign( c: ()->Any) { } //(1)
+@JvmName("aa")
+inline  operator fun B?.plusAssign( c: ()->C) { //(2)
+
+    this <!RECURSION_IN_INLINE!>+=<!> {<!CONSTANT_EXPECTED_TYPE_MISMATCH, CONSTANT_EXPECTED_TYPE_MISMATCH, CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>}
+    <!DEBUG_INFO_CALL("fqName: testPackCase1.plusAssign; typeCall: inline operator extension function")!>this <!RECURSION_IN_INLINE!>+=<!> {<!CONSTANT_EXPECTED_TYPE_MISMATCH, CONSTANT_EXPECTED_TYPE_MISMATCH, CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>}<!>
+}
+
+class C
@@ -0,0 +1,42 @@
+// !LANGUAGE: +NewInference
+// !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION
+// SKIP_TXT
+
+
+
+// FILE: TestCase1.kt
+/*
+ * TESTCASE NUMBER: 1
+ * NOTE:
+ */
+package testPackCase1
+import LibPackCase1.a.*
+import LibPackCase1.b.*
+
+fun case1 (){
+    var b: B? = B()
+    <!DEBUG_INFO_CALL("fqName: LibPackCase1.b.plusAssign; typeCall: operator extension function")!>b += { C() }<!>
+
+    <!DEBUG_INFO_CALL("fqName: LibPackCase1.a.plusAssign; typeCall: operator extension function")!>b += {1}<!>
+}
+
+class B {
+    private  operator fun plusAssign(c: () -> C) {}
+    private  operator fun plus(c: () -> C): C = c()
+}
+class C
+
+// FILE: LibCase1.kt
+package LibPackCase1.b
+import LibPackCase1.a.*
+import testPackCase1.B
+import testPackCase1.C
+
+operator fun B?.plusAssign( c: ()->C) {} //(2)
+
+
+// FILE: LibCase1.kt
+package LibPackCase1.a
+import testPackCase1.B
+
+operator fun B?.plusAssign( c: ()->Int) {} //(1)
@@ -0,0 +1,90 @@
+// !LANGUAGE: +NewInference
+// !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION
+// SKIP_TXT
+
+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
+ *
+ * SPEC VERSION: 0.1-448
+ * MAIN LINK: overload-resolution, building-the-overload-candidate-set-ocs, operator-call -> paragraph 1 -> sentence 2
+ * PRIMARY LINKS: overload-resolution, choosing-the-most-specific-candidate-from-the-overload-candidate-set, algorithm-of-msc-selection -> paragraph 3 -> sentence 1
+ * NUMBER: 4
+ * DESCRIPTION: without inline plusAssign functions
+ * UNEXPECTED BEHAVIOUR
+ * ISSUES: KT-39819
+ */
+
+
+// FILE: TestCase1.kt
+/*
+ * TESTCASE NUMBER: 1
+ * NOTE:
+ */
+package testPackCase1
+import LibPackCase1.a.*
+import LibPackCase1.b.*
+
+fun case1 (){
+    var b: B? = B()
+    <!DEBUG_INFO_CALL("fqName: testPackCase1.B.plus; typeCall: operator function"), INVISIBLE_MEMBER, TYPE_MISMATCH!>b <!UNSAFE_OPERATOR_CALL!>+=<!> { C() }<!>
+
+    <!DEBUG_INFO_CALL("fqName: testPackCase1.B.plus; typeCall: operator function"), INVISIBLE_MEMBER, TYPE_MISMATCH!>b <!UNSAFE_OPERATOR_CALL!>+=<!> {<!CONSTANT_EXPECTED_TYPE_MISMATCH, CONSTANT_EXPECTED_TYPE_MISMATCH, CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>}<!>
+}
+
+class B {
+    private  operator fun plusAssign(c: () -> C) {}
+    private  operator fun plus(c: () -> C): C = c() //(3)
+}
+class C
+
+// FILE: LibCase1b.kt
+package LibPackCase1.b
+import LibPackCase1.a.*
+import testPackCase1.B
+import testPackCase1.C
+
+operator fun B?.plusAssign( c: ()->C) {} //(2)
+
+
+// FILE: LibCase1a.kt
+package LibPackCase1.a
+import testPackCase1.B
+
+operator fun B?.plusAssign( c: ()->Int) {} //(1)
+
+// FILE: TestCase2.kt
+/*
+ * TESTCASE NUMBER: 2
+ * NOTE:
+ */
+package testPackCase2
+import LibPackCase2.a.*
+import LibPackCase2.b.*
+
+fun case2 (){
+    var b: B = B()
+    <!DEBUG_INFO_CALL("fqName: testPackCase2.B.plus; typeCall: operator function"), INVISIBLE_MEMBER, TYPE_MISMATCH!>b += { C() }<!>
+
+    <!DEBUG_INFO_CALL("fqName: testPackCase2.B.plus; typeCall: operator function"), INVISIBLE_MEMBER, TYPE_MISMATCH!>b += {<!CONSTANT_EXPECTED_TYPE_MISMATCH, CONSTANT_EXPECTED_TYPE_MISMATCH, CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>}<!>
+}
+
+class B {
+    private  operator fun plusAssign(c: () -> C) {}
+    private  operator fun plus(c: () -> C): C = c() //(3)
+}
+class C
+
+// FILE: LibCase2b.kt
+package LibPackCase2.b
+import LibPackCase2.a.*
+import testPackCase2.B
+import testPackCase2.C
+
+operator fun B.plusAssign( c: ()->C) {} //(2)
+
+
+// FILE: LibCase2a.kt
+package LibPackCase2.a
+import testPackCase2.B
+
+operator fun B.plusAssign( c: ()->Int) {} //(1)
@@ -0,0 +1,39 @@
+// !LANGUAGE: +NewInference
+// !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION
+// SKIP_TXT
+
+
+// TESTCASE NUMBER: 1
+// FILE: TestCase1.kt
+package testPackCase1
+import LibPackCase1.a.*
+import LibPackCase1.b.*
+fun case1 (){
+    var b: B? = null
+    <!DEBUG_INFO_CALL("fqName: LibPackCase1.b.plusAssign; typeCall: inline operator extension function")!>b += { C() }<!>
+
+    <!DEBUG_INFO_CALL("fqName: LibPackCase1.a.plusAssign; typeCall: inline operator extension function")!>b += {1}<!>
+}
+
+class B {
+    private inline operator fun plusAssign(c: () -> C) {}
+
+    private inline operator fun plus(c: () -> C): C = c()
+}
+
+
+// FILE: LibCase1a.kt
+package LibPackCase1.a
+import testPackCase1.B
+
+inline operator fun B?.plusAssign( c: ()->Int) {} //(1)
+
+
+// FILE: LibCase1b.kt
+package LibPackCase1.b
+import LibPackCase1.a.*
+import testPackCase1.B
+
+inline operator fun B?.plusAssign( c: ()->C) {} //(2)
+
+class C
@@ -0,0 +1,50 @@
+// !LANGUAGE: +NewInference
+// !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION
+// SKIP_TXT
+
+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
+ *
+ * SPEC VERSION: 0.1-448
+ * MAIN LINK: overload-resolution, building-the-overload-candidate-set-ocs, operator-call -> paragraph 1 -> sentence 2
+ * PRIMARY LINKS: overload-resolution, choosing-the-most-specific-candidate-from-the-overload-candidate-set, algorithm-of-msc-selection -> paragraph 3 -> sentence 1
+ * NUMBER: 5
+ * DESCRIPTION: inline plusAssign functions
+ * UNEXPECTED BEHAVIOUR
+ * ISSUES: KT-39819
+ */
+
+// TESTCASE NUMBER: 1
+// FILE: TestCase1.kt
+package testPackCase1
+import LibPackCase1.a.*
+import LibPackCase1.b.*
+fun case1 (){
+    var b: B? = null
+    <!DEBUG_INFO_CALL("fqName: testPackCase1.B.plus; typeCall: inline operator function"), INVISIBLE_MEMBER, TYPE_MISMATCH!>b <!UNSAFE_OPERATOR_CALL!>+=<!> { C() }<!>
+
+    <!DEBUG_INFO_CALL("fqName: testPackCase1.B.plus; typeCall: inline operator function"), INVISIBLE_MEMBER, TYPE_MISMATCH!>b <!UNSAFE_OPERATOR_CALL!>+=<!> {<!CONSTANT_EXPECTED_TYPE_MISMATCH, CONSTANT_EXPECTED_TYPE_MISMATCH, CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>}<!>
+}
+
+class B {
+    private inline operator fun plusAssign(c: () -> C) {}
+
+    private inline operator fun plus(c: () -> C): C = c()
+}
+
+
+// FILE: LibCase1a.kt
+package LibPackCase1.a
+import testPackCase1.B
+
+inline operator fun B?.plusAssign( c: ()->Int) {} //(1)
+
+
+// FILE: LibCase1b.kt
+package LibPackCase1.b
+import LibPackCase1.a.*
+import testPackCase1.B
+
+inline operator fun B?.plusAssign( c: ()->C) {} //(2)
+
+class C
@@ -0,0 +1,42 @@
+// !LANGUAGE: +NewInference
+// !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION
+// SKIP_TXT
+
+
+
+// FILE: TestCase1.kt
+/*
+ * TESTCASE NUMBER: 1
+ * NOTE:
+ */
+package testPackCase1
+import LibPackCase1.a.*
+import LibPackCase1.b.*
+
+fun case1 (){
+    var b: B? = B()
+    b += { C() }
+
+    b += {1}
+}
+
+class B {
+    private  operator fun plusAssign(c: () -> C) {}
+//    private  operator fun plus(c: () -> C): C = c()
+}
+class C
+
+// FILE: LibCase1b.kt
+package LibPackCase1.b
+import LibPackCase1.a.*
+import testPackCase1.B
+import testPackCase1.C
+
+operator fun B?.plusAssign( c: ()->C) {} //(2)
+
+
+// FILE: LibCase1a.kt
+package LibPackCase1.a
+import testPackCase1.B
+
+operator fun B?.plusAssign( c: ()->Int) {} //(1)
@@ -0,0 +1,53 @@
+// !LANGUAGE: +NewInference
+// !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION
+// SKIP_TXT
+
+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
+ *
+ * SPEC VERSION: 0.1-448
+ * MAIN LINK: overload-resolution, building-the-overload-candidate-set-ocs, operator-call -> paragraph 1 -> sentence 2
+ * PRIMARY LINKS: overload-resolution, choosing-the-most-specific-candidate-from-the-overload-candidate-set, algorithm-of-msc-selection -> paragraph 3 -> sentence 1
+ * NUMBER: 6
+ * DESCRIPTION: without inline plusAssign functions
+ * UNEXPECTED BEHAVIOUR
+ * ISSUES: KT-39820
+ */
+
+
+// FILE: TestCase1.kt
+/*
+ * TESTCASE NUMBER: 1
+ * NOTE:
+ */
+package testPackCase1
+import LibPackCase1.a.*
+import LibPackCase1.b.*
+
+fun case1 (){
+    var b: B? = B()
+    b <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>+=<!> { C() }
+
+    b <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>+=<!> {1}
+}
+
+class B {
+    private  operator fun plusAssign(c: () -> C) {}
+//    private  operator fun plus(c: () -> C): C = c()
+}
+class C
+
+// FILE: LibCase1b.kt
+package LibPackCase1.b
+import LibPackCase1.a.*
+import testPackCase1.B
+import testPackCase1.C
+
+operator fun B?.plusAssign( c: ()->C) {} //(2)
+
+
+// FILE: LibCase1a.kt
+package LibPackCase1.a
+import testPackCase1.B
+
+operator fun B?.plusAssign( c: ()->Int) {} //(1)
@@ -0,0 +1,42 @@
+// !LANGUAGE: +NewInference
+// !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION
+// SKIP_TXT
+
+
+
+// FILE: TestCase1.kt
+/*
+ * TESTCASE NUMBER: 1
+ * NOTE:
+ */
+package testPackCase1
+import LibPackCase1.a.plusAssign
+import LibPackCase1.b.plusAssign
+
+fun case1 (){
+    var b: B? = B()
+    b += { C() }
+
+    b += {1}
+}
+
+class B {
+    private  operator fun plusAssign(c: () -> C) {}
+//    private  operator fun plus(c: () -> C): C = c()
+}
+class C
+
+// FILE: LibCase1b.kt
+package LibPackCase1.b
+import LibPackCase1.a.*
+import testPackCase1.B
+import testPackCase1.C
+
+operator fun B?.plusAssign( c: ()->C) {} //(2)
+
+
+// FILE: LibCase1a.kt
+package LibPackCase1.a
+import testPackCase1.B
+
+operator fun B?.plusAssign( c: ()->Int) {} //(1)
@@ -0,0 +1,53 @@
+// !LANGUAGE: +NewInference
+// !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION
+// SKIP_TXT
+
+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
+ *
+ * SPEC VERSION: 0.1-448
+ * MAIN LINK: overload-resolution, building-the-overload-candidate-set-ocs, operator-call -> paragraph 1 -> sentence 2
+ * PRIMARY LINKS: overload-resolution, choosing-the-most-specific-candidate-from-the-overload-candidate-set, algorithm-of-msc-selection -> paragraph 3 -> sentence 1
+ * NUMBER: 7
+ * DESCRIPTION: without inline plusAssign functions
+ * UNEXPECTED BEHAVIOUR
+ * ISSUES: KT-39820
+ */
+
+
+// FILE: TestCase1.kt
+/*
+ * TESTCASE NUMBER: 1
+ * NOTE:
+ */
+package testPackCase1
+import LibPackCase1.a.plusAssign
+import LibPackCase1.b.plusAssign
+
+fun case1 (){
+    var b: B? = B()
+    b <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>+=<!> { C() }
+
+    b <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>+=<!> {1}
+}
+
+class B {
+    private  operator fun plusAssign(c: () -> C) {}
+//    private  operator fun plus(c: () -> C): C = c()
+}
+class C
+
+// FILE: LibCase1b.kt
+package LibPackCase1.b
+import LibPackCase1.a.*
+import testPackCase1.B
+import testPackCase1.C
+
+operator fun B?.plusAssign( c: ()->C) {} //(2)
+
+
+// FILE: LibCase1a.kt
+package LibPackCase1.a
+import testPackCase1.B
+
+operator fun B?.plusAssign( c: ()->Int) {} //(1)
@@ -0,0 +1,73 @@
+// !LANGUAGE: +NewInference
+// !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION
+// SKIP_TXT
+
+
+
+// FILE: TestCase1.kt
+/*
+ * TESTCASE NUMBER: 1
+ * NOTE:
+ */
+package testPackCase1
+import LibPackCase1.a.plusAssign
+import LibPackCase1.b.plusAssign
+
+fun case1 (){
+    var b: B = B()
+    b +={ C() }
+    b +={ 1 }
+}
+
+class B
+class C
+
+// FILE: LibCase1b.kt
+package LibPackCase1.b
+import LibPackCase1.a.*
+import testPackCase1.B
+import testPackCase1.C
+
+operator fun B?.plusAssign( c: ()->C) {} //(2)
+
+
+// FILE: LibCase1a.kt
+package LibPackCase1.a
+import testPackCase1.B
+
+operator fun B?.plusAssign( c: ()->Int) {} //(1)
+
+// FILE: TestCase2.kt
+/*
+ * TESTCASE NUMBER: 1
+ * NOTE:
+ */
+package testPackCase2
+import LibPackCase2.a.plusAssign
+import LibPackCase2.b.plusAssign
+
+fun case2 (){
+    var b: B = B()
+    b +={ C() }
+    b +={ 1 }
+
+    b.<!AMBIGUITY!>plusAssign<!>{ C() }
+}
+
+class B
+class C
+
+// FILE: LibCase2b.kt
+package LibPackCase2.b
+import LibPackCase2.a.*
+import testPackCase2.B
+import testPackCase2.C
+
+operator fun B.plusAssign( c: ()->C) {} //(2)
+
+
+// FILE: LibCase2a.kt
+package LibPackCase2.a
+import testPackCase2.B
+
+operator fun B.plusAssign( c: ()->Int) {} //(1)
@@ -0,0 +1,84 @@
+// !LANGUAGE: +NewInference
+// !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION
+// SKIP_TXT
+
+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
+ *
+ * SPEC VERSION: 0.1-448
+ * MAIN LINK: overload-resolution, building-the-overload-candidate-set-ocs, operator-call -> paragraph 1 -> sentence 2
+ * PRIMARY LINKS: overload-resolution, choosing-the-most-specific-candidate-from-the-overload-candidate-set, algorithm-of-msc-selection -> paragraph 3 -> sentence 1
+ * NUMBER: 8
+ * DESCRIPTION: without inline plusAssign functions
+ * UNEXPECTED BEHAVIOUR
+ * ISSUES: KT-39820
+ */
+
+
+// FILE: TestCase1.kt
+/*
+ * TESTCASE NUMBER: 1
+ * NOTE:
+ */
+package testPackCase1
+import LibPackCase1.a.plusAssign
+import LibPackCase1.b.plusAssign
+
+fun case1 (){
+    var b: B = B()
+    b <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>+=<!>{ C() }
+    b <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>+=<!>{ 1 }
+}
+
+class B
+class C
+
+// FILE: LibCase1b.kt
+package LibPackCase1.b
+import LibPackCase1.a.*
+import testPackCase1.B
+import testPackCase1.C
+
+operator fun B?.plusAssign( c: ()->C) {} //(2)
+
+
+// FILE: LibCase1a.kt
+package LibPackCase1.a
+import testPackCase1.B
+
+operator fun B?.plusAssign( c: ()->Int) {} //(1)
+
+// FILE: TestCase2.kt
+/*
+ * TESTCASE NUMBER: 1
+ * NOTE:
+ */
+package testPackCase2
+import LibPackCase2.a.plusAssign
+import LibPackCase2.b.plusAssign
+
+fun case2 (){
+    var b: B = B()
+    b <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>+=<!>{ C() }
+    b <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>+=<!>{ 1 }
+
+    b.<!OVERLOAD_RESOLUTION_AMBIGUITY!>plusAssign<!>{ C() }
+}
+
+class B
+class C
+
+// FILE: LibCase2b.kt
+package LibPackCase2.b
+import LibPackCase2.a.*
+import testPackCase2.B
+import testPackCase2.C
+
+operator fun B.plusAssign( c: ()->C) {} //(2)
+
+
+// FILE: LibCase2a.kt
+package LibPackCase2.a
+import testPackCase2.B
+
+operator fun B.plusAssign( c: ()->Int) {} //(1)
@@ -0,0 +1,37 @@
+// !LANGUAGE: +NewInference
+// !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION
+// SKIP_TXT
+
+
+
+// FILE: TestCase1.kt
+/*
+ * TESTCASE NUMBER: 1
+ * NOTE:
+ */
+package testPackCase1
+import LibPackCase1.a.plusAssign
+
+fun case1 (){
+    var b: B = B()
+    <!INAPPLICABLE_CANDIDATE!>b +={ C() }<!>
+    b +={ 1 }
+}
+
+class B
+class C
+
+// FILE: LibCase1b.kt
+package LibPackCase1.b
+import LibPackCase1.a.*
+import testPackCase1.B
+import testPackCase1.C
+
+operator fun B?.plusAssign( c: ()->C) {} //(2)
+
+
+// FILE: LibCase1a.kt
+package LibPackCase1.a
+import testPackCase1.B
+
+operator fun B?.plusAssign( c: ()->Int) {} //(1)
@@ -0,0 +1,47 @@
+// !LANGUAGE: +NewInference
+// !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION
+// SKIP_TXT
+
+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
+ *
+ * SPEC VERSION: 0.1-448
+ * MAIN LINK: overload-resolution, building-the-overload-candidate-set-ocs, operator-call -> paragraph 1 -> sentence 2
+ * PRIMARY LINKS: overload-resolution, choosing-the-most-specific-candidate-from-the-overload-candidate-set, algorithm-of-msc-selection -> paragraph 3 -> sentence 1
+ * overload-resolution, determining-function-applicability-for-a-specific-call, description -> paragraph 2 -> sentence 2
+ * NUMBER: 9
+ * DESCRIPTION: without inline plusAssign functions
+ */
+
+
+// FILE: TestCase1.kt
+/*
+ * TESTCASE NUMBER: 1
+ * NOTE:
+ */
+package testPackCase1
+import LibPackCase1.a.plusAssign
+
+fun case1 (){
+    var b: B = B()
+    b +={ <!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>C()<!> }
+    b +={ 1 }
+}
+
+class B
+class C
+
+// FILE: LibCase1b.kt
+package LibPackCase1.b
+import LibPackCase1.a.*
+import testPackCase1.B
+import testPackCase1.C
+
+operator fun B?.plusAssign( c: ()->C) {} //(2)
+
+
+// FILE: LibCase1a.kt
+package LibPackCase1.a
+import testPackCase1.B
+
+operator fun B?.plusAssign( c: ()->Int) {} //(1)
@@ -0,0 +1,120 @@
+// !LANGUAGE: +NewInference
+// !DIAGNOSTICS: -UNNECESSARY_SAFE_CALL -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION
+// SKIP_TXT
+
+
+// FILE: TestCase1.kt
+// TESTCASE NUMBER: 1
+package testPackCase1
+
+fun case1(a: A, c: C) {
+
+    <!DEBUG_INFO_CALL("fqName: testPackCase1.B.plusAssign; typeCall: operator function")!>a?.b += c<!>
+    a?.b .<!DEBUG_INFO_CALL("fqName: testPackCase1.B.plusAssign; typeCall: operator function")!>plusAssign(c)<!>
+
+    val x = {
+        <!DEBUG_INFO_CALL("fqName: testPackCase1.B.plusAssign; typeCall: operator function")!>a?.b += c<!>
+        a?.b.<!DEBUG_INFO_CALL("fqName: testPackCase1.B.plusAssign; typeCall: operator function")!>plusAssign(c)<!>
+    }()
+
+    <!DEBUG_INFO_CALL("fqName: testPackCase1.B.plusAssign; typeCall: operator function")!>a?.b += { c }()<!>
+
+    a?.b.<!DEBUG_INFO_CALL("fqName: testPackCase1.B.plusAssign; typeCall: operator function")!>plusAssign({ c }())<!>
+}
+
+class A(val b: B)
+
+class B {
+    operator fun plusAssign(c: C) {
+        print("1")
+    }
+
+    operator fun plus(c: C): C {
+        print("2")
+        return c
+    }
+}
+
+class C
+
+// FILE: TestCase2.kt
+// TESTCASE NUMBER: 2
+package testPackCase2
+
+fun case2(a: A?, c: C) {
+
+    <!DEBUG_INFO_CALL("fqName: testPackCase2.plusAssign; typeCall: operator extension function")!>a?.b += c<!>
+    a?.b.<!DEBUG_INFO_CALL("fqName: testPackCase2.plusAssign; typeCall: operator extension function")!>plusAssign(c)<!>
+
+    val x = {
+        <!DEBUG_INFO_CALL("fqName: testPackCase2.plusAssign; typeCall: operator extension function")!>a?.b += c<!>
+        a?.b.<!DEBUG_INFO_CALL("fqName: testPackCase2.plusAssign; typeCall: operator extension function")!>plusAssign(c)<!>
+    }()
+
+    <!DEBUG_INFO_CALL("fqName: testPackCase2.plusAssign; typeCall: operator extension function")!>a?.b += { c }()<!>
+
+    a?.b.<!DEBUG_INFO_CALL("fqName: testPackCase2.plusAssign; typeCall: operator extension function")!>plusAssign({ c }())<!>
+
+}
+
+class A(val b: B)
+
+class B {
+    operator fun plusAssign(c: C) {
+        print("1")
+    }
+
+    operator fun plus(c: C): C {
+        print("2")
+        return c
+    }
+}
+
+operator fun B?.plusAssign(c: C) {
+    print("3")
+}
+
+class C
+// FILE: TestCase3.kt
+// TESTCASE NUMBER: 3
+package testPackCase3
+
+fun case3(a: A?, c: C) {
+
+    <!DEBUG_INFO_CALL("fqName: testPackCase3.plusAssign; typeCall: operator extension function")!>a?.b += c<!>
+    a?.b.<!DEBUG_INFO_CALL("fqName: testPackCase3.plusAssign; typeCall: operator extension function")!>plusAssign(c)<!>
+
+    val x = {
+        <!DEBUG_INFO_CALL("fqName: testPackCase3.plusAssign; typeCall: operator extension function")!>a?.b += c<!>
+        a?.b.<!DEBUG_INFO_CALL("fqName: testPackCase3.plusAssign; typeCall: operator extension function")!>plusAssign(c)<!>
+    }()
+
+    <!DEBUG_INFO_CALL("fqName: testPackCase3.plusAssign; typeCall: operator extension function")!>a?.b += { c }()<!>
+
+    a?.b.<!DEBUG_INFO_CALL("fqName: testPackCase3.plusAssign; typeCall: operator extension function")!>plusAssign({ c }())<!>
+
+}
+
+class A(val b: B)
+
+class B {
+    operator fun plusAssign(c: C) {
+        print("1")
+    }
+
+    operator fun plus(c: C): C {
+        print("2")
+        return c
+    }
+}
+
+operator fun B?.plusAssign(c: C) {
+    print("3")
+}
+
+operator fun B?.plusAssign(c: Any) {
+    print("4")
+}
+
+
+class C
@@ -0,0 +1,131 @@
+// !LANGUAGE: +NewInference
+// !DIAGNOSTICS: -UNNECESSARY_SAFE_CALL -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION
+// SKIP_TXT
+
+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-448
+ * MAIN LINK: overload-resolution, building-the-overload-candidate-set-ocs, operator-call -> paragraph 1 -> sentence 2
+ * SECONDARY LINKS: statements, assignments, operator-assignments -> paragraph 2 -> sentence 1
+ * statements, assignments, operator-assignments -> paragraph 2 -> sentence 2
+ * statements, assignments, operator-assignments -> paragraph 2 -> sentence 3
+ * NUMBER: 1
+ * DESCRIPTION: Non-extension member callables
+ */
+
+// FILE: TestCase1.kt
+// TESTCASE NUMBER: 1
+package testPackCase1
+
+fun case1(a: A, c: C) {
+
+    <!DEBUG_INFO_CALL("fqName: testPackCase1.B.plusAssign; typeCall: operator function")!>a?.b += c<!>
+    a?.b .<!DEBUG_INFO_CALL("fqName: testPackCase1.B.plusAssign; typeCall: operator function")!>plusAssign(c)<!>
+
+    val x = {
+        <!DEBUG_INFO_CALL("fqName: testPackCase1.B.plusAssign; typeCall: operator function")!>a?.b += c<!>
+        a?.b.<!DEBUG_INFO_CALL("fqName: testPackCase1.B.plusAssign; typeCall: operator function")!>plusAssign(c)<!>
+    }()
+
+    <!DEBUG_INFO_CALL("fqName: testPackCase1.B.plusAssign; typeCall: operator function")!>a?.b += { c }()<!>
+
+    a?.b.<!DEBUG_INFO_CALL("fqName: testPackCase1.B.plusAssign; typeCall: operator function")!>plusAssign({ c }())<!>
+}
+
+class A(val b: B)
+
+class B {
+    operator fun plusAssign(c: C) {
+        print("1")
+    }
+
+    operator fun plus(c: C): C {
+        print("2")
+        return c
+    }
+}
+
+class C
+
+// FILE: TestCase2.kt
+// TESTCASE NUMBER: 2
+package testPackCase2
+
+fun case2(a: A?, c: C) {
+
+    <!DEBUG_INFO_CALL("fqName: testPackCase2.plusAssign; typeCall: operator extension function")!>a?.b += c<!>
+    a?.b.<!DEBUG_INFO_CALL("fqName: testPackCase2.plusAssign; typeCall: operator extension function")!>plusAssign(c)<!>
+
+    val x = {
+        <!DEBUG_INFO_CALL("fqName: testPackCase2.plusAssign; typeCall: operator extension function")!>a?.b += c<!>
+        a?.b.<!DEBUG_INFO_CALL("fqName: testPackCase2.plusAssign; typeCall: operator extension function")!>plusAssign(c)<!>
+    }()
+
+    <!DEBUG_INFO_CALL("fqName: testPackCase2.plusAssign; typeCall: operator extension function")!>a?.b += { c }()<!>
+
+    a?.b.<!DEBUG_INFO_CALL("fqName: testPackCase2.plusAssign; typeCall: operator extension function")!>plusAssign({ c }())<!>
+
+}
+
+class A(val b: B)
+
+class B {
+    operator fun plusAssign(c: C) {
+        print("1")
+    }
+
+    operator fun plus(c: C): C {
+        print("2")
+        return c
+    }
+}
+
+operator fun B?.plusAssign(c: C) {
+    print("3")
+}
+
+class C
+// FILE: TestCase3.kt
+// TESTCASE NUMBER: 3
+package testPackCase3
+
+fun case3(a: A?, c: C) {
+
+    <!DEBUG_INFO_CALL("fqName: testPackCase3.plusAssign; typeCall: operator extension function")!>a?.b += c<!>
+    a?.b.<!DEBUG_INFO_CALL("fqName: testPackCase3.plusAssign; typeCall: operator extension function")!>plusAssign(c)<!>
+
+    val x = {
+        <!DEBUG_INFO_CALL("fqName: testPackCase3.plusAssign; typeCall: operator extension function")!>a?.b += c<!>
+        a?.b.<!DEBUG_INFO_CALL("fqName: testPackCase3.plusAssign; typeCall: operator extension function")!>plusAssign(c)<!>
+    }()
+
+    <!DEBUG_INFO_CALL("fqName: testPackCase3.plusAssign; typeCall: operator extension function")!>a?.b += { c }()<!>
+
+    a?.b.<!DEBUG_INFO_CALL("fqName: testPackCase3.plusAssign; typeCall: operator extension function")!>plusAssign({ c }())<!>
+
+}
+
+class A(val b: B)
+
+class B {
+    operator fun plusAssign(c: C) {
+        print("1")
+    }
+
+    operator fun plus(c: C): C {
+        print("2")
+        return c
+    }
+}
+
+operator fun B?.plusAssign(c: C) {
+    print("3")
+}
+
+operator fun B?.plusAssign(c: Any) {
+    print("4")
+}
+
+
+class C
@@ -0,0 +1,36 @@
+// !LANGUAGE: +NewInference
+// !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION
+// SKIP_TXT
+
+
+// FILE: LibCase1b.kt
+// TESTCASE NUMBER: 1
+package LibPackCase1.b
+
+import testPackCase1.B
+import LibPackCase1.a.*
+
+inline operator fun B?.plusAssign( c: ()->C) { //(2)
+    val x = {1}
+    <!DEBUG_INFO_CALL("fqName: LibPackCase1.a.plusAssign; typeCall: inline operator extension function")!>this += x<!> //to (1)
+    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit")!>this += x<!>
+}
+
+class C
+
+// FILE: TestCase1.kt
+package testPackCase1
+
+import LibPackCase1.a.*
+import LibPackCase1.b.*
+
+class B {
+    private inline operator fun plusAssign(crossinline c: ()->C) {}
+    private inline operator fun plus(crossinline c: ()->C): C =C()
+}
+
+// FILE: LibCase1a.kt
+package LibPackCase1.a
+import testPackCase1.B
+
+inline operator fun B?.plusAssign( c: ()->Int) { } //(1)
@@ -0,0 +1,47 @@
+
+// !LANGUAGE: +NewInference
+// !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION
+// SKIP_TXT
+
+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-448
+ * MAIN LINK: overload-resolution, building-the-overload-candidate-set-ocs, operator-call -> paragraph 1 -> sentence 2
+ * PRIMARY LINKS: overload-resolution, choosing-the-most-specific-candidate-from-the-overload-candidate-set, algorithm-of-msc-selection -> paragraph 3 -> sentence 1
+ * NUMBER: 2
+ * DESCRIPTION: plusAssign as inline function
+ */
+
+// FILE: LibCase1b.kt
+// TESTCASE NUMBER: 1
+package LibPackCase1.b
+
+import testPackCase1.B
+import LibPackCase1.a.*
+
+inline operator fun B?.plusAssign( c: ()->C) { //(2)
+    val x = {1}
+    <!DEBUG_INFO_CALL("fqName: LibPackCase1.a.plusAssign; typeCall: inline operator extension function")!>this += x<!> //to (1)
+    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit")!>this += x<!>
+}
+
+class C
+
+// FILE: TestCase1.kt
+package testPackCase1
+
+import LibPackCase1.a.*
+import LibPackCase1.b.*
+
+class B {
+    private inline operator fun plusAssign(crossinline c: ()->C) {}
+    private inline operator fun plus(crossinline c: ()->C): C =C()
+}
+
+// FILE: LibCase1a.kt
+package LibPackCase1.a
+import testPackCase1.B
+
+inline operator fun B?.plusAssign( c: ()->Int) { } //(1)
+
@@ -17,6 +17,7 @@

 // FILE: LibCase1.kt
 // TESTCASE NUMBER: 1, 2
+// TESTCASE NUMBER: 1, 2
 package libPackage

 import testPackCase1.Case
@@ -146,5 +146,95 @@
        }
      ]
    }
+  },
+  "1": {
+    "neg": {
+      "2": [
+        {
+          "specVersion": "0.1-448",
+          "casesNumber": 2,
+          "description": "call with lambda as argument",
+          "path": "compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/neg/2.1.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "main"
+        },
+        {
+          "specVersion": "0.1-448",
+          "casesNumber": 1,
+          "description": "inline plusAssign functions",
+          "path": "compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/neg/2.5.kt",
+          "unexpectedBehaviour": true,
+          "linkType": "main"
+        },
+        {
+          "specVersion": "0.1-448",
+          "casesNumber": 2,
+          "description": "without inline plusAssign functions",
+          "path": "compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/neg/2.4.kt",
+          "unexpectedBehaviour": true,
+          "linkType": "main"
+        },
+        {
+          "specVersion": "0.1-448",
+          "casesNumber": 1,
+          "description": "without inline plusAssign functions",
+          "path": "compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/neg/2.9.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "main"
+        },
+        {
+          "specVersion": "0.1-448",
+          "casesNumber": 1,
+          "description": "without inline plusAssign functions",
+          "path": "compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/neg/2.8.kt",
+          "unexpectedBehaviour": true,
+          "linkType": "main"
+        },
+        {
+          "specVersion": "0.1-448",
+          "casesNumber": 1,
+          "description": "without inline plusAssign functions",
+          "path": "compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/neg/2.7.kt",
+          "unexpectedBehaviour": true,
+          "linkType": "main"
+        },
+        {
+          "specVersion": "0.1-448",
+          "casesNumber": 1,
+          "description": "plusAssign as inline function",
+          "path": "compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/neg/2.2.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "main"
+        },
+        {
+          "specVersion": "0.1-448",
+          "casesNumber": 1,
+          "description": "without inline plusAssign functions",
+          "path": "compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/neg/2.6.kt",
+          "unexpectedBehaviour": true,
+          "linkType": "main"
+        }
+      ]
+    },
+    "pos": {
+      "2": [
+        {
+          "specVersion": "0.1-448",
+          "casesNumber": 3,
+          "description": "Non-extension member callables",
+          "path": "compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos/2.1.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "main"
+        },
+        {
+          "specVersion": "0.1-448",
+          "casesNumber": 1,
+          "description": "plusAssign as inline function",
+          "path": "compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos/2.2.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "main"
+        }
+      ]
+    }
  }
 }
@@ -0,0 +1,75 @@
+// !LANGUAGE: +NewInference
+// !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION
+// SKIP_TXT
+
+
+// FILE: TestCase1.kt
+/*
+ * TESTCASE NUMBER: 1
+ * NOTE:
+ */
+package testPackCase1
+
+import LibPackCase1.a.boo
+import LibPackCase1.b.boo
+
+fun case1 (b: B?){
+    b.<!AMBIGUITY!>boo<!>({ C() })
+    b.<!AMBIGUITY!>boo<!>({1})
+}
+
+class B {
+//    private fun boo(c: () -> C) {}
+}
+class C
+
+// FILE: LibCase1.kt
+package LibPackCase1.b
+import LibPackCase1.a.*
+import testPackCase1.B
+import testPackCase1.C
+
+fun B?.boo( c: ()->C) {} //(2)
+
+
+// FILE: LibCase1.kt
+package LibPackCase1.a
+import testPackCase1.B
+
+fun B?.boo( c: ()->Int) { //(1)
+}
+
+// FILE: TestCase2.kt
+/*
+ * TESTCASE NUMBER: 2
+ */
+package testPackCase2
+
+import LibPackCase2.a.*
+import LibPackCase2.b.*
+
+fun case2 (b: B?){
+    b.<!AMBIGUITY!>boo<!>({ C() })
+    b.<!AMBIGUITY!>boo<!>({1})
+}
+
+class B {
+//    private fun boo(c: () -> C) {}
+}
+class C
+
+// FILE: LibCase2.kt
+package LibPackCase2.b
+import LibPackCase2.a.*
+import testPackCase2.B
+import testPackCase2.C
+
+fun B?.boo( c: ()->C) {} //(2)
+
+
+// FILE: LibCase2.kt
+package LibPackCase2.a
+import testPackCase2.B
+
+fun B?.boo( c: ()->Int) { //(1)
+}
@@ -0,0 +1,83 @@
+// !LANGUAGE: +NewInference
+// !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION
+// SKIP_TXT
+
+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
+ *
+ * SPEC VERSION: 0.1-448
+ * MAIN LINK: overload-resolution, choosing-the-most-specific-candidate-from-the-overload-candidate-set, algorithm-of-msc-selection -> paragraph 9 -> sentence 2
+ * NUMBER: 2
+ * DESCRIPTION: explicit receiver ambuguity
+ */
+
+// FILE: TestCase1.kt
+/*
+ * TESTCASE NUMBER: 1
+ * NOTE:
+ */
+package testPackCase1
+
+import LibPackCase1.a.boo
+import LibPackCase1.b.boo
+
+fun case1 (b: B?){
+    b.<!OVERLOAD_RESOLUTION_AMBIGUITY!>boo<!>({ C() })
+    b.<!OVERLOAD_RESOLUTION_AMBIGUITY!>boo<!>({1})
+}
+
+class B {
+//    private fun boo(c: () -> C) {}
+}
+class C
+
+// FILE: LibCase1.kt
+package LibPackCase1.b
+import LibPackCase1.a.*
+import testPackCase1.B
+import testPackCase1.C
+
+fun B?.boo( c: ()->C) {} //(2)
+
+
+// FILE: LibCase1.kt
+package LibPackCase1.a
+import testPackCase1.B
+
+fun B?.boo( c: ()->Int) { //(1)
+}
+
+// FILE: TestCase2.kt
+/*
+ * TESTCASE NUMBER: 2
+ */
+package testPackCase2
+
+import LibPackCase2.a.*
+import LibPackCase2.b.*
+
+fun case2 (b: B?){
+    b.<!OVERLOAD_RESOLUTION_AMBIGUITY!>boo<!>({ C() })
+    b.<!OVERLOAD_RESOLUTION_AMBIGUITY!>boo<!>({1})
+}
+
+class B {
+//    private fun boo(c: () -> C) {}
+}
+class C
+
+// FILE: LibCase2.kt
+package LibPackCase2.b
+import LibPackCase2.a.*
+import testPackCase2.B
+import testPackCase2.C
+
+fun B?.boo( c: ()->C) {} //(2)
+
+
+// FILE: LibCase2.kt
+package LibPackCase2.a
+import testPackCase2.B
+
+fun B?.boo( c: ()->Int) { //(1)
+}
@@ -644,6 +644,14 @@
          "unexpectedBehaviour": false,
          "linkType": "main"
        },
+        {
+          "specVersion": "0.1-448",
+          "casesNumber": 1,
+          "description": "plusAssign as inline function",
+          "path": "compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos/2.2.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "primary"
+        },
        {
          "specVersion": "0.1-413",
          "casesNumber": 2,
@@ -844,6 +852,70 @@
    },
    "neg": {
      "1": [
+        {
+          "specVersion": "0.1-448",
+          "casesNumber": 2,
+          "description": "call with lambda as argument",
+          "path": "compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/neg/2.1.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "primary"
+        },
+        {
+          "specVersion": "0.1-448",
+          "casesNumber": 1,
+          "description": "inline plusAssign functions",
+          "path": "compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/neg/2.5.kt",
+          "unexpectedBehaviour": true,
+          "linkType": "primary"
+        },
+        {
+          "specVersion": "0.1-448",
+          "casesNumber": 2,
+          "description": "without inline plusAssign functions",
+          "path": "compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/neg/2.4.kt",
+          "unexpectedBehaviour": true,
+          "linkType": "primary"
+        },
+        {
+          "specVersion": "0.1-448",
+          "casesNumber": 1,
+          "description": "without inline plusAssign functions",
+          "path": "compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/neg/2.9.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "primary"
+        },
+        {
+          "specVersion": "0.1-448",
+          "casesNumber": 1,
+          "description": "without inline plusAssign functions",
+          "path": "compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/neg/2.8.kt",
+          "unexpectedBehaviour": true,
+          "linkType": "primary"
+        },
+        {
+          "specVersion": "0.1-448",
+          "casesNumber": 1,
+          "description": "without inline plusAssign functions",
+          "path": "compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/neg/2.7.kt",
+          "unexpectedBehaviour": true,
+          "linkType": "primary"
+        },
+        {
+          "specVersion": "0.1-448",
+          "casesNumber": 1,
+          "description": "plusAssign as inline function",
+          "path": "compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/neg/2.2.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "primary"
+        },
+        {
+          "specVersion": "0.1-448",
+          "casesNumber": 1,
+          "description": "without inline plusAssign functions",
+          "path": "compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/neg/2.6.kt",
+          "unexpectedBehaviour": true,
+          "linkType": "primary"
+        },
        {
          "specVersion": "0.1-413",
          "casesNumber": 3,
@@ -935,6 +1007,14 @@
          "path": "compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-9/neg/2.1.kt",
          "unexpectedBehaviour": false,
          "linkType": "main"
+        },
+        {
+          "specVersion": "0.1-448",
+          "casesNumber": 2,
+          "description": "explicit receiver ambuguity",
+          "path": "compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-9/neg/2.2.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "main"
        }
      ]
    },
@@ -0,0 +1,39 @@
+// !LANGUAGE: +NewInference
+// !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION
+// SKIP_TXT
+
+
+// FILE: TestCase1.kt
+/*
+ * TESTCASE NUMBER: 1
+ */
+package testPackCase1
+
+import LibPackCase1.a.boo
+import LibPackCase1.b.*
+
+fun case1 (b: B?){
+    b.boo({ C() })
+    b.boo({1})
+}
+
+class B {
+    private fun boo(c: () -> C) {}
+}
+class C
+
+// FILE: LibCase1.kt
+package LibPackCase1.b
+import LibPackCase1.a.*
+import testPackCase1.B
+import testPackCase1.C
+
+fun B?.boo( c: ()->C) {} //(2)
+
+
+// FILE: LibCase1.kt
+package LibPackCase1.a
+import testPackCase1.B
+
+fun B?.boo( c: ()->Int) { //(1)
+}
@@ -0,0 +1,49 @@
+// !LANGUAGE: +NewInference
+// !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION
+// SKIP_TXT
+
+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
+ *
+ * SPEC VERSION: 0.1-448
+ * MAIN LINK: overload-resolution, determining-function-applicability-for-a-specific-call, description -> paragraph 2 -> sentence 2
+ * PRIMARY LINKS: overload-resolution, determining-function-applicability-for-a-specific-call, description -> paragraph 4 -> sentence 3
+ * SECONDARY LINKS: overload-resolution, determining-function-applicability-for-a-specific-call, description -> paragraph 5 -> sentence 1
+ * NUMBER: 1
+ * DESCRIPTION: explicit receiver with lambda
+ */
+
+// FILE: TestCase1.kt
+/*
+ * TESTCASE NUMBER: 1
+ */
+package testPackCase1
+
+import LibPackCase1.a.boo
+import LibPackCase1.b.*
+
+fun case1 (b: B?){
+    b.boo({ <!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>C()<!> })
+    b.boo({1})
+}
+
+class B {
+    private fun boo(c: () -> C) {}
+}
+class C
+
+// FILE: LibCase1.kt
+package LibPackCase1.b
+import LibPackCase1.a.*
+import testPackCase1.B
+import testPackCase1.C
+
+fun B?.boo( c: ()->C) {} //(2)
+
+
+// FILE: LibCase1.kt
+package LibPackCase1.a
+import testPackCase1.B
+
+fun B?.boo( c: ()->Int) { //(1)
+}
@@ -1,6 +1,74 @@
 {
+  "2": {
+    "neg": {
+      "2": [
+        {
+          "specVersion": "0.1-448",
+          "casesNumber": 1,
+          "description": "without inline plusAssign functions",
+          "path": "compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/neg/2.9.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "primary"
+        },
+        {
+          "specVersion": "0.1-448",
+          "casesNumber": 1,
+          "description": "explicit receiver with lambda",
+          "path": "compiler/tests-spec/testData/diagnostics/linked/overload-resolution/determining-function-applicability-for-a-specific-call/description/p-2/neg/2.1.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "main"
+        }
+      ]
+    }
+  },
+  "4": {
+    "neg": {
+      "3": [
+        {
+          "specVersion": "0.1-448",
+          "casesNumber": 1,
+          "description": "explicit receiver with lambda",
+          "path": "compiler/tests-spec/testData/diagnostics/linked/overload-resolution/determining-function-applicability-for-a-specific-call/description/p-2/neg/2.1.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "primary"
+        }
+      ]
+    }
+  },
+  "5": {
+    "neg": {
+      "1": [
+        {
+          "specVersion": "0.1-448",
+          "casesNumber": 1,
+          "description": "explicit receiver with lambda",
+          "path": "compiler/tests-spec/testData/diagnostics/linked/overload-resolution/determining-function-applicability-for-a-specific-call/description/p-2/neg/2.1.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "secondary"
+        },
+        {
+          "specVersion": "0.1-413",
+          "casesNumber": 1,
+          "description": "the case of a call with a callable reference as a not parameter",
+          "path": "compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/resolving-callable-references-not-used-as-arguments-to-a-call/p-1/neg/1.1.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "primary"
+        }
+      ]
+    }
+  },
  "3": {
    "neg": {
+      "1": [
+        {
+          "specVersion": "0.1-413",
+          "casesNumber": 1,
+          "description": "the case of a call with a callable reference as a not parameter",
+          "path": "compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/resolving-callable-references-not-used-as-arguments-to-a-call/p-1/neg/1.1.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "secondary"
+        }
+      ],
      "3": [
        {
          "specVersion": "0.1-152",
@@ -7,6 +7,8 @@
 *
 * SPEC VERSION: 0.1-413
 * MAIN LINK: overload-resolution, resolving-callable-references, resolving-callable-references-not-used-as-arguments-to-a-call -> paragraph 1 -> sentence 1
+ * PRIMARY LINKS: overload-resolution, determining-function-applicability-for-a-specific-call, description -> paragraph 5 -> sentence 1
+ * SECONDARY LINKS: overload-resolution, determining-function-applicability-for-a-specific-call, description -> paragraph 3 -> sentence 1
 * NUMBER: 1
 * DESCRIPTION: the case of a call with a callable reference as a not parameter
 */
@@ -41,6 +41,14 @@
          "path": "compiler/tests-spec/testData/diagnostics/linked/statements/assignments/operator-assignments/p-2/pos/1.1.kt",
          "unexpectedBehaviour": false,
          "linkType": "main"
+        },
+        {
+          "specVersion": "0.1-448",
+          "casesNumber": 3,
+          "description": "Non-extension member callables",
+          "path": "compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos/2.1.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "secondary"
        }
      ],
      "2": [
@@ -51,6 +59,14 @@
          "path": "compiler/tests-spec/testData/diagnostics/linked/statements/assignments/operator-assignments/p-2/pos/1.1.kt",
          "unexpectedBehaviour": false,
          "linkType": "primary"
+        },
+        {
+          "specVersion": "0.1-448",
+          "casesNumber": 3,
+          "description": "Non-extension member callables",
+          "path": "compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos/2.1.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "secondary"
        }
      ],
      "3": [
@@ -61,6 +77,14 @@
          "path": "compiler/tests-spec/testData/diagnostics/linked/statements/assignments/operator-assignments/p-2/pos/1.1.kt",
          "unexpectedBehaviour": false,
          "linkType": "primary"
+        },
+        {
+          "specVersion": "0.1-448",
+          "casesNumber": 3,
+          "description": "Non-extension member callables",
+          "path": "compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos/2.1.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "secondary"
        }
      ]
    }