azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

FIR: Add workaround for OverloadResolutionByLambdaReturnType

Browse Source 
Mostly, that should help for existing flatMap usages

^KT-43129 Submitted
This commit is contained in:
Denis Zharkov
2020-11-02 20:45:39 +03:00
parent 07ed89b02b
commit 4612f26bfb
19 changed files with 87 additions and 209 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/testData/diagnostics/testsWithStdLib/coroutines/kt41430.fir.kt
Vendored
+4 -4
View File
@@ -3,18 +3,18 @@
class A
fun test_1(list: List<Set<A>>) {
list.<!AMBIGUITY!>flatMapTo<!>(mutableSetOf()) { <!UNRESOLVED_REFERENCE!>it<!> }
list.flatMapTo(mutableSetOf()) { it }
}
fun test_2(list: List<Set<A>>) {
sequence<A> {
<!DEBUG_INFO_EXPRESSION_TYPE("ERROR CLASS: Ambiguity: flatMapTo, [kotlin/collections/flatMapTo, kotlin/collections/flatMapTo]")!>list.<!AMBIGUITY!>flatMapTo<!>(mutableSetOf()) { <!UNRESOLVED_REFERENCE!>it<!> }<!>
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.collections.MutableSet<A>")!>list.flatMapTo(mutableSetOf()) { it }<!>
}
}
fun test_3(list: List<Set<A>>) {
sequence {
list.<!AMBIGUITY!>flatMapTo<!>(mutableSetOf()) { <!UNRESOLVED_REFERENCE!>it<!> }
list.flatMapTo(mutableSetOf()) { it }
yield(A())
}
}
@@ -22,6 +22,6 @@ fun test_3(list: List<Set<A>>) {
fun test_4(list: List<Set<A>>) {
sequence {
yield(A())
list.<!AMBIGUITY!>flatMapTo<!>(mutableSetOf()) { <!UNRESOLVED_REFERENCE!>it<!> }
list.flatMapTo(mutableSetOf()) { it }
}
}
compiler/testData/diagnostics/testsWithStdLib/factoryPattern/independentResolutionInLambda.fir.kt
Vendored
-41
View File
@@ -1,41 +0,0 @@
// !LANGUAGE: +NewInference +OverloadResolutionByLambdaReturnType
// !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE -UNUSED_EXPRESSION
// ISSUE: KT-11265
// FILE: OverloadResolutionByLambdaReturnType.kt
package kotlin
annotation class OverloadResolutionByLambdaReturnType
// FILE: main.kt
import kotlin.OverloadResolutionByLambdaReturnType
@kotlin.jvm.JvmName("myFlatMapIterable")
@OverloadResolutionByLambdaReturnType
fun <T, R> Sequence<T>.myFlatMap(transform: (T) -> Iterable<R>): Sequence<R> {
TODO()
}
fun <T, R> Sequence<T>.myFlatMap(transform: (T) -> Sequence<R>): Sequence<R> {
TODO()
}
interface A {
val supertypes: Collection<B>
}
interface B {
val descriptors: Sequence<C>?
}
interface C
fun <K : Any> elvis(x: K?, y: K): K = y
fun test(a: A) {
a.supertypes.asSequence().<!AMBIGUITY!>myFlatMap<!> {
<!INAPPLICABLE_CANDIDATE!>elvis<!>(<!UNRESOLVED_REFERENCE!>it<!>.<!UNRESOLVED_REFERENCE!>descriptors<!>, sequenceOf())
}
}
compiler/testData/diagnostics/testsWithStdLib/factoryPattern/independentResolutionInLambda.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
// !LANGUAGE: +NewInference +OverloadResolutionByLambdaReturnType
// !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE -UNUSED_EXPRESSION
// ISSUE: KT-11265
compiler/testData/diagnostics/testsWithStdLib/factoryPattern/multipleOverloads_1.fir.kt
Vendored
-35
View File
@@ -1,35 +0,0 @@
// !LANGUAGE: +NewInference +OverloadResolutionByLambdaReturnType
// !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE -UNUSED_EXPRESSION -EXPERIMENTAL_API_USAGE -EXPERIMENTAL_UNSIGNED_LITERALS
// ISSUE: KT-11265
// FILE: OverloadResolutionByLambdaReturnType.kt
package kotlin
annotation class OverloadResolutionByLambdaReturnType
// FILE: main.kt
import kotlin.OverloadResolutionByLambdaReturnType
@OverloadResolutionByLambdaReturnType
fun <R> UByteArray.fooMap(t: (UByte) -> Iterable<R>): List<R> {
TODO("ub.fm")
}
@OverloadResolutionByLambdaReturnType
fun <T, R> Iterable<T>.fooMap(t: (T) -> Iterable<R>): List<R> {
TODO("i.fm(i)")
}
@JvmName("fooMapSeq")
fun <T, R> Iterable<T>.fooMap(t: (T) -> Sequence<R>): List<R> {
TODO("i.fm(s)")
}
fun test() {
val list = ubyteArrayOf(0u).<!AMBIGUITY!>fooMap<!> { <!NONE_APPLICABLE!>listOf<!>(<!UNRESOLVED_REFERENCE!>it<!>) }
takeUByteList(list)
}
fun takeUByteList(list: List<UByte>) {}
compiler/testData/diagnostics/testsWithStdLib/factoryPattern/multipleOverloads_1.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
// !LANGUAGE: +NewInference +OverloadResolutionByLambdaReturnType
// !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE -UNUSED_EXPRESSION -EXPERIMENTAL_API_USAGE -EXPERIMENTAL_UNSIGNED_LITERALS
// ISSUE: KT-11265
compiler/testData/diagnostics/testsWithStdLib/factoryPattern/multipleOverloads_3.fir.kt
Vendored
-54
View File
@@ -1,54 +0,0 @@
// !LANGUAGE: +NewInference +OverloadResolutionByLambdaReturnType
// !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE -UNUSED_EXPRESSION -EXPERIMENTAL_API_USAGE -EXPERIMENTAL_UNSIGNED_LITERALS
// ISSUE: KT-11265
// FILE: OverloadResolutionByLambdaReturnType.kt
package kotlin
annotation class OverloadResolutionByLambdaReturnType
// FILE: main.kt
import kotlin.OverloadResolutionByLambdaReturnType
public inline fun <T, R> Iterable<T>.myFlatMap(transform: (T) -> Iterable<R>): List<R> {
TODO()
}
@OverloadResolutionByLambdaReturnType
@kotlin.jvm.JvmName("myFlatMapSequence")
public inline fun <T, R> Iterable<T>.myFlatMap(transform: (T) -> Sequence<R>): List<R> {
TODO()
}
interface Name
interface DeclarationDescriptor {
val nextCandidates: List<DeclarationDescriptor>?
val nextCandidatesSeq: Sequence<DeclarationDescriptor>?
val name: Name
}
fun test_1(name: Name, toplevelDescriptors: List<DeclarationDescriptor>): List<DeclarationDescriptor> {
val candidates = toplevelDescriptors.<!AMBIGUITY!>myFlatMap<!> { container ->
val nextCandidates = container.<!UNRESOLVED_REFERENCE!>nextCandidates<!> ?: return@myFlatMap emptyList()
nextCandidates
}
return candidates
}
fun test_2(name: Name, toplevelDescriptors: List<DeclarationDescriptor>): List<DeclarationDescriptor> {
val candidates = toplevelDescriptors.<!AMBIGUITY!>myFlatMap<!> { container ->
val nextCandidates = container.<!UNRESOLVED_REFERENCE!>nextCandidatesSeq<!> ?: return@myFlatMap sequenceOf()
nextCandidates
}
return candidates
}
fun test_3(name: Name, toplevelDescriptors: List<DeclarationDescriptor>): List<DeclarationDescriptor> {
val candidates = toplevelDescriptors.<!AMBIGUITY!>myFlatMap<!> { container ->
val nextCandidates = container.<!UNRESOLVED_REFERENCE!>nextCandidatesSeq<!>!!
nextCandidates
}
return candidates
}
compiler/testData/diagnostics/testsWithStdLib/factoryPattern/multipleOverloads_3.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
// !LANGUAGE: +NewInference +OverloadResolutionByLambdaReturnType
// !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE -UNUSED_EXPRESSION -EXPERIMENTAL_API_USAGE -EXPERIMENTAL_UNSIGNED_LITERALS
// ISSUE: KT-11265
compiler/testData/diagnostics/testsWithStdLib/factoryPattern/overloadByLambdaReturnType_disabled.fir.kt
Vendored
+8 -8
View File
@@ -20,17 +20,17 @@ fun takeString(s: String) {}
fun takeInt(s: Int) {}
fun test_1() {
val x = <!AMBIGUITY!>create<!> { "" }
val x = create { "" }
takeString(x)
}
fun test_2() {
val x = <!AMBIGUITY!>create<!> { 1 }
takeInt(x)
val x = create { 1 }
<!INAPPLICABLE_CANDIDATE!>takeInt<!>(x)
}
fun test_3() {
val x = <!AMBIGUITY!>create<!> { 1.0 }
val x = create { 1.0 }
}
@OverloadResolutionByLambdaReturnType
@@ -38,11 +38,11 @@ fun <K> create(x: K, f: (K) -> Int): Int = 1
fun <T> create(x: T, f: (T) -> String): String = ""
fun test_4() {
val x = <!AMBIGUITY!>create<!>("") { "" }
val x = create("") { "" }
takeString(x)
}
fun test_5() {
val x = <!AMBIGUITY!>create<!>("") { 1 }
takeInt(x)
}
val x = create("") { 1 }
<!INAPPLICABLE_CANDIDATE!>takeInt<!>(x)
}
compiler/testData/diagnostics/testsWithStdLib/factoryPattern/overloadByLambdaReturnType_enabled.fir.kt
Vendored
+8 -8
View File
@@ -20,17 +20,17 @@ fun takeString(s: String) {}
fun takeInt(s: Int) {}
fun test_1() {
val x = <!AMBIGUITY!>create<!> { "" }
val x = create { "" }
takeString(x)
}
fun test_2() {
val x = <!AMBIGUITY!>create<!> { 1 }
takeInt(x)
val x = create { 1 }
<!INAPPLICABLE_CANDIDATE!>takeInt<!>(x)
}
fun test_3() {
val x = <!AMBIGUITY!>create<!> { 1.0 }
val x = create { 1.0 }
}
@OverloadResolutionByLambdaReturnType
@@ -38,13 +38,13 @@ fun <K> create(x: K, f: (K) -> Int): Int = 1
fun <T> create(x: T, f: (T) -> String): String = ""
fun test_4() {
val x = <!AMBIGUITY!>create<!>("") { "" }
val x = create("") { "" }
takeString(x)
}
fun test_5() {
val x = <!AMBIGUITY!>create<!>("") { 1 }
takeInt(x)
val x = create("") { 1 }
<!INAPPLICABLE_CANDIDATE!>takeInt<!>(x)
}
interface A
@@ -56,6 +56,6 @@ fun foo(f: () -> A): Int = 1
fun foo(f: () -> B): String = ""
fun test_6(c: C) {
val x = <!AMBIGUITY!>foo<!> { c }
val x = foo { c }
takeString(x)
}
compiler/testData/diagnostics/testsWithStdLib/factoryPattern/resolutionInOldInference.fir.kt
Vendored
-24
View File
@@ -1,24 +0,0 @@
// !LANGUAGE: -NewInference
// !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE -UNUSED_EXPRESSION
// ISSUE: KT-11265
// FILE: OverloadResolutionByLambdaReturnType.kt
package kotlin
annotation class OverloadResolutionByLambdaReturnType
// FILE: main.kt
import kotlin.OverloadResolutionByLambdaReturnType
@OverloadResolutionByLambdaReturnType
fun create(f: (Int) -> Int): Int = 1
fun create(f: (Int) -> String): String = ""
fun takeString(s: String) {}
fun test_1() {
val x = <!AMBIGUITY!>create<!> { "" }
takeString("")
}
compiler/testData/diagnostics/testsWithStdLib/factoryPattern/resolutionInOldInference.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
// !LANGUAGE: -NewInference
// !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE -UNUSED_EXPRESSION
// ISSUE: KT-11265
compiler/testData/diagnostics/testsWithStdLib/factoryPattern/returnFromInlineLambda.fir.kt
Vendored
+6 -6
View File
@@ -25,10 +25,10 @@ inline fun <T, R> Array<out T>.myFlatMap(transform: (T) -> Sequence<R>): List<R>
fun String.toList(): List<String> = null!!
fun test_1(a: Array<String>, b: Boolean) {
a.<!AMBIGUITY!>myFlatMap<!> { <!UNRESOLVED_REFERENCE!>it<!>.toList().ifEmpty { return } }
a.<!AMBIGUITY!>myFlatMap<!> {
a.myFlatMap { it.toList().ifEmpty { return } }
a.myFlatMap {
if (b) return
<!UNRESOLVED_REFERENCE!>it<!>.toList()
it.toList()
}
}
@@ -43,9 +43,9 @@ fun <T, R> Array<out T>.noInlineFlatMap(transform: (T) -> Sequence<R>): List<R>
}
fun test_2(a: Array<String>, b: Boolean) {
a.<!AMBIGUITY!>noInlineFlatMap<!> { <!UNRESOLVED_REFERENCE!>it<!>.toList().ifEmpty { return } }
a.<!AMBIGUITY!>noInlineFlatMap<!> {
a.noInlineFlatMap { it.toList().ifEmpty { return } }
a.noInlineFlatMap {
if (b) return
<!UNRESOLVED_REFERENCE!>it<!>.toList()
it.toList()
}
}
compiler/testData/diagnostics/testsWithStdLib/when/noTypeArgumentsInConstructor.fir.kt
Vendored
+8 -8
View File
@@ -23,21 +23,21 @@ val test3: MutableList<Int> =
}
val test4: Collection<Int> =
listOf(1, 2, 3).<!AMBIGUITY!>flatMapTo<!>(LinkedHashSet()) {
<!NONE_APPLICABLE!>listOf<!>(<!UNRESOLVED_REFERENCE!>it<!>)
listOf(1, 2, 3).flatMapTo(LinkedHashSet()) {
listOf(it)
}
val test5: Collection<Int> =
listOf(1, 2, 3).<!AMBIGUITY!>flatMapTo<!>(LinkedHashSet()) { // TODO
if (true) <!NONE_APPLICABLE!>listOf<!>(<!UNRESOLVED_REFERENCE!>it<!>) else <!NONE_APPLICABLE!>listOf<!>(<!UNRESOLVED_REFERENCE!>it<!>)
listOf(1, 2, 3).flatMapTo(LinkedHashSet()) { // TODO
if (true) listOf(it) else listOf(it)
}
val test6: Collection<Int> =
listOf(1, 2, 3).<!AMBIGUITY!>flatMapTo<!>(LinkedHashSet<Int>()) {
if (true) <!NONE_APPLICABLE!>listOf<!>(<!UNRESOLVED_REFERENCE!>it<!>) else <!NONE_APPLICABLE!>listOf<!>(<!UNRESOLVED_REFERENCE!>it<!>)
listOf(1, 2, 3).flatMapTo(LinkedHashSet<Int>()) {
if (true) listOf(it) else listOf(it)
}
val test7: Collection<Int> =
listOf(1, 2, 3).<!AMBIGUITY!>flatMapTo<!>(LinkedHashSet()) {
<!INAPPLICABLE_CANDIDATE!>select<!>(<!NONE_APPLICABLE!>listOf<!>(<!UNRESOLVED_REFERENCE!>it<!>), <!NONE_APPLICABLE!>listOf<!>(<!UNRESOLVED_REFERENCE!>it<!>))
listOf(1, 2, 3).flatMapTo(LinkedHashSet()) {
select(listOf(it), listOf(it))
}