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

compiler/tests-spec/testData/codegen/box/linked/operator-call/testsMap.json

@@ -0,0 +1,44 @@
+{
+  "1": {
+    "neg": {
+      "2": [
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver and infix functions",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/neg/2.5.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "main"
+        },
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver and infix functions",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/neg/2.6.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "main"
+        }
+      ]
+    },
+    "pos": {
+      "2": [
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver and infix functions",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos/2.5.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "main"
+        },
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver and infix functions",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos/2.6.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "main"
+        }
+      ]
+    }
+  }
+}

compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/neg/2.1.exceptions.compiletime.txt

@@ -0,0 +1 @@
+java.lang.IllegalStateException: UNSAFE_OPERATOR_CALL: Operator call corresponds to a dot-qualified call 'a?.b.plusAssign(c)' which is not allowed on a nullable receiver 'a?.b'. (20,10) in /2.1.kt

compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/neg/2.1.kt

@@ -0,0 +1,61 @@
+// WITH_RUNTIME
+
+/*
+ * KOTLIN CODEGEN BOX SPEC TEST (NEGATIVE)
+ *
+ * SPEC VERSION: 0.1-488
+ * 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: nullable receiver
+ * EXCEPTION: compiletime
+ */
+
+fun box(): String {
+    val a: A? = A(B())
+    val c: C = C()
+
+    a?.b += c
+    if (f3 && !f1 && !f2 && !f4) {
+        f3 = false
+        a?.b.plusAssign(c)
+        if (f3 && !f1 && !f2 && !f4)
+            return "OK"
+    }
+    return "NOK"
+}
+
+class A(val b: B)
+
+var f1 = false
+var f2 = false
+var f3 = false
+var f4 = false
+
+class B {
+    operator fun plusAssign(c: C) {
+        f1 = true
+        print("1")
+    }
+
+    operator fun plus(c: C): C {
+        f2 = true
+        print("2")
+        return c
+    }
+}
+
+operator fun B.plusAssign(c: C) {
+    f3 = true
+    print("3")
+}
+
+operator fun B.plusAssign(c: Any) {
+    f4 = true
+    print("4")
+}
+
+
+class C

compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/neg/2.2.exceptions.compiletime.txt

@@ -0,0 +1 @@
+java.lang.IllegalStateException: UNSAFE_OPERATOR_CALL: Operator call corresponds to a dot-qualified call 'a?.b.plusAssign({ c }())' which is not allowed on a nullable receiver 'a?.b'. (20,10) in /2.2.kt

compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/neg/2.2.kt

@@ -0,0 +1,61 @@
+// WITH_RUNTIME
+
+/*
+ * KOTLIN CODEGEN BOX SPEC TEST (NEGATIVE)
+ *
+ * SPEC VERSION: 0.1-488
+ * 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: 2
+ * DESCRIPTION: nullable receiver
+ * EXCEPTION: compiletime
+ */
+
+fun box(): String {
+    val a: A? = A(B())
+    val c: C = C()
+
+    a?.b += { c }()
+    if (f3 && !f1 && !f2 && !f4) {
+        f3 = false
+        a?.b.plusAssign({ c }())
+        if (f3 && !f1 && !f2 && !f4)
+            return "OK"
+    }
+    return "NOK"
+}
+
+class A(val b: B)
+
+var f1 = false
+var f2 = false
+var f3 = false
+var f4 = false
+
+class B {
+    operator fun plusAssign(c: C) {
+        f1 = true
+        print("1")
+    }
+
+    operator fun plus(c: C): C {
+        f2 = true
+        print("2")
+        return c
+    }
+}
+
+operator fun B.plusAssign(c: C) {
+    f3 = true
+    print("3")
+}
+
+operator fun B.plusAssign(c: Any) {
+    f4 = true
+    print("4")
+}
+
+
+class C

compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/neg/2.3.exceptions.compiletime.txt

@@ -0,0 +1 @@
+java.lang.IllegalStateException: UNSAFE_OPERATOR_CALL: Operator call corresponds to a dot-qualified call 'a?.b.plusAssign(c)' which is not allowed on a nullable receiver 'a?.b'. (20,10) in /2.3.kt

compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/neg/2.3.kt

