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

Remove OI/NI attributes from test data

Browse Source
This commit is contained in:
Denis.Zharkov
2021-05-24 12:42:39 +03:00
committed by teamcityserver
parent 2ecba6ac39
commit ddbdfafa79
441 changed files with 1005 additions and 1037 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/testData/diagnostics/testsWithStdLib/addAllProjection.kt
Vendored
+5 -6
View File
@@ -1,13 +1,12 @@
fun test(mc: MutableCollection<out CharSequence>) {
mc.addAll(<!TYPE_MISMATCH{NI}, TYPE_MISMATCH_DUE_TO_TYPE_PROJECTIONS{OI}!>mc<!>)
mc.addAll(<!TYPE_MISMATCH!>mc<!>)
mc.addAll(<!TYPE_MISMATCH{NI}, TYPE_MISMATCH_DUE_TO_TYPE_PROJECTIONS{OI}!>arrayListOf<CharSequence>()<!>)
mc.addAll(<!TYPE_MISMATCH!>arrayListOf<CharSequence>()<!>)
mc.addAll(arrayListOf())
mc.addAll(<!TYPE_MISMATCH{NI}, TYPE_MISMATCH_DUE_TO_TYPE_PROJECTIONS{OI}!>listOf("")<!>)
mc.addAll(<!TYPE_MISMATCH{NI}, TYPE_MISMATCH_DUE_TO_TYPE_PROJECTIONS{OI}!>listOf<String>("")<!>)
mc.addAll(<!TYPE_MISMATCH{NI}, TYPE_MISMATCH_DUE_TO_TYPE_PROJECTIONS{OI}!>listOf<CharSequence>("")<!>)
mc.addAll(<!TYPE_MISMATCH!>listOf("")<!>)
mc.addAll(<!TYPE_MISMATCH!>listOf<String>("")<!>)
mc.addAll(<!TYPE_MISMATCH!>listOf<CharSequence>("")<!>)
mc.addAll(emptyList())
mc.addAll(emptyList<Nothing>())
compiler/testData/diagnostics/testsWithStdLib/annotations/annotationApplicability/suppressOnFunctionReference.kt
Vendored
+1 -1
View File
@@ -1,3 +1,3 @@
// See KT-15839
val x = "1".let(@<!DEBUG_INFO_MISSING_UNRESOLVED{NI}!>Suppress<!>("DEPRECATION") Integer::parseInt)
val x = "1".let(@<!DEBUG_INFO_MISSING_UNRESOLVED!>Suppress<!>("DEPRECATION") Integer::parseInt)
compiler/testData/diagnostics/testsWithStdLib/annotations/annotationWithVarargParameter/javaAnnotationWithVarargArgument.kt
Vendored
+1 -2
View File
@@ -1,10 +1,9 @@
// FILE: A.java
public @interface A {
String[] value();
}
// FILE: b.kt
@A(*<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>arrayOf(<!CONSTANT_EXPECTED_TYPE_MISMATCH{NI}!>1<!>, "b")<!>)
@A(*<!TYPE_MISMATCH!>arrayOf(<!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>, "b")<!>)
fun test() {
}
compiler/testData/diagnostics/testsWithStdLib/annotations/annotationWithVarargParameter/kotlinAnnotationWithVarargArgument.kt
Vendored
+1 -2
View File
@@ -1,6 +1,5 @@
annotation class B(vararg val args: String)
@B(*<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>arrayOf(<!CONSTANT_EXPECTED_TYPE_MISMATCH{NI}!>1<!>, "b")<!>)
@B(*<!TYPE_MISMATCH!>arrayOf(<!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>, "b")<!>)
fun test() {
}
compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassArrayInAnnotationsInVariance.kt
Vendored
+2 -3
View File
@@ -1,4 +1,3 @@
import kotlin.reflect.KClass
open class A
@@ -13,7 +12,7 @@ class MyClass1
@Ann1(arrayOf(Any::class))
class MyClass1a
@Ann1(<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>arrayOf(<!TYPE_MISMATCH{NI}!>B1::class<!>)<!>)
@Ann1(<!TYPE_MISMATCH, TYPE_MISMATCH!>arrayOf(<!TYPE_MISMATCH!>B1::class<!>)<!>)
class MyClass2
annotation class Ann2(val arg: Array<KClass<in B1>>)
@@ -24,5 +23,5 @@ class MyClass3
@Ann2(arrayOf(B1::class))
class MyClass4
@Ann2(<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>arrayOf(<!TYPE_MISMATCH{NI}!>B2::class<!>)<!>)
@Ann2(<!TYPE_MISMATCH, TYPE_MISMATCH!>arrayOf(<!TYPE_MISMATCH!>B2::class<!>)<!>)
class MyClass5
compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassArrayInAnnotationsOutVariance.kt
Vendored
+3 -3
View File
@@ -10,7 +10,7 @@ annotation class Ann1(val arg: Array<KClass<out A>>)
@Ann1(arrayOf(A::class))
class MyClass1
@Ann1(<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>arrayOf(<!TYPE_MISMATCH{NI}!>Any::class<!>)<!>)
@Ann1(<!TYPE_MISMATCH, TYPE_MISMATCH!>arrayOf(<!TYPE_MISMATCH!>Any::class<!>)<!>)
class MyClass1a
@Ann1(arrayOf(B1::class))
@@ -18,11 +18,11 @@ class MyClass2
annotation class Ann2(val arg: Array<KClass<out B1>>)
@Ann2(<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>arrayOf(<!TYPE_MISMATCH{NI}!>A::class<!>)<!>)
@Ann2(<!TYPE_MISMATCH, TYPE_MISMATCH!>arrayOf(<!TYPE_MISMATCH!>A::class<!>)<!>)
class MyClass3
@Ann2(arrayOf(B1::class))
class MyClass4
@Ann2(<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>arrayOf(<!TYPE_MISMATCH{NI}!>B2::class<!>)<!>)
@Ann2(<!TYPE_MISMATCH, TYPE_MISMATCH!>arrayOf(<!TYPE_MISMATCH!>B2::class<!>)<!>)
class MyClass5
compiler/testData/diagnostics/testsWithStdLib/assert/cast.kt
Vendored
+2 -2
View File
@@ -10,11 +10,11 @@ class B: A {
fun test1(a: A) {
assert((a as B).bool())
<!DEBUG_INFO_SMARTCAST{NI}!>a<!>.<!UNRESOLVED_REFERENCE{OI}!>bool<!>()
<!DEBUG_INFO_SMARTCAST!>a<!>.bool()
}
fun test2() {
val a: A? = null;
assert((a as B).bool())
<!DEBUG_INFO_SMARTCAST{NI}!>a<!><!UNNECESSARY_SAFE_CALL{NI}!>?.<!><!UNRESOLVED_REFERENCE{OI}!>bool<!>()
<!DEBUG_INFO_SMARTCAST!>a<!><!UNNECESSARY_SAFE_CALL!>?.<!>bool()
}
compiler/testData/diagnostics/testsWithStdLib/assert/safeCall.kt
Vendored
+6 -7
View File
@@ -4,34 +4,33 @@
fun test1(s: String?) {
assert(s!!.isEmpty())
s<!UNNECESSARY_SAFE_CALL{NI}!>?.<!>length
s<!UNNECESSARY_SAFE_CALL!>?.<!>length
}
fun test2(s: String?) {
assert(s!!.isEmpty())
s<!UNNECESSARY_NOT_NULL_ASSERTION{NI}!>!!<!>.length
s<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>.length
}
fun test3(s: String?) {
assert(s!!.isEmpty())
<!DEBUG_INFO_SMARTCAST{NI}!>s<!><!UNSAFE_CALL{OI}!>.<!>length
<!DEBUG_INFO_SMARTCAST!>s<!>.length
}
fun test4() {
val s: String? = null;
assert(s!!.isEmpty())
s<!UNNECESSARY_SAFE_CALL{NI}!>?.<!>length
s<!UNNECESSARY_SAFE_CALL!>?.<!>length
}
fun test5() {
val s: String? = null;
assert(s!!.isEmpty())
s<!UNNECESSARY_NOT_NULL_ASSERTION{NI}!>!!<!>.length
s<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>.length
}
fun test6() {
val s: String? = null;
assert(s!!.isEmpty())
<!DEBUG_INFO_SMARTCAST{NI}!>s<!><!UNSAFE_CALL{OI}!>.<!>length
<!DEBUG_INFO_SMARTCAST!>s<!>.length
}
compiler/testData/diagnostics/testsWithStdLib/commonCollections.kt
Vendored
+4 -5
View File
@@ -1,9 +1,8 @@
import java.util.*
fun foo() {
val al = ArrayList<String>()
al.size
al.<!TYPE_INFERENCE_ONLY_INPUT_TYPES{NI}!>contains<!>(<!CONSTANT_EXPECTED_TYPE_MISMATCH{OI}!>1<!>)
al.<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>contains<!>(1)
al.contains("")
al.remove("")
@@ -11,7 +10,7 @@ fun foo() {
val hs = HashSet<String>()
hs.size
hs.<!TYPE_INFERENCE_ONLY_INPUT_TYPES{NI}!>contains<!>(<!CONSTANT_EXPECTED_TYPE_MISMATCH{OI}!>1<!>)
hs.<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>contains<!>(1)
hs.contains("")
hs.remove("")
@@ -19,10 +18,10 @@ fun foo() {
val hm = HashMap<String, Int>()
hm.size
hm.<!TYPE_INFERENCE_ONLY_INPUT_TYPES{NI}!>containsKey<!>(<!CONSTANT_EXPECTED_TYPE_MISMATCH{OI}!>1<!>)
hm.<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>containsKey<!>(1)
hm.containsKey("")
<!TYPE_INFERENCE_ONLY_INPUT_TYPES{NI}!>hm[<!CONSTANT_EXPECTED_TYPE_MISMATCH{OI}!>1<!>]<!>
<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>hm[1]<!>
hm[""]
hm.remove("")
compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/externalArguments.kt
Vendored
+1 -1
View File
@@ -5,7 +5,7 @@ import kotlin.reflect.KProperty
fun testLambdaArgumentSmartCast(foo: Int?) {
val v = run {
if (foo != null)
return@run <!DEBUG_INFO_SMARTCAST{NI}!>foo<!>
return@run <!DEBUG_INFO_SMARTCAST!>foo<!>
15
}
}
compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/applyInsideCoroutine.kt
Vendored
+10 -10
View File
@@ -7,26 +7,26 @@ class Controller<T> {
fun <S> generate(g: suspend Controller<S>.() -> Unit): S = TODO()
val test1 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>generate<!> {
<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}!>apply<!> {
<!DEBUG_INFO_MISSING_UNRESOLVED{NI}!>yield<!>(4)
val test1 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>generate<!> {
<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>apply<!> {
<!DEBUG_INFO_MISSING_UNRESOLVED!>yield<!>(4)
}
}
val test2 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>generate<!> {
val test2 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>generate<!> {
yield(B)
<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}!>apply<!> {
<!DEBUG_INFO_MISSING_UNRESOLVED{NI}!>yield<!>(<!DEBUG_INFO_MISSING_UNRESOLVED{NI}!>C<!>)
<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>apply<!> {
<!DEBUG_INFO_MISSING_UNRESOLVED!>yield<!>(<!DEBUG_INFO_MISSING_UNRESOLVED!>C<!>)
}
}
val test3 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>generate<!> {
this.<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>let<!> {
val test3 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>generate<!> {
this.<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>let<!> {
yield(B)
}
<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}!>apply<!> {
<!DEBUG_INFO_MISSING_UNRESOLVED{NI}!>yield<!>(<!DEBUG_INFO_MISSING_UNRESOLVED{NI}!>C<!>)
<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>apply<!> {
<!DEBUG_INFO_MISSING_UNRESOLVED!>yield<!>(<!DEBUG_INFO_MISSING_UNRESOLVED!>C<!>)
}
}
compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/extensionWithNonValuableConstraints.kt
Vendored
+6 -6
View File
@@ -28,7 +28,7 @@ val test1 = generate {
baseExtension()
}
val test2 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>generate<!> {
val test2 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>generate<!> {
baseExtension()
}
@@ -37,22 +37,22 @@ val test3 = generate {
outNullableAnyExtension()
}
val test4 = <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>generate<!> {
val test4 = generate {
outNullableAnyExtension()
}
val test5 = <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>generate<!> {
val test5 = generate {
yield(42)
outAnyExtension()
}
val test6 = <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>generate<!> {
val test6 = generate {
yield("bar")
invNullableAnyExtension()
}
val test7 = <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>generate<!> {
yield(<!TYPE_MISMATCH{NI}!>"baz"<!>)
val test7 = generate {
yield(<!TYPE_MISMATCH!>"baz"<!>)
genericExtension<Int>()
}
compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/extensionsWithNonValuableConstraintsGenericBase.kt
Vendored
+3 -3
View File
@@ -27,11 +27,11 @@ val test1 = generate {
yield("foo")
}
val test2 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>generate<!> {
val test2 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>generate<!> {
starBase()
}
val test3 = <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>generate<!> {
val test3 = generate {
yield("bar")
stringBase()
}
@@ -46,6 +46,6 @@ val test5 = generateSpecific {
stringBase()
}
val test6 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>generateSpecific<!> {
val test6 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>generateSpecific<!> {
stringBase()
}
compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/incorrectCalls.kt
Vendored
+2 -2
View File
@@ -24,12 +24,12 @@ val test2 = generate {
notYield(3)
}
val test3 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>generate<!> {
val test3 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>generate<!> {
yield(3)
yieldBarReturnType(3)
}
val test4 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>generate<!> {
val test4 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>generate<!> {
yield(3)
barReturnType()
}
compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/inferCoroutineTypeInOldVersion.kt
Vendored
+2 -2
View File
@@ -16,11 +16,11 @@ val member = build {
add(42)
}
val memberWithoutAnn = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>wrongBuild<!> {
val memberWithoutAnn = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>wrongBuild<!> {
<!ILLEGAL_SUSPEND_FUNCTION_CALL!>add<!>(42)
}
val extension = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>build<!> {
val extension = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>build<!> {
extensionAdd("foo")
}
compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/kt36220.kt
Vendored
+2 -2
View File
@@ -12,8 +12,8 @@ class TypeDefinition<KotlinType : Any> {
fun <KotlinType : Any> defineType(@BuilderInference definition: TypeDefinition<KotlinType>.() -> Unit): Unit = TODO()
fun main() {
<!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>defineType<!> {
defineType {
parse { it.toInt() }
serialize { <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{OI}!>it<!>.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{OI}!>toString<!>() }
serialize { it.toString() }
}
}
compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/recursiveGenerators2.kt
Vendored
+2 -2
View File
@@ -15,9 +15,9 @@ fun <S> generate(@BuilderInference g: suspend GenericController<S>.() -> Unit):
@BuilderInference
suspend fun <S> GenericController<List<S>>.yieldGenerate(g: suspend GenericController<S>.() -> Unit): Unit = TODO()
val test1 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}!>generate<!> {
val test1 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>generate<!> {
// TODO: KT-15185
<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR{OI}, TYPE_MISMATCH{OI}!>yieldGenerate<!> {
<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>yieldGenerate<!> {
yield(4)
}
}
compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/resolveUsualCallWithBuilderInference.kt
Vendored
+2 -2
View File
@@ -23,11 +23,11 @@ val member = build {
add(42)
}
val memberWithoutAnn = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>wrongBuild<!> {
val memberWithoutAnn = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>wrongBuild<!> {
add(42)
}
val extension = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>build<!> {
val extension = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>build<!> {
extensionAdd("foo")
}
compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/suspendCallsWithErrors.kt
Vendored
+3 -3
View File
@@ -14,10 +14,10 @@ fun <S> generate(@BuilderInference g: suspend Controller<S>.() -> Unit): S = TOD
class A
val test1 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>generate<!> {
val test1 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>generate<!> {
yield(<!NO_COMPANION_OBJECT!>A<!>)
}
val test2: Int = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>generate {
yield(<!TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>A()<!>)
val test2: Int = <!TYPE_MISMATCH!>generate {
yield(<!TYPE_MISMATCH, TYPE_MISMATCH!>A()<!>)
}<!>
compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/suspendCallsWrongUpperBound.kt
Vendored
+1 -1
View File
@@ -7,6 +7,6 @@ class Controller<T : Number> {
fun <S : Number> generate(g: suspend Controller<S>.() -> Unit): S = TODO()
val test = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>generate<!> {
val test = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>generate<!> {
yield("foo")
}
compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/useInferenceInformationFromExtension.kt
Vendored
+1 -1
View File
@@ -23,7 +23,7 @@ val normal = generate {
yield(42)
}
val extension = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>generate<!> {
val extension = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>generate<!> {
extensionYield("foo")
}
compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/withUninferredParameter.kt
Vendored
+1 -1
View File
@@ -7,7 +7,7 @@ class GenericController<T> {
fun <S> generate(g: suspend GenericController<S>.(S) -> Unit): S = TODO()
val test1 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>generate<!> {
val test1 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>generate<!> {
yield(4)
}
compiler/testData/diagnostics/testsWithStdLib/coroutines/kt18292.kt
Vendored
+1 -1
View File
@@ -13,6 +13,6 @@ suspend fun fib(n: Long) =
async {
when {
n < 2 -> n
else -> <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!><!DEBUG_INFO_MISSING_UNRESOLVED!>fib<!>(<!DEBUG_INFO_MISSING_UNRESOLVED!>n<!> <!DEBUG_INFO_MISSING_UNRESOLVED!>-<!> 1)<!>.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{OI}, DEBUG_INFO_MISSING_UNRESOLVED{NI}!>await<!>() <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{OI}, DEBUG_INFO_MISSING_UNRESOLVED{NI}!>+<!> fib(n - 2).<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{OI}, DEBUG_INFO_MISSING_UNRESOLVED{NI}!>await<!>()
else -> <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!><!DEBUG_INFO_MISSING_UNRESOLVED!>fib<!>(<!DEBUG_INFO_MISSING_UNRESOLVED!>n<!> <!DEBUG_INFO_MISSING_UNRESOLVED!>-<!> 1)<!>.<!DEBUG_INFO_MISSING_UNRESOLVED!>await<!>() <!DEBUG_INFO_MISSING_UNRESOLVED!>+<!> fib(n - 2).<!DEBUG_INFO_MISSING_UNRESOLVED!>await<!>()
}
}
compiler/testData/diagnostics/testsWithStdLib/coroutines/lambdaExpectedType.kt
Vendored
+2 -2
View File
@@ -20,7 +20,7 @@ fun foo() {
builder { 1 }
val x = { 1 }
builder(<!TYPE_MISMATCH{OI}, UNSUPPORTED_FEATURE{NI}!>x<!>)
builder(<!UNSUPPORTED_FEATURE!>x<!>)
builder({1} <!UNCHECKED_CAST!>as (suspend () -> Int)<!>)
var i: Int = 1
@@ -31,7 +31,7 @@ fun foo() {
genericBuilder<Int> { <!TYPE_MISMATCH, TYPE_MISMATCH!>""<!> }
val y = { 1 }
<!TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR{OI}!>genericBuilder<!>(<!TYPE_MISMATCH{OI}, UNSUPPORTED_FEATURE{NI}!>y<!>)
genericBuilder(<!UNSUPPORTED_FEATURE!>y<!>)
unitBuilder {}
unitBuilder { 1 }
compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendCoroutineOrReturn.kt
Vendored
+1 -1
View File
@@ -18,7 +18,7 @@ class Controller {
suspend fun yieldString(value: String) = suspendCoroutineUninterceptedOrReturn<Int> {
it.resume(1)
it checkType { _<Continuation<Int>>() }
it.<!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}!>resume<!>(<!TYPE_MISMATCH{NI}!>""<!>)
it.resume(<!TYPE_MISMATCH!>""<!>)
// We can return anything here, 'suspendCoroutineUninterceptedOrReturn' is not very type-safe
// Also we can call resume and then return the value too, but it's still just our problem
compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendExternalFunctions.kt
Vendored
+1 -1
View File
@@ -35,7 +35,7 @@ fun test() {
severalParams("", 89) checkType { _<Double>() }
// TODO: should we allow somehow to call with passing continuation explicitly?
severalParams("", 89, <!TOO_MANY_ARGUMENTS!>6.9<!>) checkType { <!TYPE_MISMATCH{OI}, UNRESOLVED_REFERENCE_WRONG_RECEIVER{NI}!>_<!><Unit>() }
severalParams("", 89, <!TOO_MANY_ARGUMENTS!>6.9<!>) checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><Unit>() }
"".stringReceiver(1)
Any().anyReceiver(1)
compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctions.kt
Vendored
+2 -2
View File
@@ -36,7 +36,7 @@ fun test() {
severalParams("", 89) checkType { _<Double>() }
// TODO: should we allow somehow to call with passing continuation explicitly?
severalParams("", 89, <!TOO_MANY_ARGUMENTS!>6.9<!>) checkType { <!TYPE_MISMATCH{OI}, UNRESOLVED_REFERENCE_WRONG_RECEIVER{NI}!>_<!><Unit>() }
severalParams("", 89, <!TOO_MANY_ARGUMENTS!>this <!CAST_NEVER_SUCCEEDS!>as<!> Continuation<Double><!>) checkType { <!TYPE_MISMATCH{OI}, UNRESOLVED_REFERENCE_WRONG_RECEIVER{NI}!>_<!><Unit>() }
severalParams("", 89, <!TOO_MANY_ARGUMENTS!>6.9<!>) checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><Unit>() }
severalParams("", 89, <!TOO_MANY_ARGUMENTS!>this <!CAST_NEVER_SUCCEEDS!>as<!> Continuation<Double><!>) checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><Unit>() }
}
}
compiler/testData/diagnostics/testsWithStdLib/coroutines/tryCatchLambda.kt
Vendored
+2 -2
View File
@@ -7,10 +7,10 @@ fun <T> genericBuilder(c: suspend () -> T): T = null!!
fun foo() {
var result = ""
genericBuilder<String> {
<!TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>try {
<!TYPE_MISMATCH, TYPE_MISMATCH!>try {
await("")
} catch(e: Exception) {
<!EXPECTED_TYPE_MISMATCH{OI}!>result = "fail"<!>
result = "fail"
}<!>
}
}
compiler/testData/diagnostics/testsWithStdLib/elvisOnJavaList.kt
Vendored
+1 -2
View File
@@ -1,4 +1,3 @@
// FILE: P.java
import java.util.ArrayList;
@@ -14,5 +13,5 @@ public class P {
fun foo(c: P): MutableList<Int> {
// Error should be here: see KT-8168 Typechecker fails for platform collection type
return <!TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>c.getList() ?: <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{OI}!>listOf()<!><!>
return <!TYPE_MISMATCH, TYPE_MISMATCH!>c.getList() ?: listOf()<!>
}
compiler/testData/diagnostics/testsWithStdLib/implicitCastToAny.kt
Vendored
+4 -5
View File
@@ -1,24 +1,23 @@
var longWords = 0
val smallWords = hashSetOf<String>()
fun test1(word: String) =
run {
if (word.length > 4) {
<!IMPLICIT_CAST_TO_ANY{OI}!>longWords++<!>
longWords++
}
else {
<!IMPLICIT_CAST_TO_ANY{OI}!>smallWords.add(word)<!>
smallWords.add(word)
}
}
fun test2(word: String) =
run {
if (word.length > 4) {
<!INVALID_IF_AS_EXPRESSION!>if<!> (word.startsWith("a")) <!IMPLICIT_CAST_TO_ANY{OI}!>longWords++<!>
<!INVALID_IF_AS_EXPRESSION!>if<!> (word.startsWith("a")) longWords++
}
else {
<!IMPLICIT_CAST_TO_ANY{OI}!>smallWords.add(word)<!>
smallWords.add(word)
}
}
compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/exactAnnotation.kt
Vendored
+1 -1
View File
@@ -7,5 +7,5 @@ fun test1(l: List<Number>) {
val i: Int = l.firstTyped()
val s: String = <!TYPE_MISMATCH{NI}!>l.<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}!><!TYPE_MISMATCH{NI}!>firstTyped<!>()<!><!>
val s: String = <!TYPE_MISMATCH!>l.<!TYPE_MISMATCH!>firstTyped<!>()<!>
}
compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/kt26698.kt
Vendored
+2 -2
View File
@@ -16,6 +16,6 @@ fun <@kotlin.internal.OnlyInputTypes T : Base> fooB(a: T, b: T) {}
fun usage(x: CX, y: CY) {
<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>foo<!>(x, y) // expected err, got err
<!TYPE_INFERENCE_ONLY_INPUT_TYPES{NI}!>fooA<!>(x, y) // expected err, got ok
<!TYPE_INFERENCE_ONLY_INPUT_TYPES{NI}!>fooB<!>(x, y) // expected err, got ok
<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>fooA<!>(x, y) // expected err, got ok
<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>fooB<!>(x, y) // expected err, got ok
}
compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/kt29307.kt
Vendored
+2 -2
View File
@@ -2,7 +2,7 @@
// ISSUE: KT-29307
fun test_1(map: Map<String, String>) {
val x = <!TYPE_INFERENCE_ONLY_INPUT_TYPES{NI}!>map[<!CONSTANT_EXPECTED_TYPE_MISMATCH{OI}!>42<!>]<!> // OK
val x = <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>map[42]<!> // OK
}
open class A
@@ -10,7 +10,7 @@ open class A
class B : A()
fun test_2(map: Map<A, String>) {
val x = <!TYPE_INFERENCE_ONLY_INPUT_TYPES{NI}!>map[<!CONSTANT_EXPECTED_TYPE_MISMATCH{OI}!>42<!>]<!>
val x = <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>map[42]<!>
}
fun test_3(m: Map<*, String>) {
compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/noInferAndLowPriority.kt
Vendored
+1 -1
View File
@@ -10,6 +10,6 @@ public fun <T> Iterable<T>.contains1(element: @kotlin.internal.NoInfer T): Boole
fun test() {
val a: Boolean = listOf(1).<!TYPE_INFERENCE_INCORPORATION_ERROR{OI}!>contains1<!>(<!TYPE_MISMATCH!>""<!>)
val a: Boolean = listOf(1).contains1(<!TYPE_MISMATCH!>""<!>)
val b: Boolean = listOf(1).contains1(1)
}
compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/noInferAnnotation.kt
Vendored
+7 -7
View File
@@ -10,23 +10,23 @@ fun <T> @kotlin.internal.NoInfer T.test2(t1: T): T = t1
fun <T> test3(t1: @kotlin.internal.NoInfer T): T = t1
fun usage() {
<!TYPE_INFERENCE_INCORPORATION_ERROR{OI}!>test1<!>(1, <!TYPE_MISMATCH!>"312"<!>)
<!TYPE_MISMATCH{OI}!>1<!>.<!TYPE_INFERENCE_INCORPORATION_ERROR{OI}!>test2<!>("")
<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>test3<!>("")
test1(1, <!TYPE_MISMATCH!>"312"<!>)
1.test2("")
<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>test3<!>("")
}
@Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
fun <T> List<T>.contains1(e: @kotlin.internal.NoInfer T): Boolean = true
fun test(i: Int?, a: Any, l: List<Int>) {
l.<!TYPE_INFERENCE_INCORPORATION_ERROR{OI}!>contains1<!>(<!TYPE_MISMATCH!>a<!>)
l.<!TYPE_INFERENCE_INCORPORATION_ERROR{OI}!>contains1<!>(<!TYPE_MISMATCH!>""<!>)
l.<!TYPE_INFERENCE_INCORPORATION_ERROR{OI}!>contains1<!>(<!TYPE_MISMATCH!>i<!>)
l.contains1(<!TYPE_MISMATCH!>a<!>)
l.contains1(<!TYPE_MISMATCH!>""<!>)
l.contains1(<!TYPE_MISMATCH!>i<!>)
}
@Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
fun <T> assertEquals1(e1: T, e2: @kotlin.internal.NoInfer T): Boolean = true
fun test(s: String) {
<!TYPE_INFERENCE_INCORPORATION_ERROR{OI}!>assertEquals1<!>(s, <!CONSTANT_EXPECTED_TYPE_MISMATCH!>11<!>)
assertEquals1(s, <!CONSTANT_EXPECTED_TYPE_MISMATCH!>11<!>)
}
compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesAndLowPriority.kt
Vendored
+1 -1
View File
@@ -17,7 +17,7 @@ public fun <K, V> Map<K, V>.get1(key: Any?): Int = null!!
public fun <@kotlin.internal.OnlyInputTypes K, V> Map<out K, V>.get1(key: K): V? = null!!
fun test(map: Map<Int, String>) {
val a: Int = <!TYPE_MISMATCH{NI}!>listOf(1).<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!><!TYPE_INFERENCE_ONLY_INPUT_TYPES{NI}!>contains1<!>("")<!><!>
val a: Int = <!TYPE_MISMATCH!>listOf(1).<!TYPE_MISMATCH!><!TYPE_INFERENCE_ONLY_INPUT_TYPES!>contains1<!>("")<!><!>
val b: Boolean = listOf(1).contains1(1)
val c: String? = map.<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>get1<!>("")
compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesAndTopLevelCapturedTypes.kt
Vendored
+4 -4
View File
@@ -20,12 +20,12 @@ fun test(
invOut.onlyOut(42)
invOut.onlyOut(1L)
invOut.<!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}, TYPE_INFERENCE_ONLY_INPUT_TYPES{NI}!>onlyOutUB<!>(<!TYPE_MISMATCH{NI}!>"str"<!>)
invStar.<!TYPE_INFERENCE_UPPER_BOUND_VIOLATED{OI}, UNRESOLVED_REFERENCE_WRONG_RECEIVER{NI}!>onlyOutUB<!>(0)
invOut.<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>onlyOutUB<!>(<!TYPE_MISMATCH!>"str"<!>)
invStar.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>onlyOutUB<!>(0)
invOut.onlyOutUB(42)
invOut.onlyOutUB(1L)
invIn.<!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}!>onlyIn<!>(<!TYPE_MISMATCH{NI}!>"str"<!>)
invIn.onlyIn(<!TYPE_MISMATCH!>"str"<!>)
invIn.onlyIn(42)
invIn.onlyIn(1L)
}
@@ -65,7 +65,7 @@ class Test5 {
set(value) {
if (value != null) {
val a = a
require(a != null && <!DEBUG_INFO_SMARTCAST!>value<!> in <!DEBUG_INFO_SMARTCAST{OI}!>a<!>.children)
require(a != null && <!DEBUG_INFO_SMARTCAST!>value<!> in a.children)
}
field = value
}
compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesCaptured.kt
Vendored
+3 -3
View File
@@ -16,7 +16,7 @@ class Out<out T>
// -------------------------------------------------------
fun test_0(x: Inv2<in Number, out Number>, list: List<Inv2<Any, Int>>) {
list.<!TYPE_INFERENCE_ONLY_INPUT_TYPES{NI}!>foo<!>(x)
list.<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>foo<!>(x)
}
// ------------------------- Inv -------------------------
@@ -34,11 +34,11 @@ fun test_3(x: Inv<Number>, list: List<Inv<Any>>) {
}
fun test_4(x: Inv<in Number>, list: List<Inv<Any>>) {
list.<!TYPE_INFERENCE_ONLY_INPUT_TYPES{NI}!>contains1<!>(x)
list.<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>contains1<!>(x)
}
fun test_5(x: Inv<in Number>, list: List<Inv<Number>>) {
list.<!TYPE_INFERENCE_ONLY_INPUT_TYPES{NI}!>contains1<!>(x)
list.<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>contains1<!>(x)
}
fun test_6(x: Inv<in Number>, list: List<Inv<Int>>) {
compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesUpperBound.kt
Vendored
+1 -1
View File
@@ -5,7 +5,7 @@
class Inv<T>
class Out<out T>
fun <T> foo(i: Inv<in T>, o: Out<T>) {
<!TYPE_INFERENCE_ONLY_INPUT_TYPES{NI}!>bar<!>(i, o)
<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>bar<!>(i, o)
}
fun <@kotlin.internal.OnlyInputTypes K> bar(r: Inv<out K>, o: Out<K>): K = TODO()
compiler/testData/diagnostics/testsWithStdLib/inference/kt27772.kt
Vendored
+1 -2
View File
@@ -1,6 +1,5 @@
fun <T> foo(resources: List<T>) {
resources.map { runCatching { it } }.<!TYPE_INFERENCE_UPPER_BOUND_VIOLATED{OI}!>mapNotNull<!> { it.getOrNull() }
resources.map { runCatching { it } }.mapNotNull { it.getOrNull() }
}
fun <T: Any> bar(resources: List<T>) {
compiler/testData/diagnostics/testsWithStdLib/java/concurrentHashMapContains.kt
Vendored
+8 -8
View File
@@ -28,8 +28,8 @@ fun main() {
"" in (hm as Map<String, Int>)
"" !in (hm as Map<String, Int>)
1 <!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}, TYPE_INFERENCE_ONLY_INPUT_TYPES{NI}!>in<!> (hm as Map<String, Int>)
1 <!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}, TYPE_INFERENCE_ONLY_INPUT_TYPES{NI}!>!in<!> (hm as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>in<!> (hm as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>!in<!> (hm as Map<String, Int>)
val a = A()
"" <!CONCURRENT_HASH_MAP_CONTAINS_OPERATOR!>in<!> a
@@ -44,8 +44,8 @@ fun main() {
"" in (a as Map<String, Int>)
"" !in (a as Map<String, Int>)
1 <!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}, TYPE_INFERENCE_ONLY_INPUT_TYPES{NI}!>in<!> (a as Map<String, Int>)
1 <!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}, TYPE_INFERENCE_ONLY_INPUT_TYPES{NI}!>!in<!> (a as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>in<!> (a as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>!in<!> (a as Map<String, Int>)
val b = B()
"" <!CONCURRENT_HASH_MAP_CONTAINS_OPERATOR!>in<!> b
@@ -58,8 +58,8 @@ fun main() {
"" in (b as Map<String, Int>)
"" !in (b as Map<String, Int>)
1 <!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}, TYPE_INFERENCE_ONLY_INPUT_TYPES{NI}!>in<!> (b as Map<String, Int>)
1 <!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}, TYPE_INFERENCE_ONLY_INPUT_TYPES{NI}!>!in<!> (b as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>in<!> (b as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>!in<!> (b as Map<String, Int>)
// Actually, we could've allow calls here because the owner explicitly declared as operator, but semantics is still weird
val c = C()
@@ -73,6 +73,6 @@ fun main() {
"" in (c as Map<String, Int>)
"" !in (c as Map<String, Int>)
1 <!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}, TYPE_INFERENCE_ONLY_INPUT_TYPES{NI}!>in<!> (c as Map<String, Int>)
1 <!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}, TYPE_INFERENCE_ONLY_INPUT_TYPES{NI}!>!in<!> (c as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>in<!> (c as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>!in<!> (c as Map<String, Int>)
}
compiler/testData/diagnostics/testsWithStdLib/java/concurrentHashMapContainsError.kt
Vendored
+8 -8
View File
@@ -28,8 +28,8 @@ fun main() {
"" in (hm as Map<String, Int>)
"" !in (hm as Map<String, Int>)
1 <!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}, TYPE_INFERENCE_ONLY_INPUT_TYPES{NI}!>in<!> (hm as Map<String, Int>)
1 <!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}, TYPE_INFERENCE_ONLY_INPUT_TYPES{NI}!>!in<!> (hm as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>in<!> (hm as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>!in<!> (hm as Map<String, Int>)
val a = A()
"" <!CONCURRENT_HASH_MAP_CONTAINS_OPERATOR_ERROR!>in<!> a
@@ -44,8 +44,8 @@ fun main() {
"" in (a as Map<String, Int>)
"" !in (a as Map<String, Int>)
1 <!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}, TYPE_INFERENCE_ONLY_INPUT_TYPES{NI}!>in<!> (a as Map<String, Int>)
1 <!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}, TYPE_INFERENCE_ONLY_INPUT_TYPES{NI}!>!in<!> (a as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>in<!> (a as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>!in<!> (a as Map<String, Int>)
val b = B()
"" <!CONCURRENT_HASH_MAP_CONTAINS_OPERATOR_ERROR!>in<!> b
@@ -58,8 +58,8 @@ fun main() {
"" in (b as Map<String, Int>)
"" !in (b as Map<String, Int>)
1 <!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}, TYPE_INFERENCE_ONLY_INPUT_TYPES{NI}!>in<!> (b as Map<String, Int>)
1 <!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}, TYPE_INFERENCE_ONLY_INPUT_TYPES{NI}!>!in<!> (b as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>in<!> (b as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>!in<!> (b as Map<String, Int>)
// Actually, we could've allow calls here because the owner explicitly declared as operator, but semantics is still weird
val c = C()
@@ -73,6 +73,6 @@ fun main() {
"" in (c as Map<String, Int>)
"" !in (c as Map<String, Int>)
1 <!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}, TYPE_INFERENCE_ONLY_INPUT_TYPES{NI}!>in<!> (c as Map<String, Int>)
1 <!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}, TYPE_INFERENCE_ONLY_INPUT_TYPES{NI}!>!in<!> (c as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>in<!> (c as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>!in<!> (c as Map<String, Int>)
}
compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/maps.kt
Vendored
+9 -9
View File
@@ -14,9 +14,9 @@ fun hashMapTest() {
x.put(<!TYPE_MISMATCH!>bar()<!>, 1)
x.put("", 1)
<!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}!>x[<!NULL_FOR_NONNULL_TYPE{NI}!>null<!>]<!> = 1
<!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}!>x[<!TYPE_MISMATCH{NI}!>bar()<!>]<!> = 1
<!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}!>x[""]<!> = <!TYPE_MISMATCH{NI}!>nullableInt<!>
x[<!NULL_FOR_NONNULL_TYPE!>null<!>] = 1
x[<!TYPE_MISMATCH!>bar()<!>] = 1
x[""] = <!TYPE_MISMATCH!>nullableInt<!>
x[""] = 1
val b1: MutableMap<String, Int?> = <!TYPE_MISMATCH!>x<!>
@@ -38,9 +38,9 @@ fun treeMapTest() {
x.put(<!TYPE_MISMATCH!>bar()<!>, 1)
x.put("", 1)
<!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}!>x[<!NULL_FOR_NONNULL_TYPE{NI}!>null<!>]<!> = 1
<!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}!>x[<!TYPE_MISMATCH{NI}!>bar()<!>]<!> = 1
<!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}!>x[""]<!> = <!TYPE_MISMATCH{NI}!>nullableInt<!>
x[<!NULL_FOR_NONNULL_TYPE!>null<!>] = 1
x[<!TYPE_MISMATCH!>bar()<!>] = 1
x[""] = <!TYPE_MISMATCH!>nullableInt<!>
x[""] = 1
val b1: MutableMap<String, Int?> = <!TYPE_MISMATCH!>x<!>
@@ -62,9 +62,9 @@ fun concurrentHashMapTest() {
x.put(<!TYPE_MISMATCH!>bar()<!>, 1)
x.put("", 1)
<!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}!>x[<!NULL_FOR_NONNULL_TYPE{NI}!>null<!>]<!> = 1
<!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}!>x[<!TYPE_MISMATCH{NI}!>bar()<!>]<!> = 1
<!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}!>x[""]<!> = <!TYPE_MISMATCH{NI}!>nullableInt<!>
x[<!NULL_FOR_NONNULL_TYPE!>null<!>] = 1
x[<!TYPE_MISMATCH!>bar()<!>] = 1
x[""] = <!TYPE_MISMATCH!>nullableInt<!>
x[""] = 1
val b1: MutableMap<String, Int?> = <!TYPE_MISMATCH!>x<!>
compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/mapsWithNullableKey.kt
Vendored
+2 -2
View File
@@ -15,7 +15,7 @@ fun hashMapTest() {
x[null] = 1
x[bar()] = 1
<!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}!>x[""]<!> = <!TYPE_MISMATCH{NI}!>nullableInt<!>
x[""] = <!TYPE_MISMATCH!>nullableInt<!>
x[""] = 1
val b1: MutableMap<String?, Int?> = <!TYPE_MISMATCH!>x<!>
@@ -40,7 +40,7 @@ fun treeMapTest() {
x[null] = 1
x[bar()] = 1
<!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}!>x[""]<!> = <!TYPE_MISMATCH{NI}!>nullableInt<!>
x[""] = <!TYPE_MISMATCH!>nullableInt<!>
x[""] = 1
val b1: MutableMap<String?, Int?> = <!TYPE_MISMATCH!>x<!>
compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/mapsWithNullableValues.kt
Vendored
+4 -4
View File
@@ -13,8 +13,8 @@ fun hashMapTest() {
x.put(<!TYPE_MISMATCH!>bar()<!>, 1)
x.put("", 1)
<!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}!>x[<!NULL_FOR_NONNULL_TYPE{NI}!>null<!>]<!> = 1
<!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}!>x[<!TYPE_MISMATCH{NI}!>bar()<!>]<!> = 1
x[<!NULL_FOR_NONNULL_TYPE!>null<!>] = 1
x[<!TYPE_MISMATCH!>bar()<!>] = 1
x[""] = nullableInt
x[""] = 1
@@ -37,8 +37,8 @@ fun treeMapTest() {
x.put(<!TYPE_MISMATCH!>bar()<!>, 1)
x.put("", 1)
<!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}!>x[<!NULL_FOR_NONNULL_TYPE{NI}!>null<!>]<!> = 1
<!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}!>x[<!TYPE_MISMATCH{NI}!>bar()<!>]<!> = 1
x[<!NULL_FOR_NONNULL_TYPE!>null<!>] = 1
x[<!TYPE_MISMATCH!>bar()<!>] = 1
x[""] = nullableInt
x[""] = 1
compiler/testData/diagnostics/testsWithStdLib/regression/kt9820_javaFunctionTypeInheritor.kt
Vendored
+1 -2
View File
@@ -1,4 +1,3 @@
// FILE: J.java
import kotlin.jvm.functions.Function1;
@@ -13,5 +12,5 @@ fun useJ(j: J) {
}
fun jj() {
useJ(<!TYPE_MISMATCH!>{<!TYPE_MISMATCH{NI}!><!>}<!>)
useJ(<!TYPE_MISMATCH!>{<!TYPE_MISMATCH!><!>}<!>)
}
compiler/testData/diagnostics/testsWithStdLib/resolve/kt4711.kt
Vendored
+3 -3
View File
@@ -6,15 +6,15 @@ fun main() {
val startTimeNanos = System.nanoTime()
// the problem sits on the next line:
val pi = 4.0.toDouble() * delta <!OVERLOAD_RESOLUTION_AMBIGUITY{OI}!>*<!> (1..n).<!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}!>reduce<!>(
val pi = 4.0.toDouble() * delta * (1..n).reduce(
{t, i ->
val x = (i - 0.5) * delta
<!TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>t + 1.0 / (1.0 + x * x)<!>
<!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>t + 1.0 / (1.0 + x * x)<!>
})
// !!! pi has error type here
val elapseTime = (System.nanoTime() - startTimeNanos) / 1e9
println("pi_sequential_reduce $<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{OI}!>pi<!> $n $elapseTime")
println("pi_sequential_reduce $pi $n $elapseTime")
}
compiler/testData/diagnostics/testsWithStdLib/targetedBuiltIns/unsupportedFeature.kt
Vendored
+1 -1
View File
@@ -27,7 +27,7 @@ interface A2 : List<String> {
<!NOTHING_TO_OVERRIDE!>override<!> fun stream(): java.util.stream.Stream<String> = null!!
}
class B : <!NONE_APPLICABLE{OI}!>Throwable<!>(<!TOO_MANY_ARGUMENTS{NI}!>""<!>, <!TOO_MANY_ARGUMENTS{NI}!>null<!>, <!TOO_MANY_ARGUMENTS{NI}!>false<!>, <!TOO_MANY_ARGUMENTS{NI}!>false<!>)
class B : Throwable(<!TOO_MANY_ARGUMENTS!>""<!>, <!TOO_MANY_ARGUMENTS!>null<!>, <!TOO_MANY_ARGUMENTS!>false<!>, <!TOO_MANY_ARGUMENTS!>false<!>)
class B1 : RuntimeException() {
<!NOTHING_TO_OVERRIDE!>override<!> fun fillInStackTrace(): Throwable { // 'override' keyword must be prohibited, as it was in 1.0.x
compiler/testData/diagnostics/testsWithStdLib/tryCatch/assignTry.kt
Vendored
+2 -2
View File
@@ -11,8 +11,8 @@ fun test2() {
catch (e: ExcA) {
null
}
catch (e: ExcB) <!TYPE_MISMATCH{NI}!>{
<!CONSTANT_EXPECTED_TYPE_MISMATCH{OI}!>10<!>
catch (e: ExcB) <!TYPE_MISMATCH!>{
10
}<!>
s<!UNSAFE_CALL!>.<!>length
}
compiler/testData/diagnostics/testsWithStdLib/tryCatch/falseNegativeSmartcasts_after.kt
Vendored
+1 -1
View File
@@ -13,7 +13,7 @@ fun test1(s1: String?) {
return
}
finally {
<!DEBUG_INFO_SMARTCAST{OI}!>s<!><!UNSAFE_CALL{NI}!>.<!>length
s<!UNSAFE_CALL!>.<!>length
}
<!DEBUG_INFO_SMARTCAST!>s<!>.length
}
compiler/testData/diagnostics/testsWithStdLib/tryCatch/falsePositiveSmartcasts_after.kt
Vendored
+12 -12
View File
@@ -13,15 +13,15 @@ fun test1() {
try {
x = null
} catch (e: Exception) {
<!DEBUG_INFO_SMARTCAST{OI}!>x<!><!UNSAFE_CALL{NI}!>.<!>length // smartcast shouldn't be allowed (OOME could happen after `x = null`)
x<!UNSAFE_CALL!>.<!>length // smartcast shouldn't be allowed (OOME could happen after `x = null`)
throw e
}
finally {
// smartcast shouldn't be allowed, `x = null` could've happened
<!DEBUG_INFO_SMARTCAST{OI}!>x<!><!UNSAFE_CALL{NI}!>.<!>length
x<!UNSAFE_CALL!>.<!>length
}
// smartcast shouldn't be allowed, `x = null` could've happened
<!DEBUG_INFO_SMARTCAST{OI}!>x<!><!UNSAFE_CALL{NI}!>.<!>length
x<!UNSAFE_CALL!>.<!>length
}
// With old DFA of try/catch info about unsound smartcasts after try
@@ -34,7 +34,7 @@ fun test2() {
x = null
} catch (e: Exception) {
// BAD
<!DEBUG_INFO_SMARTCAST{OI}!>x<!><!UNSAFE_CALL{NI}!>.<!>length
x<!UNSAFE_CALL!>.<!>length
}
finally {
x<!UNSAFE_CALL!>.<!>length
@@ -50,7 +50,7 @@ fun test3() {
} catch (e: Exception) {
t2 = null
}
<!DEBUG_INFO_SMARTCAST{OI}!>t2<!><!UNSAFE_CALL{NI}!>.<!>not() // wrong smartcast, NPE
t2<!UNSAFE_CALL!>.<!>not() // wrong smartcast, NPE
}
}
@@ -60,7 +60,7 @@ fun test4() {
try {
t2 = null
} finally { }
<!DEBUG_INFO_SMARTCAST{OI}!>t2<!><!UNSAFE_CALL{NI}!>.<!>not() // wrong smartcast, NPE
t2<!UNSAFE_CALL!>.<!>not() // wrong smartcast, NPE
}
}
@@ -80,10 +80,10 @@ fun test5() {
return
}
finally {
<!DEBUG_INFO_SMARTCAST{OI}!>s1<!><!UNSAFE_CALL{NI}!>.<!>length
<!DEBUG_INFO_SMARTCAST{OI}!>s2<!><!UNSAFE_CALL{NI}!>.<!>length
s1<!UNSAFE_CALL!>.<!>length
s2<!UNSAFE_CALL!>.<!>length
}
<!DEBUG_INFO_SMARTCAST{OI}!>s1<!><!UNSAFE_CALL{NI}!>.<!>length
s1<!UNSAFE_CALL!>.<!>length
<!DEBUG_INFO_SMARTCAST!>s2<!>.length
}
@@ -98,10 +98,10 @@ fun test6(s1: String?, s2: String?) {
return
}
finally {
<!DEBUG_INFO_SMARTCAST{OI}!>s<!><!UNSAFE_CALL{NI}!>.<!>length
s<!UNSAFE_CALL!>.<!>length
requireNotNull(s2)
}
<!DEBUG_INFO_SMARTCAST{OI}!>s<!><!UNSAFE_CALL{NI}!>.<!>length
<!DEBUG_INFO_SMARTCAST{NI}!>s1<!><!UNSAFE_CALL{OI}!>.<!>length
s<!UNSAFE_CALL!>.<!>length
<!DEBUG_INFO_SMARTCAST!>s1<!>.length
<!DEBUG_INFO_SMARTCAST!>s2<!>.length
}
compiler/testData/diagnostics/testsWithStdLib/tryCatch/tryExpression.kt
Vendored
+2 -2
View File
@@ -26,9 +26,9 @@ fun test1(): Map<Int, Int> = run {
}
fun test2(): Map<Int, Int> = run {
<!TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>try {
<!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>try {
emptyMap()
} catch (e: ExcA) {
<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>mapOf(<!TYPE_MISMATCH{NI}!>"" to ""<!>)<!>
<!TYPE_MISMATCH!>mapOf(<!TYPE_MISMATCH!>"" to ""<!>)<!>
}<!>
}
compiler/testData/diagnostics/testsWithStdLib/when/noTypeArgumentsInConstructor.kt
Vendored
+2 -3
View File
@@ -1,4 +1,3 @@
import java.util.*
fun <T> nullable(x: T): T? = x
@@ -27,9 +26,9 @@ val test4: Collection<Int> =
}
val test5: Collection<Int> =
listOf(1, 2, 3).<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}!>flatMapTo(<!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>LinkedHashSet<!>()) { // TODO
listOf(1, 2, 3).flatMapTo(LinkedHashSet()) { // TODO
if (true) listOf(it) else listOf(it)
}<!>
}
val test6: Collection<Int> =
listOf(1, 2, 3).flatMapTo(LinkedHashSet<Int>()) {