From f0d35a24784a3a25649fd3db3b75281c267b38d8 Mon Sep 17 00:00:00 2001 From: Denis Zharkov Date: Thu, 16 Apr 2020 13:08:02 +0300 Subject: [PATCH] FIR: Adjust testData for spec tests: operator priority ^KT-38351 Submitted --- .../operator-call/p-2/pos/3.2.fir.kt | 217 +++++++++++++++++ .../operator-call/p-2/pos/3.3.fir.kt | 193 +++++++++++++++ .../operator-call/p-2/pos/3.4.fir.kt | 194 +++++++++++++++ .../operator-call/p-2/pos/3.5.fir.kt | 103 ++++++++ .../operator-call/p-2/pos/3.6.fir.kt | 34 +++ .../operator-call/p-4/neg/1.1.fir.kt | 226 ++++++++++++++++++ .../operator-call/p-4/pos/1.1.fir.kt | 73 ++++++ 7 files changed, 1040 insertions(+) create mode 100644 compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-2/pos/3.2.fir.kt create mode 100644 compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-2/pos/3.3.fir.kt create mode 100644 compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-2/pos/3.4.fir.kt create mode 100644 compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-2/pos/3.5.fir.kt create mode 100644 compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-2/pos/3.6.fir.kt create mode 100644 compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-4/neg/1.1.fir.kt create mode 100644 compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-4/pos/1.1.fir.kt diff --git a/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-2/pos/3.2.fir.kt b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-2/pos/3.2.fir.kt new file mode 100644 index 00000000000..fce76b90335 --- /dev/null +++ b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-2/pos/3.2.fir.kt @@ -0,0 +1,217 @@ +// !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-268 + * PLACE: overload-resolution, building-the-overload-candidate-set-ocs, operator-call -> paragraph 2 -> sentence 3 + * RELEVANT PLACES: overload-resolution, building-the-overload-candidate-set-ocs, call-with-an-explicit-receiver -> paragraph 6 -> sentence 2 + * overload-resolution, building-the-overload-candidate-set-ocs, operator-call -> paragraph 4 -> sentence 1 + * NUMBER: 2 + * DESCRIPTION: Non-extension member callables + */ + + +// FILE: LibCase1.kt +// TESTCASE NUMBER: 1 +package libPackage +import testPackCase1.Case +import testPackCase1.Case.Inv +import testPackCase1.Case.E +import kotlin.reflect.KProperty + +operator fun Case.E.plus(value: Int) = Inv() +operator fun Case.Inv.invoke(i: Int) = 1 + + +// FILE: TestCase1.kt +// TESTCASE NUMBER: 1 +package testPackCase1 +import libPackage.plus +import libPackage.* +import libPackage.invoke +class Case() { + + class E(val plus: Inv? = null) { + /*operator*/ fun plus(value: Int) = Case() + } + + class Inv() { + /*operator*/ fun invoke(value: Int) = Case() + } + + fun foo(e: E) { + operator fun E.plus(value: Int) = Case() + + run { + e + 1 + } + e + 1 + + } +} + +// FILE: LibCase1.kt +// TESTCASE NUMBER: 2 +package libPackage +import testPackCase2.Case +import testPackCase2.Case.Inv +import testPackCase2.Case.E + +operator fun Case.E.plus(value: Int) = Inv() +operator fun Case.Inv.invoke(i: Int) = 1 + + +// FILE: TestCase1.kt +// TESTCASE NUMBER: 2 +package testPackCase2 +import libPackage.plus +import libPackage.* +import libPackage.invoke + +operator fun Case.E.plus(value: Int) = Case() + +class Case() { + + class E(val plus: Inv? = null) { + /*operator*/ fun plus(value: Int) = Case() + } + + class Inv() { + /*operator*/ fun invoke(value: Int) = Case() + } + + fun foo(e: E) { + operator fun E.plus(value: Int) = Case() + + run { + operator fun E.plus(value: Int) = Case() + + e + 1 + } + e + 1 + } +} + +// FILE: LibCase3.kt +// TESTCASE NUMBER: 3 +package libPackage +import testPackCase3.Case +import testPackCase3.Case.Inv +import testPackCase3.Case.E + +operator fun Case.E.plusAssign(value: Int) {} +operator fun Case.Inv.invoke(i: Int) {} + + +// FILE: TestCase3.kt +// TESTCASE NUMBER: 3 +package testPackCase3 +import libPackage.plusAssign +import libPackage.invoke +import libPackage.* +class Case() { + + class E(val plusAssign: Inv? = null) { + /*operator*/ fun plusAssign(value: Int) {} + } + + class Inv() { + /*operator*/ fun invoke(value: Int) {} + } + + fun foo(e: E) { + operator fun E.plusAssign(value: Int) {} + + run { + e += 1 + } + e += 1 + + } +} + + +// FILE: LibCase4.kt +// TESTCASE NUMBER: 4 +package libPackage +import testPackCase4.Case +import testPackCase4.Case.Inv +import testPackCase4.Case.E + +operator fun Case.E.plusAssign(value: Int) {} +operator fun Case.Inv.invoke(i: Int) {} + + +// FILE: TestCase4.kt +// TESTCASE NUMBER: 4 +package testPackCase4 +import libPackage.plusAssign +import libPackage.* +import libPackage.invoke + +operator fun Case.E.plusAssign(value: Int) {} + +class Case() { + + class E(val plusAssign: Inv? = null) { + /*operator*/ fun plusAssign(value: Int) {} + } + + class Inv() { + /*operator*/ fun invoke(value: Int) {} + } + + fun foo(e: E) { + operator fun E.plusAssign(value: Int) {} + + run { + operator fun E.plusAssign(value: Int) {} + + e += 1 + } + e += 1 + } +} + + +// FILE: TestCase5.kt +/* + * TESTCASE NUMBER: 5 + * UNEXPECTED BEHAVIOUR + * ISSUES: KT-36996 + */ +package testPackCase5 +import kotlin.reflect.KProperty + +class Delegate { + /*operator*/ fun getValue(thisRef: Any?, property: KProperty<*>): String { + return "" + } + + /*operator*/ fun setValue(thisRef: Any?, property: KProperty<*>, value: String) { + } +} + +operator fun Delegate.getValue(thisRef: Any?, property: KProperty<*>): String { + return "" +} +operator fun Delegate.setValue(thisRef: Any?, property: KProperty<*>, value: String) {} + +fun case() { + class Test { + var p: String by Delegate() + + operator fun Delegate.getValue(thisRef: Any?, property: KProperty<*>): String { + return "" + } + operator fun Delegate.setValue(thisRef: Any?, property: KProperty<*>, value: String) { + } + } + val test = Test() + test.p = "NEW" + val x = test.p + +} diff --git a/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-2/pos/3.3.fir.kt b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-2/pos/3.3.fir.kt new file mode 100644 index 00000000000..05c65523184 --- /dev/null +++ b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-2/pos/3.3.fir.kt @@ -0,0 +1,193 @@ +// !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-268 + * PLACE: overload-resolution, building-the-overload-candidate-set-ocs, operator-call -> paragraph 2 -> sentence 3 + * RELEVANT PLACES: overload-resolution, building-the-overload-candidate-set-ocs, call-with-an-explicit-receiver -> paragraph 6 -> sentence 3 + * overload-resolution, building-the-overload-candidate-set-ocs, operator-call -> paragraph 4 -> sentence 1 + * NUMBER: 3 + * DESCRIPTION: Explicitly imported extension callables + */ + + +// FILE: LibCase1.kt +// TESTCASE NUMBER: 1 +package libPackage1 +import testPackCase1.Case +import testPackCase1.Case.Inv +import testPackCase1.Case.E + +operator fun Case.E.plus(value: Int) = Inv() +operator fun Case.Inv.invoke(i: Int) = 1 + +// FILE: LibCase1.kt +// TESTCASE NUMBER: 1 +package libPackage2 +import testPackCase1.Case +import testPackCase1.Case.Inv +import testPackCase1.Case.E + +operator fun Case.E.plus(value: Int) = Inv() +operator fun Case.Inv.invoke(i: Int) = 1 + + +// FILE: TestCase1.kt +// TESTCASE NUMBER: 1 +package testPackCase1 +import libPackage1.plus +import libPackage1.invoke +import libPackage2.* +class Case() { + + class E(val plus: Inv? = null) { + /*operator*/ fun plus(value: Int) = Case() + } + + class Inv() { + /*operator*/ fun invoke(value: Int) = Case() + } + + fun foo(e: E) { + /*operator*/ fun E.plus(value: Int) = Case() + + run { + e + 1 + } + e + 1 + + } +} + +// FILE: LibCase2.kt +// TESTCASE NUMBER: 2 +package libPackage1 +import testPackCase2.Case +import testPackCase2.Case.Inv +import testPackCase2.Case.E + +operator fun Case.E.plus(value: Int) = Inv() +operator fun Case.Inv.invoke(i: Int) = 1 + +// FILE: LibCase2.kt +// TESTCASE NUMBER: 2 +package libPackage2 +import testPackCase2.Case +import testPackCase2.Case.Inv +import testPackCase2.Case.E + +operator fun Case.E.plus(value: Int) = Inv() +operator fun Case.Inv.invoke(i: Int) = 1 + + +// FILE: TestCase2.kt +// TESTCASE NUMBER: 2 +package testPackCase2 +import libPackage1.plus +import libPackage1.invoke +import libPackage2.* +class Case() { + + class E(val plus: Inv? = null) { + /*operator*/ fun plus(value: Int) = Case() + } + + class Inv() { + /*operator*/ fun invoke(value: Int) = Case() + } + + fun foo(e: E) { + /*operator*/ fun E.plus(value: Int) = Case() + + run { + /*operator*/ fun E.plus(value: Int) = Case() + + e + 1 + } + e + 1 + } +} + +// FILE: LibCase3.kt +// TESTCASE NUMBER: 3 +package libPackage +import testPackCase3.Case +import testPackCase3.Case.Inv +import testPackCase3.Case.E + +operator fun Case.E.plusAssign(value: Int) {} +operator fun Case.Inv.invoke(i: Int) {} + + +// FILE: TestCase3.kt +// TESTCASE NUMBER: 3 +package testPackCase3 +import libPackage.plusAssign +import libPackage.invoke +import libPackage.* +class Case() { + + class E(val plusAssign: Inv? = null) { + /*operator*/ fun plusAssign(value: Int) {} + } + + class Inv() { + /*operator*/ fun invoke(value: Int) {} + } + + fun foo(e: E) { + /*operator*/ fun E.plusAssign(value: Int) {} + + run { + e += 1 + } + e += 1 + + } +} + + +// FILE: LibCase4.kt +// TESTCASE NUMBER: 4 +package libPackage +import testPackCase4.Case +import testPackCase4.Case.Inv +import testPackCase4.Case.E + +operator fun Case.E.plusAssign(value: Int) {} +operator fun Case.Inv.invoke(i: Int) {} + + +// FILE: TestCase4.kt +// TESTCASE NUMBER: 4 +package testPackCase4 +import libPackage.plusAssign +import libPackage.* +import libPackage.invoke + +operator fun Case.E.plusAssign(value: Int) {} + +class Case() { + + class E(val plusAssign: Inv? = null) { + /*operator*/ fun plusAssign(value: Int) {} + } + + class Inv() { + /*operator*/ fun invoke(value: Int) {} + } + + fun foo(e: E) { + /*operator*/ fun E.plusAssign(value: Int) {} + + run { + /*operator*/ fun E.plusAssign(value: Int) {} + + e += 1 + } + e += 1 + } +} diff --git a/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-2/pos/3.4.fir.kt b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-2/pos/3.4.fir.kt new file mode 100644 index 00000000000..2858556f3e8 --- /dev/null +++ b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-2/pos/3.4.fir.kt @@ -0,0 +1,194 @@ +// !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-268 + * PLACE: overload-resolution, building-the-overload-candidate-set-ocs, operator-call -> paragraph 2 -> sentence 3 + * RELEVANT PLACES: overload-resolution, building-the-overload-candidate-set-ocs, call-with-an-explicit-receiver -> paragraph 6 -> sentence 4 + * overload-resolution, building-the-overload-candidate-set-ocs, operator-call -> paragraph 4 -> sentence 1 + * NUMBER: 4 + * DESCRIPTION: Extension callables declared in the package scope + */ + + +// FILE: LibCase1.kt +// TESTCASE NUMBER: 1 +package libPackage +import testPackCase1.Case +import testPackCase1.Case.Inv +import testPackCase1.Case.E + +operator fun Case.E.plus(value: Int) = Case().Inv() +operator fun Case.Inv.invoke(i: Int) = 1 + + +// FILE: TestCase1.kt +// TESTCASE NUMBER: 1 +package testPackCase1 +import libPackage.* + +operator fun Case.E.plus(value: Int) = Case().Inv() +operator fun Case.Inv.invoke(i: Int) = 1 + +class Case() { + class E(val plus: Inv? = null) { + /*operator*/ fun plus(value: Int) = Case() + } + + inner class Inv() { + /*operator*/ fun invoke(value: Int) = Case() + } + + fun foo(e: E) { + /*operator*/ fun E.plus(value: Int) = Case() + + run { + e + 1 + } + e + 1 + + } +} + +// FILE: Lib1.kt +// TESTCASE NUMBER: 2 +package libPackage1 +import testPackCase2.Case +import testPackCase2.Case.Inv +import testPackCase2.Case.E + +operator fun Case.E.plus(value: Int) = Inv() +operator fun Case.Inv.invoke(i: Int) = 1 + + +// FILE: Lib2.kt +// TESTCASE NUMBER: 2 +package testPackCase2 +import testPackCase2.Case +import testPackCase2.Case.Inv +import testPackCase2.Case.E + +operator fun Case.E.plus(value: Int) = Inv() +operator fun Case.Inv.invoke(i: Int) = 1 + + +// FILE: TestCase1.kt +// TESTCASE NUMBER: 2 +package testPackCase2 +import libPackage1.* +class Case() { + + operator fun plus(value: Int) = Case() + + class E(val plus: Inv? = null) { + /*operator*/ fun plus(value: Int) = Case() + } + + class Inv() { + /*operator*/ fun invoke(value: Int) = Case() + } + + fun foo(e: E) { + /*operator*/ fun E.plus(value: Int) = Case() + + run { + /*operator*/ fun E.plus(value: Int) = Case() + + e + 1 + } + e + 1 + } +} + + +// FILE: LibCase3.kt +// TESTCASE NUMBER: 3 +package libPackage +import testPackCase3.Case +import testPackCase3.Case.Inv +import testPackCase3.Case.E + +operator fun Case.E.plusAssign(value: Int) {} +operator fun Case.Inv.invoke(i: Int) {} + + +// FILE: TestCase3.kt +// TESTCASE NUMBER: 3 +package testPackCase3 +import libPackage.* + +operator fun Case.E.plusAssign(value: Int) {} +operator fun Case.Inv.invoke(i: Int) {} + +class Case() { + class E(val plusAssign: Inv? = null) { + /*operator*/ fun plusAssign(value: Int) {} + } + + inner class Inv() { + /*operator*/ fun invoke(value: Int) {} + } + + fun foo(e: E) { + /*operator*/ fun E.plusAssign(value: Int) {} + + run { + e += 1 + } + e += 1 + + } +} + +// FILE: Lib1.kt +// TESTCASE NUMBER: 4 +package libPackage1 +import testPackCase4.Case +import testPackCase4.Case.Inv +import testPackCase4.Case.E + +operator fun Case.E.plusAssign(value: Int) {} +operator fun Case.Inv.invoke(i: Int) {} + + +// FILE: Lib2.kt +// TESTCASE NUMBER: 4 +package testPackCase4 +import testPackCase4.Case +import testPackCase4.Case.Inv +import testPackCase4.Case.E + +operator fun Case.E.plusAssign(value: Int) {} +operator fun Case.Inv.invoke(i: Int) {} + + +// FILE: TestCase4.kt +// TESTCASE NUMBER: 4 +package testPackCase4 +import libPackage1.* +class Case() { + + operator fun plusAssign(value: Int) {} + + class E(val plusAssign: Inv? = null) { + /*operator*/ fun plusAssign(value: Int) {} + } + + class Inv() { + /*operator*/ fun invoke(value: Int) {} + } + + fun foo(e: E) { + /*operator*/ fun E.plusAssign(value: Int) {} + + run { + /*operator*/ fun E.plusAssign(value: Int) {} + + e += 1 + } + e += 1 + } +} diff --git a/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-2/pos/3.5.fir.kt b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-2/pos/3.5.fir.kt new file mode 100644 index 00000000000..aa3ecb2f936 --- /dev/null +++ b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-2/pos/3.5.fir.kt @@ -0,0 +1,103 @@ +// !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-268 + * PLACE: overload-resolution, building-the-overload-candidate-set-ocs, operator-call -> paragraph 2 -> sentence 3 + * RELEVANT PLACES: overload-resolution, building-the-overload-candidate-set-ocs, call-with-an-explicit-receiver -> paragraph 6 -> sentence 5 + * overload-resolution, building-the-overload-candidate-set-ocs, operator-call -> paragraph 4 -> sentence 1 + * NUMBER: 5 + * DESCRIPTION: Star-imported extension callables + */ + + +// FILE: LibCase1.kt +// TESTCASE NUMBER: 1 +package libPackage +import testPackCase1.Case +import testPackCase1.Case.Inv +import testPackCase1.Case.E + +operator fun Case.E.plus(value: Int) = Inv() +operator fun Case.Inv.invoke(i: Int) = 1 + + +// FILE: TestCase1.kt +// TESTCASE NUMBER: 1 +package testPackCase1 +import libPackage.* + +class Case() { + class E(val plus: Inv? = null) { + /*operator*/ fun plus(value: Int) = Case() + } + + class Inv() { + /*operator*/ fun invoke(value: Int) = Case() + } + + fun foo(e: E) { + /*operator*/ fun E.plus(value: Int) = Case() + + run { + e + 1 + } + e + 1 + + } +} + +// FILE: Lib1.kt +// TESTCASE NUMBER: 2 +package libPackage1 + +public inline operator fun CharSequence.contains(regex: Regex): Boolean = regex.containsMatchIn(this) + +// FILE: TestCase1.kt +// TESTCASE NUMBER: 2 +package testPackCase2 +import libPackage1.* +class Case() { + + fun foo() { + "".contains(Regex("")) + } +} + +// FILE: LibCase3.kt +// TESTCASE NUMBER: 3 +package libPackage +import testPackCase3.Case +import testPackCase3.Case.Inv +import testPackCase3.Case.E + +operator fun Case.E.plusAssign(value: Int) {} +operator fun Case.Inv.invoke(i: Int) {} + + +// FILE: TestCase3.kt +// TESTCASE NUMBER: 1 +package testPackCase3 +import libPackage.* + +class Case() { + class E(val plusAssign: Inv? = null) { + /*operator*/ fun plusAssign(value: Int) {} + } + + class Inv() { + /*operator*/ fun invoke(value: Int) {} + } + + fun foo(e: E) { + /*operator*/ fun E.plusAssign(value: Int) {} + + run { + e += 1 + } + e += 1 + } +} diff --git a/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-2/pos/3.6.fir.kt b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-2/pos/3.6.fir.kt new file mode 100644 index 00000000000..316c97fff80 --- /dev/null +++ b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-2/pos/3.6.fir.kt @@ -0,0 +1,34 @@ +// !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-268 + * PLACE: overload-resolution, building-the-overload-candidate-set-ocs, operator-call -> paragraph 2 -> sentence 3 + * RELEVANT PLACES: overload-resolution, building-the-overload-candidate-set-ocs, call-with-an-explicit-receiver -> paragraph 6 -> sentence 5 + * overload-resolution, building-the-overload-candidate-set-ocs, operator-call -> paragraph 4 -> sentence 1 + * NUMBER: 6 + * DESCRIPTION: Star-imported extension callables + */ + + +// FILE: LibCase1.kt +// TESTCASE NUMBER: 1 +package libPackage + +/*public*/ private inline operator fun CharSequence.contains(regex: Regex): Boolean = regex.containsMatchIn(this) + + +// FILE: TestCase1.kt +// TESTCASE NUMBER: 1 +package testPackCase1 +import libPackage.* + +class Case() { + + fun foo() { + "".contains(Regex("")) + } +} diff --git a/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-4/neg/1.1.fir.kt b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-4/neg/1.1.fir.kt new file mode 100644 index 00000000000..57a0841daab --- /dev/null +++ b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-4/neg/1.1.fir.kt @@ -0,0 +1,226 @@ +// !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-268 + * PLACE: overload-resolution, building-the-overload-candidate-set-ocs, operator-call -> paragraph 4 -> sentence 1 + * NUMBER: 1 + * DESCRIPTION: properties available through the invoke convention are non-eligible for operator calls + */ + +// FILE: TestCase1.kt +/* + * TESTCASE NUMBER: 1 + * NOTE:Delegated properties + * UNEXPECTED BEHAVIOUR + * ISSUES: KT-36844 + */ +package testPackCase1 + +fun case1() { + var b = B() + val a: String = b.p +} + +class B() { + val p: String by Delegate() // DELEGATE_SPECIAL_FUNCTION_MISSING expected +} + +class Delegate { + val getValue = G() +} + +class G { + operator fun invoke(i: Int): String = "" +} + + +// FILE: TestCase2.kt +/* + * TESTCASE NUMBER: 2 + * NOTE:Delegated properties + */ +package testPackCase2 +fun case2() { + var b = B() + val a: String = b.p + b.p = "" +} + +class B() { + var p: String by Delegate() // DELEGATE_SPECIAL_FUNCTION_MISSING expected +} + +class Delegate { + val getValue = G() + val setValue = S() +} + +class G { + operator fun invoke(i: Int): String = "" +} + +class S { + operator fun invoke(i: String) {} +} + +// FILE: TestCase3.kt +/* + * TESTCASE NUMBER: 3 + * NOTE: Arithmetic and comparison operators + */ +package testPackCase3 + +class Comp() { + operator fun invoke(i: Int): Int = 1 +} + +class Arifm() { + operator fun invoke(i: Int) {} +} + +class B() { + val plus = Arifm() + val minus = Arifm() + val compareTo = Comp() +} + +fun case3() { + var b = B() + b + 5 + b - 5 + b < 5 + b >= 5 +} +// FILE: TestCase4.kt +/* + * TESTCASE NUMBER: 4 + * NOTE: Operator-form assignments + */ +package testPackCase4 +class Assign() { + operator fun invoke(i: Int) {} +} + +class B(val minusAssign: Assign = Assign()) { + val plusAssign = Assign() +} + +fun case3() { + var b = B() + b += 2 + b -= 3 +} + +// FILE: TestCase5.kt +/* + * TESTCASE NUMBER: 5 + * NOTE: Arithmetic and comparison operators + * UNEXPECTED BEHAVIOUR + * ISSUES: KT-36852 + */ +package testPackCase5 + +class Case5() { + + fun f(c: Case5){ + this + 1 //OPERATOR_MODIFIER_REQUIRED for class plus, resolved to (1) + c + 1 //OPERATOR_MODIFIER_REQUIRED for class plus, resolved to (1) + } + + inner class plus constructor(val i:Int){ + operator fun invoke(i:Int) {} //(1) + } +} + +// FILE: TestCase6.kt +/* + * TESTCASE NUMBER: 6 + * NOTE: Arithmetic and comparison operators + * UNEXPECTED BEHAVIOUR + * ISSUES: KT-36852 + */ +package testPackCase6 + +class B(var a: Int = 0) { + + inner class E(){ + val plus :E =TODO() + + fun foo(b: B){ + this + 1 + } + + operator fun invoke(value: Int) = B() + } +} + +// FILE: TestCase7.kt +/* + * TESTCASE NUMBER: 7 + * NOTE: for-loop operators + * UNEXPECTED BEHAVIOUR + * ISSUES: KT-36898 + */ +package testPackCase7 + +fun case7 () { + val iterable: Iterable = Iterable(Inv('s')) + for (i in iterable) { + println(i) + } +} + +class Iterable(val iterator: Inv) { + // operator fun iterator() : CharIterator = TODO() +} + +class Inv(val c: Char) { + operator fun invoke(): CharIterator = object : CharIterator() { + private var index = 0 + + override fun nextChar(): Char { + index++; return c + } + + override fun hasNext(): Boolean = index < 5 + } +} + + +// FILE: TestCase8.kt +/* + * TESTCASE NUMBER: 8 + * NOTE: for-loop operators + * UNEXPECTED BEHAVIOUR + * ISSUES: KT-36898 + */ +package testPackCase8 + +fun case8 () { + val iterable: Iterable = Iterable() + for (i in iterable) { + println(i) + } +} + +class Iterable() { + // operator fun iterator() : CharIterator = TODO() +} +val Iterable.iterator: Inv + get() = Inv('c') + +class Inv(val c: Char) { + operator fun invoke(): CharIterator = object : CharIterator() { + private var index = 0 + + override fun nextChar(): Char { + index++; return c + } + + override fun hasNext(): Boolean = index < 5 + } +} diff --git a/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-4/pos/1.1.fir.kt b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-4/pos/1.1.fir.kt new file mode 100644 index 00000000000..63b7ecbb34f --- /dev/null +++ b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-4/pos/1.1.fir.kt @@ -0,0 +1,73 @@ +// !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-268 + * PLACE: overload-resolution, building-the-overload-candidate-set-ocs, operator-call -> paragraph 4 -> sentence 1 + * NUMBER: 1 + * DESCRIPTION: properties available through the invoke convention are non-eligible for operator calls + */ + +// FILE: TestCase1.kt +/* + * TESTCASE NUMBER: 1 + * NOTE: Arithmetic and comparison operators + * UNEXPECTED BEHAVIOUR + * ISSUES: KT-36855 + */ +package testPackCase1 + +class Arithmetic() { + operator fun invoke(i: Int) = B() +} +class B() { + operator fun plus(i: Int) : B =B() + val plusAssign = Arithmetic() + + fun case7(){ + var b =B() + b+=1 //ASSIGN_OPERATOR_AMBIGUITY + this += 1 //ASSIGNMENT_OPERATOR_SHOULD_RETURN_UNIT, PROPERTY_AS_OPERATOR + } +} + +fun case1() { + var b = B() + b += 1 //ASSIGN_OPERATOR_AMBIGUITY +} + +// FILE: TestCase2.kt +/* + * TESTCASE NUMBER: 1 + * NOTE: Arithmetic and comparison operators + * UNEXPECTED BEHAVIOUR + * ISSUES: KT-36855 + */ +package testPackCase2 + +class Arithmetic() { + operator fun invoke(i: Int) = B() +} + +class B() { + operator fun plusAssign(i: Int) {} + val plus = Arithmetic() + + + fun case2(b: B) { + b += 1 //ok + + var b1 = B() + b1 += 1 //ASSIGN_OPERATOR_AMBIGUITY + + this += 1 //ok + } +} + +fun case2() { + var b = B() + b += 1 //ASSIGN_OPERATOR_AMBIGUITY +}