@@ -0,0 +1,61 @@
+// WITH_RUNTIME
+
+/*
+ * KOTLIN CODEGEN BOX SPEC TEST (NEGATIVE)
+ *
+ * SPEC VERSION: 0.1-488
+ * 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: 3
+ * DESCRIPTION: nullable receiver
+ * EXCEPTION: compiletime
+ */
+
+fun box(): String {
+    val a: A? = A(B())
+    val c: C? = C()
+
+    a?.b += c
+    if (f3 && !f1 && !f2 && !f4) {
+        f3 = false
+        a?.b.plusAssign(c)
+        if (f3 && !f1 && !f2 && !f4)
+            return "OK"
+    }
+    return "NOK"
+}
+
+class A(val b: B)
+
+var f1 = false
+var f2 = false
+var f3 = false
+var f4 = false
+
+class B {
+    operator fun plusAssign(c: C) {
+        f1 = true
+        print("1")
+    }
+
+    operator fun plus(c: C): C {
+        f2 = true
+        print("2")
+        return c
+    }
+}
+
+operator fun B.plusAssign(c: C) {
+    f3 = true
+    print("3")
+}
+
+operator fun B.plusAssign(c: Any) {
+    f4 = true
+    print("4")
+}
+
+
+class C

compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/neg/2.4.exceptions.compiletime.txt

@@ -0,0 +1 @@
+java.lang.IllegalStateException: UNSAFE_OPERATOR_CALL: Operator call corresponds to a dot-qualified call 'a?.b.plusAssign(c)' which is not allowed on a nullable receiver 'a?.b'. (20,10) in /2.4.kt

compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/neg/2.4.kt

@@ -0,0 +1,61 @@
+// WITH_RUNTIME
+
+/*
+ * KOTLIN CODEGEN BOX SPEC TEST (NEGATIVE)
+ *
+ * SPEC VERSION: 0.1-488
+ * 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: 4
+ * DESCRIPTION: nullable receiver and infix functions
+ * EXCEPTION: compiletime
+ */
+
+fun box(): String {
+    val a: A? = A(B())
+    val c: C = C()
+
+    a?.b += c
+    if (f3 && !f1 && !f2 && !f4) {
+        f3 = false
+        a?.b plusAssign c
+        if (f3 && !f1 && !f2 && !f4)
+            return "OK"
+    }
+    return "NOK"
+}
+
+class A(val b: B)
+
+var f1 = false
+var f2 = false
+var f3 = false
+var f4 = false
+
+class B {
+   infix operator fun plusAssign(c: C) {
+        f1 = true
+        print("1")
+    }
+
+    infix operator fun plus(c: C): C {
+        f2 = true
+        print("2")
+        return c
+    }
+}
+
+infix operator fun B.plusAssign(c: C) {
+    f3 = true
+    print("3")
+}
+
+infix operator fun B.plusAssign(c: Any) {
+    f4 = true
+    print("4")
+}
+
+
+class C

compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/neg/2.5.exceptions.compiletime.txt

@@ -0,0 +1 @@
+java.lang.IllegalStateException: UNSAFE_OPERATOR_CALL: Operator call corresponds to a dot-qualified call 'a?.b.plusAssign({ c }())' which is not allowed on a nullable receiver 'a?.b'. (20,10) in /2.5.kt

compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/neg/2.5.kt

@@ -0,0 +1,61 @@
+// WITH_RUNTIME
+
+/*
+ * KOTLIN CODEGEN BOX SPEC TEST (NEGATIVE)
+ *
+ * SPEC VERSION: 0.1-488
+ * 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: 5
+ * DESCRIPTION: nullable receiver and infix functions
+ * EXCEPTION: compiletime
+ */
+
+fun box(): String {
+    val a: A? = A(B())
+    val c: C = C()
+
+    a?.b += { c }()
+    if (f3 && !f1 && !f2 && !f4) {
+        f3 = false
+        a?.b plusAssign { c }()
+        if (f3 && !f1 && !f2 && !f4)
+            return "OK"
+    }
+    return "NOK"
+}
+
+class A(val b: B)
+
+var f1 = false
+var f2 = false
+var f3 = false
+var f4 = false
+
+class B {
+    infix operator fun plusAssign(c: C) {
+        f1 = true
+        print("1")
+    }
+
+    infix operator fun plus(c: C): C {
+        f2 = true
+        print("2")
+        return c
+    }
+}
+
+infix operator fun B.plusAssign(c: C) {
+    f3 = true
+    print("3")
+}
+
+infix operator fun B.plusAssign(c: Any) {
+    f4 = true
+    print("4")
+}
+
+
+class C

compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/neg/2.6.exceptions.compiletime.txt

@@ -0,0 +1 @@
+java.lang.IllegalStateException: UNSAFE_OPERATOR_CALL: Operator call corresponds to a dot-qualified call 'a?.b.plusAssign(c)' which is not allowed on a nullable receiver 'a?.b'. (20,10) in /2.6.kt

compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/neg/2.6.kt

@@ -0,0 +1,61 @@
+// WITH_RUNTIME
+
+/*
+ * KOTLIN CODEGEN BOX SPEC TEST (NEGATIVE)
+ *
+ * SPEC VERSION: 0.1-488
+ * 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: 6
+ * DESCRIPTION: nullable receiver and infix functions
+ * EXCEPTION: compiletime
+ */
+
+fun box(): String {
+    val a: A? = A(B())
+    val c: C? = C()
+
+    a?.b += c
+    if (f3 && !f1 && !f2 && !f4) {
+        f3 = false
+        a?.b plusAssign c
+        if (f3 && !f1 && !f2 && !f4)
+            return "OK"
+    }
+    return "NOK"
+}
+
+class A(val b: B)
+
+var f1 = false
+var f2 = false
+var f3 = false
+var f4 = false
+
+class B {
+    infix operator fun plusAssign(c: C) {
+        f1 = true
+        print("1")
+    }
+
+    infix operator fun plus(c: C): C {
+        f2 = true
+        print("2")
+        return c
+    }
+}
+
+infix operator fun B.plusAssign(c: C) {
+    f3 = true
+    print("3")
+}
+
+infix operator fun B.plusAssign(c: Any) {
+    f4 = true
+    print("4")
+}
+
+
+class C

compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos/2.1.kt

@@ -0,0 +1,61 @@
+// WITH_RUNTIME
+
+/*
+ * KOTLIN CODEGEN BOX SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-488
+ * 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 3
+ * 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: nullable receiver
+ */
+
+fun box(): String {
+    val a: A? = A(B())
+    val c: C = C()
+
+    a?.b += c
+    if (f3 && !f1 && !f2 && !f4) {
+        f3 = false
+        a?.b.plusAssign(c)
+        if (f3 && !f1 && !f2 && !f4)
+            return "OK"
+    }
+    return "NOK"
+}
+
+class A(val b: B)
+
+var f1 = false
+var f2 = false
+var f3 = false
+var f4 = false
+
+class B {
+    operator fun plusAssign(c: C) {
+        f1 = true
+        print("1")
+    }
+
+    operator fun plus(c: C): C {
+        f2 = true
+        print("2")
+        return c
+    }
+}
+
+operator fun B?.plusAssign(c: C) {
+    f3 = true
+    print("3")
+}
+
+operator fun B?.plusAssign(c: Any) {
+    f4 = true
+    print("4")
+}
+
+
+class C

compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos/2.10.kt

@@ -0,0 +1,64 @@
+// WITH_RUNTIME
+
+/*
+ * KOTLIN CODEGEN BOX SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-488
+ * 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 3
+ * 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: 10
+ * DESCRIPTION: nullable receiver and inline operator function
+ */
+
+
+fun cc() : C = C()
+fun box(): String {
+    val a: A? = A(B())
+
+    a!!.b += ::cc
+    if (!f3 && f1 && !f2 && !f4) {
+        f1 = false
+        a!!.b.plusAssign(::cc)
+        if (f1 && !f3 && !f2 && !f4)
+            return "OK"
+    }
+    return "NOK"
+}
+
+class A(val b: B)
+
+var f1 = false
+var f2 = false
+var f3 = false
+var f4 = false
+
+
+class B {
+    inline operator fun plusAssign(c: ()->C) {
+        f1 = true
+        print("1")
+    }
+
+    inline operator fun plus(c: ()->C): C {
+        f2 = true
+        print("2")
+        return c()
+    }
+}
+
+@JvmName("aa")
+inline operator fun B?.plusAssign(c: ()->C) {
+    f3 = true
+    print("3")
+}
+@JvmName("bb")
+inline operator fun B?.plusAssign(c: ()->Any) {
+    f4 = true
+    print("4")
+}
+
+
+class C

compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos/2.2.kt

@@ -0,0 +1,62 @@
+// WITH_RUNTIME
+
+/*
+ * KOTLIN CODEGEN BOX SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-488
+ * 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 3
+ * 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: 2
+ * DESCRIPTION: nullable receiver
+ */
+
+
+
+fun box(): String {
+    val a: A? = A(B())
+    val c: C = C()
+    a?.b += { c }()
+    if (f3 && !f1 && !f2 && !f4) {
+        f3 = false
+        a?.b.plusAssign({ c }())
+        if (f3 && !f1 && !f2 && !f4)
+            return "OK"
+    }
+    return "NOK"
+}
+
+class A(val b: B)
+
+var f1 = false
+var f2 = false
+var f3 = false
+var f4 = false
+
+class B {
+    operator fun plusAssign(c: C) {
+        f1 = true
+        print("1")
+    }
+
+    operator fun plus(c: C): C {
+        f2 = true
+        print("2")
+        return c
+    }
+}
+
+operator fun B?.plusAssign(c: C) {
+    f3 = true
+    print("3")
+}
+
+operator fun B?.plusAssign(c: Any) {
+    f4 = true
+    print("4")
+}
+
+
+class C

compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos/2.3.kt

@@ -0,0 +1,61 @@
+// WITH_RUNTIME
+
+/*
+ * KOTLIN CODEGEN BOX SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-488
+ * 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 4
+ * 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: 3
+ * DESCRIPTION: nullable receiver
+ */
+
+fun box(): String {
+    val a: A? = A(B())
+    val c: C? = C()
+
+    a!!.b += c?: C()
+    if (f1 && !f3 && !f2 && !f4) {
+        f3 = false
+        a!!.b.plusAssign(c?: C())
+        if (f1 && !f3 && !f2 && !f4)
+            return "OK"
+    }
+    return "NOK"
+}
+
+class A(val b: B)
+
+var f1 = false
+var f2 = false
+var f3 = false
+var f4 = false
+
+class B {
+    operator fun plusAssign(c: C) {
+        f1 = true
+        print("1")
+    }
+
+    operator fun plus(c: C?): C {
+        f2 = true
+        print("2")
+        return c!!
+    }
+}
+
+operator fun B?.plusAssign(c: C?) {
+    f3 = true
+    print("3")
+}
+
+operator fun B?.plusAssign(c: Any?) {
+    f4 = true
+    print("4")
+}
+
+
+class C

compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos/2.4.kt

@@ -0,0 +1,73 @@
+// WITH_RUNTIME
+
+/*
+ * KOTLIN CODEGEN BOX SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-488
+ * 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 3
+ * 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: 4
+ * DESCRIPTION: nullable receiver
+ */
+
+fun box(): String {
+    val a: A? = A(B())
+    val c: C? = C()
+
+    a!!.b += c
+    if (f3 && !f1 && !f2 && !f4) {
+        f3 = false
+        a?.b.plusAssign(c)
+        if (f3 && !f1 && !f2 && !f4)
+            return "OK"
+    }
+    return "NOK"
+}
+
+class A(val b: B)
+
+var f1 = false
+var f2 = false
+var f3 = false
+var f4 = false
+var f5 = false
+var f6 = false
+
+class B {
+    operator fun plusAssign(c: C) {
+        f1 = true
+        print("1")
+    }
+
+    operator fun plus(c: C?): C {
+        f2 = true
+        print("2")
+        return c!!
+    }
+}
+
+operator fun B?.plusAssign(c: C?) {
+    f5 = true
+    print("5")
+}
+
+operator fun B?.plusAssign(c: Any?) {
+    f6 = true
+    print("6")
+}
+@JvmName("aa")
+operator fun B.plusAssign(c: C?) {
+    f3 = true
+    print("3")
+}
+@JvmName("bb")
+operator fun B.plusAssign(c: Any?) {
+    f4 = true
+    print("4")
+}
+
+
+class C

compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos/2.5.kt

