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

Update tests after rebase

Browse Source
This commit is contained in:
Victor Petukhov
2021-05-28 11:31:52 +03:00
parent f4788b479c
commit 54b9f39b3a
55 changed files with 266 additions and 262 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/testData/codegen/box/inference/builderInference/callableReferencesProperCompletion.kt
Vendored
-1
View File
@@ -1,6 +1,5 @@
// DONT_TARGET_EXACT_BACKEND: WASM
// WITH_RUNTIME
// IGNORE_BACKEND_FIR: JVM_IR
fun nonGenericId(x: Any?) = x
compiler/testData/codegen/box/inference/builderInference/specialCallsWithCallableReferencesNonStrictOnlyInputTypes.kt
Vendored
+1 -1
View File
@@ -9,7 +9,7 @@ import kotlin.experimental.ExperimentalTypeInference
@OptIn(ExperimentalTypeInference::class)
fun <R> scopedFlow(@BuilderInference block: suspend CoroutineScope.(FlowCollector<R>) -> Unit): Flow<R> =
flow {
val collector = <!DEBUG_INFO_EXPRESSION_TYPE("")!>this<!>
val collector = this
flowScope { block(collector) }
}
compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/misc/returnType.fir.kt
Vendored
+2 -2
View File
@@ -36,7 +36,7 @@ fun <R> main(a: ReturnType<R>) {
takeNotNullStringAndKNullable(<!TYPE_MISMATCH!>x1<!>)
takeNullableStringAndKNullable(x1)
takeNotNullStringAndNotNullK(<!TYPE_MISMATCH!>x1<!>)
takeNullableStringAndNotNullK(<!TYPE_MISMATCH, TYPE_MISMATCH!>x1<!>)
takeNullableStringAndNotNullK(<!TYPE_MISMATCH!>x1<!>)
takeNotNullString(<!TYPE_MISMATCH!>a.foo41.foo411<!>)
val x2 = a.foo2()
@@ -60,6 +60,6 @@ fun <R> main(a: ReturnType<R>) {
val x5 = a.foo5()
takeArrayOfNotNullString(<!TYPE_MISMATCH!>x5<!>)
takeArrayOfNullableString(x5)
takeArrayOfNotNullK(<!TYPE_MISMATCH, TYPE_MISMATCH!>x5<!>)
takeArrayOfNotNullK(<!TYPE_MISMATCH!>x5<!>)
takeArrayOfNullableK(x5)
}
compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/misc/returnTypeWithWarnings.fir.kt
Vendored
+7 -7
View File
@@ -37,26 +37,26 @@ fun <R> main(a: ReturnTypeWithWarnings<R>) {
val x1 = a.foo1()
takeNotNullStringAndKNullable(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>x1<!>)
takeNullableStringAndKNullable(x1)
takeNotNullStringAndNotNullK(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS, TYPE_MISMATCH, TYPE_MISMATCH!>x1<!>)
takeNullableStringAndNotNullK(<!TYPE_MISMATCH, TYPE_MISMATCH!>x1<!>)
takeNotNullStringAndNotNullK(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS, TYPE_MISMATCH!>x1<!>)
takeNullableStringAndNotNullK(<!TYPE_MISMATCH!>x1<!>)
takeNotNullString(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>a.foo41.foo411<!>)
val x2 = a.foo2()
takeNotNullStringAndKNullable(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>x2<!>)
takeNullableStringAndKNullable(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>x2<!>)
takeNotNullStringAndNotNullK(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS, TYPE_MISMATCH, TYPE_MISMATCH!>x2<!>)
takeNullableStringAndNotNullK(<!TYPE_MISMATCH, TYPE_MISMATCH!>x2<!>)
takeNotNullStringAndNotNullK(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS, TYPE_MISMATCH!>x2<!>)
takeNullableStringAndNotNullK(<!TYPE_MISMATCH!>x2<!>)
val x3 = a.foo3
takeNotNullStringAndKNullable(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>x3<!>)
takeNullableStringAndKNullable(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>x3<!>)
takeNotNullStringAndNotNullK(<!TYPE_MISMATCH, TYPE_MISMATCH!>x3<!>)
takeNullableStringAndNotNullK(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS, TYPE_MISMATCH, TYPE_MISMATCH!>x3<!>)
takeNotNullStringAndNotNullK(<!TYPE_MISMATCH!>x3<!>)
takeNullableStringAndNotNullK(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS, TYPE_MISMATCH!>x3<!>)
val x4 = a.foo4
takeArrayOfNotNullString(<!TYPE_MISMATCH!>x4<!>)
takeArrayOfNullableString(<!TYPE_MISMATCH!>x4<!>)
takeArrayOfNotNullK(<!TYPE_MISMATCH, TYPE_MISMATCH!>x4<!>)
takeArrayOfNotNullK(<!TYPE_MISMATCH!>x4<!>)
takeArrayOfNullableK(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>x4<!>)
val x5 = a.foo5()
compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/misc/returnTypeWithWarnings.kt
Vendored
+8 -8
View File
@@ -37,21 +37,21 @@ fun <R> main(a: ReturnTypeWithWarnings<R>) {
val x1 = <!DEBUG_INFO_EXPRESSION_TYPE("(ReturnTypeWithWarnings.A<(@org.jetbrains.annotations.Nullable kotlin.String..@org.jetbrains.annotations.Nullable kotlin.String?), (@org.jetbrains.annotations.Nullable R..@org.jetbrains.annotations.Nullable R?)>..ReturnTypeWithWarnings.A<(@org.jetbrains.annotations.Nullable kotlin.String..@org.jetbrains.annotations.Nullable kotlin.String?), (@org.jetbrains.annotations.Nullable R..@org.jetbrains.annotations.Nullable R?)>?)")!>a.foo1()<!>
takeNotNullStringAndKNullable(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS("ReturnTypeWithWarnings.A<String, R?>; ReturnTypeWithWarnings.A<String?, R?>!")!>x1<!>)
takeNullableStringAndKNullable(x1)
takeNotNullStringAndNotNullK(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS("ReturnTypeWithWarnings.A<String, R?>", "ReturnTypeWithWarnings.A<String?, R?>!"), TYPE_MISMATCH("Any", "R!")!>x1<!>)
takeNotNullStringAndNotNullK(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS("ReturnTypeWithWarnings.A<String, R?>; ReturnTypeWithWarnings.A<String?, R?>!"), TYPE_MISMATCH("Any; R!")!>x1<!>)
takeNullableStringAndNotNullK(<!TYPE_MISMATCH!>x1<!>)
takeNotNullString(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS("String", "String?")!>a.foo41.foo411<!>)
takeNotNullString(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS("String; String?")!>a.foo41.foo411<!>)
val x2 = <!DEBUG_INFO_EXPRESSION_TYPE("(ReturnTypeWithWarnings.A<(@org.jetbrains.annotations.Nullable kotlin.String..@org.jetbrains.annotations.Nullable kotlin.String?), (@org.jetbrains.annotations.NotNull R..@org.jetbrains.annotations.NotNull R?)>..ReturnTypeWithWarnings.A<(@org.jetbrains.annotations.Nullable kotlin.String..@org.jetbrains.annotations.Nullable kotlin.String?), (@org.jetbrains.annotations.NotNull R..@org.jetbrains.annotations.NotNull R?)>?)")!>a.foo2()<!>
takeNotNullStringAndKNullable(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS("ReturnTypeWithWarnings.A<String, R?>", "ReturnTypeWithWarnings.A<String?, R!!>!")!>x2<!>)
takeNullableStringAndKNullable(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS("ReturnTypeWithWarnings.A<String?, R?>", "ReturnTypeWithWarnings.A<String?, R!!>!")!>x2<!>)
takeNotNullStringAndNotNullK(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS("ReturnTypeWithWarnings.A<String, R!!>", "ReturnTypeWithWarnings.A<String?, R!!>!"), TYPE_MISMATCH("Any", "R!")!>x2<!>)
takeNotNullStringAndKNullable(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS("ReturnTypeWithWarnings.A<String, R?>; ReturnTypeWithWarnings.A<String?, R!!>!")!>x2<!>)
takeNullableStringAndKNullable(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS("ReturnTypeWithWarnings.A<String?, R?>; ReturnTypeWithWarnings.A<String?, R!!>!")!>x2<!>)
takeNotNullStringAndNotNullK(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS("ReturnTypeWithWarnings.A<String, R!!>; ReturnTypeWithWarnings.A<String?, R!!>!"), TYPE_MISMATCH("Any; R!")!>x2<!>)
takeNullableStringAndNotNullK(<!TYPE_MISMATCH!>x2<!>)
val x3 = <!DEBUG_INFO_EXPRESSION_TYPE("(ReturnTypeWithWarnings.A<(@org.jetbrains.annotations.NotNull kotlin.String..@org.jetbrains.annotations.NotNull kotlin.String?), (@org.jetbrains.annotations.NotNull R..@org.jetbrains.annotations.NotNull R?)>..ReturnTypeWithWarnings.A<(@org.jetbrains.annotations.NotNull kotlin.String..@org.jetbrains.annotations.NotNull kotlin.String?), (@org.jetbrains.annotations.NotNull R..@org.jetbrains.annotations.NotNull R?)>?)")!>a.foo3<!>
takeNotNullStringAndKNullable(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS("ReturnTypeWithWarnings.A<String, R?>", "ReturnTypeWithWarnings.A<String, R!!>!")!>x3<!>)
takeNullableStringAndKNullable(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS("ReturnTypeWithWarnings.A<String?, R?>", "ReturnTypeWithWarnings.A<String, R!!>!")!>x3<!>)
takeNotNullStringAndKNullable(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS("ReturnTypeWithWarnings.A<String, R?>; ReturnTypeWithWarnings.A<String, R!!>!")!>x3<!>)
takeNullableStringAndKNullable(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS("ReturnTypeWithWarnings.A<String?, R?>; ReturnTypeWithWarnings.A<String, R!!>!")!>x3<!>)
takeNotNullStringAndNotNullK(<!TYPE_MISMATCH!>x3<!>)
takeNullableStringAndNotNullK(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS("ReturnTypeWithWarnings.A<String?, R!!>", "ReturnTypeWithWarnings.A<String, R!!>!"), TYPE_MISMATCH("Any", "R!")!>x3<!>)
takeNullableStringAndNotNullK(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS("ReturnTypeWithWarnings.A<String?, R!!>; ReturnTypeWithWarnings.A<String, R!!>!"), TYPE_MISMATCH("Any; R!")!>x3<!>)
val x4 = <!DEBUG_INFO_EXPRESSION_TYPE("(kotlin.Array<(@org.jetbrains.annotations.NotNull R..@org.jetbrains.annotations.NotNull R?)>..kotlin.Array<out (@org.jetbrains.annotations.NotNull R..@org.jetbrains.annotations.NotNull R?)>)")!>a.foo4<!>
takeArrayOfNotNullString(<!TYPE_MISMATCH!>x4<!>)
compiler/testData/diagnostics/tests/ResolveToJava.kt
Vendored
+1 -1
View File
@@ -21,7 +21,7 @@ fun test(l : <!PLATFORM_CLASS_MAPPED_TO_KOTLIN!>java.util.List<Int><!>) {
val f : java.io.File? = null
Collections.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{OI}, FUNCTION_CALL_EXPECTED, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>emptyList<!>
Collections.<!FUNCTION_CALL_EXPECTED, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>emptyList<!>
Collections.<!FUNCTION_CALL_EXPECTED!>emptyList<Int><!>
Collections.emptyList<Int>()
Collections.<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>emptyList<!>()
compiler/testData/diagnostics/tests/annotations/annotationRenderingInTypes.kt
Vendored
+1 -1
View File
@@ -12,7 +12,7 @@ annotation class Ann
fun <@Ann R : @Ann Any> f3(a: Array<@Ann R>): Array<@Ann R?> = null!!
fun test2(a: @Ann Array<in @Ann Int>) {
val r: Array<in Int?> = f3(<!TYPE_MISMATCH("Any; Int"), TYPE_MISMATCH("Any; Int")!>a<!>)
val r: Array<in Int?> = f3(<!TYPE_MISMATCH("Any; Int")!>a<!>)
}
compiler/testData/diagnostics/tests/callableReference/generic/explicitTypeArguments.kt
Vendored
+2 -3
View File
@@ -1,4 +1,3 @@
// !WITH_NEW_INFERENCE
// !DIAGNOSTICS: -UNUSED_VARIABLE, -UNUSED_PARAMETER
fun <T> takeFun(f: (T) -> Unit) {}
@@ -14,12 +13,12 @@ fun <T> Wrapper<T>.baz(transform: (T) -> Unit): T = TODO()
fun test() {
takeFun<String>(::foo)
takeFun<String>(<!TYPE_MISMATCH{NI}!>::<!TYPE_INFERENCE_UPPER_BOUND_VIOLATED{OI}!>fooInt<!><!>)
takeFun<String>(<!TYPE_MISMATCH!>::fooInt<!>)
callFun<String, Wrapper<String>>(::createWrapper)
callFun<Int, Wrapper<Number>>(::createWrapper)
callFun<String, Wrapper<*>>(::createWrapper)
callFun<String, Wrapper<Int>>(::<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}!>createWrapper<!>)
callFun<String, Wrapper<Int>>(::createWrapper)
callFun<Int, Wrapper<Int>>(::createWrapper).baz(::foo)
}
compiler/testData/diagnostics/tests/callableReference/generic/genericFunctionsWithNullableTypes.kt
Vendored
+3 -4
View File
@@ -1,4 +1,3 @@
// !WITH_NEW_INFERENCE
// !CHECK_TYPE
// !DIAGNOSTICS: -UNUSED_PARAMETER, -UNUSED_VARIABLE
@@ -29,9 +28,9 @@ fun <T> test(x: T) {
<!REIFIED_TYPE_FORBIDDEN_SUBSTITUTION!>baz<!>(1, null, ::foo)
<!REIFIED_TYPE_FORBIDDEN_SUBSTITUTION, REIFIED_TYPE_FORBIDDEN_SUBSTITUTION!>baz<!>(null, null, ::foo)
val s3: Pair<Int, String?> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>bar(null, null, ::<!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>foo<!>)<!>
val s4: Pair<Int?, String> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>bar(null, null, ::<!IMPLICIT_NOTHING_TYPE_ARGUMENT_IN_RETURN_POSITION{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>foo<!>)<!>
val s3: Pair<Int, String?> = <!TYPE_MISMATCH!>bar(null, null, ::foo)<!>
val s4: Pair<Int?, String> = <!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>bar(null, null, ::<!IMPLICIT_NOTHING_TYPE_ARGUMENT_IN_RETURN_POSITION!>foo<!>)<!>
val s5: Pair<Int, String> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>bar(1, "", ::foo)<!>
val s5: Pair<Int, String> = <!TYPE_MISMATCH, TYPE_MISMATCH!>bar(1, "", ::foo)<!>
val (a1: Int, b1: String) = <!COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>bar(1, "", ::foo)<!>
}
compiler/testData/diagnostics/tests/collectionLiterals/argumentsOfAnnotation.kt
Vendored
+1 -2
View File
@@ -1,4 +1,3 @@
// !WITH_NEW_INFERENCE
// !LANGUAGE: +ArrayLiteralsInAnnotations
annotation class Foo(val a: IntArray, val b: Array<String>, val c: FloatArray)
@@ -9,7 +8,7 @@ fun test1() {}
@Foo([], [], [])
fun test2() {}
@Foo([<!CONSTANT_EXPECTED_TYPE_MISMATCH!>1f<!>], <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>[' ']<!>, [<!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>])
@Foo([<!CONSTANT_EXPECTED_TYPE_MISMATCH!>1f<!>], <!TYPE_MISMATCH!>[' ']<!>, [<!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>])
fun test3() {}
@Foo(c = [1f], b = [""], a = [1])
compiler/testData/diagnostics/tests/collectionLiterals/argumentsOfAnnotationWithKClass.kt
Vendored
+2 -3
View File
@@ -1,4 +1,3 @@
// !WITH_NEW_INFERENCE
// !LANGUAGE: +ArrayLiteralsInAnnotations +BareArrayClassLiteral
import kotlin.reflect.KClass
@@ -21,10 +20,10 @@ fun test3() {}
@Foo([<!CLASS_LITERAL_LHS_NOT_A_CLASS!>Gen<Int>::class<!>])
fun test4() {}
@Foo(<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>[""]<!>)
@Foo(<!TYPE_MISMATCH!>[""]<!>)
fun test5() {}
@Foo(<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>[Int::class, 1]<!>)
@Foo(<!TYPE_MISMATCH!>[Int::class, 1]<!>)
fun test6() {}
@Bar
compiler/testData/diagnostics/tests/collectionLiterals/basicCollectionLiterals.kt
Vendored
+3 -4
View File
@@ -1,13 +1,12 @@
// !WITH_NEW_INFERENCE
// !CHECK_TYPE
// !DIAGNOSTICS: -UNUSED_VARIABLE, -UNSUPPORTED
fun test() {
val a = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>[]<!>
val a = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>[]<!>
val b: Array<Int> = []
val c = [1, 2]
val d: Array<Int> = [1, 2]
val e: Array<String> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>[1]<!>
val e: Array<String> = <!TYPE_MISMATCH!>[1]<!>
val f: IntArray = [1, 2]
val g = [f]
@@ -20,5 +19,5 @@ fun check() {
val f: IntArray = [1]
[f] checkType { _<Array<IntArray>>() }
[1, ""] checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER{NI}!>_<!><Array<Any>>() }
[1, ""] checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><Array<Any>>() }
}
compiler/testData/diagnostics/tests/collectionLiterals/defaultValuesInAnnotation.kt
Vendored
+4 -5
View File
@@ -1,4 +1,3 @@
// !WITH_NEW_INFERENCE
// !LANGUAGE: +ArrayLiteralsInAnnotations
annotation class Foo(
@@ -8,9 +7,9 @@ annotation class Foo(
)
annotation class Bar(
val a: Array<String> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>[' ']<!>,
val b: Array<String> = <!ANNOTATION_PARAMETER_DEFAULT_VALUE_MUST_BE_CONSTANT, TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>["", <!EMPTY_CHARACTER_LITERAL!>''<!>]<!>,
val c: Array<String> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>[1]<!>
val a: Array<String> = <!TYPE_MISMATCH!>[' ']<!>,
val b: Array<String> = <!ANNOTATION_PARAMETER_DEFAULT_VALUE_MUST_BE_CONSTANT, TYPE_MISMATCH!>["", <!EMPTY_CHARACTER_LITERAL!>''<!>]<!>,
val c: Array<String> = <!TYPE_MISMATCH!>[1]<!>
)
annotation class Base(
@@ -22,5 +21,5 @@ annotation class Base(
annotation class Err(
val a: IntArray = [<!CONSTANT_EXPECTED_TYPE_MISMATCH!>1L<!>],
val b: Array<String> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>[1]<!>
val b: Array<String> = <!TYPE_MISMATCH!>[1]<!>
)
compiler/testData/diagnostics/tests/delegation/DelegationExpectedType.kt
Vendored
+1 -2
View File
@@ -1,4 +1,3 @@
// !WITH_NEW_INFERENCE
// !DIAGNOSTICS: -UNUSED_PARAMETER
interface A<T> {
@@ -21,6 +20,6 @@ class D : A<Int> by baz({ it + 1 })
fun <T> boo(t: T): A<T> = AImpl()
class E : A<Int> by <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>boo("")<!>
class E : A<Int> by <!TYPE_MISMATCH!>boo("")<!>
class F : A<Int> by <!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>AImpl<String>()<!>
compiler/testData/diagnostics/tests/functionLiterals/ExpectedParametersTypesMismatch.kt
Vendored
+9 -10
View File
@@ -1,4 +1,3 @@
// !WITH_NEW_INFERENCE
package a
fun foo0(f: () -> String) = f
@@ -9,37 +8,37 @@ fun test1() {
foo0 {
""
}
foo0 <!TYPE_MISMATCH{NI}!>{
foo0 <!TYPE_MISMATCH!>{
<!EXPECTED_PARAMETERS_NUMBER_MISMATCH!>s: String<!>-> ""
}<!>
foo0 <!TYPE_MISMATCH{NI}!>{
foo0 <!TYPE_MISMATCH!>{
<!EXPECTED_PARAMETERS_NUMBER_MISMATCH!><!CANNOT_INFER_PARAMETER_TYPE!>x<!>, <!CANNOT_INFER_PARAMETER_TYPE!>y<!><!> -> ""
}<!>
foo1 {
""
}
foo1 <!TYPE_MISMATCH{NI}!>{
foo1 <!TYPE_MISMATCH!>{
<!EXPECTED_PARAMETER_TYPE_MISMATCH!>s: String<!> -> ""
}<!>
foo1 <!TYPE_MISMATCH{NI}!>{
foo1 <!TYPE_MISMATCH!>{
<!EXPECTED_PARAMETERS_NUMBER_MISMATCH!>x, <!CANNOT_INFER_PARAMETER_TYPE!>y<!><!> -> ""
}<!>
foo1 <!TYPE_MISMATCH{NI}!>{
foo1 <!TYPE_MISMATCH!>{
<!EXPECTED_PARAMETERS_NUMBER_MISMATCH!><!>-> <!CONSTANT_EXPECTED_TYPE_MISMATCH, CONSTANT_EXPECTED_TYPE_MISMATCH!>42<!>
}<!>
foo2 <!TYPE_MISMATCH{NI}!><!EXPECTED_PARAMETERS_NUMBER_MISMATCH!>{<!>
foo2 <!TYPE_MISMATCH!><!EXPECTED_PARAMETERS_NUMBER_MISMATCH!>{<!>
""
}<!>
foo2 <!TYPE_MISMATCH{NI}!>{
foo2 <!TYPE_MISMATCH!>{
<!EXPECTED_PARAMETERS_NUMBER_MISMATCH, EXPECTED_PARAMETER_TYPE_MISMATCH!>s: String<!> -> ""
}<!>
foo2 <!TYPE_MISMATCH{NI}!>{
foo2 <!TYPE_MISMATCH!>{
<!EXPECTED_PARAMETERS_NUMBER_MISMATCH!>x<!> -> ""
}<!>
foo2 <!TYPE_MISMATCH{NI}!>{
foo2 <!TYPE_MISMATCH!>{
<!EXPECTED_PARAMETERS_NUMBER_MISMATCH!><!>-> <!CONSTANT_EXPECTED_TYPE_MISMATCH, CONSTANT_EXPECTED_TYPE_MISMATCH!>42<!>
}<!>
}
compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/fromSuperClassesLocalInsideInner.kt
Vendored
+1 -2
View File
@@ -1,4 +1,3 @@
// !WITH_NEW_INFERENCE
// !CHECK_TYPE
// !DIAGNOSTICS: -UNUSED_VALUE -VARIABLE_WITH_REDUNDANT_INITIALIZER -TOPLEVEL_TYPEALIASES_ONLY
@@ -47,7 +46,7 @@ class Outer<T> {
x().bar() checkType { _<A<T, F, String, Double, Short, Char>>() }
x = <!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>foobar<Int>()<!>
x = <!TYPE_MISMATCH!>z.<!TYPE_MISMATCH{NI}!>foobar<String>()<!><!>
x = <!TYPE_MISMATCH!>z.<!TYPE_MISMATCH!>foobar<String>()<!><!>
var y = noParameters()
y = noParameters()
compiler/testData/diagnostics/tests/generics/innerClasses/innerTP.kt
Vendored
+1 -2
View File
@@ -1,4 +1,3 @@
// !WITH_NEW_INFERENCE
// !CHECK_TYPE
// !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_PARAMETER
@@ -32,7 +31,7 @@ fun main() {
checkSubtype<Outer<*>.Inner<*>>(outer.Inner<Int>())
checkSubtype<Outer<CharSequence>.Inner<CharSequence>>(<!TYPE_MISMATCH!>outer.bar()<!>)
checkSubtype<Outer<CharSequence>.Inner<CharSequence>>(<!TYPE_MISMATCH{NI}!>outer.<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}!>Inner()<!><!>)
checkSubtype<Outer<CharSequence>.Inner<CharSequence>>(<!TYPE_MISMATCH!>outer.Inner()<!>)
outer.set(outer.bar())
outer.set(outer.Inner())
compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferences.fir.kt
Vendored
+6 -6
View File
@@ -38,7 +38,7 @@ fun <R> select(vararg x: R) = x[0]
fun poll0(): Flow<String> {
return flow {
val inv = <!NEW_INFERENCE_ERROR!>select(::bar, ::foo)<!>
val inv = select(::bar, ::foo)
inv()
}
}
@@ -52,7 +52,7 @@ fun poll01(): Flow<String> {
fun poll02(): Flow<String> {
return flow {
val inv = <!NEW_INFERENCE_ERROR!>select(::bar3, ::foo3)<!>
val inv = select(::bar3, ::foo3)
inv()
}
}
@@ -66,7 +66,7 @@ fun poll03(): Flow<String> {
fun poll04(): Flow<String> {
return flow {
val inv = <!NEW_INFERENCE_ERROR!>select(::bar5, ::foo5)<!>
val inv = select(::bar5, ::foo5)
inv
}
}
@@ -437,7 +437,7 @@ fun poll76(): Flow<String> {
fun poll8(): Flow<String> {
return flow {
val inv = <!NEW_INFERENCE_ERROR!>::bar in <!NEW_INFERENCE_ERROR!>setOf(::foo)<!><!>
val inv = ::bar in setOf(::foo)
<!UNRESOLVED_REFERENCE!>inv<!>()
}
}
@@ -451,7 +451,7 @@ fun poll81(): Flow<String> {
fun poll82(): Flow<String> {
return flow {
val inv = ::bar3 in <!NEW_INFERENCE_ERROR!>setOf(::foo3)<!>
val inv = ::bar3 in setOf(::foo3)
<!UNRESOLVED_REFERENCE!>inv<!>()
}
}
@@ -465,7 +465,7 @@ fun poll83(): Flow<String> {
fun poll84(): Flow<String> {
return flow {
val inv = <!NEW_INFERENCE_ERROR!>::bar5 in <!NEW_INFERENCE_ERROR!>setOf(::foo5)<!><!>
val inv = ::bar5 in setOf(::foo5)
inv
}
}
compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesUnrestricted.fir.kt
Vendored
+2 -2
View File
@@ -480,7 +480,7 @@ fun poll85(): Flow<String> {
fun poll86(): Flow<String> {
return flow {
val inv = ::Foo7 in setOf(::Foo7)
val inv = <!NEW_INFERENCE_ERROR!>::Foo7 in <!NEW_INFERENCE_ERROR!>setOf(::Foo7)<!><!>
inv
}
}
@@ -494,7 +494,7 @@ fun poll87(): Flow<String> {
fun poll88(): Flow<String> {
return flow {
val inv = foo7() in setOf(::Foo7)
val inv = foo7() in <!NEW_INFERENCE_ERROR!>setOf(::Foo7)<!>
inv
}
}
compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/commonSuperTypeCovariant.kt
Vendored
+1
View File
@@ -1,6 +1,7 @@
// !LANGUAGE: +UnrestrictedBuilderInference
// !DIAGNOSTICS: -UNUSED_PARAMETER -DEPRECATION -EXPERIMENTAL_IS_NOT_ENABLED -UNUSED_VARIABLE
// WITH_RUNTIME
// FIR_IDE_IGNORE
// FILE: Test.java
compiler/testData/diagnostics/tests/inference/capturedTypes/cannotCaptureInProjection.kt
Vendored
+4 -5
View File
@@ -1,17 +1,16 @@
// !WITH_NEW_INFERENCE
// !DIAGNOSTICS: -UNUSED_VARIABLE -UNUSED_PARAMETER
// !CHECK_TYPE
fun <T: Any> bar(a: Array<T>): Array<T?> = null!!
fun test1(a: Array<in Int>) {
val r: Array<in Int?> = <!TYPE_INFERENCE_CANNOT_CAPTURE_TYPES{OI}!>bar<!>(<!TYPE_MISMATCH{NI}!>a<!>)
<!TYPE_INFERENCE_CANNOT_CAPTURE_TYPES{OI}!>bar<!>(<!TYPE_MISMATCH{NI}!>a<!>)
val r: Array<in Int?> = bar(<!TYPE_MISMATCH!>a<!>)
bar(<!TYPE_MISMATCH!>a<!>)
}
fun <T: Any> foo(l: Array<T>): Array<Array<T?>> = null!!
fun test2(a: Array<in Int>) {
val r: Array<out Array<in Int?>> = <!TYPE_INFERENCE_CANNOT_CAPTURE_TYPES{OI}!>foo<!>(<!TYPE_MISMATCH{NI}!>a<!>)
<!TYPE_INFERENCE_CANNOT_CAPTURE_TYPES{OI}!>foo<!>(<!TYPE_MISMATCH{NI}!>a<!>)
val r: Array<out Array<in Int?>> = foo(<!TYPE_MISMATCH!>a<!>)
foo(<!TYPE_MISMATCH!>a<!>)
}
compiler/testData/diagnostics/tests/inference/capturedTypes/captureTypeOnlyOnTopLevel.kt
Vendored
+2 -3
View File
@@ -1,10 +1,9 @@
// !WITH_NEW_INFERENCE
// !DIAGNOSTICS: -UNUSED_VARIABLE
fun <T> foo(array: Array<Array<T>>): Array<Array<T>> = array
fun test(array: Array<Array<out Int>>) {
<!TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR{OI}!>foo<!>(<!TYPE_MISMATCH{NI}!>array<!>)
foo(<!TYPE_MISMATCH!>array<!>)
val f: Array<out Array<out Int>> = <!TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR{OI}!>foo<!>(<!TYPE_MISMATCH!>array<!>)
val f: Array<out Array<out Int>> = foo(<!TYPE_MISMATCH!>array<!>)
}
compiler/testData/diagnostics/tests/inference/completion/errorAfterCompletion.kt
Vendored
+1 -1
View File
@@ -4,5 +4,5 @@ fun foo(x: () -> Int): Int = x()
fun <R> myRun(x: () -> R): R = x()
private val a = foo { <!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>myRun { <!TYPE_MISMATCH!>"OK"<!> }<!> }
private val a = foo { <!TYPE_MISMATCH, TYPE_MISMATCH!>myRun { <!TYPE_MISMATCH!>"OK"<!> }<!> }
private val b: Int = <!TYPE_MISMATCH!>myRun { <!TYPE_MISMATCH!>"OK"<!> }<!>
compiler/testData/diagnostics/tests/inference/dependantOnVariance.kt
Vendored
+10 -11
View File
@@ -1,4 +1,3 @@
// !WITH_NEW_INFERENCE
package a
class MyList<T>(t: T) {}
@@ -14,7 +13,7 @@ fun <T> readFromMyList(l: MyList<out T>, t: T) {}
fun test1(int: Int, any: Any) {
val a0 : MyList<Any> = getMyList(int)
val a1 : MyList<Int> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>getMyList(any)<!>
val a1 : MyList<Int> = <!TYPE_MISMATCH!>getMyList(any)<!>
val a2 : MyList<out Any> = getMyList(int)
@@ -29,23 +28,23 @@ fun test1(int: Int, any: Any) {
val a7 : MyList<in Any> = getMyList(int)
val a8 : MyList<in Any> = <!TYPE_MISMATCH, TYPE_MISMATCH!>getMyListToReadFrom<Int>(int)<!>
val a9 : MyList<in Any> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>getMyListToReadFrom(int)<!>
val a9 : MyList<in Any> = <!TYPE_MISMATCH, TYPE_MISMATCH!>getMyListToReadFrom(int)<!>
val a10 : MyList<out Int> = <!TYPE_MISMATCH, TYPE_MISMATCH!>getMyList<Any>(any)<!>
val a11 : MyList<out Int> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>getMyList(any)<!>
val a11 : MyList<out Int> = <!TYPE_MISMATCH, TYPE_MISMATCH!>getMyList(any)<!>
val a12 : MyList<out Int> = <!TYPE_MISMATCH, TYPE_MISMATCH!>getMyListToWriteTo<Any>(any)<!>
val a13 : MyList<out Int> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>getMyListToWriteTo(any)<!>
val a13 : MyList<out Int> = <!TYPE_MISMATCH, TYPE_MISMATCH!>getMyListToWriteTo(any)<!>
useMyList(getMyList(int), int)
useMyList(getMyList(any), int)
<!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}!>useMyList<!>(getMyList(int), any)
useMyList(getMyList(int), any)
readFromMyList(getMyList(int), any)
readFromMyList(getMyList(any), int)
readFromMyList<Int>(<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>getMyList(any)<!>, int)
readFromMyList<Int>(<!TYPE_MISMATCH!>getMyList(any)<!>, int)
readFromMyList<Int>(<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>getMyListToReadFrom(any)<!>, int)
readFromMyList<Int>(<!TYPE_MISMATCH!>getMyListToReadFrom(any)<!>, int)
readFromMyList(getMyListToReadFrom(any), int)
readFromMyList(getMyListToReadFrom(int), any)
@@ -54,14 +53,14 @@ fun test1(int: Int, any: Any) {
writeToMyList(getMyList(any), int)
writeToMyList<Any>(getMyList(int), any)
writeToMyList(getMyList<Any>(int), any)
<!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}!>writeToMyList<!>(getMyList(int), any)
writeToMyList(getMyList(int), any)
writeToMyList(getMyListToWriteTo(any), int)
<!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}!>writeToMyList<!>(getMyListToWriteTo(int), any)
writeToMyList(getMyListToWriteTo(int), any)
readFromMyList(getMyListToWriteTo(any), any)
<!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}!>writeToMyList<!>(getMyListToReadFrom(any), <!TYPE_MISMATCH{NI}!>any<!>)
writeToMyList(getMyListToReadFrom(any), <!TYPE_MISMATCH!>any<!>)
use(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13)
}
compiler/testData/diagnostics/tests/inference/regressions/kt2283.kt
Vendored
+1 -2
View File
@@ -1,4 +1,3 @@
// !WITH_NEW_INFERENCE
//KT-2283 Bad diagnostics of failed type inference
package a
@@ -10,5 +9,5 @@ fun <A, B> Foo<A>.map(f: (A) -> B): Foo<B> = object : Foo<B> {}
fun foo() {
val l: Foo<String> = object : Foo<String> {}
val m: Foo<String> = l.<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}!>map { ppp -> <!CONSTANT_EXPECTED_TYPE_MISMATCH{NI}!>1<!> }<!>
val m: Foo<String> = l.map { ppp -> <!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!> }
}
compiler/testData/diagnostics/tests/inference/typeInferenceExpectedTypeMismatch.kt
Vendored
+4 -5
View File
@@ -1,10 +1,9 @@
// !WITH_NEW_INFERENCE
package typeInferenceExpectedTypeMismatch
import java.util.*
fun test() {
val s : Set<Int> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>newList()<!>
val s : Set<Int> = <!TYPE_MISMATCH!>newList()<!>
use(s)
}
@@ -26,16 +25,16 @@ fun <T, R> foo(o: Out<T>, i: In<R>): Two<T, R> = throw Exception("$o $i")
fun test1(outA: Out<A>, inB: In<B>) {
foo(outA, inB)
val b: Two<A, C> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>foo(outA, inB)<!>
val b: Two<A, C> = <!TYPE_MISMATCH!>foo(outA, inB)<!>
use(b)
}
fun <T> bar(o: Out<T>, i: In<T>): Two<T, T> = throw Exception("$o $i")
fun test2(outA: Out<A>, inC: In<C>) {
<!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}!>bar<!>(outA, <!TYPE_MISMATCH{NI}!>inC<!>)
bar(outA, <!TYPE_MISMATCH!>inC<!>)
val b: Two<A, B> = <!TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!><!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}!>bar<!>(outA, <!TYPE_MISMATCH{NI}!>inC<!>)<!>
val b: Two<A, B> = <!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>bar(outA, <!TYPE_MISMATCH!>inC<!>)<!>
use(b)
}
compiler/testData/diagnostics/tests/inference/upperBounds/useBoundsToInferTypeParamsSimple.kt
Vendored
+1 -2
View File
@@ -1,4 +1,3 @@
// !WITH_NEW_INFERENCE
package a
fun <V: U, U> foo(v: V, u: U) = u
@@ -16,7 +15,7 @@ fun <T> checkItIsExactlyAny(t: T, l: MutableList<T>) {}
fun <V : U, U> baz(v: V, u: MutableSet<U>) = u
fun test(a: Any, s: MutableSet<String>) {
<!TYPE_INFERENCE_UPPER_BOUND_VIOLATED{OI}!>baz<!>(a, <!TYPE_MISMATCH{NI}!>s<!>)
baz(a, <!TYPE_MISMATCH!>s<!>)
}
//from standard library
compiler/testData/diagnostics/tests/j+k/genericConstructor/innerClass.kt
Vendored
+1 -2
View File
@@ -1,4 +1,3 @@
// !WITH_NEW_INFERENCE
// !CHECK_TYPE
// FILE: Outer.java
@@ -13,6 +12,6 @@ fun test(x: List<Int>, y: List<String>) {
Outer<Int>().Inner("", y, 1) checkType { _<Outer<Int>.Inner<String>>() }
Outer<Int>().Inner<CharSequence, String, Int>("", y, 1) checkType { _<Outer<Int>.Inner<CharSequence>>() }
Outer<Int>().Inner("", x, 1) checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER{NI}!>_<!><Outer<Int>.Inner<Any>>() }
Outer<Int>().Inner("", x, 1) checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><Outer<Int>.Inner<Any>>() }
Outer<Int>().Inner<CharSequence, String, Int>("", <!TYPE_MISMATCH, TYPE_MISMATCH!>x<!>, 1)
}
compiler/testData/diagnostics/tests/regressions/correctResultSubstitutorForErrorCandidate.kt
Vendored
+1 -2
View File
@@ -1,8 +1,7 @@
// !WITH_NEW_INFERENCE
// !DIAGNOSTICS: -UNUSED_PARAMETER
fun test(a: Int, b: Boolean) {
<!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>bar<!>(a.<!TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR{OI}!>foo<!>(<!TYPE_MISMATCH!>b<!>))
bar(a.foo(<!TYPE_MISMATCH!>b<!>))
}
fun <T, R> T.foo(l: (T) -> R): R = TODO()
compiler/testData/diagnostics/tests/regressions/kt10843.kt
Vendored
+1 -1
View File
@@ -1,6 +1,6 @@
// NI_EXPECTED_FILE
// See EA-76890 / KT-10843: NPE during analysis
fun lambda(x : Int?) = x?.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{OI}, FUNCTION_CALL_EXPECTED, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER!>let<!> <!DEBUG_INFO_MISSING_UNRESOLVED!>l<!> {
fun lambda(x : Int?) = x?.<!FUNCTION_CALL_EXPECTED, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER!>let<!> <!DEBUG_INFO_MISSING_UNRESOLVED!>l<!> {
<!CANNOT_INFER_PARAMETER_TYPE!>y<!> ->
if (<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>y<!> <!DEBUG_INFO_MISSING_UNRESOLVED!>><!> 0) return<!UNRESOLVED_REFERENCE!>@l<!> x
<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>y<!>
compiler/testData/diagnostics/tests/resolve/specialConstructions/constantsInIf.kt
Vendored
+4 -5
View File
@@ -1,14 +1,13 @@
// !WITH_NEW_INFERENCE
// !DIAGNOSTICS: -USELESS_ELVIS
fun test() {
bar(<!TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>if (true) {
<!CONSTANT_EXPECTED_TYPE_MISMATCH{OI}!>1<!>
bar(<!TYPE_MISMATCH, TYPE_MISMATCH!>if (true) {
1
} else {
<!CONSTANT_EXPECTED_TYPE_MISMATCH{OI}!>2<!>
2
}<!>)
bar(<!TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!><!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!> ?: <!CONSTANT_EXPECTED_TYPE_MISMATCH!>2<!><!>)
bar(<!TYPE_MISMATCH, TYPE_MISMATCH!><!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!> ?: <!CONSTANT_EXPECTED_TYPE_MISMATCH!>2<!><!>)
}
fun bar(s: String) = s
compiler/testData/diagnostics/tests/secondaryConstructors/constructorCallType.kt
Vendored
+2 -3
View File
@@ -1,4 +1,3 @@
// !WITH_NEW_INFERENCE
// !DIAGNOSTICS: -UNUSED_PARAMETER
// NI_EXPECTED_FILE
class A(x: Int) {
@@ -21,8 +20,8 @@ val y4: B<Int> = B<Int>("")
val y5: B<String> = B<String>(<!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>)
val y6: B<String> = B<String>("")
val y7: B<String> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>B(1)<!>
val y7: B<String> = <!TYPE_MISMATCH!>B(1)<!>
val y8: B<String> = B("")
val y9 = B(1)
val y10 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>B<!>("")
val y10 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>B<!>("")
compiler/testData/diagnostics/tests/smartCasts/lambdaArgumentWithBoundWithoutType.kt
Vendored
+4 -5
View File
@@ -1,4 +1,3 @@
// !WITH_NEW_INFERENCE
interface Foo
interface Bar : Foo
@@ -13,14 +12,14 @@ val foo: Foo = run {
<!DEBUG_INFO_SMARTCAST!>x<!>
}
val foofoo: Foo = <!TYPE_INFERENCE_UPPER_BOUND_VIOLATED{OI}!>run<!> {
val foofoo: Foo = run {
val x = foo()
if (x == null) throw Exception()
<!DEBUG_INFO_SMARTCAST, TYPE_MISMATCH{NI}!>x<!>
<!DEBUG_INFO_SMARTCAST, TYPE_MISMATCH!>x<!>
}
val bar: Bar = <!TYPE_MISMATCH{NI}!><!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}!>run<!> {
val bar: Bar = <!TYPE_MISMATCH!>run {
val x = foo()
if (x == null) throw Exception()
<!DEBUG_INFO_SMARTCAST{NI}, TYPE_MISMATCH!>x<!>
<!DEBUG_INFO_SMARTCAST, TYPE_MISMATCH!>x<!>
}<!>
compiler/testData/diagnostics/tests/typeParameters/implicitNothingInReturnPosition.kt
Vendored
+1 -2
View File
@@ -1,5 +1,4 @@
// !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE -UNCHECKED_CAST
// !WITH_NEW_INFERENCE
// SKIP_TXT
// Issue: KT-20849
@@ -40,7 +39,7 @@ class Context<T>
fun <T> Any.decodeIn(typeFrom: Context<in T>): T = something()
fun <T> Any?.decodeOut1(typeFrom: Context<out T>): T {
return <!TYPE_MISMATCH{NI}!>this?.<!IMPLICIT_NOTHING_TYPE_ARGUMENT_IN_RETURN_POSITION!>decodeIn<!>(typeFrom) ?: <!TYPE_MISMATCH{OI}!>kotlin.Unit<!><!>
return <!TYPE_MISMATCH!>this?.<!IMPLICIT_NOTHING_TYPE_ARGUMENT_IN_RETURN_POSITION!>decodeIn<!>(typeFrom) ?: kotlin.Unit<!>
}
fun <T> Any.decodeOut2(typeFrom: Context<out T>): T {
compiler/testData/diagnostics/tests/typeParameters/kt42042.fir.kt
Vendored
-2
View File
@@ -1,5 +1,3 @@
// !LANGUAGE: -ProperTypeInferenceConstraintsProcessing
sealed class Subtype<A1, B1> {
abstract fun cast(value: A1): B1
class Trivial<A2 : B2, B2> : Subtype<A2, B2>() {
compiler/testData/diagnostics/tests/typeParameters/kt42042.kt
Vendored
+1 -1
View File
@@ -6,6 +6,6 @@ sealed class Subtype<A1, B1> {
}
fun <A, B> unsafeCast(value: A): B {
val proof: Subtype<A, B> = Subtype.<!TYPE_MISMATCH!>Trivial()<!>
val proof: Subtype<A, B> = Subtype.<!TYPE_MISMATCH_WARNING!>Trivial()<!>
return proof.cast(value)
}
compiler/testData/diagnostics/tests/typeParameters/kt42042Error.kt
Vendored
+1 -1
View File
@@ -8,6 +8,6 @@ sealed class Subtype<A1, B1> {
}
fun <A, B> unsafeCast(value: A): B {
val proof: Subtype<A, B> = Subtype.<!TYPE_MISMATCH, TYPE_MISMATCH!>Trivial()<!>
val proof: Subtype<A, B> = Subtype.<!TYPE_MISMATCH!>Trivial()<!>
return proof.cast(value)
}
compiler/testData/diagnostics/tests/typealias/typeAliasConstructorTypeArgumentsInference.kt
Vendored
+8 -9
View File
@@ -1,19 +1,18 @@
// !WITH_NEW_INFERENCE
// NI_EXPECTED_FILE
class Num<Tn : Number>(val x: Tn)
typealias N<T> = Num<T>
val test0 = N(1)
val test1 = <!TYPE_INFERENCE_UPPER_BOUND_VIOLATED{OI}!>N<!>(<!TYPE_MISMATCH{NI}!>"1"<!>)
val test1 = N(<!TYPE_MISMATCH!>"1"<!>)
class Cons<T>(val head: T, val tail: Cons<T>?)
typealias C<T> = Cons<T>
typealias CC<T> = C<C<T>>
val test2 = <!TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR{OI}!>C<!>(1, <!CONSTANT_EXPECTED_TYPE_MISMATCH!>2<!>)
val test3 = <!TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR{OI}!>CC<!>(<!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>, <!CONSTANT_EXPECTED_TYPE_MISMATCH!>2<!>)
val test2 = C(1, <!CONSTANT_EXPECTED_TYPE_MISMATCH!>2<!>)
val test3 = CC(<!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>, <!CONSTANT_EXPECTED_TYPE_MISMATCH!>2<!>)
val test4 = CC(C(1, null), null)
@@ -21,13 +20,13 @@ class Pair<X, Y>(val x: X, val y: Y)
typealias PL<T> = Pair<T, List<T>>
typealias PN<T> = Pair<T, Num<T>>
val test5 = <!TYPE_INFERENCE_INCORPORATION_ERROR{OI}!>PL<!>(1, <!NULL_FOR_NONNULL_TYPE!>null<!>)
val test5 = PL(1, <!NULL_FOR_NONNULL_TYPE!>null<!>)
class Foo<T>(val p: Pair<T, T>)
typealias F<T> = Foo<T>
fun testProjections1(x: Pair<in Int, out String>) = <!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}!>F<!>(<!TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>x<!>)
fun testProjections2(x: Pair<in Int, out Number>) = <!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}!>F<!>(<!TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>x<!>)
fun testProjections3(x: Pair<in Number, out Int>) = <!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}!>F<!>(<!TYPE_MISMATCH{NI}!>x<!>)
fun testProjections4(x: Pair<in Int, in Int>) = <!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}!>F<!>(<!TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>x<!>)
fun testProjections1(x: Pair<in Int, out String>) = F(<!TYPE_MISMATCH, TYPE_MISMATCH!>x<!>)
fun testProjections2(x: Pair<in Int, out Number>) = F(<!TYPE_MISMATCH, TYPE_MISMATCH!>x<!>)
fun testProjections3(x: Pair<in Number, out Int>) = F(<!TYPE_MISMATCH!>x<!>)
fun testProjections4(x: Pair<in Int, in Int>) = F(<!TYPE_MISMATCH, TYPE_MISMATCH!>x<!>)
compiler/testData/diagnostics/tests/typealias/typeAliasConstructorTypeArgumentsInferenceWithNestedCalls.kt
Vendored
+2 -2
View File
@@ -14,5 +14,5 @@ typealias C2<T> = MapLike<T>
val test1 = C(1, C(2, null))
val test2 = C(1, <!TYPE_MISMATCH!>C(<!TYPE_MISMATCH!>""<!>, null)<!>)
val test23 = <!UPPER_BOUND_VIOLATED_IN_TYPEALIAS_EXPANSION_BASED_ON_JAVA_ANNOTATIONS!>C2(if (true) 1 else null)<!>
val test234 = C2(<!UPPER_BOUND_VIOLATED_IN_TYPEALIAS_EXPANSION_BASED_ON_JAVA_ANNOTATIONS!>C2(if (true) 1 else null)<!>)
val test23 = <!UPPER_BOUND_VIOLATED_IN_TYPEALIAS_EXPANSION_BASED_ON_JAVA_ANNOTATIONS!>C2(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>if (true) 1 else null<!>)<!>
val test234 = C2(<!UPPER_BOUND_VIOLATED_IN_TYPEALIAS_EXPANSION_BASED_ON_JAVA_ANNOTATIONS!>C2(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>if (true) 1 else null<!>)<!>)
compiler/testData/diagnostics/tests/when/kt9972.kt
Vendored
+5 -6
View File
@@ -1,4 +1,3 @@
// !WITH_NEW_INFERENCE
/*
* KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE)
*
@@ -11,18 +10,18 @@
*/
fun test1(): Int {
val x: String = if (true) <!TYPE_MISMATCH{NI}!>{
val x: String = if (true) <!TYPE_MISMATCH!>{
when {
true -> <!TYPE_MISMATCH{OI}!>Any()<!>
else -> <!NULL_FOR_NONNULL_TYPE{OI}!>null<!>
true -> Any()
else -> null
}
}<!> else ""
return x.hashCode()
}
fun test2(): Int {
val x: String = <!TYPE_MISMATCH{NI}!>when {
true -> <!TYPE_MISMATCH{OI}!>Any()<!>
val x: String = <!TYPE_MISMATCH!>when {
true -> Any()
else -> null
} ?: return 0<!>
return x.hashCode()
compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassArrayInAnnotationsInVariance.kt
Vendored
+2 -4
View File
@@ -1,5 +1,3 @@
// !WITH_NEW_INFERENCE
import kotlin.reflect.KClass
open class A
@@ -14,7 +12,7 @@ class MyClass1
@Ann1(arrayOf(Any::class))
class MyClass1a
@Ann1(<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>arrayOf(<!TYPE_MISMATCH{NI}!>B1::class<!>)<!>)
@Ann1(<!TYPE_MISMATCH!>arrayOf(<!TYPE_MISMATCH!>B1::class<!>)<!>)
class MyClass2
annotation class Ann2(val arg: Array<KClass<in B1>>)
@@ -25,5 +23,5 @@ class MyClass3
@Ann2(arrayOf(B1::class))
class MyClass4
@Ann2(<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>arrayOf(<!TYPE_MISMATCH{NI}!>B2::class<!>)<!>)
@Ann2(<!TYPE_MISMATCH!>arrayOf(<!TYPE_MISMATCH!>B2::class<!>)<!>)
class MyClass5
compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassArrayInAnnotationsOutVariance.kt
Vendored
+3 -5
View File
@@ -1,5 +1,3 @@
// !WITH_NEW_INFERENCE
import kotlin.reflect.KClass
open class A
@@ -11,7 +9,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}!>arrayOf(<!TYPE_MISMATCH{NI}!>Any::class<!>)<!>)
@Ann1(<!TYPE_MISMATCH!>arrayOf(<!TYPE_MISMATCH!>Any::class<!>)<!>)
class MyClass1a
@Ann1(arrayOf(B1::class))
@@ -19,11 +17,11 @@ class MyClass2
annotation class Ann2(val arg: Array<KClass<out B1>>)
@Ann2(<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>arrayOf(<!TYPE_MISMATCH{NI}!>A::class<!>)<!>)
@Ann2(<!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}!>arrayOf(<!TYPE_MISMATCH{NI}!>B2::class<!>)<!>)
@Ann2(<!TYPE_MISMATCH!>arrayOf(<!TYPE_MISMATCH!>B2::class<!>)<!>)
class MyClass5
compiler/testData/diagnostics/testsWithStdLib/builderInference/incorrectCalls.fir.kt
Vendored
-37
View File
@@ -1,37 +0,0 @@
// !LANGUAGE: +UnrestrictedBuilderInference
// !USE_EXPERIMENTAL: kotlin.RequiresOptIn
// !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_PARAMETER -UNUSED_VARIABLE
// !WITH_NEW_INFERENCE
@file:OptIn(ExperimentalTypeInference::class)
import kotlin.experimental.ExperimentalTypeInference
class GenericController<T> {
suspend fun yield(t: T) {}
fun notYield(t: T) {}
suspend fun yieldBarReturnType(t: T) = t
fun barReturnType(): T = TODO()
}
fun <S> generate(@BuilderInference g: suspend GenericController<S>.() -> Unit): List<S> = TODO()
val test1 = generate {
yield(3)
}
val test2 = generate {
yield(3)
notYield(3)
}
val test3 = generate {
yield(3)
yieldBarReturnType(3)
}
val test4 = generate {
yield(3)
barReturnType()
}
compiler/testData/diagnostics/testsWithStdLib/builderInference/incorrectCalls.kt
Vendored
+3 -2
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
// !LANGUAGE: +UnrestrictedBuilderInference
// !USE_EXPERIMENTAL: kotlin.RequiresOptIn
// !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_PARAMETER -UNUSED_VARIABLE
@@ -25,12 +26,12 @@ val test2 = generate {
notYield(3)
}
val test3 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>generate<!> {
val test3 = generate {
yield(3)
yieldBarReturnType(3)
}
val test4 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>generate<!> {
val test4 = generate {
yield(3)
barReturnType()
}
compiler/testData/diagnostics/testsWithStdLib/builderInference/incorrectCallsWithRestrictions.kt
Vendored
+2 -3
View File
@@ -1,6 +1,5 @@
// !USE_EXPERIMENTAL: kotlin.RequiresOptIn
// !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_PARAMETER -UNUSED_VARIABLE
// !WITH_NEW_INFERENCE
@file:OptIn(ExperimentalTypeInference::class)
@@ -25,12 +24,12 @@ val test2 = generate {
notYield(3)
}
val test3 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, 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, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>generate<!> {
val test4 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>generate<!> {
yield(3)
barReturnType()
}
compiler/testData/diagnostics/testsWithStdLib/builderInference/resolveUsualCallWithBuilderInference.kt
Vendored
+1 -1
View File
@@ -28,7 +28,7 @@ val memberWithoutAnn = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>wrongBuild<
add(42)
}
val extension = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>build<!> {
val extension = build {
extensionAdd("foo")
}
compiler/testData/diagnostics/testsWithStdLib/builderInference/useInferenceInformationFromExtension.fir.kt
Vendored
-34
View File
@@ -1,34 +0,0 @@
// !LANGUAGE: +UnrestrictedBuilderInference
// !DIAGNOSTICS: -UNUSED_PARAMETER
// !WITH_NEW_INFERENCE
// FILE: annotation.kt
package kotlin
annotation class BuilderInference
// FILE: test.kt
class GenericController<T> {
suspend fun yield(t: T) {}
}
suspend fun <S> GenericController<S>.extensionYield(s: S) {}
@BuilderInference
suspend fun <S> GenericController<S>.safeExtensionYield(s: S) {}
fun <S> generate(@BuilderInference g: suspend GenericController<S>.() -> Unit): List<S> = TODO()
val normal = generate {
yield(42)
}
val extension = generate {
extensionYield("foo")
}
val safeExtension = generate {
safeExtensionYield("foo")
}
compiler/testData/diagnostics/testsWithStdLib/builderInference/useInferenceInformationFromExtension.kt
Vendored
+2 -1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
// !LANGUAGE: +UnrestrictedBuilderInference
// !DIAGNOSTICS: -UNUSED_PARAMETER
@@ -24,7 +25,7 @@ val normal = generate {
yield(42)
}
val extension = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>generate<!> {
val extension = generate {
extensionYield("foo")
}
compiler/testData/diagnostics/testsWithStdLib/builderInference/useInferenceInformationFromExtensionWithRestrictions.kt
Vendored
+1 -2
View File
@@ -1,5 +1,4 @@
// !DIAGNOSTICS: -UNUSED_PARAMETER
// !WITH_NEW_INFERENCE
// FILE: annotation.kt
@@ -24,7 +23,7 @@ val normal = generate {
yield(42)
}
val extension = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, 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/suspendCallsWithErrors.kt
Vendored
+3 -4
View File
@@ -1,6 +1,5 @@
// !USE_EXPERIMENTAL: kotlin.RequiresOptIn
// !DIAGNOSTICS: -UNUSED_PARAMETER
// !WITH_NEW_INFERENCE
// NI_EXPECTED_FILE
@file:OptIn(ExperimentalTypeInference::class)
@@ -15,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}!>A()<!>)
val test2: Int = <!TYPE_MISMATCH!>generate {
yield(<!TYPE_MISMATCH!>A()<!>)
}<!>
compiler/testData/diagnostics/testsWithStdLib/coroutines/tryCatchLambda.kt
Vendored
+2 -3
View File
@@ -1,5 +1,4 @@
// !DIAGNOSTICS: -UNUSED_PARAMETER -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_VARIABLE
// !WITH_NEW_INFERENCE
suspend fun <V> await(f: V): V = f
@@ -8,10 +7,10 @@ fun <T> genericBuilder(c: suspend () -> T): T = null!!
fun foo() {
var result = ""
genericBuilder<String> {
<!TYPE_MISMATCH{NI}!>try {
<!TYPE_MISMATCH!>try {
await("")
} catch(e: Exception) {
<!EXPECTED_TYPE_MISMATCH{OI}!>result = "fail"<!>
result = "fail"
}<!>
}
}
compiler/testData/diagnostics/testsWithStdLib/elvisOnJavaList.kt
Vendored
+1 -3
View File
@@ -1,5 +1,3 @@
// !WITH_NEW_INFERENCE
// FILE: P.java
import java.util.ArrayList;
@@ -15,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}!>c.getList() ?: <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{OI}!>listOf()<!><!>
return <!TYPE_MISMATCH!>c.getList() ?: listOf()<!>
}
compiler/testData/diagnostics/testsWithStdLib/resolve/kt4711.kt
Vendored
+3 -4
View File
@@ -1,4 +1,3 @@
// !WITH_NEW_INFERENCE
//KT-4711 Error type with no error reported from type inference
fun main() {
@@ -7,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}!>t + 1.0 / (1.0 + x * x)<!>
<!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/tryCatch/tryExpression.kt
Vendored
+2 -3
View File
@@ -1,4 +1,3 @@
// !WITH_NEW_INFERENCE
// SKIP_TXT
class ExcA : Exception()
@@ -27,9 +26,9 @@ fun test1(): Map<Int, Int> = run {
}
fun test2(): Map<Int, Int> = run {
<!TYPE_MISMATCH{NI}!>try {
<!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 ""<!>)<!>
}<!>
}
idea/idea-frontend-fir/idea-fir-low-level-api/tests/org/jetbrains/kotlin/idea/fir/low/level/api/diagnostic/compiler/based/DiagnosisCompilerTestFE10TestdataTestGenerated.java
Generated
+131 -20
View File
@@ -10998,6 +10998,11 @@ public class DiagnosisCompilerTestFE10TestdataTestGenerated extends AbstractDiag
KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/builderInference"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true);
}
@TestMetadata("labaledCall.kt")
public void testLabaledCall() throws Exception {
runTest("compiler/testData/diagnostics/tests/inference/builderInference/labaledCall.kt");
}
@TestMetadata("simpleLambdaInCallWithAnotherLambdaWithBuilderInference.kt")
public void testSimpleLambdaInCallWithAnotherLambdaWithBuilderInference() throws Exception {
runTest("compiler/testData/diagnostics/tests/inference/builderInference/simpleLambdaInCallWithAnotherLambdaWithBuilderInference.kt");
@@ -11028,15 +11033,106 @@ public class DiagnosisCompilerTestFE10TestdataTestGenerated extends AbstractDiag
runTest("compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesErrorType.kt");
}
@TestMetadata("specialCallsWithCallableReferencesErrorTypeUnrestricted.kt")
public void testSpecialCallsWithCallableReferencesErrorTypeUnrestricted() throws Exception {
runTest("compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesErrorTypeUnrestricted.kt");
}
@TestMetadata("specialCallsWithCallableReferencesNonStrictOnlyInputTypes.kt")
public void testSpecialCallsWithCallableReferencesNonStrictOnlyInputTypes() throws Exception {
runTest("compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesNonStrictOnlyInputTypes.kt");
}
@TestMetadata("specialCallsWithCallableReferencesUnrestricted.kt")
public void testSpecialCallsWithCallableReferencesUnrestricted() throws Exception {
runTest("compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesUnrestricted.kt");
}
@TestMetadata("specialCallsWithLambdas.kt")
public void testSpecialCallsWithLambdas() throws Exception {
runTest("compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithLambdas.kt");
}
@TestMetadata("compiler/testData/diagnostics/tests/inference/builderInference/constraints")
@TestDataPath("$PROJECT_ROOT")
@RunWith(JUnit3RunnerWithInners.class)
public static class Constraints extends AbstractDiagnosisCompilerTestDataTest {
private void runTest(String testDataFilePath) throws Exception {
KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
}
public void testAllFilesPresentInConstraints() throws Exception {
KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/builderInference/constraints"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true);
}
@TestMetadata("violating.kt")
public void testViolating() throws Exception {
runTest("compiler/testData/diagnostics/tests/inference/builderInference/constraints/violating.kt");
}
}
@TestMetadata("compiler/testData/diagnostics/tests/inference/builderInference/stubTypes")
@TestDataPath("$PROJECT_ROOT")
@RunWith(JUnit3RunnerWithInners.class)
public static class StubTypes extends AbstractDiagnosisCompilerTestDataTest {
private void runTest(String testDataFilePath) throws Exception {
KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
}
public void testAllFilesPresentInStubTypes() throws Exception {
KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/builderInference/stubTypes"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true);
}
@TestMetadata("capturedTypes.kt")
public void testCapturedTypes() throws Exception {
runTest("compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/capturedTypes.kt");
}
@TestMetadata("commonSuperType.kt")
public void testCommonSuperType() throws Exception {
runTest("compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/commonSuperType.kt");
}
@TestMetadata("commonSuperTypeContravariant.kt")
public void testCommonSuperTypeContravariant() throws Exception {
runTest("compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/commonSuperTypeContravariant.kt");
}
@TestMetadata("commonSuperTypeCovariant.kt")
public void testCommonSuperTypeCovariant() throws Exception {
runTest("compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/commonSuperTypeCovariant.kt");
}
@TestMetadata("commonSuperTypeInvariant.kt")
public void testCommonSuperTypeInvariant() throws Exception {
runTest("compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/commonSuperTypeInvariant.kt");
}
@TestMetadata("commonSuperTypeNullable.kt")
public void testCommonSuperTypeNullable() throws Exception {
runTest("compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/commonSuperTypeNullable.kt");
}
@TestMetadata("intersect.kt")
public void testIntersect() throws Exception {
runTest("compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/intersect.kt");
}
@TestMetadata("memberScope.kt")
public void testMemberScope() throws Exception {
runTest("compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/memberScope.kt");
}
@TestMetadata("nullability.kt")
public void testNullability() throws Exception {
runTest("compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/nullability.kt");
}
@TestMetadata("renderingStubTypes.kt")
public void testRenderingStubTypes() throws Exception {
runTest("compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/renderingStubTypes.kt");
}
}
}
@TestMetadata("compiler/testData/diagnostics/tests/inference/capturedTypes")
@@ -28249,6 +28345,41 @@ public class DiagnosisCompilerTestFE10TestdataTestGenerated extends AbstractDiag
public void testCompleteIrrelevantCalls() throws Exception {
runTest("compiler/testData/diagnostics/testsWithStdLib/builderInference/completeIrrelevantCalls.kt");
}
@TestMetadata("incorrectCalls.kt")
public void testIncorrectCalls() throws Exception {
runTest("compiler/testData/diagnostics/testsWithStdLib/builderInference/incorrectCalls.kt");
}
@TestMetadata("incorrectCallsWithRestrictions.kt")
public void testIncorrectCallsWithRestrictions() throws Exception {
runTest("compiler/testData/diagnostics/testsWithStdLib/builderInference/incorrectCallsWithRestrictions.kt");
}
@TestMetadata("inferCoroutineTypeInOldVersion.kt")
public void testInferCoroutineTypeInOldVersion() throws Exception {
runTest("compiler/testData/diagnostics/testsWithStdLib/builderInference/inferCoroutineTypeInOldVersion.kt");
}
@TestMetadata("resolveUsualCallWithBuilderInference.kt")
public void testResolveUsualCallWithBuilderInference() throws Exception {
runTest("compiler/testData/diagnostics/testsWithStdLib/builderInference/resolveUsualCallWithBuilderInference.kt");
}
@TestMetadata("resolveUsualCallWithBuilderInferenceWithRestrictions.kt")
public void testResolveUsualCallWithBuilderInferenceWithRestrictions() throws Exception {
runTest("compiler/testData/diagnostics/testsWithStdLib/builderInference/resolveUsualCallWithBuilderInferenceWithRestrictions.kt");
}
@TestMetadata("useInferenceInformationFromExtension.kt")
public void testUseInferenceInformationFromExtension() throws Exception {
runTest("compiler/testData/diagnostics/testsWithStdLib/builderInference/useInferenceInformationFromExtension.kt");
}
@TestMetadata("useInferenceInformationFromExtensionWithRestrictions.kt")
public void testUseInferenceInformationFromExtensionWithRestrictions() throws Exception {
runTest("compiler/testData/diagnostics/testsWithStdLib/builderInference/useInferenceInformationFromExtensionWithRestrictions.kt");
}
}
@TestMetadata("compiler/testData/diagnostics/testsWithStdLib/builtins")
@@ -29334,16 +29465,6 @@ public class DiagnosisCompilerTestFE10TestdataTestGenerated extends AbstractDiag
runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/extensionsWithNonValuableConstraints_1_2.kt");
}
@TestMetadata("incorrectCalls.kt")
public void testIncorrectCalls() throws Exception {
runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/incorrectCalls.kt");
}
@TestMetadata("inferCoroutineTypeInOldVersion.kt")
public void testInferCoroutineTypeInOldVersion() throws Exception {
runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/inferCoroutineTypeInOldVersion.kt");
}
@TestMetadata("inferenceFromMethodInsideLocalVariable.kt")
public void testInferenceFromMethodInsideLocalVariable() throws Exception {
runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/inferenceFromMethodInsideLocalVariable.kt");
@@ -29464,11 +29585,6 @@ public class DiagnosisCompilerTestFE10TestdataTestGenerated extends AbstractDiag
runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/recursiveGenerators2.kt");
}
@TestMetadata("resolveUsualCallWithBuilderInference.kt")
public void testResolveUsualCallWithBuilderInference() throws Exception {
runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/resolveUsualCallWithBuilderInference.kt");
}
@TestMetadata("returnTypeInference.kt")
public void testReturnTypeInference() throws Exception {
runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/returnTypeInference.kt");
@@ -29509,11 +29625,6 @@ public class DiagnosisCompilerTestFE10TestdataTestGenerated extends AbstractDiag
runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/typeFromReceiver.kt");
}
@TestMetadata("useInferenceInformationFromExtension.kt")
public void testUseInferenceInformationFromExtension() throws Exception {
runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/useInferenceInformationFromExtension.kt");
}
@TestMetadata("variableCallInsideBuilderFunction.kt")
public void testVariableCallInsideBuilderFunction() throws Exception {
runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/variableCallInsideBuilderFunction.kt");