diff --git a/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver/p-6/pos/2.3.kt b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver/p-6/pos/2.3.kt index c8d736bbb07..5fdec5b31ba 100644 --- a/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver/p-6/pos/2.3.kt +++ b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver/p-6/pos/2.3.kt @@ -10,13 +10,19 @@ * RELEVANT PLACES: overload-resolution, c-level-partition -> paragraph 1 -> sentence 1 * overload-resolution, building-the-overload-candidate-set-ocs, call-with-an-explicit-receiver -> paragraph 3 -> sentence 1 * overload-resolution, building-the-overload-candidate-set-ocs, call-with-an-explicit-receiver -> paragraph 2 -> sentence 1 + * overload-resolution, building-the-overload-candidate-set-ocs, call-with-trailing-lambda-expressions -> paragraph 1 -> sentence 2 * NUMBER: 3 * DESCRIPTION: set of non-extension member callables only */ // TESTCASE NUMBER: 1 class Case1 { - operator fun String.invoke() :String{ return this} //fqName: Case1.invoke; typeCall: function - fun String.foo() : String = this //fqName: Case1.foo; typeCall: function; + operator fun String.invoke(): String { + return this + } + + operator fun String?.invoke(x: Any? = null, body: () -> String = { "" }): String = body() + + fun String.foo(): String = this fun bar() { "".foo() "".invoke() @@ -27,4 +33,17 @@ class Case1 { "1".foo()() "1"()().invoke()().foo() } + + fun testTrailingLambda(s: String?){ + //trailing lambda + s.invoke { "ss" } + s.invoke (x= 1) { "ss" } + s.invoke (body = { "ss" }) + s.invoke (body = { "ss" }, x = '1') + + s (x= 1) { "ss" } + s (body = { "ss" }) + s (body = { "ss" }, x = '1') + + } } \ No newline at end of file diff --git a/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver/p-6/pos/2.4.kt b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver/p-6/pos/2.4.kt index 3c29ec3b3f2..b024dce3d57 100644 --- a/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver/p-6/pos/2.4.kt +++ b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver/p-6/pos/2.4.kt @@ -12,6 +12,7 @@ * 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, call-with-an-explicit-receiver -> paragraph 11 -> sentence 1 * overload-resolution, receivers -> paragraph 5 -> sentence 1 + * overload-resolution, building-the-overload-candidate-set-ocs, call-with-trailing-lambda-expressions -> paragraph 1 -> sentence 2 * NUMBER: 4 * DESCRIPTION: sets of local, explicitly imported, declared in the package scope and star-imported extension callables */ @@ -20,6 +21,8 @@ package libPackage public fun String?.orEmpty(): String = "my Extension for $this" +/* a call with trailing lambda expression */ +public fun String?.funWithTrailingLambda( x : Any? = null, body : ()-> String = {""} ): String = body() // FILE: TestCase1.kt @@ -27,14 +30,24 @@ package sentence3 import libPackage.* import libPackage.orEmpty +import libPackage.funWithTrailingLambda private fun String?.orEmpty(): String = "my top-level (pack scope) Extension for $this" +/* a call with trailing lambda expression */ +private fun String?.funWithTrailingLambda( x : Any? = null, body : ()-> String = {""} ): String = body() // TESTCASE NUMBER: 1 class Case1() { fun String?.orEmpty(): String = "my local extension for $this" + fun String?.funWithTrailingLambda( x : Any? = null, body : ()-> String = {""} ): String = body() + fun case1(s: String?) { s.orEmpty() + //trailing lambda + s.funWithTrailingLambda { "ss" } + s.funWithTrailingLambda (x= 1) { "ss" } + s.funWithTrailingLambda (body = { "ss" }) + s.funWithTrailingLambda (body = { "ss" }, x = '1') } } @@ -44,28 +57,64 @@ import libPackage.* //import libPackage.orEmpty private fun String?.orEmpty(): String = "my top-level (pack scope) Extension for $this" +private fun String?.funWithTrailingLambda( x : Any? = null, body : ()-> String = {""} ): String = body() // TESTCASE NUMBER: 2 class Case2() { fun String?.orEmpty(): String = "my local extension for $this" + fun String?.funWithTrailingLambda( x : Any? = null, body : ()-> String = {""} ): String = body() + fun case2(s: String?) { s.orEmpty() + + //trailing lambda + s.funWithTrailingLambda { "ss" } + s.funWithTrailingLambda (x= 1) { "ss" } + s.funWithTrailingLambda (body = { "ss" }) + s.funWithTrailingLambda (body = { "ss" }, x = '1') } } // TESTCASE NUMBER: 3 class Case3() { fun String?.orEmpty(): String = "my local extension for $this" + fun String?.funWithTrailingLambda( x : Any? = null, body : ()-> String = {""} ): String = body() + fun case3(s: String?) { s.orEmpty() + //trailing lambda + s.funWithTrailingLambda { "ss" } + s.funWithTrailingLambda (x= 1) { "ss" } + s.funWithTrailingLambda (body = { "ss" }) + s.funWithTrailingLambda (body = { "ss" }, x = '1') + fun innerFirst(s: String?){ fun String?.orEmpty(): String = "my local inner extension for $this" + fun String?.funWithTrailingLambda( x : Any? = null, body : ()-> String = {""} ): String = body() + s?.orEmpty() + //trailing lambda + s.funWithTrailingLambda { "ss" } + s.funWithTrailingLambda (x= 1) { "ss" } + s.funWithTrailingLambda (body = { "ss" }) + s.funWithTrailingLambda (body = { "ss" }, x = '1') } fun innerSecond(){ fun String?.orEmpty(): String = "my local inner extension for $this" + fun String?.funWithTrailingLambda( x : Any? = null, body : ()-> String = {""} ): String = body() + s.orEmpty() + //trailing lambda + s.funWithTrailingLambda { "ss" } + s.funWithTrailingLambda (x= 1) { "ss" } + s.funWithTrailingLambda (body = { "ss" }) + s.funWithTrailingLambda (body = { "ss" }, x = '1') } s.orEmpty() + //trailing lambda + s.funWithTrailingLambda { "ss" } + s.funWithTrailingLambda (x= 1) { "ss" } + s.funWithTrailingLambda (body = { "ss" }) + s.funWithTrailingLambda (body = { "ss" }, x = '1') } } diff --git a/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver/p-6/pos/3.1.kt b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver/p-6/pos/3.1.kt index bbed7ef2ec9..f425131f6cd 100644 --- a/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver/p-6/pos/3.1.kt +++ b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver/p-6/pos/3.1.kt @@ -10,6 +10,7 @@ * 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, call-with-an-explicit-receiver -> paragraph 6 -> sentence 5 * overload-resolution, building-the-overload-candidate-set-ocs, call-with-an-explicit-receiver -> paragraph 11 -> sentence 1 + * overload-resolution, building-the-overload-candidate-set-ocs, call-with-trailing-lambda-expressions -> paragraph 1 -> sentence 2 * NUMBER: 1 * DESCRIPTION: sets of explicitly imported, declared in the package scope and star-imported extension callables */ @@ -18,18 +19,28 @@ package libPackage public fun String?.orEmpty(): String = "my Extension for $this" +/* a call with trailing lambda expression */ +public fun String?.funWithTrailingLambda( x : Any? = null, body : ()-> String = {""} ): String = body() // FILE: TestCase1.kt package sentence3 import libPackage.* import libPackage.orEmpty +import libPackage.funWithTrailingLambda private fun String?.orEmpty(): String = "my top level extension for $this" +/* a call with trailing lambda expression */ +public fun String?.funWithTrailingLambda( x : Any? = null, body : ()-> String = {""} ): String = body() // TESTCASE NUMBER: 1 fun case1(s: String?) { s.orEmpty() + + s.funWithTrailingLambda { "ss" } + s.funWithTrailingLambda (x= 1) { "ss" } + s.funWithTrailingLambda (body = { "ss" }) + s.funWithTrailingLambda (body = { "ss" }, x = '1') } diff --git a/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver/p-6/pos/4.2.kt b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver/p-6/pos/4.2.kt index 44ce8fefd46..384087a56a8 100644 --- a/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver/p-6/pos/4.2.kt +++ b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver/p-6/pos/4.2.kt @@ -9,6 +9,7 @@ * PLACE: overload-resolution, building-the-overload-candidate-set-ocs, call-with-an-explicit-receiver -> paragraph 6 -> sentence 4 * 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, call-with-an-explicit-receiver -> paragraph 11 -> sentence 1 + * overload-resolution, building-the-overload-candidate-set-ocs, call-with-trailing-lambda-expressions -> paragraph 1 -> sentence 2 * NUMBER: 2 * DESCRIPTION: sets of declared in the package scope and star-imported extension callables */ @@ -17,6 +18,8 @@ package libPackage public fun String?.orEmpty(): String = "my Extension for $this" +/* a call with trailing lambda expression */ +public fun String?.funWithTrailingLambda( x : Any? = null, body : ()-> String = {""} ): String = body() // FILE: TestCase2.kt package sentence3 @@ -25,9 +28,16 @@ import libPackage.* //import libPackage.orEmpty private fun String?.orEmpty(): String = "my top level extension for $this" +/* a call with trailing lambda expression */ +private fun String?.funWithTrailingLambda( x : Any? = null, body : ()-> String = {""} ): String = body() // TESTCASE NUMBER: 1 fun case2(s: String?) { s.orEmpty() + //trailing lambda + s.funWithTrailingLambda { "ss" } + s.funWithTrailingLambda (x= 1) { "ss" } + s.funWithTrailingLambda (body = { "ss" }) + s.funWithTrailingLambda (body = { "ss" }, x = '1') } diff --git a/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver/p-6/pos/5.1.kt b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver/p-6/pos/5.1.kt index d59d5470076..95a9c5d8671 100644 --- a/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver/p-6/pos/5.1.kt +++ b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver/p-6/pos/5.1.kt @@ -8,6 +8,7 @@ * SPEC VERSION: 0.1-268 * PLACE: overload-resolution, building-the-overload-candidate-set-ocs, call-with-an-explicit-receiver -> paragraph 6 -> sentence 5 * RELEVANT PLACES: overload-resolution, building-the-overload-candidate-set-ocs, call-with-an-explicit-receiver -> paragraph 11 -> sentence 1 + * overload-resolution, building-the-overload-candidate-set-ocs, call-with-trailing-lambda-expressions -> paragraph 1 -> sentence 2 * NUMBER: 1 * DESCRIPTION: set of star-imported extension callables */ @@ -16,6 +17,8 @@ package libPackage public fun String?.orEmpty(): String = "my Extension for $this" +/* a call with trailing lambda expression */ +public fun String?.funWithTrailingLambda( x : Any? = null, body : ()-> String = {""} ): String = body() // FILE: TestCase2.kt package sentence3 @@ -25,4 +28,10 @@ import libPackage.* // TESTCASE NUMBER: 1 fun case2(s: String?) { s.orEmpty() -} + s.orEmpty() + //trailing lambda + s.funWithTrailingLambda { "ss" } + s.funWithTrailingLambda (x= 1) { "ss" } + s.funWithTrailingLambda (body = { "ss" }) + s.funWithTrailingLambda (body = { "ss" }, x = '1') +} \ No newline at end of file diff --git a/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-named-parameters/testsMap.json b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-named-parameters/testsMap.json index 7ca08045896..7735dc632f4 100644 --- a/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-named-parameters/testsMap.json +++ b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-named-parameters/testsMap.json @@ -1,109 +1,112 @@ { - "1": { - "pos": { - "2": [ - { - "specVersion": "0.1-280", - "casesNumber": 3, - "description": "Explicit receiver: Top-level non-extension functions: Callables star-imported into the current file;", - "unexpectedBehaviour": false - }, - { - "specVersion": "0.1-280", - "casesNumber": 5, - "description": "Implicit receiver: sets of non-extension member callables, local, explicitly imported, declared in the package scope and star-imported extension callables", - "unexpectedBehaviour": true - }, - { - "specVersion": "0.1-280", - "casesNumber": 3, - "description": "Explicit receiver: The overload candidate sets for each pair of implicit receivers: Explicitly imported extension callables", - "unexpectedBehaviour": false - }, - { - "specVersion": "0.1-280", - "casesNumber": 1, - "description": "Implicit receiver: set of star-imported extension callables", - "unexpectedBehaviour": false - }, - { - "specVersion": "0.1-280", - "casesNumber": 3, - "description": "Explicit receiver: The overload candidate sets for each pair of implicit receivers: declared in the package scope extension callables", - "unexpectedBehaviour": false - }, - { - "specVersion": "0.1-280", - "casesNumber": 1, - "description": "Implicit receiver: sets of declared in the package scope and star-imported extension callables", - "unexpectedBehaviour": false - }, - { - "specVersion": "0.1-280", - "casesNumber": 2, - "description": "Explicit receiver: Top-level non-extension functions: Implicitly imported callables", - "unexpectedBehaviour": false - }, - { - "specVersion": "0.1-280", - "casesNumber": 3, - "description": "Explicit receiver: Top-level non-extension functions: Callables declared in the same package", - "unexpectedBehaviour": false - }, - { - "specVersion": "0.1-280", - "casesNumber": 3, - "description": "Explicit receiver: Top-level non-extension functions: Callables explicitly imported into the current file", - "unexpectedBehaviour": false - }, - { - "specVersion": "0.1-280", - "casesNumber": 3, - "description": "Explicit receiver: The overload candidate sets for each pair of implicit receivers: Implicitly imported extension callables", - "unexpectedBehaviour": false - }, - { - "specVersion": "0.1-280", - "casesNumber": 1, - "description": "Implicit receiver: set of implicitly-imported extension callables", - "unexpectedBehaviour": false - }, - { - "specVersion": "0.1-280", - "casesNumber": 3, - "description": "Explicit receiver: The overload candidate sets for each pair of implicit receivers: Local extension callables", - "unexpectedBehaviour": false - }, - { - "specVersion": "0.1-280", - "casesNumber": 1, - "description": "Implicit receiver: sets of explicitly imported, declared in the package scope and star-imported extension callables", - "unexpectedBehaviour": false - }, - { - "specVersion": "0.1-280", - "casesNumber": 3, - "description": "Explicit receiver: The overload candidate sets for each pair of implicit receivers: Local extension callables", - "unexpectedBehaviour": true - }, - { - "specVersion": "0.1-280", - "casesNumber": 3, - "description": "Implicit receiver: sets of local, explicitly imported, declared in the package scope and star-imported extension callables", - "unexpectedBehaviour": false - }, - { - "specVersion": "0.1-280", - "casesNumber": 1, - "description": "Implicit receiver: set of implicitly-imported extension callables", - "unexpectedBehaviour": false - } - ] - } - }, "2": { "pos": { "1": [ + { + "specVersion": "0.1-300", + "casesNumber": 3, + "description": "call-with-trailing-lambda-expressions,Explicit receiver: Top-level non-extension functions: Callables star-imported into the current file;", + "path": "compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.10.kt", + "unexpectedBehaviour": false + }, + { + "specVersion": "0.1-300", + "casesNumber": 3, + "description": "call-with-trailing-lambda-expressions,Explicit receiver: The overload candidate sets for each pair of implicit receivers: Explicitly imported extension callables", + "path": "compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.14.kt", + "unexpectedBehaviour": false + }, + { + "specVersion": "0.1-300", + "casesNumber": 1, + "description": "call-with-trailing-lambda-expressions,Implicit receiver: set of star-imported extension callables", + "path": "compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.5.kt", + "unexpectedBehaviour": false + }, + { + "specVersion": "0.1-300", + "casesNumber": 3, + "description": "call-with-trailing-lambda-expressions,Explicit receiver: The overload candidate sets for each pair of implicit receivers: declared in the package scope extension callables", + "path": "compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.15.kt", + "unexpectedBehaviour": false + }, + { + "specVersion": "0.1-300", + "casesNumber": 1, + "description": "call-with-trailing-lambda-expressions,Implicit receiver: sets of declared in the package scope and star-imported extension callables", + "path": "compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.4.kt", + "unexpectedBehaviour": false + }, + { + "specVersion": "0.1-300", + "casesNumber": 2, + "description": "call-with-trailing-lambda-expressions,Explicit receiver: Top-level non-extension functions: Implicitly imported callables", + "path": "compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.11.kt", + "unexpectedBehaviour": false + }, + { + "specVersion": "0.1-300", + "casesNumber": 3, + "description": "call-with-trailing-lambda-expressions,Explicit receiver: Top-level non-extension functions: Callables declared in the same package", + "path": "compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.9.kt", + "unexpectedBehaviour": false + }, + { + "specVersion": "0.1-300", + "casesNumber": 3, + "description": "call-with-trailing-lambda-expressions,Explicit receiver: Top-level non-extension functions: Callables explicitly imported into the current file", + "path": "compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.8.kt", + "unexpectedBehaviour": false + }, + { + "specVersion": "0.1-300", + "casesNumber": 3, + "description": "call-with-trailing-lambda-expressions,Explicit receiver: The overload candidate sets for each pair of implicit receivers: Implicitly imported extension callables", + "path": "compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.16.kt", + "unexpectedBehaviour": false + }, + { + "specVersion": "0.1-300", + "casesNumber": 1, + "description": "call-with-trailing-lambda-expressions,Implicit receiver: set of implicitly-imported extension callables", + "path": "compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.7.kt", + "unexpectedBehaviour": false + }, + { + "specVersion": "0.1-300", + "casesNumber": 3, + "description": "call-with-trailing-lambda-expressions,Explicit receiver: The overload candidate sets for each pair of implicit receivers: Local extension callables", + "path": "compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.12.kt", + "unexpectedBehaviour": false + }, + { + "specVersion": "0.1-300", + "casesNumber": 1, + "description": "call-with-trailing-lambda-expressions,Implicit receiver: sets of explicitly imported, declared in the package scope and star-imported extension callables", + "path": "compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.3.kt", + "unexpectedBehaviour": false + }, + { + "specVersion": "0.1-300", + "casesNumber": 3, + "description": "call-with-trailing-lambda-expressions,Explicit receiver: The overload candidate sets for each pair of implicit receivers: Local extension callables", + "path": "compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.13.kt", + "unexpectedBehaviour": true + }, + { + "specVersion": "0.1-300", + "casesNumber": 3, + "description": "call-with-trailing-lambda-expressions,Implicit receiver: sets of local, explicitly imported, declared in the package scope and star-imported extension callables", + "path": "compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.2.kt", + "unexpectedBehaviour": false + }, + { + "specVersion": "0.1-300", + "casesNumber": 1, + "description": "call-with-trailing-lambda-expressions,Implicit receiver: set of implicitly-imported extension callables", + "path": "compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.6.kt", + "unexpectedBehaviour": false + }, { "specVersion": "0.1-280", "casesNumber": 3, @@ -215,6 +218,13 @@ "3": { "pos": { "1": [ + { + "specVersion": "0.1-300", + "casesNumber": 5, + "description": "call-with-trailing-lambda-expressions,Implicit receiver: sets of non-extension member callables, local, explicitly imported, declared in the package scope and star-imported extension callables", + "path": "compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.1.kt", + "unexpectedBehaviour": true + }, { "specVersion": "0.1-280", "casesNumber": 5, @@ -224,5 +234,107 @@ } ] } + }, + "1": { + "pos": { + "2": [ + { + "specVersion": "0.1-280", + "casesNumber": 3, + "description": "Explicit receiver: Top-level non-extension functions: Callables star-imported into the current file;", + "unexpectedBehaviour": false + }, + { + "specVersion": "0.1-280", + "casesNumber": 5, + "description": "Implicit receiver: sets of non-extension member callables, local, explicitly imported, declared in the package scope and star-imported extension callables", + "unexpectedBehaviour": true + }, + { + "specVersion": "0.1-280", + "casesNumber": 3, + "description": "Explicit receiver: The overload candidate sets for each pair of implicit receivers: Explicitly imported extension callables", + "unexpectedBehaviour": false + }, + { + "specVersion": "0.1-280", + "casesNumber": 1, + "description": "Implicit receiver: set of star-imported extension callables", + "unexpectedBehaviour": false + }, + { + "specVersion": "0.1-280", + "casesNumber": 3, + "description": "Explicit receiver: The overload candidate sets for each pair of implicit receivers: declared in the package scope extension callables", + "unexpectedBehaviour": false + }, + { + "specVersion": "0.1-280", + "casesNumber": 1, + "description": "Implicit receiver: sets of declared in the package scope and star-imported extension callables", + "unexpectedBehaviour": false + }, + { + "specVersion": "0.1-280", + "casesNumber": 2, + "description": "Explicit receiver: Top-level non-extension functions: Implicitly imported callables", + "unexpectedBehaviour": false + }, + { + "specVersion": "0.1-280", + "casesNumber": 3, + "description": "Explicit receiver: Top-level non-extension functions: Callables declared in the same package", + "unexpectedBehaviour": false + }, + { + "specVersion": "0.1-280", + "casesNumber": 3, + "description": "Explicit receiver: Top-level non-extension functions: Callables explicitly imported into the current file", + "unexpectedBehaviour": false + }, + { + "specVersion": "0.1-280", + "casesNumber": 3, + "description": "Explicit receiver: The overload candidate sets for each pair of implicit receivers: Implicitly imported extension callables", + "unexpectedBehaviour": false + }, + { + "specVersion": "0.1-280", + "casesNumber": 1, + "description": "Implicit receiver: set of implicitly-imported extension callables", + "unexpectedBehaviour": false + }, + { + "specVersion": "0.1-280", + "casesNumber": 3, + "description": "Explicit receiver: The overload candidate sets for each pair of implicit receivers: Local extension callables", + "unexpectedBehaviour": false + }, + { + "specVersion": "0.1-280", + "casesNumber": 1, + "description": "Implicit receiver: sets of explicitly imported, declared in the package scope and star-imported extension callables", + "unexpectedBehaviour": false + }, + { + "specVersion": "0.1-280", + "casesNumber": 3, + "description": "Explicit receiver: The overload candidate sets for each pair of implicit receivers: Local extension callables", + "unexpectedBehaviour": true + }, + { + "specVersion": "0.1-280", + "casesNumber": 3, + "description": "Implicit receiver: sets of local, explicitly imported, declared in the package scope and star-imported extension callables", + "unexpectedBehaviour": false + }, + { + "specVersion": "0.1-280", + "casesNumber": 1, + "description": "Implicit receiver: set of implicitly-imported extension callables", + "unexpectedBehaviour": false + } + ] + } } } \ No newline at end of file diff --git a/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.1.kt b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.1.kt new file mode 100644 index 00000000000..cc5f2c101dd --- /dev/null +++ b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.1.kt @@ -0,0 +1,95 @@ +// !LANGUAGE: +NewInference +// !DIAGNOSTICS: -UNUSED_VARIABLE -UNREACHABLE_CODE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION -IMPLICIT_NOTHING_RETURN_TYPE +// SKIP_TXT + +/* + * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE) + * + * SPEC VERSION: 0.1-300 + * PLACE: overload-resolution, building-the-overload-candidate-set-ocs, call-with-trailing-lambda-expressions -> paragraph 1 -> sentence 2 + * RELEVANT PLACES: overload-resolution, building-the-overload-candidate-set-ocs, call-with-named-parameters -> paragraph 3 -> sentence 1 + * overload-resolution, building-the-overload-candidate-set-ocs, call-with-named-parameters -> paragraph 2 -> sentence 1 + * overload-resolution, building-the-overload-candidate-set-ocs, call-with-named-parameters -> paragraph 4 -> sentence 1 + * NUMBER: 1 + * DESCRIPTION: call-with-trailing-lambda-expressions,Implicit receiver: sets of non-extension member callables, local, explicitly imported, declared in the package scope and star-imported extension callables + */ + +// TESTCASE NUMBER: 1, 2, 3, 4, 5 + +// FILE: Marker.kt +package libPackage + +class Marker { + fun foo(y: () -> Int) = TODO() + val foo: Marker = this + operator fun invoke(x: () -> Int) = TODO() +} + +// FILE: Tests.kt +package tests +import libPackage.Marker + +// TESTCASE NUMBER: 1 + +class Case1() { + fun Marker.foo(y: ()->Int) = TODO() + + fun test() { + Marker().foo(y = { 1 }) + Marker().foo(x = { 1 }) + } +} + +fun case1() { + Marker().foo(y = { 1 }) + Marker().foo(x = { 1 }) +} + +// TESTCASE NUMBER: 2 +class Case2() { + fun test() { + fun Marker.foo(x: ()->Int) = TODO() + Marker().foo(y = { 1 }) + Marker().foo(x = { 1 }) + } +} + +fun Marker.foo(x: ()->Int) = TODO() + +fun case2() { + Marker().foo(y = { 1 }) + Marker().foo(x = { 1 }) +} + +// TESTCASE NUMBER: 3 +fun case3() { + fun Marker.foo(y: ()->Int) = TODO() + Marker().foo(y = { 1 }) + Marker().foo(x = { 1 }) +} + +/* + * TESTCASE NUMBER: 4 + * UNEXPECTED BEHAVIOUR + * ISSUES: KT-37391 + */ +fun case4(marker: Marker?) { + marker?.foo(y = { 1 }) + marker?.foo(x = { 1 })> +} + + +/* + * TESTCASE NUMBER: 5 + * UNEXPECTED BEHAVIOUR + * ISSUES: KT-37391 + */ +fun case5(marker: Marker?) { + fun bar() { + fun Marker.foo(y: ()->Int) = TODO() + marker?.foo(y = { 1 }) + marker?.foo(x = { 1 }) + } + marker?.foo(y = { 1 }) + marker?.foo(x = { 1 }) +} \ No newline at end of file diff --git a/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.10.kt b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.10.kt new file mode 100644 index 00000000000..db37545cb0c --- /dev/null +++ b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.10.kt @@ -0,0 +1,72 @@ +// !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-300 + * PLACE: overload-resolution, building-the-overload-candidate-set-ocs, call-with-trailing-lambda-expressions -> paragraph 1 -> sentence 2 + * RELEVANT PLACES: overload-resolution, building-the-overload-candidate-set-ocs, call-with-named-parameters -> paragraph 2 -> sentence 1 + * NUMBER: 10 + * DESCRIPTION: call-with-trailing-lambda-expressions,Explicit receiver: Top-level non-extension functions: Callables star-imported into the current file; + */ + +// FILE: TestCase.kt +// TESTCASE NUMBER: 1 +package testsCase1 + +import libPackageCase1.* + +fun case1() { + listOf(elements = arrayOf(1), body = { "" }) +} +// FILE: Lib.kt +package libPackageCase1 + +fun listOf(vararg elements: T = TODO(), body: () -> T = { TODO() }): List = TODO() + +// FILE: TestCase.kt +// TESTCASE NUMBER: 2 +package testsCase2 +import libPackageCase2.* + +fun case2() { + listOf(elements = arrayOf(1), body = { "" }) +} + + +class A { + operator fun invoke(): T = TODO() +} + +// FILE: Lib.kt +package libPackageCase2 +import testsCase2.* + +fun listOf(vararg elements: T = TODO(), body: () -> T = { TODO() }): List = TODO() +val listOf: A + get() = A() + +// FILE: TestCase.kt +// TESTCASE NUMBER: 3 +package testsCase3 +import libPackageCase3.* + +fun case3() { + listOf(elements = arrayOf(1), body = { "" }) +} + + +class A { + operator fun invoke(vararg elements: T = TODO(), body: () -> T = { TODO() }): List = TODO() +} + +// FILE: Lib.kt +package libPackageCase3 +import testsCase3.* + +private fun listOf(vararg elements: T = TODO(), body: () -> T = { TODO() }): List = TODO() + +val listOf: A + get() = A() \ No newline at end of file diff --git a/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.11.kt b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.11.kt new file mode 100644 index 00000000000..491aeac31c3 --- /dev/null +++ b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.11.kt @@ -0,0 +1,54 @@ +// !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-300 + * PLACE: overload-resolution, building-the-overload-candidate-set-ocs, call-with-trailing-lambda-expressions -> paragraph 1 -> sentence 2 + * RELEVANT PLACES: overload-resolution, building-the-overload-candidate-set-ocs, call-with-named-parameters -> paragraph 2 -> sentence 1 + * NUMBER: 11 + * DESCRIPTION: call-with-trailing-lambda-expressions,Explicit receiver: Top-level non-extension functions: Implicitly imported callables + */ + +// FILE: TestCase.kt +// TESTCASE NUMBER: 1 +package testsCase1 + +import libPackageCase1.* //nothing to import + +fun case1() { + run(block = { "ss" }) +} +// FILE: Lib.kt +package libPackageCase1 + +private fun run(vararg elements: R = TODO(), block: () -> R): R = TODO() + +// FILE: TestCase.kt +// TESTCASE NUMBER: 2 +package testscase2 + +import libPackagecase2.* //nothing to import + +class Case2 { + + fun case2() { + run(block = { "ss" }) + } +} + +class A { + fun run(vararg elements: R = TODO(), block: () -> R): R = TODO() +} + +// FILE: Lib.kt +package libPackagecase2 +import testscase2.* + +private fun run(vararg elements: R = TODO(), block: () -> R): R = TODO() + +private val Case2.run: A + get() = A() + diff --git a/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.12.kt b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.12.kt new file mode 100644 index 00000000000..957655037ba --- /dev/null +++ b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.12.kt @@ -0,0 +1,167 @@ +// !LANGUAGE: +NewInference +// !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION -NOTHING_TO_INLINE -EXTENSION_SHADOWED_BY_MEMBER +// SKIP_TXT + +/* + * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE) + * + * SPEC VERSION: 0.1-300 + * PLACE: overload-resolution, building-the-overload-candidate-set-ocs, call-with-trailing-lambda-expressions -> paragraph 1 -> sentence 2 + * RELEVANT PLACES: overload-resolution, building-the-overload-candidate-set-ocs, call-with-named-parameters -> paragraph 2 -> sentence 1 + * NUMBER: 12 + * DESCRIPTION: call-with-trailing-lambda-expressions,Explicit receiver: The overload candidate sets for each pair of implicit receivers: Local extension callables + */ + +// FILE: TestCase.kt +// TESTCASE NUMBER: 1 +package testsCase1 + +import libPackageCase1.* +import libPackageCase1Explicit.listOf + +class Case1() { + fun listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + + fun case1() { + fun Case1.listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + + listOf(elements1 = arrayOf(1), body = { "" }) + } +} +// FILE: Lib.kt +package libPackageCase1 +import testsCase1.* + +public fun listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() +fun Case1.listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + +// FILE: Lib.kt +package libPackageCase1Explicit +import testsCase1.* + +fun Case1.listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + +public fun listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + +// FILE: LibtestsPack.kt +package testsCase1 +fun Case1.listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + +public fun listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + + +// FILE: TestCase.kt +// TESTCASE NUMBER: 2 +package testsCase2 +import libPackageCase2.* +import libPackageCase2Explicit.listOf + +class Case2() { + fun listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + + val listOf: A + get() = A() + + fun case1() { + fun Case2.listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + + listOf(elements1 = arrayOf(1), body = { "" }) + } +} + +class A { + operator fun invoke(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() +} +// FILE: Lib.kt +package libPackageCase2 +import testsCase2.* + +val Case2.listOf: A + get() = A() + +public fun listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() +fun Case2.listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + +// FILE: Lib.kt +package libPackageCase2Explicit +import testsCase2.* + +val Case2.listOf: A + get() = A() + +fun Case2.listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + +public fun listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + +// FILE: LibtestsPack.kt +package testsCase2 +val Case2.listOf: A + get() = A() + +fun Case2.listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + +public fun listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + + +// FILE: TestCase.kt +// TESTCASE NUMBER: 3 +package testsCase3 +import libPackageCase3.* +import libPackageCase3Explicit.listOf + +class Case3() { + fun Case3.listOf(vararg elements1: T = TODO(), body: () -> T = + { TODO() }): List = TODO() + + val listOf: A + get() = A() + + fun case1() { + fun Case3.listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + + listOf(elements1 = arrayOf(1), body = { "" }) + } +} + +class A { + operator fun invoke(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() +} +// FILE: Lib.kt +// TESTCASE NUMBER: 3 + +package libPackageCase3 +import testsCase3.* + +val Case3.listOf: A + get() = A() + +public fun listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() +fun Case3.listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + +// FILE: Lib.kt +// TESTCASE NUMBER: 3 + +package libPackageCase3Explicit +import testsCase3.* + +val Case3.listOf: A + get() = A() + +fun Case3.listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + +public fun listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + +// FILE: LibtestsPack.kt +// TESTCASE NUMBER: 3 + +package testsCase3 +val Case3.listOf: A + get() = A() + +fun Case3.listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + +public fun listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + + + + diff --git a/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.13.kt b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.13.kt new file mode 100644 index 00000000000..e54340bf929 --- /dev/null +++ b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.13.kt @@ -0,0 +1,193 @@ +// !LANGUAGE: +NewInference +// !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION -NOTHING_TO_INLINE +// SKIP_TXT + +/* + * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE) + * + * SPEC VERSION: 0.1-300 + * PLACE: overload-resolution, building-the-overload-candidate-set-ocs, call-with-trailing-lambda-expressions -> paragraph 1 -> sentence 2 + * RELEVANT PLACES: overload-resolution, building-the-overload-candidate-set-ocs, call-with-named-parameters -> paragraph 2 -> sentence 1 + * NUMBER: 13 + * DESCRIPTION: call-with-trailing-lambda-expressions,Explicit receiver: The overload candidate sets for each pair of implicit receivers: Local extension callables + */ + +// FILE: TestCase.kt +// TESTCASE NUMBER: 1 +package testsCase1 + +import libPackageCase1.* +import libPackageCase1Explicit.listOf + +class Case1() { + + fun case1_0() { + fun Case1.listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + + listOf(elements1 = arrayOf(1), body = { "" }) + + fun case1_1() { + fun Case1.listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + listOf(elements1 = arrayOf(1), body = { "" }) + } + } + +} + +// FILE: Lib.kt +package libPackageCase1 +import testsCase1.* + +public fun listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() +fun Case1.listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + +// FILE: Lib.kt +package libPackageCase1Explicit +import testsCase1.* + +fun Case1.listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + +public fun listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + +// FILE: LibtestsPack.kt +package testsCase1 +fun Case1.listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + +public fun listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + + +// FILE: TestCase.kt + +/* + * TESTCASE NUMBER: 2 + * UNEXPECTED BEHAVIOUR + * ISSUES: KT-37179 + */ +package testsCase2 +import libPackageCase2.* +import libPackageCase2Explicit.listOf + +class Case2() { + + fun case1_0() { + fun Case2.listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + listOf(elements1 = arrayOf(1), body = { "" }) + + fun case1_1() { + fun Case2.listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + listOf(elements1 = arrayOf(1), body = { "" }) + } + } + + val Case2.listOf: A + get() = A() + + fun Case2.listOf(vararg elements1: T = TODO(), body: () -> T = + { TODO() }): List = TODO() + + fun case2_0() { + listOf(elements1 = arrayOf(1), body = { "" }) + } + +} + +class A { + operator fun invoke(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() +} + +// FILE: Lib.kt +// TESTCASE NUMBER: 2 +package libPackageCase2 +import testsCase2.* + +val Case2.listOf: A + get() = A() + +public fun listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() +fun Case2.listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + +// FILE: Lib.kt +// TESTCASE NUMBER: 2 + +package libPackageCase2Explicit +import testsCase2.* + +fun Case2.listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + +public fun listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + +// FILE: LibtestsPack.kt +// TESTCASE NUMBER: 2 + +package testsCase2 +fun Case2.listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + +public fun listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + + +// FILE: TestCase.kt + +/* + * TESTCASE NUMBER: 3 + * UNEXPECTED BEHAVIOUR + * ISSUES: KT-37179 + */ +package testsCase3 +import libPackageCase3.* +import libPackageCase3Explicit.listOf + +class Case3() { + + fun case1_0() { + //fun Case3.listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + listOf(elements1 = arrayOf(1), body = { "" }) + + fun case1_1() { + // fun Case3.listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + listOf(elements1 = arrayOf(1), body = { "" }) + } + } + + val Case3.listOf: A + get() = A() + + //fun Case3.listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + + fun case2_0() { + listOf(elements1 = arrayOf(1), body = { "" }) + } + +} + +class A { + operator fun invoke(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() +} + +// FILE: Lib.kt +// TESTCASE NUMBER: 3 +package libPackageCase3 +import testsCase3.* + +val Case3.listOf: A + get() = A() + +public fun listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() +fun Case3.listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + +// FILE: Lib.kt +// TESTCASE NUMBER: 3 + +package libPackageCase3Explicit +import testsCase3.* + +fun Case3.listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + +public fun listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + +// FILE: LibtestsPack.kt +// TESTCASE NUMBER: 3 +package testsCase3 +fun Case3.listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + +public fun listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + diff --git a/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.14.kt b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.14.kt new file mode 100644 index 00000000000..0aed05aecc8 --- /dev/null +++ b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.14.kt @@ -0,0 +1,136 @@ +// !LANGUAGE: +NewInference +// !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION -NOTHING_TO_INLINE +// SKIP_TXT + +/* + * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE) + * + * SPEC VERSION: 0.1-300 + * PLACE: overload-resolution, building-the-overload-candidate-set-ocs, call-with-trailing-lambda-expressions -> paragraph 1 -> sentence 2 + * RELEVANT PLACES: overload-resolution, building-the-overload-candidate-set-ocs, call-with-named-parameters -> paragraph 2 -> sentence 1 + * NUMBER: 14 + * DESCRIPTION: call-with-trailing-lambda-expressions,Explicit receiver: The overload candidate sets for each pair of implicit receivers: Explicitly imported extension callables + */ + +// FILE: TestCase.kt +// TESTCASE NUMBER: 1 + +package testsCase1 + +import libPackageCase1.* +import libPackageCase1Explicit.listOf + +class Case1() { + + fun case1() { + listOf(elements1 = arrayOf(1), body = { "" }) + } +} + +// FILE: Lib.kt +package libPackageCase1 +import testsCase1.* + +public fun listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() +fun Case1.listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + +// FILE: Lib.kt +package libPackageCase1Explicit +import testsCase1.* + +fun Case1.listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + +public fun listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + +// FILE: LibtestsPack.kt +package testsCase1 +fun Case1.listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + +public fun listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + + +// FILE: TestCase.kt +// TESTCASE NUMBER: 2 + +package testsCase2 +import libPackageCase2.* +import libPackageCase2Explicit.listOf + +class Case2() { + + fun case1() { + listOf(elements1 = arrayOf(1), body = { "" }) + } +} + +class A { + operator fun invoke(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() +} + +// FILE: Lib.kt +package libPackageCase2 +import testsCase2.* + +public fun listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() +fun Case2.listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + +// FILE: Lib.kt +package libPackageCase2Explicit +import testsCase2.* + +val Case2.listOf: A + get() = A() + +fun Case2.listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + +public fun listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + +// FILE: LibtestsPack.kt +package testsCase2 +fun Case2.listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + +public fun listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + + +// FILE: TestCase.kt +// TESTCASE NUMBER: 3 + +package testsCase3 +import libPackageCase3.* +import libPackageCase3Explicit.listOf + +class Case3() { + + fun case1() { + listOf(elements1 = arrayOf(1), body = { "" }) + } +} + +class A { + operator fun invoke(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() +} + +// FILE: Lib.kt +package libPackageCase3 +import testsCase3.* + +public fun listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() +fun Case3.listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + +// FILE: Lib.kt +package libPackageCase3Explicit +import testsCase3.* + +val Case3.listOf: A + get() = A() + +private fun Case3.listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + +public fun listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + +// FILE: LibtestsPack.kt +package testsCase3 +fun Case3.listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + +public fun listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + diff --git a/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.15.kt b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.15.kt new file mode 100644 index 00000000000..09e9b82093b --- /dev/null +++ b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.15.kt @@ -0,0 +1,127 @@ +// !LANGUAGE: +NewInference +// !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION -NOTHING_TO_INLINE +// SKIP_TXT + +/* + * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE) + * + * SPEC VERSION: 0.1-300 + * PLACE: overload-resolution, building-the-overload-candidate-set-ocs, call-with-trailing-lambda-expressions -> paragraph 1 -> sentence 2 + * RELEVANT PLACES: overload-resolution, building-the-overload-candidate-set-ocs, call-with-named-parameters -> paragraph 2 -> sentence 1 + * NUMBER: 15 + * DESCRIPTION: call-with-trailing-lambda-expressions,Explicit receiver: The overload candidate sets for each pair of implicit receivers: declared in the package scope extension callables + */ + +// FILE: TestCase.kt +// TESTCASE NUMBER: 1 +package testsCase1 + +import libPackageCase1.* +import libPackageCase1Explicit.listOf + +class Case1() { + + fun case1() { + listOf(elements1 = arrayOf(1), body = { "" }) + } +} + +// FILE: Lib.kt +package libPackageCase1 +import testsCase1.* + +public fun listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() +fun Case1.listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + +// FILE: Lib.kt +package libPackageCase1Explicit + +public fun listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + +// FILE: LibtestsPack.kt +package testsCase1 +fun Case1.listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + +public fun listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + + +// FILE: TestCase.kt +// TESTCASE NUMBER: 2 +package testsCase2 +import libPackageCase2.* +import libPackageCase2Explicit.listOf + +class Case2() { + + fun case1() { + listOf(elements1 = arrayOf(1), body = { "" }) + } +} + +class A { + operator fun invoke(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() +} + +// FILE: Lib.kt +package libPackageCase2 +import testsCase2.* + +val Case2.listOf: A + get() = A() + +fun listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() +fun Case2.listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + +// FILE: Lib.kt +package libPackageCase2Explicit + +public fun listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + +// FILE: LibtestsPack.kt +package testsCase2 +fun Case2.listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + +public fun listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() +val Case2.listOf: A + get() = A() + +// FILE: TestCase.kt +// TESTCASE NUMBER: 3 +package testsCase3 +import libPackageCase3.* +import libPackageCase3Explicit.listOf + +class Case3() { + + fun case1() { + listOf(elements1 = arrayOf(1), body = { "" }) + } +} + +class A { + operator fun invoke(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() +} + +// FILE: Lib.kt +package libPackageCase3 +import testsCase3.* + +fun listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() +fun Case3.listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + +// FILE: Lib.kt +package libPackageCase3Explicit + +public fun listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + +// FILE: LibtestsPack.kt +package testsCase3 + +val Case3.listOf: A + get() = A() + +private fun Case3.listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + +public fun listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + + diff --git a/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.16.kt b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.16.kt new file mode 100644 index 00000000000..9ce13486c63 --- /dev/null +++ b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.16.kt @@ -0,0 +1,123 @@ +// !LANGUAGE: +NewInference +// !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION -NOTHING_TO_INLINE +// SKIP_TXT + +/* + * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE) + * + * SPEC VERSION: 0.1-300 + * PLACE: overload-resolution, building-the-overload-candidate-set-ocs, call-with-trailing-lambda-expressions -> paragraph 1 -> sentence 2 + * RELEVANT PLACES: overload-resolution, building-the-overload-candidate-set-ocs, call-with-named-parameters -> paragraph 2 -> sentence 1 + * NUMBER: 16 + * DESCRIPTION: call-with-trailing-lambda-expressions,Explicit receiver: The overload candidate sets for each pair of implicit receivers: Implicitly imported extension callables + */ + +// FILE: TestCase.kt +// TESTCASE NUMBER: 1 +package testsCase1 + +import libPackageCase1.* +import libPackageCase1Explicit.listOf + +class Case1() { + + fun case() { + listOf(elements1 = arrayOf(1), body = { "" }) + } +} + +// FILE: Lib.kt +package libPackageCase1 +import testsCase1.* + +public fun listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() +fun Case1.listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + +// FILE: Lib.kt +package libPackageCase1Explicit + +public fun listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + +// FILE: LibtestsPack.kt +package testsCase1 + +public fun listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + + +// FILE: TestCase.kt +// TESTCASE NUMBER: 2 +package testsCase2 +import libPackageCase2.* +import libPackageCase2Explicit.listOf + +class Case2() { + + fun case() { + listOf(elements1 = arrayOf(1), body = { "" }) + } +} + +class A { + operator fun invoke(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() +} + + +// FILE: Lib.kt +package libPackageCase2 +import testsCase2.* + +val Case2.listOf: A + get() = A() + +public fun listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() +fun Case2.listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + +// FILE: Lib.kt +package libPackageCase2Explicit + +public fun listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + +// FILE: LibtestsPack.kt +package testsCase2 + +public fun listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + + +// FILE: TestCase.kt +// TESTCASE NUMBER: 3 +package testsCase3 +import libPackageCase3.* +import libPackageCase3Explicit.listOf + +class Case3() { + + fun case() { + listOf(elements1 = arrayOf(1), body = { "" }) + } +} + +class A { + operator fun invoke(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() +} + + +// FILE: Lib.kt +package libPackageCase3 +import testsCase3.* + +val Case3.listOf: A + get() = A() + +fun listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() +private fun Case3.listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + +// FILE: Lib.kt +package libPackageCase3Explicit + +public fun listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + +// FILE: LibtestsPack.kt +package testsCase3 + +public fun listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + diff --git a/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.17.kt b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.17.kt new file mode 100644 index 00000000000..8fb737c4256 --- /dev/null +++ b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.17.kt @@ -0,0 +1,123 @@ +// !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-300 + * PLACE: overload-resolution, building-the-overload-candidate-set-ocs, call-with-trailing-lambda-expressions -> paragraph 1 -> sentence 2 + * RELEVANT PLACES: overload-resolution, building-the-overload-candidate-set-ocs, infix-function-call -> paragraph 2 -> sentence 1 + * overload-resolution, building-the-overload-candidate-set-ocs, infix-function-call -> paragraph 2 -> sentence 2 + * overload-resolution, building-the-overload-candidate-set-ocs, call-with-an-explicit-receiver -> paragraph 6 -> sentence 1 + * NUMBER: 17 + * DESCRIPTION: Infix fun: Local extension infix extension callables + */ + +// TESTCASE NUMBER: 0, 1, 2, 3, 4 +// FILE: Extensions.kt +package libPackage + +class A() { + infix fun foo(x: ()->Int) = "member fun foo" +} + +// FILE: Extensions.kt +// TESTCASE NUMBER: 0 + +package sentence3 +import libPackage.A + +infix fun A.foo(x: ()->Int) = "pack scope extension fun foo" + +// FILE: TestCase1.kt +// TESTCASE NUMBER: 1 + +package sentence3 +import libPackage.A + +class Case1() { + infix fun A.foo(x: ()->Int) = "local extension fun foo" + + fun case1() { + val a = A() + a foo {1} + A() foo {1} + } +} +// FILE: TestCase2.kt +// TESTCASE NUMBER: 2 + +package sentence3 +import libPackage.A + +interface Case2 { + infix fun A.foo(x: ()->Int) = "local extension fun foo" + + fun case2() { + val a = A() + a foo {1} + A() foo {1} + } +} + +// FILE: TestCase3.kt +// TESTCASE NUMBER: 3 +package testPack +import libPackage.A + +infix fun A.foo(x: ()->Int) = "my package scope top level trim" + + +fun case3() { + infix fun A.foo(x: ()->Int) = "my local scope trim" + + val a = A() + a foo {1} + A() foo {1} +} + +// FILE: TestCase4.kt +// TESTCASE NUMBER: 4 +package testPackNew +import libPackage.A + +infix fun A.foo(x: ()->Int) = "my package scope top level trim" + + +fun case4() { + + infix fun A.foo(x: ()->Int) = "my local trim" + + fun subfun() { + infix fun A.foo(x: ()->Int) = "my local trim" + val a = A() + a foo {1} + A() foo {1} + } +} + +// FILE: TestCase5.kt +// TESTCASE NUMBER: 5 +package testPackNew + +class A() { + fun foo(i: ()->Int) {} + infix fun A.foo(i: ()->Int) {} + + fun bar(a: A) { + //todo: add info if function is infix one + a foo {1} + } + + fun buz(a: A) { + fun foo(i: ()->Int) {} + //todo: add info if function is infix one + a foo {1} + } + + fun boo(a: A) { + infix fun A.foo(i: ()->Int) {} + a foo {1} + } +} diff --git a/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.18.kt b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.18.kt new file mode 100644 index 00000000000..f92b5268f3b --- /dev/null +++ b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.18.kt @@ -0,0 +1,85 @@ +// !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-300 + * PLACE: overload-resolution, building-the-overload-candidate-set-ocs, call-with-trailing-lambda-expressions -> paragraph 1 -> sentence 2 + * RELEVANT PLACES: overload-resolution, building-the-overload-candidate-set-ocs, infix-function-call -> paragraph 2 -> sentence 1 + * overload-resolution, building-the-overload-candidate-set-ocs, infix-function-call -> paragraph 2 -> sentence 2 + * overload-resolution, building-the-overload-candidate-set-ocs, call-with-an-explicit-receiver -> paragraph 6 -> sentence 2 + * + * NUMBER: 18 + * DESCRIPTION: Infix fun: Local extension infix extension callables + */ + +// FILE: Extensions.kt +package libPackage + +infix fun CharSequence.trim(predicate: (Char) -> Boolean): CharSequence = TODO() +// FILE: Extensions.kt + +package sentence3 + +infix fun CharSequence.trim(predicate: (Char) -> Boolean): CharSequence = TODO() + +// FILE: TestCase1.kt +// TESTCASE NUMBER: 1 + +package sentence3 +import libPackage.trim + +class Case1() { + infix fun CharSequence.trim(predicate: (Char) -> Boolean): CharSequence = TODO() + + fun case1() { + "" trim {true} + } +} +// FILE: TestCase2.kt +// TESTCASE NUMBER: 2 + +package sentence3 +import libPackage.trim + +interface Case2 { + infix fun CharSequence.trim(predicate: (Char) -> Boolean): CharSequence = TODO() + + fun case2() { + "" trim {true} + } +} + +// FILE: TestCase3.kt +// TESTCASE NUMBER: 3 +package testPack +import libPackage.trim + +infix fun CharSequence.trim(predicate: (Char) -> Boolean): CharSequence = TODO() +fun case3() { + infix fun CharSequence.trim(predicate: (Char) -> Boolean): CharSequence = TODO() + + "" trim {true} +} + +// FILE: TestCase4.kt +// TESTCASE NUMBER: 4 +package testPackNew +import libPackage.trim + +infix fun CharSequence.trim(predicate: (Char) -> Boolean): CharSequence = TODO() + +fun case4() { + + infix fun CharSequence.trim(predicate: (Char) -> Boolean): CharSequence = TODO() + + fun subfun() { + + infix fun CharSequence.trim(predicate: (Char) -> Boolean): CharSequence = TODO() + + "" trim {true} + + } +} diff --git a/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.19.kt b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.19.kt new file mode 100644 index 00000000000..23e2ce8a982 --- /dev/null +++ b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.19.kt @@ -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 (POSITIVE) + * + * SPEC VERSION: 0.1-300 + * PLACE: overload-resolution, building-the-overload-candidate-set-ocs, call-with-trailing-lambda-expressions -> paragraph 1 -> sentence 2 + * RELEVANT PLACES: overload-resolution, building-the-overload-candidate-set-ocs, infix-function-call -> paragraph 2 -> sentence 1 + * overload-resolution, building-the-overload-candidate-set-ocs, infix-function-call -> paragraph 2 -> sentence 2 + * overload-resolution, building-the-overload-candidate-set-ocs, call-with-an-explicit-receiver -> paragraph 6 -> sentence 3 + * + * NUMBER: 19 + * DESCRIPTION: infix fun: Explicitly imported infix extension callables + */ + +// FILE: Extensions.kt +package libPackage + +infix fun CharSequence.trim(predicate: (Char) -> Boolean): CharSequence = TODO() + +// FILE: Extensions.kt + +package sentence3 + +infix fun CharSequence.trim(predicate: (Char) -> Boolean): CharSequence = TODO() + + +// FILE: TestCase1.kt +// TESTCASE NUMBER: 1 + +package sentence3 +import libPackage.trim + + +fun case1() { + "" trim {true} +} + +// FILE: TestCase2.kt +// TESTCASE NUMBER: 2 + +package sentence3 +import libPackage.trim + + +fun case2() { + infix fun CharSequence.trim(predicate: (Char) -> Boolean): CharSequence = TODO() + + "" trim {true} +} + diff --git a/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.2.kt b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.2.kt new file mode 100644 index 00000000000..894d3c4f270 --- /dev/null +++ b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.2.kt @@ -0,0 +1,69 @@ +// !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-300 + * PLACE: overload-resolution, building-the-overload-candidate-set-ocs, call-with-trailing-lambda-expressions -> paragraph 1 -> sentence 2 + * RELEVANT PLACES: overload-resolution, building-the-overload-candidate-set-ocs, call-with-named-parameters -> paragraph 2 -> sentence 1 + * NUMBER: 2 + * DESCRIPTION: call-with-trailing-lambda-expressions,Implicit receiver: sets of local, explicitly imported, declared in the package scope and star-imported extension callables + */ + +// FILE: Extensions.kt +package libPackage + +public fun T.let(block: (T) -> R): R = TODO() + +// FILE: TestCase1.kt + +package sentence3 + +import libPackage.* +import libPackage.let + +private fun T.let(block: (T) -> R): R = TODO() + +// TESTCASE NUMBER: 1 +class Case1() { + fun T.let(block: (T) -> R): R = TODO() + fun case1(s: String) { + s.let (block = { "" }) + } +} + +// FILE: TestCase2.kt +package sentence3 +import libPackage.* + +//import libPackage.orEmpty + +private fun T.let(block: (T) -> R): R = TODO() + +// TESTCASE NUMBER: 2 +class Case2() { + fun T.let(block: (T) -> R): R = TODO() + fun case2(s: String) { + s.let (block = { "" }) + } +} + +// TESTCASE NUMBER: 3 +class Case3() { + fun T.let(block: (T) -> R): R = TODO() + fun case3(s: String) { + s.let (block = { "" }) + fun innerFirst(s: String?) { + fun T.let(block: (T) -> R): R = TODO() + s?.let (block = { "" }) + } + + fun innerSecond() { + fun T.let(block: (T) -> R): R = TODO() + s.let (block = { "" }) + } + s.let (block = { "" }) + } +} diff --git a/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.20.kt b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.20.kt new file mode 100644 index 00000000000..606b2653cf0 --- /dev/null +++ b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.20.kt @@ -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 (POSITIVE) + * + * SPEC VERSION: 0.1-300 + * PLACE: overload-resolution, building-the-overload-candidate-set-ocs, call-with-trailing-lambda-expressions -> paragraph 1 -> sentence 2 + * RELEVANT PLACES: overload-resolution, building-the-overload-candidate-set-ocs, infix-function-call -> paragraph 2 -> sentence 1 + * overload-resolution, building-the-overload-candidate-set-ocs, infix-function-call -> paragraph 2 -> sentence 2 + * overload-resolution, building-the-overload-candidate-set-ocs, call-with-an-explicit-receiver -> paragraph 6 -> sentence 4 + * + * NUMBER: 20 + * DESCRIPTION: infix fun: Star-imported infix extension callables + */ + +// FILE: Extensions.kt +package libPackage + +infix fun CharSequence.trim(predicate: (Char) -> Boolean): CharSequence = TODO() + +// FILE: Extensions.kt + +package sentence3 + +infix fun CharSequence.trim(predicate: (Char) -> Boolean): CharSequence = TODO() + + +// FILE: TestCase1.kt +// TESTCASE NUMBER: 1 + +package sentence3 +import libPackage.* + + +fun case1() { + val regex = Regex("") + "" trim {true} +} + +// FILE: TestCase2.kt +// TESTCASE NUMBER: 2 +package testPack +import libPackage.* + +infix fun CharSequence.trim(predicate: (Char) -> Boolean): CharSequence = TODO() + + +fun case2() { + val regex = Regex("") + "" trim {true} +} diff --git a/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.21.kt b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.21.kt new file mode 100644 index 00000000000..bb47642ea50 --- /dev/null +++ b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.21.kt @@ -0,0 +1,32 @@ +// !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-300 + * PLACE: overload-resolution, building-the-overload-candidate-set-ocs, call-with-trailing-lambda-expressions -> paragraph 1 -> sentence 2 + * RELEVANT PLACES: overload-resolution, building-the-overload-candidate-set-ocs, infix-function-call -> paragraph 2 -> sentence 1 + * overload-resolution, building-the-overload-candidate-set-ocs, infix-function-call -> paragraph 2 -> sentence 2 + * overload-resolution, building-the-overload-candidate-set-ocs, call-with-an-explicit-receiver -> paragraph 6 -> sentence 5 + * + * NUMBER: 21 + * DESCRIPTION: infix fun: Star-imported infix extension callables + */ + +// FILE: Extensions.kt +package libPackage + +infix fun CharSequence.trim(predicate: (Char) -> Boolean): CharSequence = TODO() + +// FILE: TestCase1.kt +// TESTCASE NUMBER: 1 + +package sentence3 +import libPackage.* + +fun case1() { + "" trim {true} +} + diff --git a/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.3.kt b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.3.kt new file mode 100644 index 00000000000..bfe4b6b3b17 --- /dev/null +++ b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.3.kt @@ -0,0 +1,35 @@ +// !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-300 + * PLACE: overload-resolution, building-the-overload-candidate-set-ocs, call-with-trailing-lambda-expressions -> paragraph 1 -> sentence 2 + * RELEVANT PLACES: overload-resolution, building-the-overload-candidate-set-ocs, call-with-named-parameters -> paragraph 2 -> sentence 1 + * NUMBER: 3 + * DESCRIPTION: call-with-trailing-lambda-expressions,Implicit receiver: sets of explicitly imported, declared in the package scope and star-imported extension callables + */ + +// FILE: Extensions.kt +package libPackageExplicit + +public fun T.let(block: (T) -> R): R = TODO() + +// FILE: Extensions.kt +package libPackage + +public fun T.let(block: (T) -> R): R = TODO() + +// FILE: TestCase1.kt +package tests + +import libPackage.* +import libPackageExplicit.let + +// TESTCASE NUMBER: 1 +fun case1(s: String) { + s.let (block = { "" }) +} + diff --git a/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.4.kt b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.4.kt new file mode 100644 index 00000000000..e918cfb9367 --- /dev/null +++ b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.4.kt @@ -0,0 +1,31 @@ +// !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-300 + * PLACE: overload-resolution, building-the-overload-candidate-set-ocs, call-with-trailing-lambda-expressions -> paragraph 1 -> sentence 2 + * RELEVANT PLACES: overload-resolution, building-the-overload-candidate-set-ocs, call-with-named-parameters -> paragraph 2 -> sentence 1 + * NUMBER: 4 + * DESCRIPTION: call-with-trailing-lambda-expressions,Implicit receiver: sets of declared in the package scope and star-imported extension callables + */ + +// FILE: Extensions.kt +package libPackage + +public fun T.let(block: (T) -> R): R = TODO() + +// FILE: TestCase2.kt +package tests + +import libPackage.* + +public fun T.let(block: (T) -> R): R = TODO() + +// TESTCASE NUMBER: 1 +fun case2(s: String) { + s.let (block = { "" }) +} + diff --git a/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.5.kt b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.5.kt new file mode 100644 index 00000000000..0f7e67b33c3 --- /dev/null +++ b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.5.kt @@ -0,0 +1,28 @@ +// !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-300 + * PLACE: overload-resolution, building-the-overload-candidate-set-ocs, call-with-trailing-lambda-expressions -> paragraph 1 -> sentence 2 + * RELEVANT PLACES: overload-resolution, building-the-overload-candidate-set-ocs, call-with-named-parameters -> paragraph 2 -> sentence 1 + * NUMBER: 5 + * DESCRIPTION: call-with-trailing-lambda-expressions,Implicit receiver: set of star-imported extension callables + */ + +// FILE: Extensions.kt +package libPackage + +public fun T.let(block: (T) -> R): R = TODO() + +// FILE: TestCase2.kt +package sentence3 + +import libPackage.* + +// TESTCASE NUMBER: 1 +fun case2(s: String) { + s.let (block = { "" }) +} diff --git a/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.6.kt b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.6.kt new file mode 100644 index 00000000000..b7c903eeea2 --- /dev/null +++ b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.6.kt @@ -0,0 +1,28 @@ +// !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-300 + * PLACE: overload-resolution, building-the-overload-candidate-set-ocs, call-with-trailing-lambda-expressions -> paragraph 1 -> sentence 2 + * RELEVANT PLACES: overload-resolution, building-the-overload-candidate-set-ocs, call-with-named-parameters -> paragraph 2 -> sentence 1 + * NUMBER: 6 + * DESCRIPTION: call-with-trailing-lambda-expressions,Implicit receiver: set of implicitly-imported extension callables + */ + +// FILE: Extensions.kt +package libPackage + +public fun T.let(block_: (T) -> R): R = TODO() + +// FILE: TestCase.kt +package testCase1 +import libPackage.* + +// TESTCASE NUMBER: 1 +fun case2(s: String) { + s.let (block_ = { "" }) + s.let (block = { "" }) +} diff --git a/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.7.kt b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.7.kt new file mode 100644 index 00000000000..f796898718f --- /dev/null +++ b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.7.kt @@ -0,0 +1,27 @@ +// !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-300 + * PLACE: overload-resolution, building-the-overload-candidate-set-ocs, call-with-trailing-lambda-expressions -> paragraph 1 -> sentence 2 + * RELEVANT PLACES: overload-resolution, building-the-overload-candidate-set-ocs, call-with-named-parameters -> paragraph 2 -> sentence 1 + * NUMBER: 7 + * DESCRIPTION: call-with-trailing-lambda-expressions,Implicit receiver: set of implicitly-imported extension callables + */ + +// FILE: Extensions.kt +package libPackage + +private fun T.let(block: (T) -> R): R = TODO() + +// FILE: TestCase.kt +package testCase1 +import libPackage.* + +// TESTCASE NUMBER: 1 +fun case2(s: String) { + s.let (block = { "" }) +} diff --git a/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.8.kt b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.8.kt new file mode 100644 index 00000000000..59386bb4220 --- /dev/null +++ b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.8.kt @@ -0,0 +1,106 @@ +// !LANGUAGE: +NewInference +// !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION -NOTHING_TO_INLINE +// SKIP_TXT + +/* + * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE) + * + * SPEC VERSION: 0.1-300 + * PLACE: overload-resolution, building-the-overload-candidate-set-ocs, call-with-trailing-lambda-expressions -> paragraph 1 -> sentence 2 + * RELEVANT PLACES: overload-resolution, building-the-overload-candidate-set-ocs, call-with-named-parameters -> paragraph 2 -> sentence 1 + * NUMBER: 8 + * DESCRIPTION: call-with-trailing-lambda-expressions,Explicit receiver: Top-level non-extension functions: Callables explicitly imported into the current file + */ + +// FILE: TestCase.kt +// TESTCASE NUMBER: 1 +package testsCase1 + +import libPackageCase1.* +import libPackageCase1Explicit.listOf + +fun case1() { + listOf(elements1 = arrayOf(1), body = { "" }) +} + +// FILE: Lib.kt +package libPackageCase1 + +public fun listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + +// FILE: Lib.kt +package libPackageCase1Explicit + +public fun listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + +// FILE: LibtestsPack.kt +package testsCase1 + +public fun listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + + +// FILE: TestCase.kt +// TESTCASE NUMBER: 2 +package testsCase2 +import libPackageCase2.* +import libPackageCase2Explicit.listOf + +fun case2() { + listOf(elements1 = arrayOf(1), body = { "" }) +} + +class A { + operator fun invoke(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() +} +// FILE: Lib.kt +package libPackageCase2 + +public fun listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + +// FILE: Lib.kt +package libPackageCase2Explicit +import testsCase2.* + +val listOf: A + get() = A() + +public fun listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + +// FILE: LibtestsPack.kt +package testsCase2 + +public fun listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + + +// FILE: TestCase.kt +// TESTCASE NUMBER: 3 +package testsCase3 +import libPackageCase3.* +import libPackageCase3Explicit.listOf + +fun case3() { + listOf(elements1 = arrayOf(1), body = { "" }) +} + +class A { + operator fun invoke(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() +} +// FILE: Lib.kt +package libPackageCase3 + +public fun listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + +// FILE: Lib.kt +package libPackageCase3Explicit +import testsCase3.* + +val listOf: A + get() = A() + +private fun listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + +// FILE: LibtestsPack.kt +package testsCase3 + +public fun listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + diff --git a/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.9.kt b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.9.kt new file mode 100644 index 00000000000..77955223a8b --- /dev/null +++ b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.9.kt @@ -0,0 +1,89 @@ +// !LANGUAGE: +NewInference +// !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION -NOTHING_TO_INLINE +// SKIP_TXT + +/* + * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE) + * + * SPEC VERSION: 0.1-300 + * PLACE: overload-resolution, building-the-overload-candidate-set-ocs, call-with-trailing-lambda-expressions -> paragraph 1 -> sentence 2 + * RELEVANT PLACES: overload-resolution, building-the-overload-candidate-set-ocs, call-with-named-parameters -> paragraph 2 -> sentence 1 + * NUMBER: 9 + * DESCRIPTION: call-with-trailing-lambda-expressions,Explicit receiver: Top-level non-extension functions: Callables declared in the same package + */ + +// FILE: TestCase.kt +// TESTCASE NUMBER: 1 +package testsCase1 + +import libPackageCase1.* + +fun case1() { + listOf(elements1 = arrayOf(1), body = { "" }) +} + +// FILE: Lib.kt +package libPackageCase1 + +public fun listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + +// FILE: LibtestsPack.kt +package testsCase1 + +public fun listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + +// FILE: TestCase.kt +// TESTCASE NUMBER: 2 +package testsCase2 +import libPackageCase2.* + +fun case2() { + listOf(elements1 = arrayOf(1), body = { "" }) +} + +// FILE: Lib.kt +package libPackageCase2 + +public fun listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + +// FILE: LibtestsPack.kt +package testsCase2 +import testsCase2.* + +public val listOf: A + get() = A() + +class A { + operator fun invoke(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() +} + +public fun listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + + +// FILE: TestCase.kt +// TESTCASE NUMBER: 3 +package testsCase3 +import libPackageCase3.* + +fun case3() { + listOf(elements1 = arrayOf(1), body = { "" }) +} + +// FILE: Lib.kt +package libPackageCase3 + +public fun listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + +// FILE: LibtestsPack.kt +package testsCase3 +import testsCase3.* + +public val listOf: A + get() = A() + +class A { + operator fun invoke(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() +} + +private fun listOf(vararg elements1: T = TODO(), body: () -> T = { TODO() }): List = TODO() + diff --git a/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/testsMap.json b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/testsMap.json new file mode 100644 index 00000000000..ac2c307aa11 --- /dev/null +++ b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/testsMap.json @@ -0,0 +1,134 @@ +{ + "1": { + "pos": { + "2": [ + { + "specVersion": "0.1-300", + "casesNumber": 3, + "description": "call-with-trailing-lambda-expressions,Explicit receiver: Top-level non-extension functions: Callables star-imported into the current file;", + "unexpectedBehaviour": false + }, + { + "specVersion": "0.1-300", + "casesNumber": 5, + "description": "call-with-trailing-lambda-expressions,Implicit receiver: sets of non-extension member callables, local, explicitly imported, declared in the package scope and star-imported extension callables", + "unexpectedBehaviour": true + }, + { + "specVersion": "0.1-300", + "casesNumber": 2, + "description": "infix fun: Star-imported infix extension callables", + "unexpectedBehaviour": false + }, + { + "specVersion": "0.1-300", + "casesNumber": 3, + "description": "call-with-trailing-lambda-expressions,Explicit receiver: The overload candidate sets for each pair of implicit receivers: Explicitly imported extension callables", + "unexpectedBehaviour": false + }, + { + "specVersion": "0.1-300", + "casesNumber": 1, + "description": "call-with-trailing-lambda-expressions,Implicit receiver: set of star-imported extension callables", + "unexpectedBehaviour": false + }, + { + "specVersion": "0.1-300", + "casesNumber": 1, + "description": "infix fun: Star-imported infix extension callables", + "unexpectedBehaviour": false + }, + { + "specVersion": "0.1-300", + "casesNumber": 3, + "description": "call-with-trailing-lambda-expressions,Explicit receiver: The overload candidate sets for each pair of implicit receivers: declared in the package scope extension callables", + "unexpectedBehaviour": false + }, + { + "specVersion": "0.1-300", + "casesNumber": 1, + "description": "call-with-trailing-lambda-expressions,Implicit receiver: sets of declared in the package scope and star-imported extension callables", + "unexpectedBehaviour": false + }, + { + "specVersion": "0.1-300", + "casesNumber": 2, + "description": "call-with-trailing-lambda-expressions,Explicit receiver: Top-level non-extension functions: Implicitly imported callables", + "unexpectedBehaviour": false + }, + { + "specVersion": "0.1-300", + "casesNumber": 3, + "description": "call-with-trailing-lambda-expressions,Explicit receiver: Top-level non-extension functions: Callables declared in the same package", + "unexpectedBehaviour": false + }, + { + "specVersion": "0.1-300", + "casesNumber": 4, + "description": "Infix fun: Local extension infix extension callables", + "unexpectedBehaviour": false + }, + { + "specVersion": "0.1-300", + "casesNumber": 3, + "description": "call-with-trailing-lambda-expressions,Explicit receiver: Top-level non-extension functions: Callables explicitly imported into the current file", + "unexpectedBehaviour": false + }, + { + "specVersion": "0.1-300", + "casesNumber": 2, + "description": "infix fun: Explicitly imported infix extension callables", + "unexpectedBehaviour": false + }, + { + "specVersion": "0.1-300", + "casesNumber": 3, + "description": "call-with-trailing-lambda-expressions,Explicit receiver: The overload candidate sets for each pair of implicit receivers: Implicitly imported extension callables", + "unexpectedBehaviour": false + }, + { + "specVersion": "0.1-300", + "casesNumber": 1, + "description": "call-with-trailing-lambda-expressions,Implicit receiver: set of implicitly-imported extension callables", + "unexpectedBehaviour": false + }, + { + "specVersion": "0.1-300", + "casesNumber": 3, + "description": "call-with-trailing-lambda-expressions,Explicit receiver: The overload candidate sets for each pair of implicit receivers: Local extension callables", + "unexpectedBehaviour": false + }, + { + "specVersion": "0.1-300", + "casesNumber": 1, + "description": "call-with-trailing-lambda-expressions,Implicit receiver: sets of explicitly imported, declared in the package scope and star-imported extension callables", + "unexpectedBehaviour": false + }, + { + "specVersion": "0.1-300", + "casesNumber": 3, + "description": "call-with-trailing-lambda-expressions,Explicit receiver: The overload candidate sets for each pair of implicit receivers: Local extension callables", + "unexpectedBehaviour": true + }, + { + "specVersion": "0.1-300", + "casesNumber": 3, + "description": "call-with-trailing-lambda-expressions,Implicit receiver: sets of local, explicitly imported, declared in the package scope and star-imported extension callables", + "unexpectedBehaviour": false + }, + { + "specVersion": "0.1-300", + "casesNumber": 6, + "description": "Infix fun: Local extension infix extension callables", + "unexpectedBehaviour": false + }, + { + "specVersion": "0.1-300", + "casesNumber": 1, + "description": "call-with-trailing-lambda-expressions,Implicit receiver: set of implicitly-imported extension callables", + "unexpectedBehaviour": false + } + ] + } + } +} \ No newline at end of file diff --git a/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call/testsMap.json b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call/testsMap.json index 2c339c20f1f..eacc97b7fd7 100644 --- a/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call/testsMap.json +++ b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call/testsMap.json @@ -1,5 +1,111 @@ { "2": { + "pos": { + "1": [ + { + "specVersion": "0.1-300", + "casesNumber": 2, + "description": "infix fun: Star-imported infix extension callables", + "path": "compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.20.kt", + "unexpectedBehaviour": false + }, + { + "specVersion": "0.1-300", + "casesNumber": 1, + "description": "infix fun: Star-imported infix extension callables", + "path": "compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.21.kt", + "unexpectedBehaviour": false + }, + { + "specVersion": "0.1-300", + "casesNumber": 4, + "description": "Infix fun: Local extension infix extension callables", + "path": "compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.18.kt", + "unexpectedBehaviour": false + }, + { + "specVersion": "0.1-300", + "casesNumber": 2, + "description": "infix fun: Explicitly imported infix extension callables", + "path": "compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.19.kt", + "unexpectedBehaviour": false + }, + { + "specVersion": "0.1-300", + "casesNumber": 6, + "description": "Infix fun: Local extension infix extension callables", + "path": "compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.17.kt", + "unexpectedBehaviour": false + }, + { + "specVersion": "0.1-268", + "casesNumber": 2, + "description": "Star-imported infix extension callables", + "path": "compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call/p-2/pos/3.4.kt", + "unexpectedBehaviour": false + }, + { + "specVersion": "0.1-268", + "casesNumber": 1, + "description": "Star-imported infix extension callables", + "path": "compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call/p-2/pos/3.5.kt", + "unexpectedBehaviour": false + }, + { + "specVersion": "0.1-268", + "casesNumber": 6, + "description": "Local extension infix extension callables", + "path": "compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call/p-2/pos/3.1.kt", + "unexpectedBehaviour": false + }, + { + "specVersion": "0.1-268", + "casesNumber": 4, + "description": "Local extension infix extension callables", + "path": "compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call/p-2/pos/3.2.kt", + "unexpectedBehaviour": false + }, + { + "specVersion": "0.1-268", + "casesNumber": 2, + "description": "Explicitly imported infix extension callables", + "path": "compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call/p-2/pos/3.3.kt", + "unexpectedBehaviour": false + } + ], + "3": [ + { + "specVersion": "0.1-268", + "casesNumber": 2, + "description": "Star-imported infix extension callables", + "unexpectedBehaviour": false + }, + { + "specVersion": "0.1-268", + "casesNumber": 1, + "description": "Star-imported infix extension callables", + "unexpectedBehaviour": false + }, + { + "specVersion": "0.1-268", + "casesNumber": 6, + "description": "Local extension infix extension callables", + "unexpectedBehaviour": false + }, + { + "specVersion": "0.1-268", + "casesNumber": 4, + "description": "Local extension infix extension callables", + "unexpectedBehaviour": false + }, + { + "specVersion": "0.1-268", + "casesNumber": 2, + "description": "Explicitly imported infix extension callables", + "unexpectedBehaviour": false + } + ] + }, "neg": { "1": [ { @@ -72,77 +178,6 @@ "unexpectedBehaviour": false } ] - }, - "pos": { - "3": [ - { - "specVersion": "0.1-268", - "casesNumber": 2, - "description": "Star-imported infix extension callables", - "unexpectedBehaviour": false - }, - { - "specVersion": "0.1-268", - "casesNumber": 1, - "description": "Star-imported infix extension callables", - "unexpectedBehaviour": false - }, - { - "specVersion": "0.1-268", - "casesNumber": 6, - "description": "Local extension infix extension callables", - "unexpectedBehaviour": false - }, - { - "specVersion": "0.1-268", - "casesNumber": 4, - "description": "Local extension infix extension callables", - "unexpectedBehaviour": false - }, - { - "specVersion": "0.1-268", - "casesNumber": 2, - "description": "Explicitly imported infix extension callables", - "unexpectedBehaviour": false - } - ], - "1": [ - { - "specVersion": "0.1-268", - "casesNumber": 2, - "description": "Star-imported infix extension callables", - "path": "compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call/p-2/pos/3.4.kt", - "unexpectedBehaviour": false - }, - { - "specVersion": "0.1-268", - "casesNumber": 1, - "description": "Star-imported infix extension callables", - "path": "compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call/p-2/pos/3.5.kt", - "unexpectedBehaviour": false - }, - { - "specVersion": "0.1-268", - "casesNumber": 6, - "description": "Local extension infix extension callables", - "path": "compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call/p-2/pos/3.1.kt", - "unexpectedBehaviour": false - }, - { - "specVersion": "0.1-268", - "casesNumber": 4, - "description": "Local extension infix extension callables", - "path": "compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call/p-2/pos/3.2.kt", - "unexpectedBehaviour": false - }, - { - "specVersion": "0.1-268", - "casesNumber": 2, - "description": "Explicitly imported infix extension callables", - "path": "compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call/p-2/pos/3.3.kt", - "unexpectedBehaviour": false - } - ] } } } \ No newline at end of file diff --git a/compiler/tests-spec/tests/org/jetbrains/kotlin/spec/checkers/DiagnosticsTestSpecGenerated.java b/compiler/tests-spec/tests/org/jetbrains/kotlin/spec/checkers/DiagnosticsTestSpecGenerated.java index 692656ba7ba..0a2d6a009d3 100644 --- a/compiler/tests-spec/tests/org/jetbrains/kotlin/spec/checkers/DiagnosticsTestSpecGenerated.java +++ b/compiler/tests-spec/tests/org/jetbrains/kotlin/spec/checkers/DiagnosticsTestSpecGenerated.java @@ -3623,6 +3623,150 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } } + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Call_with_trailing_lambda_expressions extends AbstractDiagnosticsTestSpec { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); + } + + public void testAllFilesPresentInCall_with_trailing_lambda_expressions() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions"), Pattern.compile("^(.+)\\.kt$"), null, true); + } + + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class P_1 extends AbstractDiagnosticsTestSpec { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); + } + + public void testAllFilesPresentInP_1() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1"), Pattern.compile("^(.+)\\.kt$"), null, true); + } + + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Pos extends AbstractDiagnosticsTestSpec { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); + } + + @TestMetadata("2.1.kt") + public void test2_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.1.kt"); + } + + @TestMetadata("2.10.kt") + public void test2_10() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.10.kt"); + } + + @TestMetadata("2.11.kt") + public void test2_11() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.11.kt"); + } + + @TestMetadata("2.12.kt") + public void test2_12() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.12.kt"); + } + + @TestMetadata("2.13.kt") + public void test2_13() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.13.kt"); + } + + @TestMetadata("2.14.kt") + public void test2_14() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.14.kt"); + } + + @TestMetadata("2.15.kt") + public void test2_15() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.15.kt"); + } + + @TestMetadata("2.16.kt") + public void test2_16() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.16.kt"); + } + + @TestMetadata("2.17.kt") + public void test2_17() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.17.kt"); + } + + @TestMetadata("2.18.kt") + public void test2_18() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.18.kt"); + } + + @TestMetadata("2.19.kt") + public void test2_19() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.19.kt"); + } + + @TestMetadata("2.2.kt") + public void test2_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.2.kt"); + } + + @TestMetadata("2.20.kt") + public void test2_20() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.20.kt"); + } + + @TestMetadata("2.21.kt") + public void test2_21() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.21.kt"); + } + + @TestMetadata("2.3.kt") + public void test2_3() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.3.kt"); + } + + @TestMetadata("2.4.kt") + public void test2_4() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.4.kt"); + } + + @TestMetadata("2.5.kt") + public void test2_5() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.5.kt"); + } + + @TestMetadata("2.6.kt") + public void test2_6() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.6.kt"); + } + + @TestMetadata("2.7.kt") + public void test2_7() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.7.kt"); + } + + @TestMetadata("2.8.kt") + public void test2_8() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.8.kt"); + } + + @TestMetadata("2.9.kt") + public void test2_9() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.9.kt"); + } + + public void testAllFilesPresentInPos() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + } + } + } + } + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-without-an-explicit-receiver") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class)