@@ -0,0 +1,61 @@
+// WITH_RUNTIME
+
+/*
+ * KOTLIN CODEGEN BOX SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-488
+ * 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 3
+ * 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: 5
+ * DESCRIPTION: nullable receiver and infix functions
+ */
+
+fun box(): String {
+    val a: A? = A(B())
+    val c: C = C()
+
+    a?.b += c
+    if (f3 && !f1 && !f2 && !f4) {
+        f3 = false
+        a?.b plusAssign c
+        if (f3 && !f1 && !f2 && !f4)
+            return "OK"
+    }
+    return "NOK"
+}
+
+class A(val b: B)
+
+var f1 = false
+var f2 = false
+var f3 = false
+var f4 = false
+
+class B {
+    infix operator fun plusAssign(c: C) {
+        f1 = true
+        print("1")
+    }
+
+    infix operator fun plus(c: C): C {
+        f2 = true
+        print("2")
+        return c
+    }
+}
+
+infix operator fun B?.plusAssign(c: C) {
+    f3 = true
+    print("3")
+}
+
+infix operator fun B?.plusAssign(c: Any) {
+    f4 = true
+    print("4")
+}
+
+
+class C

compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos/2.6.kt

@@ -0,0 +1,62 @@
+// WITH_RUNTIME
+
+/*
+ * KOTLIN CODEGEN BOX SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-488
+ * 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 3
+ * 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: 6
+ * DESCRIPTION: nullable receiver and infix functions
+ */
+
+
+
+fun box(): String {
+    val a: A? = A(B())
+    val c: C = C()
+    a?.b += { c }()
+    if (f3 && !f1 && !f2 && !f4) {
+        f3 = false
+        a?.b plusAssign { c }()
+        if (f3 && !f1 && !f2 && !f4)
+            return "OK"
+    }
+    return "NOK"
+}
+
+class A(val b: B)
+
+var f1 = false
+var f2 = false
+var f3 = false
+var f4 = false
+
+class B {
+    infix operator fun plusAssign(c: C) {
+        f1 = true
+        print("1")
+    }
+
+    infix operator fun plus(c: C): C {
+        f2 = true
+        print("2")
+        return c
+    }
+}
+
+infix operator fun B?.plusAssign(c: C) {
+    f3 = true
+    print("3")
+}
+
+infix operator fun B?.plusAssign(c: Any) {
+    f4 = true
+    print("4")
+}
+
+
+class C

compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos/2.7.kt

@@ -0,0 +1,61 @@
+// WITH_RUNTIME
+
+/*
+ * KOTLIN CODEGEN BOX SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-488
+ * 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 4
+ * 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: 7
+ * DESCRIPTION: nullable receiver and infix functions
+ */
+
+fun box(): String {
+    val a: A? = A(B())
+    val c: C? = C()
+
+    a!!.b += c?: C()
+    if (f1 && !f3 && !f2 && !f4) {
+        f3 = false
+        a!!.b plusAssign (c?: C())
+        if (f1 && !f3 && !f2 && !f4)
+            return "OK"
+    }
+    return "NOK"
+}
+
+class A(val b: B)
+
+var f1 = false
+var f2 = false
+var f3 = false
+var f4 = false
+
+class B {
+    infix operator fun plusAssign(c: C) {
+        f1 = true
+        print("1")
+    }
+
+    infix operator fun plus(c: C?): C {
+        f2 = true
+        print("2")
+        return c!!
+    }
+}
+
+infix operator fun B?.plusAssign(c: C?) {
+    f3 = true
+    print("3")
+}
+
+infix operator fun B?.plusAssign(c: Any?) {
+    f4 = true
+    print("4")
+}
+
+
+class C

compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos/2.8.kt

@@ -0,0 +1,73 @@
+// WITH_RUNTIME
+
+/*
+ * KOTLIN CODEGEN BOX SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-488
+ * 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 3
+ * 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: 8
+ * DESCRIPTION: nullable receiver
+ */
+
+fun box(): String {
+    val a: A? = A(B())
+    val c: C? = C()
+
+    a!!.b += c
+    if (f3 && !f1 && !f2 && !f4) {
+        f3 = false
+        a?.b plusAssign c
+        if (f3 && !f1 && !f2 && !f4)
+            return "OK"
+    }
+    return "NOK"
+}
+
+class A(val b: B)
+
+var f1 = false
+var f2 = false
+var f3 = false
+var f4 = false
+var f5 = false
+var f6 = false
+
+class B {
+    infix operator fun plusAssign(c: C) {
+        f1 = true
+        print("1")
+    }
+
+    infix operator fun plus(c: C?): C {
+        f2 = true
+        print("2")
+        return c!!
+    }
+}
+
+infix operator fun B?.plusAssign(c: C?) {
+    f5 = true
+    print("5")
+}
+
+infix operator fun B?.plusAssign(c: Any?) {
+    f6 = true
+    print("6")
+}
+@JvmName("aa")
+infix operator fun B.plusAssign(c: C?) {
+    f3 = true
+    print("3")
+}
+@JvmName("bb")
+infix operator fun B.plusAssign(c: Any?) {
+    f4 = true
+    print("4")
+}
+
+
+class C

compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos/2.9.kt

@@ -0,0 +1,64 @@
+// WITH_RUNTIME
+
+/*
+ * KOTLIN CODEGEN BOX SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-488
+ * 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 3
+ * 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: 9
+ * DESCRIPTION: nullable receiver and inline operator function
+ */
+
+fun cc() : C = C()
+
+fun box(): String {
+    val a: A? = A(B())
+
+    a?.b += ::cc
+    if (f3 && !f1 && !f2 && !f4) {
+        f3 = false
+        a?.b.plusAssign(::cc)
+        if (f3 && !f1 && !f2 && !f4)
+            return "OK"
+    }
+    return "NOK"
+}
+
+class A(val b: B)
+
+var f1 = false
+var f2 = false
+var f3 = false
+var f4 = false
+
+
+class B {
+    inline operator fun plusAssign(c: ()->C) {
+        f1 = true
+        print("1")
+    }
+
+    inline operator fun plus(c: ()->C): C {
+        f2 = true
+        print("2")
+        return c()
+    }
+}
+
+@JvmName("aa")
+inline operator fun B?.plusAssign(c: ()->C) {
+    f3 = true
+    print("3")
+}
+@JvmName("bb")
+inline operator fun B?.plusAssign(c: ()->Any) {
+    f4 = true
+    print("4")
+}
+
+
+class C

compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/testsMap.json

@@ -1,4 +1,142 @@
 {
+  "1": {
+    "neg": {
+      "2": [
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/neg/2.1.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "main"
+        },
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver and infix functions",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/neg/2.5.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "main"
+        },
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver and infix functions",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/neg/2.4.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "main"
+        },
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/neg/2.3.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "main"
+        },
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/neg/2.2.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "main"
+        },
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver and infix functions",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/neg/2.6.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "main"
+        }
+      ]
+    },
+    "pos": {
+      "2": [
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver and inline operator function",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos/2.10.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "main"
+        },
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos/2.1.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "main"
+        },
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver and infix functions",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos/2.5.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "main"
+        },
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos/2.4.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "main"
+        },
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver and inline operator function",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos/2.9.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "main"
+        },
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos/2.8.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "main"
+        },
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver and infix functions",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos/2.7.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "main"
+        },
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos/2.3.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "main"
+        },
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos/2.2.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "main"
+        },
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver and infix functions",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos/2.6.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "main"
+        }
+      ]
+    }
+  },
   "2": {
     "pos": {
       "3": [

compiler/tests-spec/testData/codegen/box/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/testsMap.json

@@ -18,6 +18,90 @@
           "unexpectedBehaviour": false,
           "linkType": "main"
         }
+      ],
+      "3": [
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver and inline operator function",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos/2.10.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "primary"
+        },
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos/2.1.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "primary"
+        },
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver and infix functions",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos/2.5.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "primary"
+        },
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos/2.4.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "primary"
+        },
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver and inline operator function",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos/2.9.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "primary"
+        },
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos/2.8.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "primary"
+        },
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos/2.2.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "primary"
+        },
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver and infix functions",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos/2.6.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "primary"
+        }
+      ],
+      "4": [
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver and infix functions",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos/2.7.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "primary"
+        },
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos/2.3.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "primary"
+        }
       ]
     }
   }

compiler/tests-spec/testData/codegen/box/linked/statements/assignments/operator-assignments/testsMap.json

@@ -17,6 +17,54 @@
           "path": "compiler/tests-spec/testData/codegen/box/linked/statements/assignments/operator-assignments/p-2/neg/1.1.kt",
           "unexpectedBehaviour": false,
           "linkType": "main"
