Dmitriy Novozhilov
419f54259c
Previously helpers from checkType.kt was in special package, and
if directive was enabled then test runner (`AbstractDiagnosticTest`)
injected additional imports to test files and removed them after test
was completed.
It's very hard to support such behavior in new test infrastructure so
there was a decision about changing `CHECK_TYPE`:
1. All helpers from `checkType.kt` now stays in default package
2. `CHECK_TYPE` only adds `checkType.kt` to set of analyzed files
and don't modify their content
For test which are written in default package (most of tests actually)
there are no changes. On the other hand if there is a test where dev
want to use checkType functions in testfile with some package then he
should explicitly import functions which he needed (`checkSubtype`,
`checkType`, `_`)
48 lines
1.2 KiB
Kotlin
Vendored
48 lines
1.2 KiB
Kotlin
Vendored
// !CHECK_TYPE
|
|
|
|
//KT-2179 Nested function literal breaks compiler
|
|
package i
|
|
|
|
//+JDK
|
|
import java.util.*
|
|
import checkSubtype
|
|
|
|
fun test() {
|
|
val sample1: List<List<Int?>> = arrayList(arrayList<Int?>(1, 7, null, 8))
|
|
|
|
//breaks compiler
|
|
val sample2 = sample1.map({it.map({it})})
|
|
checkSubtype<List<List<Int?>>>(sample2)
|
|
|
|
//breaks compiler
|
|
val sample3 = sample1.map({row -> row.map({column -> column})})
|
|
checkSubtype<List<List<Int?>>>(sample3)
|
|
|
|
//doesn't break compiler
|
|
val identity: (Int?) -> Int? = {column -> column}
|
|
val sample4 = sample1.map({row -> row.map(identity)})
|
|
checkSubtype<List<List<Int?>>>(sample4)
|
|
}
|
|
|
|
//------------
|
|
|
|
fun <T> arrayList(vararg values: T) : ArrayList<T> = values.toCollection(ArrayList<T>(values.size))
|
|
|
|
fun <T, R> Collection<T>.map(transform : (T) -> R) : List<R> {
|
|
return mapTo(java.util.ArrayList<R>(this.size), transform)
|
|
}
|
|
|
|
fun <T, R, C: MutableCollection<in R>> Collection<T>.mapTo(result: C, transform : (T) -> R) : C {
|
|
for (item in this)
|
|
result.add(transform(item))
|
|
return result
|
|
}
|
|
|
|
fun <T, C: MutableCollection<in T>> Array<T>.toCollection(result: C) : C {
|
|
for (element in this) result.add(element)
|
|
return result
|
|
}
|
|
|
|
val Collection<*>.size : Int
|
|
get() = size
|