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/tests/AutoCreatedIt.kt
Vendored
+5 -5
View File
@@ -2,17 +2,17 @@ fun text() {
"direct:a" to "mock:a"
"direct:a" on {it.body == "<hello/>"} to "mock:a"
"direct:a" on {it -> it.body == "<hello/>"} to "mock:a"
bar <!TYPE_MISMATCH{NI}!><!EXPECTED_PARAMETERS_NUMBER_MISMATCH!>{<!>1}<!>
bar <!TYPE_MISMATCH{NI}!><!EXPECTED_PARAMETERS_NUMBER_MISMATCH!>{<!><!UNRESOLVED_REFERENCE!>it<!> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{OI}, DEBUG_INFO_MISSING_UNRESOLVED{NI}!>+<!> 1}<!>
bar <!TYPE_MISMATCH!><!EXPECTED_PARAMETERS_NUMBER_MISMATCH!>{<!>1}<!>
bar <!TYPE_MISMATCH!><!EXPECTED_PARAMETERS_NUMBER_MISMATCH!>{<!><!UNRESOLVED_REFERENCE!>it<!> <!DEBUG_INFO_MISSING_UNRESOLVED!>+<!> 1}<!>
bar {it, it1 -> it}
bar1 {1}
bar1 {it + 1}
bar2 <!TYPE_MISMATCH{NI}!>{<!TYPE_MISMATCH!><!>}<!>
bar2 <!TYPE_MISMATCH!>{<!TYPE_MISMATCH!><!>}<!>
bar2 {1}
bar2 <!TYPE_MISMATCH{NI}!>{<!UNRESOLVED_REFERENCE!>it<!>}<!>
bar2 <!TYPE_MISMATCH{NI}!>{<!CANNOT_INFER_PARAMETER_TYPE, EXPECTED_PARAMETERS_NUMBER_MISMATCH!>it<!> -> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{OI}, TYPE_MISMATCH{NI}!>it<!>}<!>
bar2 <!TYPE_MISMATCH!>{<!UNRESOLVED_REFERENCE!>it<!>}<!>
bar2 <!TYPE_MISMATCH!>{<!CANNOT_INFER_PARAMETER_TYPE, EXPECTED_PARAMETERS_NUMBER_MISMATCH!>it<!> -> <!TYPE_MISMATCH!>it<!>}<!>
}
fun bar(f : (Int, Int) -> Int) {}
compiler/testData/diagnostics/tests/BinaryCallsOnNullableValues.kt
Vendored
+3 -3
View File
@@ -5,10 +5,10 @@ class A() {
fun f(): Unit {
var x: Int? = <!VARIABLE_WITH_REDUNDANT_INITIALIZER!>1<!>
x = null
<!DEBUG_INFO_CONSTANT{OI}!>x<!> + 1
x + 1
<!DEBUG_INFO_CONSTANT!>x<!> <!INFIX_MODIFIER_REQUIRED!>plus<!> 1
<!DEBUG_INFO_CONSTANT!>x<!> <!UNSAFE_OPERATOR_CALL!><<!> 1
<!TYPE_MISMATCH!><!DEBUG_INFO_CONSTANT{OI}!>x<!> += 1<!>
<!TYPE_MISMATCH!>x += 1<!>
<!DEBUG_INFO_CONSTANT!>x<!> == 1
<!DEBUG_INFO_CONSTANT!>x<!> != 1
@@ -21,7 +21,7 @@ fun f(): Unit {
<!IMPLICIT_BOXING_IN_IDENTITY_EQUALS!><!DEBUG_INFO_CONSTANT!>x<!> === 1<!>
<!IMPLICIT_BOXING_IN_IDENTITY_EQUALS!><!DEBUG_INFO_CONSTANT!>x<!> !== 1<!>
<!DEBUG_INFO_CONSTANT{OI}!>x<!><!UNSAFE_OPERATOR_CALL!>..<!>2
x<!UNSAFE_OPERATOR_CALL!>..<!>2
<!DEBUG_INFO_CONSTANT, TYPE_MISMATCH!>x<!> in 1..2
val y : Boolean? = true
compiler/testData/diagnostics/tests/CompareToWithErrorType.kt
Vendored
+1 -1
View File
@@ -1,5 +1,5 @@
fun test() {
if (<!UNRESOLVED_REFERENCE!>x<!> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{OI}, DEBUG_INFO_MISSING_UNRESOLVED{NI}!>><!> 0) {
if (<!UNRESOLVED_REFERENCE!>x<!> <!DEBUG_INFO_MISSING_UNRESOLVED!>><!> 0) {
}
}
compiler/testData/diagnostics/tests/DefaultValuesTypechecking.kt
Vendored
+4 -4
View File
@@ -15,13 +15,13 @@ val z = 3
fun foo(x: Int = <!UNINITIALIZED_PARAMETER!>y<!>, y: Int = x, i : Int = z): Int = x + y
fun foo(x: () -> Int = { <!UNINITIALIZED_PARAMETER{OI}!>y<!> }, y: Int = x(), i : Int = z): Int = x() + y
fun foo(x: () -> Int = { y }, y: Int = x(), i : Int = z): Int = x() + y
fun bar(x: () -> Int = { <!UNINITIALIZED_PARAMETER{OI}!>y<!>; 1 }, y: Int) {}
fun bar(x: () -> Int = { y; 1 }, y: Int) {}
fun baz(
x: () -> Int = {
fun bar(xx: () -> Int = { <!UNINITIALIZED_PARAMETER{OI}!>y<!>; 1 }) = xx
fun bar(xx: () -> Int = { y; 1 }) = xx
bar()()
},
y: Int
@@ -30,7 +30,7 @@ fun baz(
fun boo(
x: () -> Int = {
fun bar(): Int = <!UNINITIALIZED_PARAMETER{OI}!>y<!>
fun bar(): Int = y
bar()
},
y: Int
compiler/testData/diagnostics/tests/FunctionCalleeExpressions.kt
Vendored
+8 -8
View File
@@ -29,26 +29,26 @@ fun <T> fooT2() : (t : T) -> T {
fun main(args : Array<String>) {
args.foo()()
args.foo1()(<!NO_VALUE_FOR_PARAMETER!>)<!>
<!UNRESOLVED_REFERENCE!>a<!>.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{OI}, DEBUG_INFO_MISSING_UNRESOLVED{NI}!>foo1<!>()()
<!UNRESOLVED_REFERENCE!>a<!>.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{OI}, DEBUG_INFO_MISSING_UNRESOLVED{NI}!>foo1<!>()(<!UNRESOLVED_REFERENCE!>a<!>)
<!UNRESOLVED_REFERENCE!>a<!>.<!DEBUG_INFO_MISSING_UNRESOLVED!>foo1<!>()()
<!UNRESOLVED_REFERENCE!>a<!>.<!DEBUG_INFO_MISSING_UNRESOLVED!>foo1<!>()(<!UNRESOLVED_REFERENCE!>a<!>)
args.foo1()(1)
args.foo1()(<!TYPE_MISMATCH!>"1"<!>)
<!UNRESOLVED_REFERENCE!>a<!>.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{OI}, DEBUG_INFO_MISSING_UNRESOLVED{NI}!>foo1<!>()("1")
<!UNRESOLVED_REFERENCE!>a<!>.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{OI}, DEBUG_INFO_MISSING_UNRESOLVED{NI}!>foo1<!>()(<!UNRESOLVED_REFERENCE!>a<!>)
<!UNRESOLVED_REFERENCE!>a<!>.<!DEBUG_INFO_MISSING_UNRESOLVED!>foo1<!>()("1")
<!UNRESOLVED_REFERENCE!>a<!>.<!DEBUG_INFO_MISSING_UNRESOLVED!>foo1<!>()(<!UNRESOLVED_REFERENCE!>a<!>)
foo2()({})
foo2()<!TOO_MANY_ARGUMENTS!>{}<!>
(foo2()){}
(foo2())<!TYPE_MISMATCH{NI}!>{<!CANNOT_INFER_PARAMETER_TYPE, EXPECTED_PARAMETERS_NUMBER_MISMATCH!>x<!> -> }<!>
foo2()(<!TYPE_MISMATCH{NI}!>{<!CANNOT_INFER_PARAMETER_TYPE, EXPECTED_PARAMETERS_NUMBER_MISMATCH!>x<!> -> }<!>)
(foo2())<!TYPE_MISMATCH!>{<!CANNOT_INFER_PARAMETER_TYPE, EXPECTED_PARAMETERS_NUMBER_MISMATCH!>x<!> -> }<!>
foo2()(<!TYPE_MISMATCH!>{<!CANNOT_INFER_PARAMETER_TYPE, EXPECTED_PARAMETERS_NUMBER_MISMATCH!>x<!> -> }<!>)
val a = fooT1(1)()
checkSubtype<Int>(a)
val b = fooT2<Int>()(1)
checkSubtype<Int>(b)
<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>fooT2<!>()(1) // : Any?
<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>fooT2<!>()(1) // : Any?
<!FUNCTION_EXPECTED!>1<!>()
<!FUNCTION_EXPECTED!>1<!>{}
@@ -78,7 +78,7 @@ fun main1() {
fun test() {
{x : Int -> 1}(<!NO_VALUE_FOR_PARAMETER!>)<!>;
(fun Int.() = 1)(<!NO_VALUE_FOR_PARAMETER!>)<!>
<!TYPE_MISMATCH{OI}!>"sd"<!>.<!FUNCTION_EXPECTED{NI}!>(fun Int.() = 1)<!>()
"sd".<!FUNCTION_EXPECTED!>(fun Int.() = 1)<!>()
val i : Int? = null
i<!UNSAFE_CALL!>.<!>(fun Int.() = 1)();
{}<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><Int><!>()
compiler/testData/diagnostics/tests/FunctionReturnTypes.kt
Vendored
+2 -2
View File
@@ -145,14 +145,14 @@ fun illegalConstantBlock(): String {
return <!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>
}
fun illegalIfBody(): Int =
if (1 < 2) <!CONSTANT_EXPECTED_TYPE_MISMATCH!>'a'<!> else <!TYPE_MISMATCH{NI}!>{ <!CONSTANT_EXPECTED_TYPE_MISMATCH{OI}!>1.0<!> }<!>
if (1 < 2) <!CONSTANT_EXPECTED_TYPE_MISMATCH!>'a'<!> else <!TYPE_MISMATCH!>{ 1.0 }<!>
fun illegalIfBlock(): Boolean {
if (1 < 2)
return false
else { return <!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!> }
}
fun illegalReturnIf(): Char {
return if (1 < 2) 'a' else <!TYPE_MISMATCH{NI}!>{ <!CONSTANT_EXPECTED_TYPE_MISMATCH{OI}!>1<!> }<!>
return if (1 < 2) 'a' else <!TYPE_MISMATCH!>{ 1 }<!>
}
fun returnNothing(): Nothing {
compiler/testData/diagnostics/tests/InvokeAndRecursiveResolve.kt
Vendored
+2 -2
View File
@@ -13,6 +13,6 @@ class B {
}
class C {
val bar = <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{OI}!><!DEBUG_INFO_MISSING_UNRESOLVED{NI}, UNINITIALIZED_VARIABLE{OI}!>test<!>()<!>
val test = <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM{NI}!><!DEBUG_INFO_MISSING_UNRESOLVED{NI}, FUNCTION_EXPECTED{OI}!>bar<!>()<!>
val bar = <!DEBUG_INFO_MISSING_UNRESOLVED!>test<!>()
val test = <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!><!DEBUG_INFO_MISSING_UNRESOLVED!>bar<!>()<!>
}
compiler/testData/diagnostics/tests/Nullability.fir.kt
Vendored
+1 -1
View File
@@ -145,7 +145,7 @@ fun test() {
out?.println();
val out2 : java.io.PrintStream? = null
while (out2 == null) {
out2?.println();
out2<!UNSAFE_CALL!>.<!>println();
compiler/testData/diagnostics/tests/Nullability.kt
Vendored
+2 -2
View File
@@ -145,10 +145,10 @@ fun test() {
<!DEBUG_INFO_CONSTANT!>out<!>?.println();
val out2 : java.io.PrintStream? = null
while (out2 == null) {
<!DEBUG_INFO_CONSTANT!>out2<!>?.println();
<!DEBUG_INFO_CONSTANT{OI}!>out2<!><!UNSAFE_CALL!>.<!>println();
out2<!UNSAFE_CALL!>.<!>println();
}
<!DEBUG_INFO_SMARTCAST!>out2<!>.println()
compiler/testData/diagnostics/tests/PackageQualified.kt
Vendored
+1 -1
View File
@@ -24,7 +24,7 @@ package foobar.a
// FILE: d.kt
package foobar
val x1 = <!UNRESOLVED_REFERENCE!>a<!>.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{OI}, DEBUG_INFO_MISSING_UNRESOLVED{NI}!>a<!>
val x1 = <!UNRESOLVED_REFERENCE!>a<!>.<!DEBUG_INFO_MISSING_UNRESOLVED!>a<!>
val x2 = foobar.a.a
val y1 = foobar.a.b
compiler/testData/diagnostics/tests/QualifiedExpressions.kt
Vendored
+2 -2
View File
@@ -4,8 +4,8 @@ fun test(s: IntRange?) {
val a: Int = <!TYPE_MISMATCH!>s?.start<!>
val b: Int? = s?.start
val c: Int = s?.start ?: -11
val d: Int = <!TYPE_MISMATCH{NI}!>s?.start ?: <!TYPE_MISMATCH{OI}!>"empty"<!><!>
val e: String = <!TYPE_MISMATCH{NI}!><!TYPE_MISMATCH{OI}!>s?.start<!> ?: "empty"<!>
val d: Int = <!TYPE_MISMATCH!>s?.start ?: "empty"<!>
val e: String = <!TYPE_MISMATCH!>s?.start ?: "empty"<!>
val f: Int = s?.endInclusive ?: b ?: 1
val g: Boolean? = e.startsWith("s")//?.length
}
compiler/testData/diagnostics/tests/RecursiveTypeInference.kt
Vendored
+1 -1
View File
@@ -4,7 +4,7 @@
package a
val foo = bar()
fun bar() = <!DEBUG_INFO_MISSING_UNRESOLVED{NI}, TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>foo<!>
fun bar() = <!DEBUG_INFO_MISSING_UNRESOLVED, TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>foo<!>
// FILE: b.kt
package b
compiler/testData/diagnostics/tests/ReserveYield.kt
Vendored
+1 -1
View File
@@ -19,7 +19,7 @@ fun yield(yield: Int) {
val foo = <!YIELD_IS_RESERVED!>yield<!> + <!YIELD_IS_RESERVED!>yield<!>
val foo2 = <!YIELD_IS_RESERVED!>yield<!>
bar(<!YIELD_IS_RESERVED{OI}!>yield<!> = 5)
bar(yield = 5)
yield(4)
<!YIELD_IS_RESERVED!>yield<!> {}
compiler/testData/diagnostics/tests/ResolveOfJavaGenerics.kt
Vendored
+1 -1
View File
@@ -4,7 +4,7 @@ fun test(a : java.lang.annotation.RetentionPolicy) {
}
fun test() {
java.util.Collections.<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>emptyList<!>()
java.util.Collections.<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>emptyList<!>()
val a : Collection<String>? = java.util.Collections.emptyList()
}
compiler/testData/diagnostics/tests/ResolveToJava.kt
Vendored
+2 -2
View File
@@ -21,10 +21,10 @@ fun test(l : <!PLATFORM_CLASS_MAPPED_TO_KOTLIN!>java.util.List<Int><!>) {
val f : java.io.File? = null
Collections.<!FUNCTION_CALL_EXPECTED, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>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{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>emptyList<!>()
Collections.<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>emptyList<!>()
checkSubtype<Set<Int>?>(Collections.singleton<Int>(1))
Collections.singleton<Int>(<!CONSTANT_EXPECTED_TYPE_MISMATCH!>1.0<!>)
compiler/testData/diagnostics/tests/SafeCallUnknownType.kt
Vendored
+1 -1
View File
@@ -2,5 +2,5 @@ import <!UNRESOLVED_REFERENCE!>com<!>.<!DEBUG_INFO_MISSING_UNRESOLVED!>unknown<!
fun ff() {
val a = <!UNRESOLVED_REFERENCE!>unknown<!>()
val b = <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>a<!>?.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{OI}, DEBUG_INFO_MISSING_UNRESOLVED{NI}!>plus<!>(42)
val b = <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>a<!>?.<!DEBUG_INFO_MISSING_UNRESOLVED!>plus<!>(42)
}
compiler/testData/diagnostics/tests/StarsInFunctionCalls.kt
Vendored
+5 -6
View File
@@ -1,14 +1,13 @@
fun <T> getT() {}
fun <A, B> getTT() {}
fun <A, B, C> getTTT(x : Any) {}
fun foo(a : Any?) {}
public fun main() {
<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}!>getT<!><<!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>*<!>>()
<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getT<!><<!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>*<!>>()
<!UNRESOLVED_REFERENCE!>ggetT<!><<!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>*<!>>()
<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}!>getTT<!><<!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>*<!>, <!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>*<!>>()
<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}!>getTT<!><<!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>*<!>, Int>()
<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}!>getTT<!><Int, <!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>*<!>>()
foo(<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}!>getTTT<!><Int, <!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>*<!>, Int>(1))
<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getTT<!><<!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>*<!>, <!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>*<!>>()
<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getTT<!><<!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>*<!>, Int>()
<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getTT<!><Int, <!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>*<!>>()
foo(<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getTTT<!><Int, <!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>*<!>, Int>(1))
}
compiler/testData/diagnostics/tests/TypeInference.kt
Vendored
+2 -2
View File
@@ -9,10 +9,10 @@ fun main() {
val a : C<Int> = C();
val x : C<in String> = C()
val y : C<out String> = C()
val z : C<*> = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>C<!>()
val z : C<*> = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>C<!>()
val ba : C<Int> = bar();
val bx : C<in String> = bar()
val by : C<out String> = bar()
val bz : C<*> = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>bar<!>()
val bz : C<*> = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>bar<!>()
}
compiler/testData/diagnostics/tests/annotations/AmbigiousAnnotationConstructor.kt
Vendored
+1 -1
View File
@@ -1,5 +1,5 @@
import java.util.ArrayList
<!NOT_AN_ANNOTATION_CLASS{NI}!>@<!NONE_APPLICABLE{OI}!>ArrayList<!><Int>(<!TOO_MANY_ARGUMENTS{NI}!>1<!>, <!TOO_MANY_ARGUMENTS{NI}!>1<!>)<!> fun b() {}
<!NOT_AN_ANNOTATION_CLASS!>@ArrayList<Int>(<!TOO_MANY_ARGUMENTS!>1<!>, <!TOO_MANY_ARGUMENTS!>1<!>)<!> fun b() {}
@<!UNRESOLVED_REFERENCE!>Xoo<!>(<!UNRESOLVED_REFERENCE!>x<!>) fun c() {}
<!DEPRECATED_JAVA_ANNOTATION!>@java.lang.Deprecated(<!TOO_MANY_ARGUMENTS, UNRESOLVED_REFERENCE!>x<!>)<!> fun a() {}
compiler/testData/diagnostics/tests/annotations/annotationRenderingInTypes.kt
Vendored
+2 -2
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?> = <!TYPE_INFERENCE_CANNOT_CAPTURE_TYPES{OI}("'R' cannot capture 'in Int'. Type parameter has an upper bound 'Any' that cannot be satisfied capturing 'in' projection")!>f3<!>(<!TYPE_MISMATCH{NI}("Any; Int"), TYPE_MISMATCH{NI}("Any; Int")!>a<!>)
val r: Array<in Int?> = f3(<!TYPE_MISMATCH("Any; Int"), TYPE_MISMATCH("Any; Int")!>a<!>)
}
@@ -22,4 +22,4 @@ var test3: Int = 0
fun f4(fn: (@Ann Int, @Ann Int) -> Unit) {}
val test4 = f4 <!TYPE_MISMATCH{NI}("(Int, Int) -> Unit; (Int) -> Unit")!>{ <!EXPECTED_PARAMETERS_NUMBER_MISMATCH("2; Int, Int")!>single<!> -> }<!>
val test4 = f4 <!TYPE_MISMATCH("(Int, Int) -> Unit; (Int) -> Unit")!>{ <!EXPECTED_PARAMETERS_NUMBER_MISMATCH("2; Int, Int")!>single<!> -> }<!>
compiler/testData/diagnostics/tests/annotations/options/functions.kt
Vendored
+1 -1
View File
@@ -33,7 +33,7 @@ fun foo(arg: Int) {
val f = @FunAnn fun(): Int { return 42 }
// But here, f and gav should be annotated instead
bar(<!WRONG_ANNOTATION_TARGET!>@FunAnn<!> f)
bar(<!WRONG_ANNOTATION_TARGET{OI}!>@<!DEBUG_INFO_MISSING_UNRESOLVED{NI}!>FunAnn<!><!> ::gav)
bar(@<!DEBUG_INFO_MISSING_UNRESOLVED!>FunAnn<!> ::gav)
// Function expression, ok
fast(f)
}
compiler/testData/diagnostics/tests/annotations/options/targets/field.fir.kt
Vendored
+1 -1
View File
@@ -1,4 +1,4 @@
@Target(AnnotationTarget.FIELD)
@Target(AnnotationTarget.FIELD)
annotation class Field
<!WRONG_ANNOTATION_TARGET!>@Field<!>
compiler/testData/diagnostics/tests/annotations/options/targets/field.kt
Vendored
+2 -2
View File
@@ -1,4 +1,4 @@
@Target(AnnotationTarget.FIELD)
@Target(AnnotationTarget.FIELD)
annotation class Field
<!WRONG_ANNOTATION_TARGET!>@Field<!>
@@ -27,7 +27,7 @@ abstract class My(<!WRONG_ANNOTATION_TARGET!>@Field<!> arg: Int, @Field val w: I
fun foo() {}
<!WRONG_ANNOTATION_TARGET!>@Field<!>
val v: Int by <!UNRESOLVED_REFERENCE!>Delegates<!>.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{OI}, DEBUG_INFO_MISSING_UNRESOLVED{NI}!>lazy<!> { 42 }
val v: Int by <!UNRESOLVED_REFERENCE!>Delegates<!>.<!DEBUG_INFO_MISSING_UNRESOLVED!>lazy<!> { 42 }
}
enum class Your {
compiler/testData/diagnostics/tests/annotations/rendering/memberProjectedOut.kt
Vendored
+1 -1
View File
@@ -11,5 +11,5 @@ class C<T> {
}
fun test(a: C<out CharSequence>) {
<!MEMBER_PROJECTED_OUT{OI}("public final operator fun set(x: Int, y: T): Unit defined in C; C<out CharSequence>")!>a[1]<!> = <!CONSTANT_EXPECTED_TYPE_MISMATCH{NI}("integer; Nothing")!>25<!>
a[1] = <!CONSTANT_EXPECTED_TYPE_MISMATCH("integer; Nothing")!>25<!>
}
compiler/testData/diagnostics/tests/annotations/rendering/typeMismatchDueToTypeProjections.kt
Vendored
+1 -1
View File
@@ -13,5 +13,5 @@ class C<T> {
class Out<out F>
fun test(a: C<out CharSequence>, y: Out<CharSequence>) {
a + <!TYPE_MISMATCH{NI}("Out<Nothing>; Out<CharSequence>"), TYPE_MISMATCH_DUE_TO_TYPE_PROJECTIONS{OI}!>y<!>
a + <!TYPE_MISMATCH("Out<Nothing>; Out<CharSequence>")!>y<!>
}
compiler/testData/diagnostics/tests/callableReference/bound/reservedExpressionSyntax3.kt
Vendored
+1 -1
View File
@@ -22,7 +22,7 @@ class Test {
val Int.c: Int get() = 42
val test1: () -> Right = <!RESERVED_SYNTAX_IN_CALLABLE_REFERENCE_LHS!><!DEBUG_INFO_MISSING_UNRESOLVED!>a<!>.<!DEBUG_INFO_MISSING_UNRESOLVED!>b<!><<!DEBUG_INFO_MISSING_UNRESOLVED!>Int<!>>.<!DEBUG_INFO_MISSING_UNRESOLVED!>c<!><!>::<!DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>
val test1a: () -> Right = a.<!DEBUG_INFO_LEAKING_THIS{NI}!>b<!>.<!DEBUG_INFO_LEAKING_THIS{NI}!>c<!>::foo
val test1a: () -> Right = a.<!DEBUG_INFO_LEAKING_THIS!>b<!>.<!DEBUG_INFO_LEAKING_THIS!>c<!>::foo
val test2: () -> Right = <!RESERVED_SYNTAX_IN_CALLABLE_REFERENCE_LHS!><!DEBUG_INFO_MISSING_UNRESOLVED!>a<!>.<!DEBUG_INFO_MISSING_UNRESOLVED!>b<!><<!DEBUG_INFO_MISSING_UNRESOLVED!>Int<!>>.<!DEBUG_INFO_MISSING_UNRESOLVED!>c<!><!>?::<!DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>
}
compiler/testData/diagnostics/tests/callableReference/constraintFromLHSWithCorrectDirection.kt
Vendored
+1 -1
View File
@@ -18,6 +18,6 @@ fun <K, V> B<K>.star(p: KProperty1<*, V>): B<V> = TODO()
fun <R : A> B<R>.test(){
foo(A::bla)
bar(A::bla)
<!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}!>baz<!>(<!TYPE_MISMATCH{NI}!>A::bla<!>)
baz(<!TYPE_MISMATCH!>A::bla<!>)
star(A::bla)
}
compiler/testData/diagnostics/tests/callableReference/expectedTypeAsSubtypeOfFunctionType.kt
Vendored
+2 -2
View File
@@ -7,6 +7,6 @@ fun <T> takeIt(x: T, f: SubFunction) {}
fun cr() {}
fun test() {
<!TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR{OI}!>takeIt<!>(42, <!TYPE_MISMATCH!>::cr<!>)
<!TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR{OI}!>takeIt<!>(42, <!TYPE_MISMATCH!>{ }<!>)
takeIt(42, <!TYPE_MISMATCH!>::cr<!>)
takeIt(42, <!TYPE_MISMATCH!>{ }<!>)
}
compiler/testData/diagnostics/tests/callableReference/function/lhsNotAClass.kt
Vendored
+2 -3
View File
@@ -1,13 +1,12 @@
class A<T, U : Any> {
fun foo() = <!CALLABLE_REFERENCE_LHS_NOT_A_CLASS!>T::<!UNRESOLVED_REFERENCE!>toString<!><!>
fun bar() = <!CALLABLE_REFERENCE_LHS_NOT_A_CLASS!>U::<!UNRESOLVED_REFERENCE!>toString<!><!>
fun baz() {
take(<!CALLABLE_REFERENCE_LHS_NOT_A_CLASS!>T::<!UNRESOLVED_REFERENCE{OI}!>toString<!><!>)
take(<!CALLABLE_REFERENCE_LHS_NOT_A_CLASS!>T::toString<!>)
take(<!CALLABLE_REFERENCE_LHS_NOT_A_CLASS!>U::<!UNRESOLVED_REFERENCE{OI}!>toString<!><!>)
take(<!CALLABLE_REFERENCE_LHS_NOT_A_CLASS!>U::toString<!>)
}
}
compiler/testData/diagnostics/tests/callableReference/function/unresolved.kt
Vendored
+2 -2
View File
@@ -17,7 +17,7 @@ fun test2() {
fun foo() {}
<!UNRESOLVED_REFERENCE!>Unresolved<!>::<!DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>
foo(<!UNRESOLVED_REFERENCE!>Unresolved<!>::<!CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY{NI}, DEBUG_INFO_MISSING_UNRESOLVED{OI}!>foo<!>)
foo(<!UNRESOLVED_REFERENCE!>Unresolved<!>::<!DEBUG_INFO_MISSING_UNRESOLVED{OI}, UNRESOLVED_REFERENCE{NI}!>unresolved<!>)
foo(<!UNRESOLVED_REFERENCE!>Unresolved<!>::<!CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY!>foo<!>)
foo(<!UNRESOLVED_REFERENCE!>Unresolved<!>::<!UNRESOLVED_REFERENCE!>unresolved<!>)
::<!UNRESOLVED_REFERENCE!>unresolved<!>
}
compiler/testData/diagnostics/tests/callableReference/functionReferenceWithDefaultValueAsOtherFunctionType.kt
Vendored
+1 -2
View File
@@ -1,4 +1,3 @@
fun foo(a: String, b: Int = 5): String {
return a + b
}
@@ -12,6 +11,6 @@ fun bar2(body: (String, Int) -> String): String {
}
fun test() {
bar1(<!TYPE_MISMATCH{OI}!>::foo<!>)
bar1(::foo)
bar2(::foo)
}
compiler/testData/diagnostics/tests/callableReference/generic/argumentAndReturnExpectedType.kt
Vendored
+2 -2
View File
@@ -15,9 +15,9 @@ fun test1() {
bar("", 1, ::foo).checkType { _<Pair<String, Int>>() }
bar("", 1, ::fooReturnInt).checkType { _<Pair<String, Int>>() }
bar("", 1, ::fooTakeString).checkType { _<Pair<String, Int>>() }
bar("", "", ::fooReturnInt).checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER{NI}!>_<!><Pair<String, Any>>() }
bar("", "", ::fooReturnInt).checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><Pair<String, Any>>() }
val x: String = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>bar("", "", ::fooReturnInt)<!>
val x: String = <!TYPE_MISMATCH, TYPE_MISMATCH!>bar("", "", ::fooReturnInt)<!>
baz(Int::toString, ::foo).checkType { _<Pair<Int, String>>() }
}
compiler/testData/diagnostics/tests/callableReference/generic/explicitTypeArguments.kt
Vendored
+2 -2
View File
@@ -13,12 +13,12 @@ fun <T> Wrapper<T>.baz(transform: (T) -> Unit): T = TODO()
fun test() {
takeFun<String>(::foo)
takeFun<String>(<!TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>::<!TYPE_INFERENCE_UPPER_BOUND_VIOLATED{OI}!>fooInt<!><!>)
takeFun<String>(<!TYPE_MISMATCH, 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/genericExtensionFunction.kt
Vendored
+2 -2
View File
@@ -22,8 +22,8 @@ fun test1() {
fun <T> test2() {
bar<Wrapper, Int, String>(Wrapper::fooReturnString).checkType { _<Tripple<Wrapper, Int, String>>() }
bar<Wrapper, T, String>(Wrapper::fooReturnString).checkType { _<Tripple<Wrapper, T, String>>() }
bar<Wrapper, T, T>(<!TYPE_MISMATCH{NI}!>Wrapper::<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}!>fooReturnString<!><!>)
bar<Wrapper, Int, Int>(<!TYPE_MISMATCH{NI}!>Wrapper::<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}!>fooReturnString<!><!>)
bar<Wrapper, T, T>(<!TYPE_MISMATCH!>Wrapper::fooReturnString<!>)
bar<Wrapper, Int, Int>(<!TYPE_MISMATCH!>Wrapper::fooReturnString<!>)
bar<Wrapper, Int, T>(Wrapper::fooTakeInt).checkType { _<Tripple<Wrapper, Int, T>>() }
bar<Wrapper, Int, String>(Wrapper::fooTakeInt).checkType { _<Tripple<Wrapper, Int, String>>() }
compiler/testData/diagnostics/tests/callableReference/generic/genericFunctionsWithNullableTypes.kt
Vendored
+3 -3
View File
@@ -28,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}, 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, 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/callableReference/generic/nestedCallWithOverload.kt
Vendored
+1 -1
View File
@@ -10,7 +10,7 @@ fun test() {
val x2: (Int) -> Unit = baz(id(::foo), ::foo)
val x3: (Int) -> Unit = baz(id(::foo), id(id(::foo)))
val x4: (String) -> Unit = baz(id(::foo), id(id(::foo)))
val x5: (Double) -> Unit = baz(id(::<!CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY{NI}, NONE_APPLICABLE{OI}!>foo<!>), id(id(::<!CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY{NI}, NONE_APPLICABLE{OI}!>foo<!>)))
val x5: (Double) -> Unit = baz(id(::<!CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY!>foo<!>), id(id(::<!CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY!>foo<!>)))
id<(Int) -> Unit>(id(id(::foo)))
compiler/testData/diagnostics/tests/callableReference/generic/resolutionGenericCallableWithNullableTypes.kt
Vendored
+3 -3
View File
@@ -16,7 +16,7 @@ fun test1() {
baz<String>(::foo).checkType { _<String?>() }
baz<Boolean>(::foo).checkType { _<Boolean?>() }
val b1: Int = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>baz(::<!CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY{NI}!>foo<!>)<!>
val b2: String = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>baz(::<!CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY{NI}!>foo<!>)<!>
val b3: Boolean = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>baz(::<!CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY{NI}!>foo<!>)<!>
val b1: Int = <!TYPE_MISMATCH, TYPE_MISMATCH!>baz(::<!CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY!>foo<!>)<!>
val b2: String = <!TYPE_MISMATCH, TYPE_MISMATCH!>baz(::<!CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY!>foo<!>)<!>
val b3: Boolean = <!TYPE_MISMATCH, TYPE_MISMATCH!>baz(::<!CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY!>foo<!>)<!>
}
compiler/testData/diagnostics/tests/callableReference/generic/resolutionWithGenericCallable.kt
Vendored
+4 -4
View File
@@ -4,9 +4,9 @@ fun test() {
val a1: Array<Double.(Double) -> Double> = arrayOf(Double::plus, Double::minus)
val a2: Array<Double.(Int) -> Double> = arrayOf(Double::plus, Double::minus)
val a3: Array<Int.(Int) -> Double> = arrayOf(Double::<!CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY{NI}, NONE_APPLICABLE{OI}!>plus<!>, Double::<!CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY{NI}, NONE_APPLICABLE{OI}!>minus<!>)
val a4: Array<Int.(Double) -> Double> = arrayOf(Int::plus, Double::<!CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY{NI}, NONE_APPLICABLE{OI}!>minus<!>)
val a5: Array<Double.(Double) -> Double> = arrayOf(Double::plus, Int::<!CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY{NI}, NONE_APPLICABLE{OI}!>minus<!>)
val a3: Array<Int.(Int) -> Double> = arrayOf(Double::<!CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY!>plus<!>, Double::<!CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY!>minus<!>)
val a4: Array<Int.(Double) -> Double> = arrayOf(Int::plus, Double::<!CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY!>minus<!>)
val a5: Array<Double.(Double) -> Double> = arrayOf(Double::plus, Int::<!CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY!>minus<!>)
}
fun foo(x: Int) {}
@@ -17,5 +17,5 @@ fun <T> bar(x: T, f: (T) -> Unit) {}
fun test2() {
bar(1, ::foo)
bar("", ::foo)
bar(1.0, ::<!CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY{NI}, NONE_APPLICABLE{OI}!>foo<!>)
bar(1.0, ::<!CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY!>foo<!>)
}
compiler/testData/diagnostics/tests/callableReference/kt34314.kt
Vendored
+1 -1
View File
@@ -1,5 +1,5 @@
// !DIAGNOSTICS: -UNUSED_VARIABLE
fun main() {
val x = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}!>run<!> { <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}!>::<!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>run<!><!> } // no error
val x = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>run<!> { <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>::run<!> } // no error
}
compiler/testData/diagnostics/tests/callableReference/kt34314_lambda.kt
Vendored
+1 -1
View File
@@ -3,5 +3,5 @@
fun <T> materialize(): T = TODO()
fun main() {
val x = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}!>run<!> { <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>materialize<!>() }
val x = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>run<!> { <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>materialize<!>() }
}
compiler/testData/diagnostics/tests/callableReference/resolve/byGenericArgType.kt
Vendored
+1 -1
View File
@@ -7,4 +7,4 @@ fun foo(s: String) {}
val x1 = ofType<() -> Unit>(::foo)
val x2 = ofType<(String) -> Unit>(::foo)
val x3 = ofType<(Int) -> Unit>(::<!CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY{NI}, NONE_APPLICABLE{OI}!>foo<!>)
val x3 = ofType<(Int) -> Unit>(::<!CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY!>foo<!>)
compiler/testData/diagnostics/tests/callableReference/resolve/intersectionTypeOverloadWithWrongParameter.kt
Vendored
+1 -1
View File
@@ -10,7 +10,7 @@ class Foo {
}
fun foo() {
<!NONE_APPLICABLE{NI}, OVERLOAD_RESOLUTION_AMBIGUITY{OI}!>installRoute<!><Any>(::route)
<!NONE_APPLICABLE!>installRoute<!><Any>(::route)
}
}
compiler/testData/diagnostics/tests/callableReference/resolve/withGenericFun.kt
Vendored
+1 -1
View File
@@ -8,4 +8,4 @@ fun foo(s: String) {}
val x1 = apply(1, ::foo)
val x2 = apply("hello", ::foo)
val x3 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>apply<!>(true, ::<!CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY{NI}, NONE_APPLICABLE{OI}!>foo<!>)
val x3 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>apply<!>(true, ::<!CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY!>foo<!>)
compiler/testData/diagnostics/tests/callableReference/resolve/withPlaceholderTypes.kt
Vendored
+2 -2
View File
@@ -21,7 +21,7 @@ val x1 = fn1(1, ::foo, ::foo)
val x2 = fn1(1, ::foo, ::bar)
val x3 = fn2(::bar, ::foo)
val x4 = <!OVERLOAD_RESOLUTION_AMBIGUITY!>fn2<!>(::<!DEBUG_INFO_MISSING_UNRESOLVED{NI}, OVERLOAD_RESOLUTION_AMBIGUITY{OI}!>foo<!>, ::bar)
val x5 = <!OVERLOAD_RESOLUTION_AMBIGUITY!>fn2<!>(::<!DEBUG_INFO_MISSING_UNRESOLVED{NI}, OVERLOAD_RESOLUTION_AMBIGUITY{OI}!>foo<!>, ::<!DEBUG_INFO_MISSING_UNRESOLVED{NI}, OVERLOAD_RESOLUTION_AMBIGUITY{OI}!>foo<!>)
val x4 = <!OVERLOAD_RESOLUTION_AMBIGUITY!>fn2<!>(::<!DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>, ::bar)
val x5 = <!OVERLOAD_RESOLUTION_AMBIGUITY!>fn2<!>(::<!DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>, ::<!DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>)
val x6 = fn3(1, ::qux)
compiler/testData/diagnostics/tests/cast/AsInBlockWithReturnType.kt
Vendored
+6 -6
View File
@@ -5,7 +5,7 @@ fun runWithoutReturn(r: () -> Unit) = r()
fun testRun() {
run {
1 <!USELESS_CAST!>as Any<!>
1 <!USELESS_CAST{NI}!>as Any<!>
1 <!USELESS_CAST!>as Any<!>
}
run<Any> {
@@ -16,11 +16,11 @@ fun testRun() {
fun foo(): Int = 1
run {
foo() <!USELESS_CAST{NI}!>as Any<!>
foo() <!USELESS_CAST!>as Any<!>
}
run {
(if (true) 1 else 2) <!USELESS_CAST{NI}!>as Any<!>
(if (true) 1 else 2) <!USELESS_CAST!>as Any<!>
}
run<Int?> {
@@ -35,17 +35,17 @@ fun testRun() {
}
fun testReturn(): Number {
run { 1 <!USELESS_CAST{NI}!>as Number<!> }
run { 1 <!USELESS_CAST!>as Number<!> }
return run { 1 <!USELESS_CAST!>as Number<!> }
}
fun <T> testDependent() {
listOf(1).map {
it <!USELESS_CAST!>as Any<!>
it <!USELESS_CAST{NI}!>as Any<!>
it <!USELESS_CAST!>as Any<!>
}
listOf<T>().map { it <!USELESS_CAST{NI}!>as Any?<!> }
listOf<T>().map { it <!USELESS_CAST!>as Any?<!> }
}
fun <T> listOf(vararg elements: T): List<T> = TODO()
compiler/testData/diagnostics/tests/cast/UselessSafeCast.kt
Vendored
+1 -1
View File
@@ -10,7 +10,7 @@ fun test(x: Int?) {
val a7: Number? = 1 <!USELESS_CAST!>as? Number<!>
run { x <!USELESS_CAST!>as? Int<!> }
run { x <!USELESS_CAST{NI}!>as? Number<!> }
run { x <!USELESS_CAST!>as? Number<!> }
foo(x as? Number)
compiler/testData/diagnostics/tests/cast/kt15161.kt
Vendored
+1 -1
View File
@@ -1,6 +1,6 @@
class Array<E>(e: E) {
val k = Array(1) {
1 <!USELESS_CAST!>as Any<!>
e <!USELESS_CAST{NI}!>as Any?<!>
e <!USELESS_CAST!>as Any?<!>
}
}
compiler/testData/diagnostics/tests/checkArguments/SpreadVarargs.kt
Vendored
+3 -3
View File
@@ -43,10 +43,10 @@ fun main() {
joinG(1, "2")
joinG(<!NON_VARARG_SPREAD!>*<!>1, "2")
<!TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR{OI}!>joinG<!>(1, *<!TYPE_MISMATCH!>"2"<!>)
joinG(1, *<!TYPE_MISMATCH!>"2"<!>)
joinG(x = 1, a = a)
<!TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR{OI}!>joinG<!>(x = 1, a = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION_ERROR, TYPE_MISMATCH!>"2"<!>)
<!TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR{OI}!>joinG<!>(x = <!NON_VARARG_SPREAD!>*<!>1, a = *<!TYPE_MISMATCH!>"2"<!>)
joinG(x = 1, a = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION_ERROR, TYPE_MISMATCH!>"2"<!>)
joinG(x = <!NON_VARARG_SPREAD!>*<!>1, a = *<!TYPE_MISMATCH!>"2"<!>)
joinG(1, *a)
joinG(1, *a, "3")
joinG(1, "4", *a, "3")
compiler/testData/diagnostics/tests/checkArguments/arrayAccessSetTooManyArgs.kt
Vendored
+1 -1
View File
@@ -5,6 +5,6 @@ class A {
operator fun set(x: String, value: Int) {}
fun d(x: Int) {
this["", <!TOO_MANY_ARGUMENTS{OI}!>1<!>] = <!TOO_MANY_ARGUMENTS{NI}!>1<!>
this["", 1] = <!TOO_MANY_ARGUMENTS!>1<!>
}
}
compiler/testData/diagnostics/tests/checkArguments/kt1897_diagnostic_part.kt
Vendored
+1 -1
View File
@@ -20,7 +20,7 @@ fun test() {
foo(<!TYPE_MISMATCH!>""<!>, s = <!CONSTANT_EXPECTED_TYPE_MISMATCH!>2<!>)
foo(i = <!TYPE_MISMATCH!>""<!>, s = <!CONSTANT_EXPECTED_TYPE_MISMATCH!>2<!>, <!MIXING_NAMED_AND_POSITIONED_ARGUMENTS{OI}, TOO_MANY_ARGUMENTS{NI}!>33<!>)
foo(i = <!TYPE_MISMATCH!>""<!>, s = <!CONSTANT_EXPECTED_TYPE_MISMATCH!>2<!>, <!TOO_MANY_ARGUMENTS!>33<!>)
foo(<!TYPE_MISMATCH!>""<!>, <!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>) <!TOO_MANY_ARGUMENTS!>{}<!>
compiler/testData/diagnostics/tests/checkArguments/overloadedFunction.kt
Vendored
+1 -1
View File
@@ -11,6 +11,6 @@ fun test() {
<!NONE_APPLICABLE!>foo<!>(1, 2)
foo(<!TYPE_MISMATCH!>""<!>)
<!NONE_APPLICABLE{OI}!>bar<!>(1, <!TOO_MANY_ARGUMENTS{NI}!>2<!>)
bar(1, <!TOO_MANY_ARGUMENTS!>2<!>)
<!NONE_APPLICABLE!>bar<!>()
}
compiler/testData/diagnostics/tests/checkType.kt
Vendored
+2 -2
View File
@@ -6,6 +6,6 @@ interface C : B
fun test(b: B) {
b checkType { _<B>() }
b checkType { <!TYPE_MISMATCH{OI}, UNRESOLVED_REFERENCE_WRONG_RECEIVER{NI}!>_<!><A>() }
b checkType { <!TYPE_MISMATCH{OI}, UNRESOLVED_REFERENCE_WRONG_RECEIVER{NI}!>_<!><C>() }
b checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><A>() }
b checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><C>() }
}
compiler/testData/diagnostics/tests/collectionLiterals/argumentsOfAnnotation.kt
Vendored
+1 -1
View File
@@ -8,7 +8,7 @@ fun test1() {}
@Foo([], [], [])
fun test2() {}
@Foo([<!CONSTANT_EXPECTED_TYPE_MISMATCH!>1f<!>], <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>[' ']<!>, [<!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>])
@Foo([<!CONSTANT_EXPECTED_TYPE_MISMATCH!>1f<!>], <!TYPE_MISMATCH, TYPE_MISMATCH!>[' ']<!>, [<!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>])
fun test3() {}
@Foo(c = [1f], b = [""], a = [1])
compiler/testData/diagnostics/tests/collectionLiterals/argumentsOfAnnotationWithKClass.kt
Vendored
+2 -2
View File
@@ -20,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}, TYPE_MISMATCH{NI}!>[""]<!>)
@Foo(<!TYPE_MISMATCH, TYPE_MISMATCH!>[""]<!>)
fun test5() {}
@Foo(<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>[Int::class, 1]<!>)
@Foo(<!TYPE_MISMATCH, TYPE_MISMATCH!>[Int::class, 1]<!>)
fun test6() {}
@Bar
compiler/testData/diagnostics/tests/collectionLiterals/basicCollectionLiterals.kt
Vendored
+3 -3
View File
@@ -2,11 +2,11 @@
// !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}, TYPE_MISMATCH{NI}!>[1]<!>
val e: Array<String> = <!TYPE_MISMATCH, TYPE_MISMATCH!>[1]<!>
val f: IntArray = [1, 2]
val g = [f]
@@ -19,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/collectionLiteralsWithVarargs.kt
Vendored
+3 -3
View File
@@ -16,7 +16,7 @@ fun test1_0() {}
@Ann1(*["a", "b"])
fun test1_1() {}
@Ann1(*<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>["a", 1, <!ANNOTATION_ARGUMENT_MUST_BE_CONST!>null<!>]<!>)
@Ann1(*<!TYPE_MISMATCH, TYPE_MISMATCH!>["a", 1, <!ANNOTATION_ARGUMENT_MUST_BE_CONST!>null<!>]<!>)
fun test1_2() {}
@Ann2(*[])
@@ -33,8 +33,8 @@ fun test6() {}
annotation class AnnArray(val a: Array<String>)
@AnnArray(<!NON_VARARG_SPREAD{OI}!>*<!>["/"])
@AnnArray(*["/"])
fun testArray() {}
@Ann1(<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH, TYPE_MISMATCH!>[""]<!>)
@Ann1(<!TYPE_MISMATCH, TYPE_MISMATCH!>[""]<!>)
fun testVararg() {}
compiler/testData/diagnostics/tests/collectionLiterals/defaultValuesInAnnotation.kt
Vendored
+4 -4
View File
@@ -7,9 +7,9 @@ annotation class Foo(
)
annotation class Bar(
val a: Array<String> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}, 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}, TYPE_MISMATCH{NI}!>[1]<!>
val a: Array<String> = <!TYPE_MISMATCH, TYPE_MISMATCH!>[' ']<!>,
val b: Array<String> = <!ANNOTATION_PARAMETER_DEFAULT_VALUE_MUST_BE_CONSTANT, TYPE_MISMATCH!>["", <!EMPTY_CHARACTER_LITERAL!>''<!>]<!>,
val c: Array<String> = <!TYPE_MISMATCH, TYPE_MISMATCH!>[1]<!>
)
annotation class Base(
@@ -21,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}, TYPE_MISMATCH{NI}!>[1]<!>
val b: Array<String> = <!TYPE_MISMATCH, TYPE_MISMATCH!>[1]<!>
)
compiler/testData/diagnostics/tests/collectionLiterals/noCollectionLiterals.kt
Vendored
+1 -1
View File
@@ -5,7 +5,7 @@ fun test(): Array<Int> {
foo(<!UNSUPPORTED!>[""]<!>)
val p = <!UNSUPPORTED!>[1, 2]<!> <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>+<!> <!UNSUPPORTED{OI}!>[3, 4]<!>
val p = <!UNSUPPORTED!>[1, 2]<!> <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>+<!> [3, 4]
return <!UNSUPPORTED!>[1, 2]<!>
}
compiler/testData/diagnostics/tests/controlFlowAnalysis/UninitializedOrReassignedVariables.kt
Vendored
+1 -1
View File
@@ -240,7 +240,7 @@ class Outer() {
}
class ForwardAccessToBackingField() { //kt-147
val a = <!DEBUG_INFO_MISSING_UNRESOLVED{NI}, TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM, UNINITIALIZED_VARIABLE{OI}!>a<!> // error
val a = <!DEBUG_INFO_MISSING_UNRESOLVED, TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>a<!> // error
val b = <!UNINITIALIZED_VARIABLE!>c<!> // error
val c = 1
}
compiler/testData/diagnostics/tests/controlFlowAnalysis/elvisNotProcessed.kt
Vendored
+5 -5
View File
@@ -11,16 +11,16 @@ else {
}
val ww = if (true) {
<!TYPE_MISMATCH{OI}!>{ true }<!> <!USELESS_ELVIS!>?: null!!<!>
{ true } <!USELESS_ELVIS!>?: null!!<!>
}
else if (true) {
<!TYPE_MISMATCH{OI}!>{ true }<!> <!USELESS_ELVIS!>?: null!!<!>
{ true } <!USELESS_ELVIS!>?: null!!<!>
}
else {
null!!
}
val <!IMPLICIT_NOTHING_PROPERTY_TYPE{OI}!>n<!> = null ?: (null ?: <!TYPE_MISMATCH{OI}!>{ true }<!>)
val n = null ?: (null ?: { true })
fun l(): (() -> Boolean)? = null
@@ -33,6 +33,6 @@ val bbb = null ?: ( l() <!USELESS_ELVIS_RIGHT_IS_NULL!>?: null<!>)
val bbbb = ( l() <!USELESS_ELVIS_RIGHT_IS_NULL!>?: null<!>) ?: ( l() <!USELESS_ELVIS_RIGHT_IS_NULL!>?: null<!>)
fun f(x : Long?): Long {
var a = x ?: (<!TYPE_MISMATCH{OI}!>fun() {}<!> <!USELESS_ELVIS!>?: <!TYPE_MISMATCH{OI}!>fun() {}<!><!>)
return <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{OI}, TYPE_MISMATCH{NI}!>a<!>
var a = x ?: (fun() {} <!USELESS_ELVIS!>?: fun() {}<!>)
return <!TYPE_MISMATCH!>a<!>
}
compiler/testData/diagnostics/tests/controlFlowAnalysis/kt10805.kt
Vendored
+4 -4
View File
@@ -1,11 +1,11 @@
// AssertionError for nested ifs with lambdas and Nothing as results
// NI_EXPECTED_FILE
val <!IMPLICIT_NOTHING_PROPERTY_TYPE{OI}!>fn<!> = if (true) {
<!TYPE_MISMATCH{OI}!>{ true }<!>
}
val fn = if (true) {
{ true }
}
else if (true) {
<!TYPE_MISMATCH{OI}!>{ true }<!>
{ true }
}
else {
null!!
compiler/testData/diagnostics/tests/controlStructures/ifElseIntersection.kt
Vendored
+3 -3
View File
@@ -8,7 +8,7 @@ class None<T> : Option<T>
fun <T> bind(r: Option<T>): Option<T> {
return if (r is Some) {
// Ideally we should infer Option<T> here (see KT-10896)
(<!TYPE_INFERENCE_FAILED_ON_SPECIAL_CONSTRUCT{OI}!>if<!> (true) <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}!>None()<!> else <!DEBUG_INFO_SMARTCAST{OI}!>r<!>) checkType { <!TYPE_MISMATCH{OI}!>_<!><Option<T>>() }
(if (true) None() else r) checkType { _<Option<T>>() }
// Works correctly
if (true) None() else r
}
@@ -24,9 +24,9 @@ fun <T> bind2(r: Option<T>): Option<T> {
}
fun <T, R> bind3(r: Option<T>): Option<T> {
return if (r is Some) <!TYPE_MISMATCH{NI}!>{
return if (r is Some) <!TYPE_MISMATCH!>{
// Diagnoses an error correctly
if (true) <!TYPE_MISMATCH{OI}!>None<R>()<!> else r
if (true) None<R>() else r
}<!>
else r
}
compiler/testData/diagnostics/tests/controlStructures/ifInResultOfLambda.kt
Vendored
+2 -2
View File
@@ -1,8 +1,8 @@
// NI_EXPECTED_FILE
val test1 = { if (true) <!IMPLICIT_CAST_TO_ANY{OI}!>1<!> else <!IMPLICIT_CAST_TO_ANY{OI}!>""<!> }
val test1 = { if (true) 1 else "" }
val test2 = { { if (true) <!IMPLICIT_CAST_TO_ANY{OI}!>1<!> else <!IMPLICIT_CAST_TO_ANY{OI}!>""<!> } }
val test2 = { { if (true) 1 else "" } }
val test3: (Boolean) -> Any = { if (it) 1 else "" }
compiler/testData/diagnostics/tests/controlStructures/ifToAnyDiscriminatingUsages.kt
Vendored
+3 -3
View File
@@ -16,8 +16,8 @@ fun testResultOfLambda2() =
fun testResultOfAnonFun1() =
run(fun () =
if (true) <!IMPLICIT_CAST_TO_ANY{OI}!>42<!>
else <!IMPLICIT_CAST_TO_ANY{OI}!>println()<!>
if (true) 42
else println()
)
fun testResultOfAnonFun2() =
@@ -27,7 +27,7 @@ fun testResultOfAnonFun2() =
fun testReturnFromAnonFun() =
run(fun () {
return <!TYPE_MISMATCH{NI}!>if (true) <!CONSTANT_EXPECTED_TYPE_MISMATCH{OI}!>42<!> else println()<!>
return <!TYPE_MISMATCH!>if (true) 42 else println()<!>
})
fun <!IMPLICIT_NOTHING_RETURN_TYPE!>testReturn1<!>() =
compiler/testData/diagnostics/tests/controlStructures/ifWhenWithoutElse.kt
Vendored
+4 -4
View File
@@ -19,10 +19,10 @@ val xx6 = null ?: <!INVALID_IF_AS_EXPRESSION!>if<!> (true) 42
val xx7 = "" + <!INVALID_IF_AS_EXPRESSION!>if<!> (true) 42
val wxx1 = <!NO_ELSE_IN_WHEN!>when<!> { true -> 42 }
val wxx2: Unit = <!TYPE_MISMATCH{NI}!><!NO_ELSE_IN_WHEN!>when<!> { true -> <!CONSTANT_EXPECTED_TYPE_MISMATCH{OI}!>42<!> }<!>
val wxx2: Unit = <!TYPE_MISMATCH!><!NO_ELSE_IN_WHEN!>when<!> { true -> 42 }<!>
val wxx3 = idAny(<!NO_ELSE_IN_WHEN!>when<!> { true -> 42 })
val wxx4 = id(<!NO_ELSE_IN_WHEN!>when<!> { true -> 42 })
val wxx5 = idUnit(<!TYPE_MISMATCH{NI}!><!NO_ELSE_IN_WHEN!>when<!> { true -> <!CONSTANT_EXPECTED_TYPE_MISMATCH{OI}!>42<!> }<!>)
val wxx5 = idUnit(<!TYPE_MISMATCH!><!NO_ELSE_IN_WHEN!>when<!> { true -> 42 }<!>)
val wxx6 = null ?: <!NO_ELSE_IN_WHEN!>when<!> { true -> 42 }
val wxx7 = "" + <!NO_ELSE_IN_WHEN!>when<!> { true -> 42 }
@@ -50,8 +50,8 @@ fun g1() = <!NO_ELSE_IN_WHEN!>when<!> { true -> work() }
fun g2() = <!NO_ELSE_IN_WHEN!>when<!> { true -> mlist.add() }
fun g3() = <!NO_ELSE_IN_WHEN!>when<!> { true -> 42 }
fun g4(): Unit = <!NO_ELSE_IN_WHEN!>when<!> { true -> work() }
fun g5(): Unit = <!TYPE_MISMATCH{NI}!><!NO_ELSE_IN_WHEN!>when<!> { true -> <!TYPE_MISMATCH{OI}!>mlist.add()<!> }<!>
fun g6(): Unit = <!TYPE_MISMATCH{NI}!><!NO_ELSE_IN_WHEN!>when<!> { true -> <!CONSTANT_EXPECTED_TYPE_MISMATCH{OI}!>42<!> }<!>
fun g5(): Unit = <!TYPE_MISMATCH!><!NO_ELSE_IN_WHEN!>when<!> { true -> mlist.add() }<!>
fun g6(): Unit = <!TYPE_MISMATCH!><!NO_ELSE_IN_WHEN!>when<!> { true -> 42 }<!>
fun foo1(x: String?) {
"" + <!INVALID_IF_AS_EXPRESSION!>if<!> (true) 42
compiler/testData/diagnostics/tests/controlStructures/improperElseInExpression.kt
Vendored
+1 -1
View File
@@ -29,5 +29,5 @@ fun example() {
return <!TYPE_MISMATCH!><!INVALID_IF_AS_EXPRESSION!>if<!> (true) true<!>
}
return <!TYPE_MISMATCH{NI}!>if (true) <!CONSTANT_EXPECTED_TYPE_MISMATCH{OI}!>true<!> else {}<!>
return <!TYPE_MISMATCH!>if (true) true else {}<!>
}
compiler/testData/diagnostics/tests/controlStructures/kt1075.kt
Vendored
+1 -1
View File
@@ -4,7 +4,7 @@ package kt1075
fun foo(b: String) {
if (<!TYPE_MISMATCH!>b<!> in 1..10) {} //type mismatch
when (<!TYPE_MISMATCH{NI}!>b<!>) {
when (<!TYPE_MISMATCH!>b<!>) {
<!TYPE_MISMATCH_IN_RANGE!>in<!> 1..10 -> 1 //no type mismatch, but it should be here
else -> 2
}
compiler/testData/diagnostics/tests/controlStructures/kt4310.kt
Vendored
+3 -3
View File
@@ -3,9 +3,9 @@ package f
fun test(a: Boolean, b: Boolean): Int {
return if(a) {
1
} else <!TYPE_MISMATCH{NI}!>{
<!TYPE_MISMATCH{OI}!><!INVALID_IF_AS_EXPRESSION!>if<!> (b) {
} else <!TYPE_MISMATCH!>{
<!INVALID_IF_AS_EXPRESSION!>if<!> (b) {
3
}<!>
}
}<!>
}
compiler/testData/diagnostics/tests/controlStructures/kt770.kt351.kt735_StatementType.kt
Vendored
+2 -2
View File
@@ -104,8 +104,8 @@ fun testImplicitCoercion() {
val g = <!INVALID_IF_AS_EXPRESSION!>if<!> (true) 4
val h = if (false) <!IMPLICIT_CAST_TO_ANY!>4<!> else <!IMPLICIT_CAST_TO_ANY!>{}<!>
bar(<!TYPE_MISMATCH{NI}!>if (true) {
<!CONSTANT_EXPECTED_TYPE_MISMATCH{OI}!>4<!>
bar(<!TYPE_MISMATCH!>if (true) {
4
} else {
z = 342
}<!>)
compiler/testData/diagnostics/tests/controlStructures/lambdasInExclExclAndElvis.kt
Vendored
+2 -2
View File
@@ -7,9 +7,9 @@ fun test() {
use({ }<!NOT_NULL_ASSERTION_ON_LAMBDA_EXPRESSION!>!!<!>);
// KT-KT-9070
<!TYPE_MISMATCH{OI}!>{ }<!> <!USELESS_ELVIS!>?: 1<!>
{ } <!USELESS_ELVIS!>?: 1<!>
use({ 2 } <!USELESS_ELVIS!>?: 1<!>);
1 <!USELESS_ELVIS!>?: <!TYPE_MISMATCH{OI}!>{ }<!><!>
1 <!USELESS_ELVIS!>?: { }<!>
use(1 <!USELESS_ELVIS!>?: { }<!>)
}
compiler/testData/diagnostics/tests/controlStructures/tryReturnType.kt
Vendored
+4 -4
View File
@@ -13,11 +13,11 @@ fun foo() : Int {
}
fun bar() : Int =
try <!TYPE_MISMATCH{NI}!>{
<!TYPE_MISMATCH{OI}!>doSmth()<!>
try <!TYPE_MISMATCH!>{
doSmth()
}<!>
catch (e: Exception) <!TYPE_MISMATCH{NI}!>{
<!TYPE_MISMATCH{OI}!>""<!>
catch (e: Exception) <!TYPE_MISMATCH!>{
""
}<!>
finally {
""
compiler/testData/diagnostics/tests/controlStructures/typeInferenceForExclExcl.kt
Vendored
+2 -2
View File
@@ -12,9 +12,9 @@ fun <T: Any> exclExcl(t: T?): T = t!!
fun test11() {
// not 'String!'
exclExcl(A.foo()) checkType { _<String>() }
exclExcl(A.foo()) checkType { <!TYPE_MISMATCH{OI}, UNRESOLVED_REFERENCE_WRONG_RECEIVER{NI}!>_<!><String?>() }
exclExcl(A.foo()) checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><String?>() }
// not 'String!'
A.foo()!! checkType { _<String>() }
A.foo()!! checkType { <!TYPE_MISMATCH{OI}, UNRESOLVED_REFERENCE_WRONG_RECEIVER{NI}!>_<!><String?>() }
A.foo()!! checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><String?>() }
}
compiler/testData/diagnostics/tests/controlStructures/whenInResultOfLambda.kt
Vendored
+2 -2
View File
@@ -1,8 +1,8 @@
// NI_EXPECTED_FILE
val test1 = { when (true) { true -> <!IMPLICIT_CAST_TO_ANY{OI}!>1<!>; else -> <!IMPLICIT_CAST_TO_ANY{OI}!>""<!> } }
val test1 = { when (true) { true -> 1; else -> "" } }
val test2 = { { when (true) { true -> <!IMPLICIT_CAST_TO_ANY{OI}!>1<!>; else -> <!IMPLICIT_CAST_TO_ANY{OI}!>""<!> } } }
val test2 = { { when (true) { true -> 1; else -> "" } } }
val test3: (Boolean) -> Any = { when (true) { true -> 1; else -> "" } }
compiler/testData/diagnostics/tests/dataClasses/extensionComponentsOnNullable.kt
Vendored
+2 -2
View File
@@ -8,7 +8,7 @@ fun foo(): Int {
val d: Data<Int>? = null
// An error must be here
val (x, y) = <!COMPONENT_FUNCTION_ON_NULLABLE, COMPONENT_FUNCTION_ON_NULLABLE!>d<!>
return <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{NI}!>x<!> <!DEBUG_INFO_MISSING_UNRESOLVED{NI}!>+<!> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{NI}!>y<!>
return <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>x<!> <!DEBUG_INFO_MISSING_UNRESOLVED!>+<!> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>y<!>
}
data class NormalData<T>(val x: T, val y: T)
@@ -17,5 +17,5 @@ fun bar(): Int {
val d: NormalData<Int>? = null
// An error must be here
val (x, y) = <!COMPONENT_FUNCTION_ON_NULLABLE, COMPONENT_FUNCTION_ON_NULLABLE!>d<!>
return <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>x<!> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{OI}, DEBUG_INFO_MISSING_UNRESOLVED{NI}!>+<!> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>y<!>
return <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>x<!> <!DEBUG_INFO_MISSING_UNRESOLVED!>+<!> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>y<!>
}
compiler/testData/diagnostics/tests/dataFlowInfoTraversal/BinaryExpression.kt
Vendored
+1 -1
View File
@@ -5,6 +5,6 @@ fun foo() {
val x: Int? = null
bar(1 + (if (x == null) 0 else x))
bar(<!TYPE_MISMATCH{NI}!>if (x == null) <!DEBUG_INFO_CONSTANT, TYPE_MISMATCH{OI}!>x<!> else x<!>)
bar(<!TYPE_MISMATCH!>if (x == null) <!DEBUG_INFO_CONSTANT!>x<!> else x<!>)
if (x != null) bar(x + x/(x-x*x))
}
compiler/testData/diagnostics/tests/declarationChecks/MultiDeclarationErrors.kt
Vendored
+1 -1
View File
@@ -11,7 +11,7 @@ class MyClass2 {}
fun test(mc1: MyClass, mc2: MyClass2) {
val (<!OPERATOR_MODIFIER_REQUIRED!>a<!>, b) = <!COMPONENT_FUNCTION_MISSING, COMPONENT_FUNCTION_MISSING!>mc1<!>
val (c) = <!COMPONENT_FUNCTION_AMBIGUITY{OI}, COMPONENT_FUNCTION_MISSING{NI}!>mc2<!>
val (c) = <!COMPONENT_FUNCTION_MISSING!>mc2<!>
//a,b,c are error types
use(<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>a<!>, <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>b<!>, <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>c<!>)
compiler/testData/diagnostics/tests/declarationChecks/localVariablesWithTypeParameters_1_3.kt
Vendored
+1 -1
View File
@@ -10,7 +10,7 @@ fun test() {
<!WRONG_MODIFIER_TARGET!>const<!> val <!LOCAL_VARIABLE_WITH_TYPE_PARAMETERS_WARNING!><T><!> a3 = 0
<!INAPPLICABLE_LATEINIT_MODIFIER, INAPPLICABLE_LATEINIT_MODIFIER, INAPPLICABLE_LATEINIT_MODIFIER!>lateinit<!> val <!LOCAL_VARIABLE_WITH_TYPE_PARAMETERS_WARNING!><T><!> a4 = 0
val <!LOCAL_VARIABLE_WITH_TYPE_PARAMETERS_WARNING!><T><!> a5 by Delegate<Int>()
val <!LOCAL_VARIABLE_WITH_TYPE_PARAMETERS_WARNING!><T><!> a6 by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE{NI}!>Delegate<<!UNRESOLVED_REFERENCE!>T<!>>()<!>
val <!LOCAL_VARIABLE_WITH_TYPE_PARAMETERS_WARNING!><T><!> a6 by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>Delegate<<!UNRESOLVED_REFERENCE!>T<!>>()<!>
}
class Delegate<F> {
compiler/testData/diagnostics/tests/declarationChecks/localVariablesWithTypeParameters_1_4.kt
Vendored
+1 -1
View File
@@ -10,7 +10,7 @@ fun test() {
<!WRONG_MODIFIER_TARGET!>const<!> val <!LOCAL_VARIABLE_WITH_TYPE_PARAMETERS!><T><!> a3 = 0
<!INAPPLICABLE_LATEINIT_MODIFIER, INAPPLICABLE_LATEINIT_MODIFIER, INAPPLICABLE_LATEINIT_MODIFIER!>lateinit<!> val <!LOCAL_VARIABLE_WITH_TYPE_PARAMETERS!><T><!> a4 = 0
val <!LOCAL_VARIABLE_WITH_TYPE_PARAMETERS!><T><!> a5 by Delegate<Int>()
val <!LOCAL_VARIABLE_WITH_TYPE_PARAMETERS!><T><!> a6 by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE{NI}!>Delegate<<!UNRESOLVED_REFERENCE!>T<!>>()<!>
val <!LOCAL_VARIABLE_WITH_TYPE_PARAMETERS!><T><!> a6 by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>Delegate<<!UNRESOLVED_REFERENCE!>T<!>>()<!>
}
class Delegate<F> {
compiler/testData/diagnostics/tests/declarationChecks/namedFunAsLastExpressionInBlock.kt
Vendored
+9 -9
View File
@@ -6,8 +6,8 @@ fun test() {
val x = fun <!ANONYMOUS_FUNCTION_WITH_NAME!>named1<!>(x: Int): Int { return 1 }
x checkType { _<Function1<Int, Int>>() }
foo <!TYPE_MISMATCH{NI}!>{ <!EXPECTED_TYPE_MISMATCH("() -> Int")!>fun named2(): Int {return 1}<!> }<!>
foo(<!TYPE_MISMATCH{NI}!>{ <!EXPECTED_TYPE_MISMATCH!>fun named3() = 1<!> }<!>)
foo <!TYPE_MISMATCH!>{ <!EXPECTED_TYPE_MISMATCH("() -> Int")!>fun named2(): Int {return 1}<!> }<!>
foo(<!TYPE_MISMATCH!>{ <!EXPECTED_TYPE_MISMATCH!>fun named3() = 1<!> }<!>)
val x1 =
<!INVALID_IF_AS_EXPRESSION!>if<!> (1 == 1)
@@ -26,15 +26,15 @@ fun test() {
<!SYNTAX!><!>fun named7() = 1
val x3 = when (1) {
0 -> <!EXPECTED_TYPE_MISMATCH{OI}!>fun <!ANONYMOUS_FUNCTION_WITH_NAME{NI}!>named8<!>(): Int {return 1}<!>
else -> <!EXPECTED_TYPE_MISMATCH{OI}!>fun <!ANONYMOUS_FUNCTION_WITH_NAME{NI}!>named9<!>() = 1<!>
0 -> fun <!ANONYMOUS_FUNCTION_WITH_NAME!>named8<!>(): Int {return 1}
else -> fun <!ANONYMOUS_FUNCTION_WITH_NAME!>named9<!>() = 1
}
val x31 = when (1) {
0 -> {
<!EXPECTED_TYPE_MISMATCH{OI}!>fun named10(): Int {return 1}<!>
fun named10(): Int {return 1}
}
else -> <!EXPECTED_TYPE_MISMATCH{OI}!>fun <!ANONYMOUS_FUNCTION_WITH_NAME{NI}!>named11<!>() = 1<!>
else -> fun <!ANONYMOUS_FUNCTION_WITH_NAME!>named11<!>() = 1
}
val x4 = {
@@ -64,11 +64,11 @@ fun success() {
val y = when (1) {
0 -> {
<!EXPECTED_TYPE_MISMATCH{OI}!>fun named4(): Int {return 1}<!>
fun named4(): Int {return 1}
}
else -> {
<!EXPECTED_TYPE_MISMATCH{OI}!>fun named5(): Int {return 1}<!>
fun named5(): Int {return 1}
}
}
y checkType { <!TYPE_MISMATCH{OI}!>_<!><Unit>() }
y checkType { _<Unit>() }
}
compiler/testData/diagnostics/tests/delegatedProperty/inference/differentDelegatedExpressions.kt
Vendored
+4 -4
View File
@@ -9,10 +9,10 @@ class A(outer: Outer) {
var g: String by outer.getContainer().getMyProperty()
var b: String by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE{NI}, DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE{NI}!>foo(<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>getMyProperty<!>())<!>
var r: String by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE{NI}, DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE{NI}!>foo(outer.getContainer().<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>getMyProperty<!>())<!>
var e: String by <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{OI}, DEBUG_INFO_MISSING_UNRESOLVED{NI}!>+<!> <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>foo<!>(<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>getMyProperty<!>())
var f: String by <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>foo<!>(<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>getMyProperty<!>()) <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{OI}, DEBUG_INFO_MISSING_UNRESOLVED{NI}!>-<!> 1
var b: String by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>foo(<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getMyProperty<!>())<!>
var r: String by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>foo(outer.getContainer().<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getMyProperty<!>())<!>
var e: String by <!DEBUG_INFO_MISSING_UNRESOLVED!>+<!> <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>(<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getMyProperty<!>())
var f: String by <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>(<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getMyProperty<!>()) <!DEBUG_INFO_MISSING_UNRESOLVED!>-<!> 1
}
fun <A, B> foo(a: Any?) = MyProperty<A, B>()
compiler/testData/diagnostics/tests/delegatedProperty/inference/extensionProperty.kt
Vendored
+2 -2
View File
@@ -3,10 +3,10 @@ package foo
import kotlin.reflect.KProperty
open class A {
val B.w: Int by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE{NI}!><!TYPE_INFERENCE_UPPER_BOUND_VIOLATED{OI}!>MyProperty<!>()<!>
val B.w: Int by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>MyProperty()<!>
}
val B.r: Int by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE{NI}!><!TYPE_INFERENCE_UPPER_BOUND_VIOLATED{OI}!>MyProperty<!>()<!>
val B.r: Int by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>MyProperty()<!>
val A.e: Int by MyProperty()
compiler/testData/diagnostics/tests/delegatedProperty/inference/genericMethodInGenericClass.kt
Vendored
+2 -2
View File
@@ -7,7 +7,7 @@ class A<R>() {
operator fun <T> setValue(t: Any?, p: KProperty<*>, x: T) = Unit
}
var a1: Int by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE{NI}, DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE{NI}!><!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>A<!>()<!>
var a1: Int by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!><!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>A<!>()<!>
var a2: Int by A<String>()
class B<R>() {
@@ -24,4 +24,4 @@ class C<R>() {
}
var c1: Int by C()
var c2: Int by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE{NI}, DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE{NI}, DELEGATE_SPECIAL_FUNCTION_RETURN_TYPE_MISMATCH{OI}!>C<Number>()<!>
var c2: Int by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>C<Number>()<!>
compiler/testData/diagnostics/tests/delegatedProperty/inference/manyIncompleteCandidates.kt
Vendored
+1 -1
View File
@@ -4,7 +4,7 @@ package test
import first.*
import second.*
val a12 by <!DELEGATE_SPECIAL_FUNCTION_AMBIGUITY{NI}, DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE{OI}!>A()<!>
val a12 by <!DELEGATE_SPECIAL_FUNCTION_AMBIGUITY!>A()<!>
// FILE: first.kt
package first
compiler/testData/diagnostics/tests/delegatedProperty/inference/noErrorsForImplicitConstraints.kt
Vendored
+4 -4
View File
@@ -3,8 +3,8 @@ package foo
import kotlin.reflect.KProperty
class A {
var a5: String by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE{NI}, DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE{NI}!><!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>MyProperty1<!>()<!>
var b5: String by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE{NI}, DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE{NI}!><!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>getMyProperty1<!>()<!>
var a5: String by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!><!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>MyProperty1<!>()<!>
var b5: String by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!><!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getMyProperty1<!>()<!>
}
fun <A, B> getMyProperty1() = MyProperty1<A, B>()
@@ -23,8 +23,8 @@ class MyProperty1<T, R> {
// -----------------
class B {
var a5: String by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!><!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}!>MyProperty2<!>()<!>
var b5: String by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!><!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}!>getMyProperty2<!>()<!>
var a5: String by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!><!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>MyProperty2<!>()<!>
var b5: String by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!><!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getMyProperty2<!>()<!>
}
fun <A, B> getMyProperty2() = MyProperty2<A, B>()
compiler/testData/diagnostics/tests/delegatedProperty/inference/noExpectedTypeForSupertypeConstraint.kt
Vendored
+1 -1
View File
@@ -2,7 +2,7 @@
import kotlin.reflect.KProperty
class A {
var a by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE{NI}!><!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>MyProperty<!>()<!>
var a by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!><!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>MyProperty<!>()<!>
}
class MyProperty<T, R> {
compiler/testData/diagnostics/tests/delegatedProperty/propertyDefferedType.kt
Vendored
+1 -1
View File
@@ -4,7 +4,7 @@
import kotlin.reflect.KProperty
class B {
val c by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE{NI}!>Delegate(<!UNRESOLVED_REFERENCE!>ag<!>)<!>
val c by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>Delegate(<!UNRESOLVED_REFERENCE!>ag<!>)<!>
}
class Delegate<T: Any>(val init: T) {
compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/commonCaseForInference.kt
Vendored
+1 -1
View File
@@ -8,6 +8,6 @@ object CommonCase {
operator fun <D, E, R> Fas<D, E, R>.provideDelegate(host: D, p: Any?): Fas<D, E, R> = TODO()
operator fun <D, E, R> Fas<D, E, R>.getValue(receiver: E, p: Any?): R = TODO()
val Long.test1: String by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE{NI}!><!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>delegate<!>()<!> // common test, not working because of Inference1
val Long.test1: String by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!><!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>delegate<!>()<!> // common test, not working because of Inference1
val Long.test2: String by delegate<CommonCase, Long, String>() // should work
}
compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/hostAndReceiver2.kt
Vendored
+1 -1
View File
@@ -9,5 +9,5 @@ object T2 {
operator fun <T> Foo<T>.getValue(receiver: String, p: Any?): T = TODO()
val String.test1: String by delegate()
val test2: String by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE{NI}!><!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>delegate<!>()<!>
val test2: String by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>delegate()<!>
}
compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/inferenceFromReceiver1.kt
Vendored
+1 -1
View File
@@ -8,7 +8,7 @@ object Inference1 {
operator fun <T> Foo<T>.getValue(receiver: T, p: Any?): String = TODO()
// not working because resulting descriptor for getValue contains type `???` instead of `T`
val test1: String by <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>delegate<!>()
val test1: String by delegate()
val test2: String by delegate<Inference1>()
}
compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/inferenceFromReceiver2.kt
Vendored
+1 -1
View File
@@ -8,6 +8,6 @@ object Inference2 {
operator fun <T> Foo<T>.provideDelegate(host: T, p: Any?): Foo<T> = TODO()
operator fun <T> Foo<T>.getValue(receiver: Inference2, p: Any?): String = TODO()
val test1: String by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE{NI}!><!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>delegate<!>()<!> // same story like in Inference1
val test1: String by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!><!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>delegate<!>()<!> // same story like in Inference1
val test2: String by delegate<Inference2>()
}
compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/noOperatorModifierOnProvideDelegate.kt
Vendored
+1 -2
View File
@@ -12,6 +12,5 @@ fun String.provideDelegate(a: Any?, p: KProperty<*>) = StringDelegate(this)
operator fun String.getValue(a: Any?, p: KProperty<*>) = this
val test1: String by "OK"
val test2: Int by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE{NI}, DELEGATE_SPECIAL_FUNCTION_RETURN_TYPE_MISMATCH{OI}!>"OK"<!>
val test2: Int by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>"OK"<!>
val test3 by "OK"
compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/setValue.kt
Vendored
+2 -2
View File
@@ -7,10 +7,10 @@ operator fun <T> Delegate<T>.setValue(receiver: Any?, p: Any, value: T) {}
operator fun <T> String.provideDelegate(receiver: Any?, p: Any) = Delegate<T>()
var test1: String by <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>Delegate<!>()
var test1: String by Delegate()
var test2: String by Delegate<String>()
var test3: String by <!DELEGATE_SPECIAL_FUNCTION_MISSING, DELEGATE_SPECIAL_FUNCTION_MISSING, DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>"OK"<!>
var test4: String by "OK".<!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>provideDelegate<!>(null, "")
var test4: String by "OK".provideDelegate(null, "")
var test5: String by "OK".provideDelegate<String>(null, "")
compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/unsupportedOperatorProvideDelegate.kt
Vendored
+1 -1
View File
@@ -10,5 +10,5 @@ class WrongDelegate(val x: Int) {
operator fun String.getValue(thisRef: Any?, prop: Any) = this
val test1: String by "OK"
val test2: Int by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE{NI}, DELEGATE_SPECIAL_FUNCTION_RETURN_TYPE_MISMATCH{OI}!>"OK"<!>
val test2: Int by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>"OK"<!>
val test3 by "OK"
compiler/testData/diagnostics/tests/delegatedProperty/recursiveType.kt
Vendored
+3 -3
View File
@@ -3,12 +3,12 @@
import kotlin.reflect.KProperty
val a by <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{NI}, TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM{OI}!>a<!>
val a by <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>a<!>
val b by Delegate(<!DEBUG_INFO_MISSING_UNRESOLVED{NI}, TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>b<!>)
val b by Delegate(<!DEBUG_INFO_MISSING_UNRESOLVED, TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>b<!>)
val c by <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE, UNINITIALIZED_VARIABLE!>d<!>
val d by <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{NI}, TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM{OI}!>c<!>
val d by <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>c<!>
class Delegate(i: Int) {
operator fun getValue(t: Any?, p: KProperty<*>): Int {
compiler/testData/diagnostics/tests/delegatedProperty/typeMismatchForGetReturnType.kt
Vendored
+1 -1
View File
@@ -2,7 +2,7 @@
import kotlin.reflect.KProperty
val c: Int by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE{NI}, DELEGATE_SPECIAL_FUNCTION_RETURN_TYPE_MISMATCH{OI}!>Delegate()<!>
val c: Int by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>Delegate()<!>
class Delegate {
operator fun getValue(t: Any?, p: KProperty<*>): String {
compiler/testData/diagnostics/tests/delegation/DelegationExpectedType.kt
Vendored
+1 -1
View File
@@ -20,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}, TYPE_MISMATCH{NI}!>boo("")<!>
class E : A<Int> by <!TYPE_MISMATCH, TYPE_MISMATCH!>boo("")<!>
class F : A<Int> by <!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>AImpl<String>()<!>
compiler/testData/diagnostics/tests/enum/kt8972_cloneNotAllowed.kt
Vendored
+1 -1
View File
@@ -1,6 +1,6 @@
enum class E : Cloneable {
A;
<!OVERRIDING_FINAL_MEMBER!>override<!> fun clone(): Any {
return <!AMBIGUOUS_SUPER!>super<!>.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{OI}, DEBUG_INFO_MISSING_UNRESOLVED{NI}!>clone<!>()
return <!AMBIGUOUS_SUPER!>super<!>.<!DEBUG_INFO_MISSING_UNRESOLVED!>clone<!>()
}
}
compiler/testData/diagnostics/tests/extensions/ExtensionFunctions.kt
Vendored
+1 -1
View File
@@ -19,7 +19,7 @@ class A
infix operator fun A.plus(a : Any) {
1.foo()
true.<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>foo<!>(<!NO_VALUE_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER!>)<!>
true.<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>(<!NO_VALUE_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER!>)<!>
1
}
compiler/testData/diagnostics/tests/extensions/throwOutCandidatesByReceiver.kt
Vendored
+4 -4
View File
@@ -34,22 +34,22 @@ fun test4() {
// should be an error on receiver, shouldn't be thrown away
fun test5() {
<!TYPE_MISMATCH{OI}!>1<!>.<!FUNCTION_EXPECTED{NI}!>(fun String.()=1)<!>()
1.<!FUNCTION_EXPECTED!>(fun String.()=1)<!>()
}
fun <R: Any> R?.sure() : R = this!!
fun <T> test6(l: List<T>?) {
<!TYPE_MISMATCH{OI}!>l<!>.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER{NI}!>sure<!><<!UPPER_BOUND_VIOLATED{OI}!>T<!>>()
l.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>sure<!><T>()
}
fun List<String>.b() {}
fun test7(l: List<String?>) {
<!TYPE_MISMATCH{OI}!>l<!>.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER{NI}!>b<!>()
l.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>b<!>()
}
fun test8(l: List<Any>?) {
<!TYPE_MISMATCH{OI}!>l<!>.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER{NI}!>b<!>()
l.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>b<!>()
}
compiler/testData/diagnostics/tests/functionAsExpression/InferenceParametersTypes.kt
Vendored
+1 -1
View File
@@ -11,7 +11,7 @@ fun test(a: (Int) -> Int) {
}
fun test2(a: () -> List<Int>) {
test2(fun () = <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>listOf<!>())
test2(fun () = listOf())
}
val a: (Int) -> Unit = fun(x) { checkSubtype<Int>(x) }

Some files were not shown because too many files have changed in this diff Show More