+        },
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/neg/2.1.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "secondary"
+        },
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver and infix functions",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/neg/2.5.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "secondary"
+        },
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver and infix functions",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/neg/2.4.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "secondary"
+        },
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/neg/2.3.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "secondary"
+        },
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/neg/2.2.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "secondary"
+        },
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver and infix functions",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/neg/2.6.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "secondary"
         }
       ],
       "2": [
@@ -35,6 +83,54 @@
           "path": "compiler/tests-spec/testData/codegen/box/linked/statements/assignments/operator-assignments/p-2/neg/1.1.kt",
           "unexpectedBehaviour": false,
           "linkType": "primary"
+        },
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/neg/2.1.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "secondary"
+        },
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver and infix functions",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/neg/2.5.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "secondary"
+        },
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver and infix functions",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/neg/2.4.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "secondary"
+        },
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/neg/2.3.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "secondary"
+        },
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/neg/2.2.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "secondary"
+        },
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver and infix functions",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/neg/2.6.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "secondary"
         }
       ],
       "3": [
@@ -45,6 +141,54 @@
           "path": "compiler/tests-spec/testData/codegen/box/linked/statements/assignments/operator-assignments/p-2/neg/1.2.kt",
           "unexpectedBehaviour": false,
           "linkType": "primary"
+        },
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/neg/2.1.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "secondary"
+        },
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver and infix functions",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/neg/2.5.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "secondary"
+        },
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver and infix functions",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/neg/2.4.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "secondary"
+        },
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/neg/2.3.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "secondary"
+        },
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/neg/2.2.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "secondary"
+        },
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver and infix functions",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/neg/2.6.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "secondary"
         }
       ],
       "10": [
@@ -249,6 +393,86 @@
           "path": "compiler/tests-spec/testData/codegen/box/linked/statements/assignments/operator-assignments/p-2/pos/1.1.kt",
           "unexpectedBehaviour": false,
           "linkType": "main"
+        },
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver and inline operator function",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos/2.10.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "secondary"
+        },
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos/2.1.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "secondary"
+        },
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver and infix functions",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos/2.5.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "secondary"
+        },
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos/2.4.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "secondary"
+        },
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver and inline operator function",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos/2.9.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "secondary"
+        },
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos/2.8.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "secondary"
+        },
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver and infix functions",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos/2.7.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "secondary"
+        },
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos/2.3.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "secondary"
+        },
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos/2.2.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "secondary"
+        },
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver and infix functions",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos/2.6.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "secondary"
         }
       ],
       "2": [
@@ -267,6 +491,86 @@
           "path": "compiler/tests-spec/testData/codegen/box/linked/statements/assignments/operator-assignments/p-2/pos/1.1.kt",
           "unexpectedBehaviour": false,
           "linkType": "primary"
+        },
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver and inline operator function",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos/2.10.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "secondary"
+        },
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos/2.1.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "secondary"
+        },
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver and infix functions",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos/2.5.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "secondary"
+        },
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos/2.4.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "secondary"
+        },
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver and inline operator function",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos/2.9.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "secondary"
+        },
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos/2.8.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "secondary"
+        },
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver and infix functions",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos/2.7.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "secondary"
+        },
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos/2.3.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "secondary"
+        },
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos/2.2.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "secondary"
+        },
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver and infix functions",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos/2.6.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "secondary"
         }
       ],
       "3": [
@@ -277,6 +581,86 @@
           "path": "compiler/tests-spec/testData/codegen/box/linked/statements/assignments/operator-assignments/p-2/pos/1.2.kt",
           "unexpectedBehaviour": false,
           "linkType": "primary"
+        },
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver and inline operator function",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos/2.10.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "secondary"
+        },
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos/2.1.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "secondary"
+        },
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver and infix functions",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos/2.5.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "secondary"
+        },
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos/2.4.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "secondary"
+        },
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver and inline operator function",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos/2.9.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "secondary"
+        },
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos/2.8.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "secondary"
+        },
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver and infix functions",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos/2.7.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "secondary"
+        },
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos/2.3.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "secondary"
+        },
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos/2.2.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "secondary"
+        },
+        {
+          "specVersion": "0.1-488",
+          "casesNumber": 0,
+          "description": "nullable receiver and infix functions",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos/2.6.kt",
+          "unexpectedBehaviour": false,
+          "linkType": "secondary"
         }
       ],
       "10": [