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

Add diagnostics to test data from NI

Browse Source
This commit is contained in:
Mikhail Zarechenskiy
2017-11-22 08:50:30 +03:00
parent a71238bf94
commit 8757298994
480 changed files with 1136 additions and 1120 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/testData/diagnostics/tests/AutoCreatedIt.kt
Vendored
+3 -3
View File
@@ -3,8 +3,8 @@ 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 <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!>{<!>1}
bar <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!>{<!><!UNRESOLVED_REFERENCE!>it<!> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>+<!> 1}
bar <!NI;TYPE_MISMATCH!><!EXPECTED_PARAMETERS_NUMBER_MISMATCH!>{<!>1}<!>
bar <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!>{<!><!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!><!UNRESOLVED_REFERENCE!>it<!> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>+<!> 1<!>}
bar {it, <!UNUSED_ANONYMOUS_PARAMETER!>it1<!> -> it}
bar1 {1}
@@ -13,7 +13,7 @@ fun text() {
bar2 {<!TYPE_MISMATCH!><!>}
bar2 {1}
bar2 {<!UNRESOLVED_REFERENCE!>it<!>}
bar2 {<!EXPECTED_PARAMETERS_NUMBER_MISMATCH, CANNOT_INFER_PARAMETER_TYPE!>it<!> -> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>it<!>}
bar2 <!NI;TYPE_MISMATCH!>{<!OI;CANNOT_INFER_PARAMETER_TYPE, OI;EXPECTED_PARAMETERS_NUMBER_MISMATCH!>it<!> -> <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>it<!>}<!>
}
fun bar(<!UNUSED_PARAMETER!>f<!> : (Int, Int) -> Int) {}
compiler/testData/diagnostics/tests/Basic.kt
Vendored
+1 -1
View File
@@ -10,7 +10,7 @@ fun test() : Int {
}
class A() {
val x : Int = <!TYPE_MISMATCH!>foo1(<!UNRESOLVED_REFERENCE, TOO_MANY_ARGUMENTS!>xx<!>)<!>
val x : Int = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>foo1(<!UNRESOLVED_REFERENCE, TOO_MANY_ARGUMENTS!>xx<!>)<!>
}
fun foo1() {}
compiler/testData/diagnostics/tests/BinaryCallsOnNullableValues.kt
Vendored
+6 -6
View File
@@ -6,10 +6,10 @@ class A() {
fun f(): Unit {
var x: Int? = <!VARIABLE_WITH_REDUNDANT_INITIALIZER!>1<!>
x = null
<!DEBUG_INFO_CONSTANT!>x<!> + 1
<!OI;DEBUG_INFO_CONSTANT!>x<!> + 1
<!DEBUG_INFO_CONSTANT!>x<!> <!INFIX_MODIFIER_REQUIRED!>plus<!> 1
<!DEBUG_INFO_CONSTANT!>x<!> <!UNSAFE_OPERATOR_CALL!><<!> 1
<!TYPE_MISMATCH!><!DEBUG_INFO_CONSTANT!>x<!> += 1<!>
<!TYPE_MISMATCH!><!OI;DEBUG_INFO_CONSTANT!>x<!> += 1<!>
<!DEBUG_INFO_CONSTANT!>x<!> == 1
<!DEBUG_INFO_CONSTANT!>x<!> != 1
@@ -22,11 +22,11 @@ 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!>x<!><!UNSAFE_OPERATOR_CALL!>..<!>2
<!OI;DEBUG_INFO_CONSTANT!>x<!><!UNSAFE_OPERATOR_CALL!>..<!>2
<!TYPE_MISMATCH, DEBUG_INFO_CONSTANT!>x<!> in 1..2
val y : Boolean? = true
<!UNUSED_EXPRESSION!>false || <!TYPE_MISMATCH!>y<!><!>
<!UNUSED_EXPRESSION!><!TYPE_MISMATCH!>y<!> && true<!>
<!UNUSED_EXPRESSION!><!TYPE_MISMATCH!>y<!> && <!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!><!>
<!UNUSED_EXPRESSION!>false || <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>y<!><!>
<!UNUSED_EXPRESSION!><!NI;TYPE_MISMATCH, TYPE_MISMATCH!>y<!> && true<!>
<!UNUSED_EXPRESSION!><!NI;TYPE_MISMATCH, TYPE_MISMATCH!>y<!> && <!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!><!>
}
compiler/testData/diagnostics/tests/Bounds.kt
Vendored
+2 -2
View File
@@ -7,12 +7,12 @@ package boundsWithSubstitutors
class C : A<C>()
val a = B<C>()
val a1 = B<<!UPPER_BOUND_VIOLATED!>Int<!>>()
val a1 = B<<!NI;UPPER_BOUND_VIOLATED, NI;UPPER_BOUND_VIOLATED, NI;UPPER_BOUND_VIOLATED, NI;UPPER_BOUND_VIOLATED, UPPER_BOUND_VIOLATED!>Int<!>>()
class X<A, B : A>()
val b = X<Any, X<A<C>, C>>()
val b0 = X<Any, <!UPPER_BOUND_VIOLATED!>Any?<!>>()
val b0 = X<Any, <!NI;UPPER_BOUND_VIOLATED, UPPER_BOUND_VIOLATED!>Any?<!>>()
val b1 = X<Any, X<A<C>, <!UPPER_BOUND_VIOLATED!>String<!>>>()
// FILE: b.kt
compiler/testData/diagnostics/tests/CompareToWithErrorType.kt
Vendored
+1 -1
View File
@@ -1,6 +1,6 @@
// !WITH_NEW_INFERENCE
fun test() {
if (<!UNRESOLVED_REFERENCE!>x<!> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>><!> 0) {
if (<!UNRESOLVED_REFERENCE!>x<!> <!NI;COMPARE_TO_TYPE_MISMATCH, DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>><!> 0) {
}
}
compiler/testData/diagnostics/tests/DefaultValuesTypechecking.kt
Vendored
+2 -2
View File
@@ -1,14 +1,14 @@
// !WITH_NEW_INFERENCE
val x = ""
fun bar(x : Int = <!TYPE_MISMATCH!>""<!>, y : Int = x, <!UNUSED_PARAMETER!>z<!> : String = <!TYPE_MISMATCH!>y<!>) {
fun bar(x : Int = <!TYPE_MISMATCH!>""<!>, y : Int = x, <!UNUSED_PARAMETER!>z<!> : String = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>y<!>) {
}
// KT-371 Resolve default parameters for constructors
class A(x : Int = <!UNINITIALIZED_PARAMETER!>y<!>, y : Int = x) { // None of the references is resolved, no types checked
fun foo(<!UNUSED_PARAMETER!>bool<!>: Boolean, a: Int = <!TYPE_MISMATCH, UNINITIALIZED_PARAMETER!>b<!>, b: String = <!TYPE_MISMATCH!>a<!>) {}
fun foo(<!UNUSED_PARAMETER!>bool<!>: Boolean, a: Int = <!NI;TYPE_MISMATCH, TYPE_MISMATCH, UNINITIALIZED_PARAMETER!>b<!>, b: String = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>a<!>) {}
}
val z = 3
compiler/testData/diagnostics/tests/DeprecatedUnaryOperatorConventions.kt
Vendored
+2 -2
View File
@@ -16,7 +16,7 @@ operator fun String.unaryPlus(): Int = 0
fun test() {
requireInt(+ "")
requireInt(+ Example())
requireString(<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>+<!> ExampleDeprecated())
requireString(<!NI;DEBUG_INFO_UNRESOLVED_WITH_TARGET, UNRESOLVED_REFERENCE_WRONG_RECEIVER!>+<!> ExampleDeprecated())
}
fun requireInt(n: Int) {}
@@ -27,7 +27,7 @@ class Example2 {
<!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun minus() = this
fun test() {
<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>+<!>this
<!NI;DEBUG_INFO_UNRESOLVED_WITH_TARGET, UNRESOLVED_REFERENCE_WRONG_RECEIVER!>+<!>this
<!UNRESOLVED_REFERENCE!>-<!>this
}
}
compiler/testData/diagnostics/tests/EnumEntryAsType.kt
Vendored
+3 -3
View File
@@ -9,7 +9,7 @@ enum class Color {
class MyColor(val x: Color.<!ENUM_ENTRY_AS_TYPE!>RED<!>, y: Color.<!ENUM_ENTRY_AS_TYPE!>RED<!>) : Color.<!ENUM_ENTRY_AS_TYPE!>RED<!> {
var z: Color.<!ENUM_ENTRY_AS_TYPE!>RED<!> = <!TYPE_MISMATCH!>Color.RED<!>
var z: Color.<!ENUM_ENTRY_AS_TYPE!>RED<!> = <!TYPE_MISMATCH!>Color.<!NI;TYPE_MISMATCH!>RED<!><!>
set(arg: Color.<!ENUM_ENTRY_AS_TYPE!>RED<!>) { z = arg }
fun foo(arg: Color.<!ENUM_ENTRY_AS_TYPE!>RED<!>): Color.<!ENUM_ENTRY_AS_TYPE!>RED<!> = arg
@@ -17,7 +17,7 @@ class MyColor(val x: Color.<!ENUM_ENTRY_AS_TYPE!>RED<!>, y: Color.<!ENUM_ENTRY_A
fun bar(): Color.<!ENUM_ENTRY_AS_TYPE!>RED<!> {
class Local : Color.<!ENUM_ENTRY_AS_TYPE!>RED<!>
fun local(arg: Color.<!ENUM_ENTRY_AS_TYPE!>RED<!>): Color.<!ENUM_ENTRY_AS_TYPE!>RED<!> = arg
val temp: Color.<!ENUM_ENTRY_AS_TYPE!>RED<!> = <!TYPE_MISMATCH!>Color.RED<!>
val temp: Color.<!ENUM_ENTRY_AS_TYPE!>RED<!> = <!TYPE_MISMATCH!>Color.<!NI;TYPE_MISMATCH!>RED<!><!>
temp <!USELESS_CAST!>as? Color.<!ENUM_ENTRY_AS_TYPE!>RED<!><!>
if (<!USELESS_IS_CHECK!>temp is <!IS_ENUM_ENTRY!>Color.<!ENUM_ENTRY_AS_TYPE!>RED<!><!><!>) {
return temp <!USELESS_CAST!>as Color.<!ENUM_ENTRY_AS_TYPE!>RED<!><!>
@@ -26,7 +26,7 @@ class MyColor(val x: Color.<!ENUM_ENTRY_AS_TYPE!>RED<!>, y: Color.<!ENUM_ENTRY_A
if (<!USELESS_IS_CHECK!>obj is <!IS_ENUM_ENTRY!>Color.<!ENUM_ENTRY_AS_TYPE!>RED<!><!><!>) {
return obj
}
return <!TYPE_MISMATCH!>Color.RED<!>
return <!TYPE_MISMATCH!>Color.<!NI;TYPE_MISMATCH!>RED<!><!>
}
}
compiler/testData/diagnostics/tests/FunctionCalleeExpressions.kt
Vendored
+5 -5
View File
@@ -26,13 +26,13 @@ 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!>foo1<!>()()
<!UNRESOLVED_REFERENCE!>a<!>.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>foo1<!>()(<!UNRESOLVED_REFERENCE!>a<!>)
<!NI;FUNCTION_EXPECTED!><!UNRESOLVED_REFERENCE!>a<!>.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>foo1<!>()<!>()
<!NI;FUNCTION_EXPECTED!><!UNRESOLVED_REFERENCE!>a<!>.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>foo1<!>()<!>(<!UNRESOLVED_REFERENCE!>a<!>)
args.foo1()(1)
args.foo1()(<!TYPE_MISMATCH!>"1"<!>)
<!UNRESOLVED_REFERENCE!>a<!>.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>foo1<!>()("1")
<!UNRESOLVED_REFERENCE!>a<!>.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>foo1<!>()(<!UNRESOLVED_REFERENCE!>a<!>)
<!NI;FUNCTION_EXPECTED!><!UNRESOLVED_REFERENCE!>a<!>.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>foo1<!>()<!>("1")
<!NI;FUNCTION_EXPECTED!><!UNRESOLVED_REFERENCE!>a<!>.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>foo1<!>()<!>(<!UNRESOLVED_REFERENCE!>a<!>)
foo2()({})
foo2()<!TOO_MANY_ARGUMENTS!>{}<!>
@@ -45,7 +45,7 @@ fun main(args : Array<String>) {
val b = fooT2<Int>()(1)
checkSubtype<Int>(b)
<!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>fooT2<!>()(1) // : Any?
<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>fooT2<!>()(1) // : Any?
<!FUNCTION_EXPECTED!>1<!>()
<!FUNCTION_EXPECTED!>1<!>{}
compiler/testData/diagnostics/tests/FunctionReturnTypes.kt
Vendored
+5 -5
View File
@@ -45,7 +45,7 @@ fun intFunctionLiteral(): Int = <!TYPE_MISMATCH_DUE_TO_EQUALS_LAMBDA_IN_FUN!>{ 1
fun blockReturnUnitMismatch() : Int {<!RETURN_TYPE_MISMATCH!>return<!>}
fun blockReturnValueTypeMismatch() : Int {return <!CONSTANT_EXPECTED_TYPE_MISMATCH!>3.4<!>}
fun blockReturnValueTypeMatch() : Int {return 1}
fun blockReturnValueTypeMismatchUnit() : Int {return <!TYPE_MISMATCH!>Unit<!>}
fun blockReturnValueTypeMismatchUnit() : Int {return <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>Unit<!>}
fun blockAndAndMismatch() : Int {
<!UNUSED_EXPRESSION!>true && false<!>
@@ -67,7 +67,7 @@ fun blockAndAndMismatch5() : Int {
(return <!CONSTANT_EXPECTED_TYPE_MISMATCH!>true<!>) || (return <!CONSTANT_EXPECTED_TYPE_MISMATCH!>false<!>)
}
fun blockReturnValueTypeMatch1() : Int {
return if (1 > 2) <!CONSTANT_EXPECTED_TYPE_MISMATCH!>1.0<!> else <!CONSTANT_EXPECTED_TYPE_MISMATCH!>2.0<!>
return if (1 > 2) <!CONSTANT_EXPECTED_TYPE_MISMATCH!>1.0<!> else <!OI;CONSTANT_EXPECTED_TYPE_MISMATCH!>2.0<!>
}
fun blockReturnValueTypeMatch2() : Int {
return <!TYPE_MISMATCH!><!INVALID_IF_AS_EXPRESSION!>if<!> (1 > 2) 1<!>
@@ -134,7 +134,7 @@ fun blockNoReturnIfUnitInOneBranch(): Int {
}
}
<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
fun nonBlockReturnIfEmptyIf(): Int = if (1 < 2) <!TYPE_MISMATCH!>{}<!> else <!TYPE_MISMATCH!>{}<!>
fun nonBlockReturnIfEmptyIf(): Int = if (1 < 2) <!TYPE_MISMATCH!>{}<!> else <!OI;TYPE_MISMATCH!>{}<!>
fun nonBlockNoReturnIfUnitInOneBranch(): Int = if (1 < 2) <!TYPE_MISMATCH!>{}<!> else 2
val a = <!RETURN_NOT_ALLOWED!>return<!> 1
@@ -146,14 +146,14 @@ fun illegalConstantBlock(): String {
return <!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>
}
fun illegalIfBody(): Int =
if (1 < 2) <!CONSTANT_EXPECTED_TYPE_MISMATCH!>'a'<!> else { <!CONSTANT_EXPECTED_TYPE_MISMATCH!>1.0<!> }
if (1 < 2) <!CONSTANT_EXPECTED_TYPE_MISMATCH!>'a'<!> else <!NI;TYPE_MISMATCH!>{ <!OI;CONSTANT_EXPECTED_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 { <!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!> }
return if (1 < 2) 'a' else <!NI;TYPE_MISMATCH!>{ <!OI;CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!> }<!>
}
fun returnNothing(): Nothing {
compiler/testData/diagnostics/tests/InvokeAndRecursiveResolve.kt
Vendored
+1 -1
View File
@@ -13,5 +13,5 @@ class B {
class C {
val bar = <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!><!UNINITIALIZED_VARIABLE!>test<!>()<!>
val test = <!FUNCTION_EXPECTED!>bar<!>()
val test = <!NI;TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!><!NI;DEBUG_INFO_MISSING_UNRESOLVED, OI;FUNCTION_EXPECTED!>bar<!>()<!>
}
compiler/testData/diagnostics/tests/Nullability.kt
Vendored
+1 -1
View File
@@ -147,7 +147,7 @@ fun test() {
while (out2 == null) {
<!DEBUG_INFO_CONSTANT!>out2<!>?.println();
<!DEBUG_INFO_CONSTANT!>out2<!><!UNSAFE_CALL!>.<!>println();
<!OI;DEBUG_INFO_CONSTANT!>out2<!><!UNSAFE_CALL!>.<!>println();
}
<!DEBUG_INFO_SMARTCAST!>out2<!>.println()
compiler/testData/diagnostics/tests/PackageInExpressionPosition.kt
Vendored
+1 -1
View File
@@ -23,5 +23,5 @@ fun main(args : Array<String>) {
<!INVISIBLE_MEMBER!>System<!>()
(<!NO_COMPANION_OBJECT!>System<!>)
foo@ <!NO_COMPANION_OBJECT!>System<!>
null in <!NO_COMPANION_OBJECT!>System<!>
null <!NI;RESULT_TYPE_MISMATCH!>in<!> <!NO_COMPANION_OBJECT!>System<!>
}
compiler/testData/diagnostics/tests/PackageQualified.kt
Vendored
+1 -1
View File
@@ -20,7 +20,7 @@ abstract class Foo<T>() {
package foobar.a
import java.util.*
val b : List<Int>? = <!TYPE_MISMATCH!>a<!>
val b : List<Int>? = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>a<!>
val b1 : <!UNRESOLVED_REFERENCE!>util<!>.<!DEBUG_INFO_MISSING_UNRESOLVED!>List<!><Int>? = a
// FILE: b.kt
compiler/testData/diagnostics/tests/Properties.kt
Vendored
+3 -1
View File
@@ -1,8 +1,10 @@
// !WITH_NEW_INFERENCE
var x : Int = 1 + <!UNINITIALIZED_VARIABLE!>x<!>
get() : Int = 1
set(value : <!WRONG_SETTER_PARAMETER_TYPE!>Long<!>) {
field = value.toInt()
field = <!TYPE_MISMATCH!>1.toLong()<!>
field = <!TYPE_MISMATCH!>1.<!NI;TYPE_MISMATCH!>toLong()<!><!>
}
val xx : Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>1 + x<!>
compiler/testData/diagnostics/tests/QualifiedExpressions.kt
Vendored
+2 -2
View File
@@ -5,8 +5,8 @@ fun test(s: IntRange?) {
val <!UNUSED_VARIABLE!>a<!>: Int = <!TYPE_MISMATCH!>s?.start<!>
val b: Int? = s?.start
val <!UNUSED_VARIABLE!>c<!>: Int = s?.start ?: -11
val <!UNUSED_VARIABLE!>d<!>: Int = s?.start ?: <!TYPE_MISMATCH!>"empty"<!>
val e: String = <!TYPE_MISMATCH!>s?.start<!> ?: "empty"
val <!UNUSED_VARIABLE!>d<!>: Int = <!NI;TYPE_MISMATCH!>s?.start ?: <!OI;TYPE_MISMATCH!>"empty"<!><!>
val e: String = <!NI;TYPE_MISMATCH!><!OI;TYPE_MISMATCH!>s?.start<!> ?: "empty"<!>
val <!UNUSED_VARIABLE!>f<!>: Int = s?.endInclusive ?: b ?: 1
val <!UNUSED_VARIABLE!>g<!>: Boolean? = e.startsWith("s")//?.length
}
compiler/testData/diagnostics/tests/RecursiveTypeInference.kt
Vendored
+3 -3
View File
@@ -3,19 +3,19 @@
package a
val foo = bar()
fun bar() = <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>foo<!>
fun bar() = <!NI;DEBUG_INFO_MISSING_UNRESOLVED, TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>foo<!>
// FILE: f.kt
package b
fun foo() = bar()
fun bar() = <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>foo()<!>
fun bar() = <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!><!NI;DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>()<!>
// FILE: f.kt
package c
fun bazz() = bar()
fun foo() = <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>bazz()<!>
fun foo() = <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!><!NI;DEBUG_INFO_MISSING_UNRESOLVED!>bazz<!>()<!>
fun bar() = foo()
compiler/testData/diagnostics/tests/ReserveYield.kt
Vendored
+1 -1
View File
@@ -20,7 +20,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!>yield<!> = 5)
bar(<!OI;YIELD_IS_RESERVED!>yield<!> = 5)
yield(4)
<!YIELD_IS_RESERVED!>yield<!> {}
compiler/testData/diagnostics/tests/ResolveOfJavaGenerics.kt
Vendored
+1 -1
View File
@@ -5,7 +5,7 @@ fun test(<!UNUSED_PARAMETER!>a<!> : java.lang.annotation.RetentionPolicy) {
}
fun test() {
java.util.Collections.<!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>emptyList<!>()
java.util.Collections.<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>emptyList<!>()
val <!UNUSED_VARIABLE!>a<!> : Collection<String>? = java.util.Collections.emptyList()
}
compiler/testData/diagnostics/tests/ResolveToJava.kt
Vendored
+2 -2
View File
@@ -20,10 +20,10 @@ fun test(<!UNUSED_PARAMETER!>l<!> : <!PLATFORM_CLASS_MAPPED_TO_KOTLIN!>java.util
val <!UNUSED_VARIABLE!>f<!> : java.io.File? = null
Collections.<!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER, FUNCTION_CALL_EXPECTED!>emptyList<!>
Collections.<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER, FUNCTION_CALL_EXPECTED!>emptyList<!>
Collections.<!FUNCTION_CALL_EXPECTED!>emptyList<Int><!>
Collections.emptyList<Int>()
Collections.<!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>emptyList<!>()
Collections.<!OI;TYPE_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/SafeCallInvoke.kt
Vendored
+1 -1
View File
@@ -14,7 +14,7 @@ fun foo() {
rule?.apply?.invoke()
// this should be an error
rule?.<!UNSAFE_IMPLICIT_INVOKE_CALL!>apply<!>()
rule?.<!OI;UNSAFE_IMPLICIT_INVOKE_CALL!>apply<!>()
// these both also ok (with smart cast / unnecessary safe call)
if (rule != null) {
compiler/testData/diagnostics/tests/SafeCallNonNullReceiverReturnNull.kt
Vendored
+1 -1
View File
@@ -3,5 +3,5 @@ fun Int.gg() = null
fun ff() {
val a: Int = 1
val <!UNUSED_VARIABLE!>b<!>: Int = <!TYPE_MISMATCH!>a<!UNNECESSARY_SAFE_CALL!>?.<!>gg()<!>
val <!UNUSED_VARIABLE!>b<!>: Int = <!TYPE_MISMATCH!>a<!UNNECESSARY_SAFE_CALL!>?.<!><!NI;TYPE_MISMATCH!>gg()<!><!>
}
compiler/testData/diagnostics/tests/TypeInference.kt
Vendored
+2 -2
View File
@@ -10,10 +10,10 @@ fun main(args : Array<String>) {
val <!UNUSED_VARIABLE!>a<!> : C<Int> = C();
val <!UNUSED_VARIABLE!>x<!> : C<in String> = C()
val <!UNUSED_VARIABLE!>y<!> : C<out String> = C()
val <!UNUSED_VARIABLE!>z<!> : C<*> = <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>C<!>()
val <!UNUSED_VARIABLE!>z<!> : C<*> = <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>C<!>()
val <!UNUSED_VARIABLE!>ba<!> : C<Int> = bar();
val <!UNUSED_VARIABLE!>bx<!> : C<in String> = bar()
val <!UNUSED_VARIABLE!>by<!> : C<out String> = bar()
val <!UNUSED_VARIABLE!>bz<!> : C<*> = <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>bar<!>()
val <!UNUSED_VARIABLE!>bz<!> : C<*> = <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>bar<!>()
}
compiler/testData/diagnostics/tests/Variance.kt
Vendored
+4 -4
View File
@@ -8,14 +8,14 @@ abstract class Producer<out T> {}
abstract class Usual<T> {}
fun foo(c: Consumer<Int>, p: Producer<Int>, u: Usual<Int>) {
val c1: Consumer<Any> = <!TYPE_MISMATCH!>c<!>
val c1: Consumer<Any> = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>c<!>
val <!UNUSED_VARIABLE!>c2<!>: Consumer<Int> = c1
val p1: Producer<Any> = p
val <!UNUSED_VARIABLE!>p2<!>: Producer<Int> = <!TYPE_MISMATCH!>p1<!>
val <!UNUSED_VARIABLE!>p2<!>: Producer<Int> = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>p1<!>
val u1: Usual<Any> = <!TYPE_MISMATCH!>u<!>
val <!UNUSED_VARIABLE!>u2<!>: Usual<Int> = <!TYPE_MISMATCH!>u1<!>
val u1: Usual<Any> = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>u<!>
val <!UNUSED_VARIABLE!>u2<!>: Usual<Int> = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>u1<!>
}
//Arrays copy example
compiler/testData/diagnostics/tests/annotations/AmbigiousAnnotationConstructor.kt
Vendored
+1 -1
View File
@@ -1,6 +1,6 @@
// !WITH_NEW_INFERENCE
import java.util.ArrayList
@<!NONE_APPLICABLE!>ArrayList<!><Int>(1, 1) fun b() {}
<!NI;NOT_AN_ANNOTATION_CLASS!>@<!OI;NONE_APPLICABLE!>ArrayList<!><Int>(<!NI;TOO_MANY_ARGUMENTS!>1<!>, <!NI;TOO_MANY_ARGUMENTS!>1<!>)<!> fun b() {}
@<!UNRESOLVED_REFERENCE!>Xoo<!>(<!UNRESOLVED_REFERENCE!>x<!>) fun c() {}
<!DEPRECATED_JAVA_ANNOTATION!>@java.lang.Deprecated(<!UNRESOLVED_REFERENCE, TOO_MANY_ARGUMENTS!>x<!>)<!> fun a() {}
compiler/testData/diagnostics/tests/annotations/kt1860-negative.kt
Vendored
+1 -1
View File
@@ -4,7 +4,7 @@ fun foo(@<!UNRESOLVED_REFERENCE!>varargs<!> <!UNUSED_PARAMETER!>f<!> : Int) {}
var bar : Int = 1
set(@<!UNRESOLVED_REFERENCE!>varargs<!> v) {}
val x : (Int) -> Int = {@<!UNRESOLVED_REFERENCE!>varargs<!> <!TYPE_MISMATCH, UNINITIALIZED_VARIABLE!>x<!> <!SYNTAX!>: Int -> x<!>}
val x : (Int) -> Int = {@<!UNRESOLVED_REFERENCE!>varargs<!> <!NI;TYPE_MISMATCH, TYPE_MISMATCH, UNINITIALIZED_VARIABLE!>x<!> <!SYNTAX!>: Int -> x<!>}
class Hello(@<!UNRESOLVED_REFERENCE!>varargs<!> <!UNUSED_PARAMETER!>args<!>: Any) {
}
compiler/testData/diagnostics/tests/annotations/kt1860-positive.kt
Vendored
+1 -1
View File
@@ -7,7 +7,7 @@ fun foo(@test <!UNUSED_PARAMETER!>f<!> : Int) {}
var bar : Int = 1
set(@test v) {}
val x : (Int) -> Int = {@test <!TYPE_MISMATCH, UNINITIALIZED_VARIABLE!>x<!> <!SYNTAX!>: Int -> x<!>} // todo fix parser annotation on lambda parameter
val x : (Int) -> Int = {@test <!NI;TYPE_MISMATCH, TYPE_MISMATCH, UNINITIALIZED_VARIABLE!>x<!> <!SYNTAX!>: Int -> x<!>} // todo fix parser annotation on lambda parameter
class Hello(@test <!UNUSED_PARAMETER!>args<!>: Any) {
}
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!>@FunAnn<!> ::gav)
bar(<!OI;WRONG_ANNOTATION_TARGET!>@<!NI;DEBUG_INFO_MISSING_UNRESOLVED!>FunAnn<!><!> ::gav)
// Function expression, ok
fast(f)
}
compiler/testData/diagnostics/tests/annotations/options/targets/field.kt
Vendored
+1 -1
View File
@@ -28,7 +28,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!>lazy<!> { 42 }
val v: Int by <!NI;DELEGATE_SPECIAL_FUNCTION_MISSING!><!UNRESOLVED_REFERENCE!>Delegates<!>.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>lazy<!> { 42 }<!>
}
enum class Your {
compiler/testData/diagnostics/tests/callableReference/bound/reservedExpressionSyntax3.kt
Vendored
+1 -1
View File
@@ -23,7 +23,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.b.c::foo
val test1a: () -> Right = a.<!NI;DEBUG_INFO_LEAKING_THIS!>b<!>.<!NI;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/function/extensionToSupertype.kt
Vendored
+1 -1
View File
@@ -15,5 +15,5 @@ fun take(f: () -> Unit) {}
fun test() {
B::foo checkType { _<KFunction1<B, Unit>>() }
<!NONE_APPLICABLE!>take<!>(B::foo)
<!NI;OVERLOAD_RESOLUTION_AMBIGUITY, OI;NONE_APPLICABLE!>take<!>(B::<!NI;DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>)
}
compiler/testData/diagnostics/tests/callableReference/generic/argumentAndReturnExpectedType.kt
Vendored
+2 -2
View File
@@ -16,9 +16,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 { _<Pair<String, Any>>() }
bar("", "", ::fooReturnInt).checkType { <!NI;DEBUG_INFO_UNRESOLVED_WITH_TARGET, NI;UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><Pair<String, Any>>() }
val x: String = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>bar("", "", ::fooReturnInt)<!>
val x: String = <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_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
@@ -14,12 +14,12 @@ fun <T> Wrapper<T>.baz(transform: (T) -> Unit): T = TODO()
fun test() {
takeFun<String>(::foo)
takeFun<String>(::<!TYPE_INFERENCE_UPPER_BOUND_VIOLATED!>fooInt<!>)
takeFun<String>(<!NI;TYPE_MISMATCH!>::<!OI;TYPE_INFERENCE_UPPER_BOUND_VIOLATED!>fooInt<!><!>)
callFun<String, Wrapper<String>>(::createWrapper)
callFun<Int, Wrapper<Number>>(::createWrapper)
callFun<String, Wrapper<*>>(::createWrapper)
callFun<String, Wrapper<Int>>(::<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>createWrapper<!>)
callFun<String, Wrapper<Int>>(::<!OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>createWrapper<!>)
callFun<Int, Wrapper<Int>>(::createWrapper).baz(::foo)
}
compiler/testData/diagnostics/tests/callableReference/generic/genericExtensionFunction.kt
Vendored
+2 -2
View File
@@ -23,8 +23,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>(Wrapper::<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>fooReturnString<!>)
bar<Wrapper, Int, Int>(Wrapper::<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>fooReturnString<!>)
bar<Wrapper, T, T>(<!NI;TYPE_MISMATCH!>Wrapper::<!OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>fooReturnString<!><!>)
bar<Wrapper, Int, Int>(<!NI;TYPE_MISMATCH!>Wrapper::<!OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>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
+4 -4
View File
@@ -29,9 +29,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!>bar(null, null, ::<!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>)<!>
val s4: Pair<Int?, String> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>bar(null, null, ::<!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>)<!>
val s3: Pair<Int, String?> = <!NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>bar(null, null, ::<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>)<!>
val s4: Pair<Int?, String> = <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>bar(null, null, ::<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>)<!>
val s5: Pair<Int, String> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>bar(1, "", ::foo)<!>
val (a1: Int, b1: String) = <!COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>bar(1, "", ::foo)<!>
val s5: Pair<Int, String> = <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>bar(1, "", ::foo)<!>
val (a1: Int, <!NI;TYPE_MISMATCH!>b1: String<!>) = <!OI;COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>bar(1, "", ::foo)<!>
}
compiler/testData/diagnostics/tests/callableReference/generic/nestedCallWithOverload.kt
Vendored
+1 -1
View File
@@ -11,7 +11,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(::<!NONE_APPLICABLE!>foo<!>), id(id(::<!NONE_APPLICABLE!>foo<!>)))
val x5: (Double) -> Unit = baz(id(::<!NI;DEBUG_INFO_MISSING_UNRESOLVED, OI;NONE_APPLICABLE!>foo<!>), id(id(::<!NI;DEBUG_INFO_MISSING_UNRESOLVED, OI;NONE_APPLICABLE!>foo<!>)))
id<(Int) -> Unit>(id(id(::foo)))
compiler/testData/diagnostics/tests/callableReference/generic/resolutionGenericCallableWithNullableTypes.kt
Vendored
+3 -3
View File
@@ -17,7 +17,7 @@ fun test1() {
baz<String>(::foo).checkType { _<String?>() }
baz<Boolean>(::foo).checkType { _<Boolean?>() }
val b1: Int = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>baz(::foo)<!>
val b2: String = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>baz(::foo)<!>
val b3: Boolean = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>baz(::foo)<!>
val b1: Int = <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>baz(::<!NI;DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>)<!>
val b2: String = <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>baz(::<!NI;DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>)<!>
val b3: Boolean = <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>baz(::<!NI;DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>)<!>
}
compiler/testData/diagnostics/tests/callableReference/generic/resolutionWithGenericCallable.kt
Vendored
+4 -4
View File
@@ -5,9 +5,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::<!NONE_APPLICABLE!>plus<!>, Double::<!NONE_APPLICABLE!>minus<!>)
val a4: Array<Int.(Double) -> Double> = arrayOf(Int::plus, Double::<!NONE_APPLICABLE!>minus<!>)
val a5: Array<Double.(Double) -> Double> = arrayOf(Double::plus, Int::<!NONE_APPLICABLE!>minus<!>)
val a3: Array<Int.(Int) -> Double> = arrayOf(Double::<!NI;DEBUG_INFO_MISSING_UNRESOLVED, OI;NONE_APPLICABLE!>plus<!>, Double::<!NI;DEBUG_INFO_MISSING_UNRESOLVED, OI;NONE_APPLICABLE!>minus<!>)
val a4: Array<Int.(Double) -> Double> = arrayOf(Int::plus, Double::<!NI;DEBUG_INFO_MISSING_UNRESOLVED, OI;NONE_APPLICABLE!>minus<!>)
val a5: Array<Double.(Double) -> Double> = arrayOf(Double::plus, Int::<!NI;DEBUG_INFO_MISSING_UNRESOLVED, OI;NONE_APPLICABLE!>minus<!>)
}
fun foo(x: Int) {}
@@ -18,5 +18,5 @@ fun <T> bar(x: T, f: (T) -> Unit) {}
fun test2() {
bar(1, ::foo)
bar("", ::foo)
bar(1.0, ::<!NONE_APPLICABLE!>foo<!>)
bar(1.0, ::<!NI;DEBUG_INFO_MISSING_UNRESOLVED, OI;NONE_APPLICABLE!>foo<!>)
}
compiler/testData/diagnostics/tests/callableReference/generic/specialCalls.kt
Vendored
+1 -1
View File
@@ -9,7 +9,7 @@ fun nullableFun(): ((Int) -> Int)? = null
fun test() {
val x1: (Int) -> Int = bar(if (true) ::baz else ::baz)
val x2: (Int) -> Int = bar(nullableFun() ?: ::baz)
val x3: (Int) -> Int = bar(::baz <!USELESS_ELVIS!>?: ::baz<!>)
val x3: (Int) -> Int = bar(::baz <!OI;USELESS_ELVIS!><!NI;USELESS_ELVIS_ON_CALLABLE_REFERENCE!>?:<!> ::baz<!>)
val i = 0
val x4: (Int) -> Int = bar(when (i) {
compiler/testData/diagnostics/tests/callableReference/property/kt7945_unrelatedClass.kt
Vendored
+1 -1
View File
@@ -7,5 +7,5 @@ class TestClass(var prop: Int)
open class OtherClass
fun OtherClass.test(prop: KProperty1<TestClass, Int>): Unit = throw Exception()
class OtherClass2: OtherClass() {
val result = test(TestClass::<!UNRESOLVED_REFERENCE!>result<!>)
val result = test(TestClass::<!NI;DEBUG_INFO_MISSING_UNRESOLVED, OI;UNRESOLVED_REFERENCE!>result<!>)
}
compiler/testData/diagnostics/tests/callableReference/resolve/byGenericArgType.kt
Vendored
+1 -1
View File
@@ -8,4 +8,4 @@ fun foo(s: String) {}
val x1 = ofType<() -> Unit>(::foo)
val x2 = ofType<(String) -> Unit>(::foo)
val x3 = ofType<(Int) -> Unit>(::<!NONE_APPLICABLE!>foo<!>)
val x3 = ofType<(Int) -> Unit>(::<!NI;DEBUG_INFO_MISSING_UNRESOLVED, OI;NONE_APPLICABLE!>foo<!>)
compiler/testData/diagnostics/tests/callableReference/resolve/intersectionTypeOverloadWithWrongParameter.kt
Vendored
+1 -1
View File
@@ -11,7 +11,7 @@ class Foo {
}
fun foo() {
<!OVERLOAD_RESOLUTION_AMBIGUITY!>installRoute<!><Any>(::route)
<!NI;NONE_APPLICABLE, OI;OVERLOAD_RESOLUTION_AMBIGUITY!>installRoute<!><Any>(::<!NI;DEBUG_INFO_MISSING_UNRESOLVED!>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 = <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>apply<!>(true, ::<!NONE_APPLICABLE!>foo<!>)
val <!NI;IMPLICIT_NOTHING_PROPERTY_TYPE!>x3<!> = <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>apply<!>(true, ::<!NI;DEBUG_INFO_MISSING_UNRESOLVED, OI;NONE_APPLICABLE!>foo<!>)
compiler/testData/diagnostics/tests/callableReference/resolve/withPlaceholderTypes.kt
Vendored
+3 -3
View File
@@ -20,8 +20,8 @@ fun fn3(i: Int, f: (Int, Int, Int) -> Int): Int = f(i, i, i)
val x1 = fn1(1, ::foo, ::foo)
val x2 = fn1(1, ::foo, ::bar)
val x3 = fn2(::bar, ::foo)
val x4 = <!OVERLOAD_RESOLUTION_AMBIGUITY!>fn2<!>(::<!OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!>, ::bar)
val x5 = <!OVERLOAD_RESOLUTION_AMBIGUITY!>fn2<!>(::<!OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!>, ::<!OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!>)
val x3 = <!NI;OVERLOAD_RESOLUTION_AMBIGUITY!>fn2<!>(::<!NI;DEBUG_INFO_MISSING_UNRESOLVED!>bar<!>, ::<!NI;DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>)
val x4 = <!OVERLOAD_RESOLUTION_AMBIGUITY!>fn2<!>(::<!NI;DEBUG_INFO_MISSING_UNRESOLVED, OI;OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!>, ::<!NI;DEBUG_INFO_MISSING_UNRESOLVED!>bar<!>)
val x5 = <!OVERLOAD_RESOLUTION_AMBIGUITY!>fn2<!>(::<!NI;DEBUG_INFO_MISSING_UNRESOLVED, OI;OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!>, ::<!NI;DEBUG_INFO_MISSING_UNRESOLVED, OI;OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!>)
val x6 = fn3(1, ::qux)
compiler/testData/diagnostics/tests/cast/AsInBinaryUnary.kt
Vendored
+2 -2
View File
@@ -20,11 +20,11 @@ operator fun Impl2.unaryMinus() = Impl2()
// See also KT-10384: in non-error functions, as is necessary!
fun add1(x: Impl2, y: Base): Impl1 = x as Base + y
fun error1(x: Impl2, y: Base): Impl1 = <!TYPE_MISMATCH!>x + y<!>
fun error1(x: Impl2, y: Base): Impl1 = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>x + y<!>
fun add2(x: Base, y: Impl2): Impl1 = x + y as Base
fun error2(x: Base, y: Impl2): Impl1 = <!TYPE_MISMATCH!>x + y<!>
fun error2(x: Base, y: Impl2): Impl1 = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>x + y<!>
fun minus3(x: Impl2): Impl1 = -(x as Base)
compiler/testData/diagnostics/tests/cast/AsInBlockWithReturnType.kt
Vendored
+6 -6
View File
@@ -6,7 +6,7 @@ fun runWithoutReturn(r: () -> Unit) = r()
fun testRun() {
run {
1 <!USELESS_CAST!>as Any<!>
1 as Any
1 <!NI;USELESS_CAST!>as Any<!>
}
run<Any> {
@@ -17,11 +17,11 @@ fun testRun() {
fun foo(): Int = 1
run {
foo() as Any
foo() <!NI;USELESS_CAST!>as Any<!>
}
run {
(if (true) 1 else 2) as Any
(if (true) 1 else 2) <!NI;USELESS_CAST!>as Any<!>
}
run<Int?> {
@@ -36,17 +36,17 @@ fun testRun() {
}
fun testReturn(): Number {
run { 1 as Number }
run { 1 <!NI;USELESS_CAST!>as Number<!> }
return run { 1 <!USELESS_CAST!>as Number<!> }
}
fun <T> testDependent() {
listOf(1).map {
it <!USELESS_CAST!>as Any<!>
it as Any
it <!NI;USELESS_CAST!>as Any<!>
}
listOf<T>().map { it as Any? }
listOf<T>().map { it <!NI;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
@@ -11,7 +11,7 @@ fun test(x: Int?) {
val a7: Number? = 1 <!USELESS_CAST!>as? Number<!>
run { x <!USELESS_CAST!>as? Int<!> }
run { x as? Number }
run { x <!NI;USELESS_CAST!>as? Number<!> }
foo(x as? Number)
compiler/testData/diagnostics/tests/cast/kt15161.kt
Vendored
+1 -1
View File
@@ -2,6 +2,6 @@
class Array<E>(e: E) {
val k = Array(1) {
1 <!USELESS_CAST!>as Any<!>
e as Any?
e <!NI;USELESS_CAST!>as Any?<!>
}
}
compiler/testData/diagnostics/tests/checkArguments/SpreadVarargs.kt
Vendored
+2 -2
View File
@@ -43,10 +43,10 @@ fun main(args : Array<String>) {
joinG(1, "2")
joinG(<!NON_VARARG_SPREAD!>*<!>1, "2")
<!TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR!>joinG<!>(1, *<!TYPE_MISMATCH!>"2"<!>)
<!OI;TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR!>joinG<!>(1, *<!TYPE_MISMATCH!>"2"<!>)
joinG(x = 1, a = *a)
joinG(x = 1, a = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION!>"2"<!>)
<!TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR!>joinG<!>(x = <!NON_VARARG_SPREAD!>*<!>1, a = *<!TYPE_MISMATCH!>"2"<!>)
<!OI;TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR!>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
@@ -6,6 +6,6 @@ class A {
operator fun set(x: String, value: Int) {}
fun d(x: Int) {
this["", <!TOO_MANY_ARGUMENTS!>1<!>] = 1
this["", <!OI;TOO_MANY_ARGUMENTS!>1<!>] = <!NI;TOO_MANY_ARGUMENTS!>1<!>
}
}
compiler/testData/diagnostics/tests/checkArguments/booleanExpressions.kt
Vendored
+4 -4
View File
@@ -1,7 +1,7 @@
// !WITH_NEW_INFERENCE
fun foo1(b: Boolean, c: Int) {
if (b && <!TYPE_MISMATCH!>c<!>) {}
if (b || <!TYPE_MISMATCH!>c<!>) {}
if (<!TYPE_MISMATCH!>c<!> && b) {}
if (<!TYPE_MISMATCH!>c<!> || b) {}
if (b && <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>c<!>) {}
if (b || <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>c<!>) {}
if (<!NI;TYPE_MISMATCH, TYPE_MISMATCH!>c<!> && b) {}
if (<!NI;TYPE_MISMATCH, TYPE_MISMATCH!>c<!> || b) {}
}
compiler/testData/diagnostics/tests/checkArguments/kt1897_diagnostic_part.kt
Vendored
+1 -1
View File
@@ -25,5 +25,5 @@ fun test() {
foo(<!TYPE_MISMATCH!>""<!>, <!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>) <!TOO_MANY_ARGUMENTS!>{}<!>
foo(<!TYPE_MISMATCH!>""<!>, <!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>) <!TOO_MANY_ARGUMENTS!>{}<!> <!MANY_LAMBDA_EXPRESSION_ARGUMENTS!>{}<!>
foo(<!TYPE_MISMATCH!>""<!>, <!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>) <!NI;TOO_MANY_ARGUMENTS, TOO_MANY_ARGUMENTS!>{}<!> <!OI;MANY_LAMBDA_EXPRESSION_ARGUMENTS!>{}<!>
}
compiler/testData/diagnostics/tests/checkArguments/overloadedFunction.kt
Vendored
+1 -1
View File
@@ -12,6 +12,6 @@ fun test() {
<!NONE_APPLICABLE!>foo<!>(1, 2)
foo(<!TYPE_MISMATCH!>""<!>)
<!NONE_APPLICABLE!>bar<!>(1, 2)
<!OI;NONE_APPLICABLE!>bar<!>(1, <!NI;TOO_MANY_ARGUMENTS!>2<!>)
<!NONE_APPLICABLE!>bar<!>()
}
compiler/testData/diagnostics/tests/checkType.kt
Vendored
+2 -2
View File
@@ -7,6 +7,6 @@ interface C : B
fun test(b: B) {
b checkType { _<B>() }
b checkType { <!TYPE_MISMATCH!>_<!><A>() }
b checkType { <!TYPE_MISMATCH!>_<!><C>() }
b checkType { <!NI;DEBUG_INFO_UNRESOLVED_WITH_TARGET, NI;UNRESOLVED_REFERENCE_WRONG_RECEIVER, OI;TYPE_MISMATCH!>_<!><A>() }
b checkType { <!NI;DEBUG_INFO_UNRESOLVED_WITH_TARGET, NI;UNRESOLVED_REFERENCE_WRONG_RECEIVER, OI;TYPE_MISMATCH!>_<!><C>() }
}
compiler/testData/diagnostics/tests/collectionLiterals/argumentsOfAnnotation.kt
Vendored
+1 -1
View File
@@ -9,7 +9,7 @@ fun test1() {}
@Foo([], [], [])
fun test2() {}
@Foo([<!CONSTANT_EXPECTED_TYPE_MISMATCH!>1f<!>], <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>[' ']<!>, [<!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>])
@Foo([<!CONSTANT_EXPECTED_TYPE_MISMATCH!>1f<!>], <!NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_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
@@ -21,10 +21,10 @@ fun test3() {}
@Foo([<!CLASS_LITERAL_LHS_NOT_A_CLASS!>Gen<Int>::class<!>])
fun test4() {}
@Foo(<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>[""]<!>)
@Foo(<!NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>[""]<!>)
fun test5() {}
@Foo(<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>[Int::class, 1]<!>)
@Foo(<!NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>[Int::class, 1]<!>)
fun test6() {}
@Bar
compiler/testData/diagnostics/tests/collectionLiterals/basicCollectionLiterals.kt
Vendored
+3 -3
View File
@@ -3,11 +3,11 @@
// !DIAGNOSTICS: -UNUSED_VARIABLE, -UNSUPPORTED
fun test() {
val a = <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>[]<!>
val a = <!OI;TYPE_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!>[1]<!>
val e: Array<String> = <!NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>[1]<!>
val f: IntArray = [1, 2]
val g = [f]
@@ -20,5 +20,5 @@ fun check() {
val f: IntArray = [1]
[f] checkType { _<Array<IntArray>>() }
[1, ""] checkType { _<Array<Any>>() }
[1, ""] checkType { <!NI;DEBUG_INFO_UNRESOLVED_WITH_TARGET, NI;UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><Array<Any>>() }
}
compiler/testData/diagnostics/tests/collectionLiterals/collectionLiteralsWithVarargs.kt
Vendored
+3 -3
View File
@@ -17,7 +17,7 @@ fun test1_0() {}
@Ann1(*["a", "b"])
fun test1_1() {}
@Ann1(*<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>["a", 1, <!ANNOTATION_PARAMETER_MUST_BE_CONST!>null<!>]<!>)
@Ann1(*<!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>["a", 1, <!OI;ANNOTATION_PARAMETER_MUST_BE_CONST!>null<!>]<!>)
fun test1_2() {}
@Ann2(*[])
@@ -34,8 +34,8 @@ fun test6() {}
annotation class AnnArray(val a: Array<String>)
@AnnArray(<!NON_VARARG_SPREAD!>*<!>["/"])
@AnnArray(<!OI;NON_VARARG_SPREAD!>*<!>["/"])
fun testArray() {}
@Ann1(<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH, TYPE_MISMATCH!>[""]<!>)
@Ann1(<!NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH, TYPE_MISMATCH!>[""]<!>)
fun testVararg() {}
compiler/testData/diagnostics/tests/collectionLiterals/defaultValuesInAnnotation.kt
Vendored
+4 -4
View File
@@ -8,9 +8,9 @@ annotation class Foo(
)
annotation class Bar(
val a: Array<String> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>[' ']<!>,
val b: Array<String> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH, ANNOTATION_PARAMETER_DEFAULT_VALUE_MUST_BE_CONSTANT!>["", <!EMPTY_CHARACTER_LITERAL!>''<!>]<!>,
val c: Array<String> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>[1]<!>
val a: Array<String> = <!NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>[' ']<!>,
val b: Array<String> = <!NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH, ANNOTATION_PARAMETER_DEFAULT_VALUE_MUST_BE_CONSTANT!>["", <!EMPTY_CHARACTER_LITERAL!>''<!>]<!>,
val c: Array<String> = <!NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>[1]<!>
)
annotation class Base(
@@ -22,5 +22,5 @@ annotation class Base(
annotation class Err(
val a: IntArray = [<!CONSTANT_EXPECTED_TYPE_MISMATCH!>1L<!>],
val b: Array<String> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>[1]<!>
val b: Array<String> = <!NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>[1]<!>
)
compiler/testData/diagnostics/tests/collectionLiterals/noCollectionLiterals.kt
Vendored
+1 -1
View File
@@ -6,7 +6,7 @@ fun test(): Array<Int> {
foo(<!UNSUPPORTED!>[""]<!>)
val <!UNUSED_VARIABLE!>p<!> = <!UNSUPPORTED!>[1, 2]<!> <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>+<!> <!UNSUPPORTED!>[3, 4]<!>
val <!UNUSED_VARIABLE!>p<!> = <!UNSUPPORTED!>[1, 2]<!> <!NI;DEBUG_INFO_UNRESOLVED_WITH_TARGET, UNRESOLVED_REFERENCE_WRONG_RECEIVER!>+<!> <!OI;UNSUPPORTED!>[3, 4]<!>
return <!UNSUPPORTED!>[1, 2]<!>
}
compiler/testData/diagnostics/tests/controlFlowAnalysis/UninitializedOrReassignedVariables.kt
Vendored
+1 -1
View File
@@ -241,7 +241,7 @@ class Outer() {
}
class ForwardAccessToBackingField() { //kt-147
val a = <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM, UNINITIALIZED_VARIABLE!>a<!> // error
val a = <!NI;DEBUG_INFO_MISSING_UNRESOLVED, OI;UNINITIALIZED_VARIABLE, 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!>{ true }<!> <!USELESS_ELVIS_ON_LAMBDA_EXPRESSION!>?:<!> null!!
<!OI;TYPE_MISMATCH!>{ true }<!> <!USELESS_ELVIS_ON_LAMBDA_EXPRESSION!>?:<!> null!!
}
else if (true) {
<!TYPE_MISMATCH!>{ true }<!> <!USELESS_ELVIS_ON_LAMBDA_EXPRESSION!>?:<!> null!!
<!OI;TYPE_MISMATCH!>{ true }<!> <!USELESS_ELVIS_ON_LAMBDA_EXPRESSION!>?:<!> null!!
}
else {
null!!
}
val <!IMPLICIT_NOTHING_PROPERTY_TYPE!>n<!> = null ?: (null ?: <!TYPE_MISMATCH!>{ true }<!>)
val <!OI;IMPLICIT_NOTHING_PROPERTY_TYPE!>n<!> = null ?: (null ?: <!OI;TYPE_MISMATCH!>{ 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!>fun() {}<!> <!USELESS_ELVIS!>?: <!TYPE_MISMATCH!>fun() {}<!><!>)
return <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>a<!>
var a = x ?: (<!NI;TYPE_MISMATCH, TYPE_MISMATCH!>fun() {}<!> <!OI;USELESS_ELVIS!><!NI;USELESS_ELVIS_ON_LAMBDA_EXPRESSION!>?:<!> <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>fun() {}<!><!>)
return <!OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>a<!>
}
compiler/testData/diagnostics/tests/controlFlowAnalysis/fieldAsClassDelegate.kt
Vendored
+1 -1
View File
@@ -28,7 +28,7 @@ private fun <T> lazy(init: () -> T): kotlin.<!UNRESOLVED_REFERENCE!>Lazy<!><T> {
}
object DefaultHttpClientWithBy : HttpClient by client {
val client by lazy { HttpClientImpl() }
val client by <!NI;DELEGATE_SPECIAL_FUNCTION_MISSING!>lazy { HttpClientImpl() }<!>
}
object DefaultFqHttpClient : HttpClient by DefaultFqHttpClient.<!UNINITIALIZED_VARIABLE!>client<!> {
compiler/testData/diagnostics/tests/controlFlowAnalysis/kt10805.kt
Vendored
+3 -3
View File
@@ -1,11 +1,11 @@
// !WITH_NEW_INFERENCE
// AssertionError for nested ifs with lambdas and Nothing as results
val <!IMPLICIT_NOTHING_PROPERTY_TYPE!>fn<!> = if (true) {
<!TYPE_MISMATCH!>{ true }<!>
val <!OI;IMPLICIT_NOTHING_PROPERTY_TYPE!>fn<!> = if (true) {
<!OI;TYPE_MISMATCH!>{ true }<!>
}
else if (true) {
<!TYPE_MISMATCH!>{ true }<!>
<!OI;TYPE_MISMATCH!>{ true }<!>
}
else {
null!!
compiler/testData/diagnostics/tests/controlFlowAnalysis/throwInLambda.kt
Vendored
+2 -2
View File
@@ -8,6 +8,6 @@ fun foo(): String {
}
fun bar(): String {
val x = fn() ?: return ""
<!UNREACHABLE_CODE!>val <!UNUSED_VARIABLE!>y<!> =<!> x<!UNNECESSARY_SAFE_CALL!>?.<!>let { throw Exception() } <!USELESS_ELVIS, UNREACHABLE_CODE!>?: "unreachable"<!>
<!UNREACHABLE_CODE!>return y<!>
<!OI;UNREACHABLE_CODE!>val <!OI;UNUSED_VARIABLE!>y<!> =<!> x<!UNNECESSARY_SAFE_CALL!>?.<!>let { throw Exception() } <!OI;UNREACHABLE_CODE, OI;USELESS_ELVIS!>?: "unreachable"<!>
<!OI;UNREACHABLE_CODE!>return y<!>
}
compiler/testData/diagnostics/tests/controlStructures/ForLoopWithExtensionIteratorOnNullable.kt
Vendored
+1 -1
View File
@@ -18,5 +18,5 @@ class OtherContainer<K>(val k: K) {
fun test2() {
val other: OtherContainer<String>? = null
// Error
for (s in <!ITERATOR_ON_NULLABLE!>other<!>) {}
for (s in <!NI;ITERATOR_MISSING, OI;ITERATOR_ON_NULLABLE!>other<!>) {}
}
compiler/testData/diagnostics/tests/controlStructures/ifElseIntersection.kt
Vendored
+4 -4
View File
@@ -9,7 +9,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!>if<!> (true) <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>None()<!> else <!DEBUG_INFO_SMARTCAST!>r<!>) checkType { <!TYPE_MISMATCH!>_<!><Option<T>>() }
(<!OI;TYPE_INFERENCE_FAILED_ON_SPECIAL_CONSTRUCT!>if<!> (true) <!OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>None()<!> else <!DEBUG_INFO_SMARTCAST!>r<!>) checkType { <!NI;DEBUG_INFO_UNRESOLVED_WITH_TARGET, NI;UNRESOLVED_REFERENCE_WRONG_RECEIVER, OI;TYPE_MISMATCH!>_<!><Option<T>>() }
// Works correctly
if (true) None() else r
}
@@ -25,10 +25,10 @@ fun <T> bind2(r: Option<T>): Option<T> {
}
fun <T, R> bind3(r: Option<T>): Option<T> {
return if (r is Some) {
return if (r is Some) <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>{
// Diagnoses an error correctly
if (true) <!TYPE_MISMATCH!>None<R>()<!> else r
}
if (true) <!OI;TYPE_MISMATCH!>None<R>()<!> else r
}<!>
else r
}
compiler/testData/diagnostics/tests/controlStructures/ifInResultOfLambda.kt
Vendored
+2 -2
View File
@@ -1,7 +1,7 @@
// !WITH_NEW_INFERENCE
val test1 = { if (true) <!IMPLICIT_CAST_TO_ANY!>1<!> else <!IMPLICIT_CAST_TO_ANY!>""<!> }
val test1 = { if (true) <!OI;IMPLICIT_CAST_TO_ANY!>1<!> else <!OI;IMPLICIT_CAST_TO_ANY!>""<!> }
val test2 = { { if (true) <!IMPLICIT_CAST_TO_ANY!>1<!> else <!IMPLICIT_CAST_TO_ANY!>""<!> } }
val test2 = { { if (true) <!OI;IMPLICIT_CAST_TO_ANY!>1<!> else <!OI;IMPLICIT_CAST_TO_ANY!>""<!> } }
val test3: (Boolean) -> Any = { if (it) 1 else "" }
compiler/testData/diagnostics/tests/controlStructures/ifToAnyDiscriminatingUsages.kt
Vendored
+3 -3
View File
@@ -17,8 +17,8 @@ fun testResultOfLambda2() =
fun testResultOfAnonFun1() =
run(fun () =
if (true) <!IMPLICIT_CAST_TO_ANY!>42<!>
else <!IMPLICIT_CAST_TO_ANY!>println()<!>
if (true) <!OI;IMPLICIT_CAST_TO_ANY!>42<!>
else <!OI;IMPLICIT_CAST_TO_ANY!>println()<!>
)
fun testResultOfAnonFun2() =
@@ -28,7 +28,7 @@ fun testResultOfAnonFun2() =
fun testReturnFromAnonFun() =
run(fun () {
return if (true) <!CONSTANT_EXPECTED_TYPE_MISMATCH!>42<!> else println()
return <!NI;TYPE_MISMATCH!>if (true) <!OI;CONSTANT_EXPECTED_TYPE_MISMATCH!>42<!> else println()<!>
})
fun <!IMPLICIT_NOTHING_RETURN_TYPE!>testReturn1<!>() =
compiler/testData/diagnostics/tests/controlStructures/ifWhenWithoutElse.kt
Vendored
+4 -4
View File
@@ -20,10 +20,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 = <!NO_ELSE_IN_WHEN!>when<!> { true -> <!CONSTANT_EXPECTED_TYPE_MISMATCH!>42<!> }
val wxx2: Unit = <!NI;TYPE_MISMATCH!><!NO_ELSE_IN_WHEN!>when<!> { true -> <!OI;CONSTANT_EXPECTED_TYPE_MISMATCH!>42<!> }<!>
val wxx3 = idAny(<!NO_ELSE_IN_WHEN!>when<!> { true -> 42 })
val wxx4 = id(<!NO_ELSE_IN_WHEN!>when<!> { true -> 42 })
val wxx5 = idUnit(<!NO_ELSE_IN_WHEN!>when<!> { true -> <!CONSTANT_EXPECTED_TYPE_MISMATCH!>42<!> })
val wxx5 = idUnit(<!NI;TYPE_MISMATCH!><!NO_ELSE_IN_WHEN!>when<!> { true -> <!OI;CONSTANT_EXPECTED_TYPE_MISMATCH!>42<!> }<!>)
val wxx6 = null ?: <!NO_ELSE_IN_WHEN!>when<!> { true -> 42 }
val wxx7 = "" + <!NO_ELSE_IN_WHEN!>when<!> { true -> 42 }
@@ -51,8 +51,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 = <!NO_ELSE_IN_WHEN!>when<!> { true -> <!TYPE_MISMATCH!>mlist.add()<!> }
fun g6(): Unit = <!NO_ELSE_IN_WHEN!>when<!> { true -> <!CONSTANT_EXPECTED_TYPE_MISMATCH!>42<!> }
fun g5(): Unit = <!NI;TYPE_MISMATCH!><!NO_ELSE_IN_WHEN!>when<!> { true -> <!OI;TYPE_MISMATCH!>mlist.add()<!> }<!>
fun g6(): Unit = <!NI;TYPE_MISMATCH!><!NO_ELSE_IN_WHEN!>when<!> { true -> <!OI;CONSTANT_EXPECTED_TYPE_MISMATCH!>42<!> }<!>
fun foo1(x: String?) {
"" + <!INVALID_IF_AS_EXPRESSION!>if<!> (true) 42
compiler/testData/diagnostics/tests/controlStructures/improperElseInExpression.kt
Vendored
+1 -1
View File
@@ -30,5 +30,5 @@ fun example() {
return <!TYPE_MISMATCH!><!INVALID_IF_AS_EXPRESSION!>if<!> (true) true<!>
}
return if (true) <!CONSTANT_EXPECTED_TYPE_MISMATCH!>true<!> else {}
return <!NI;TYPE_MISMATCH!>if (true) <!OI;CONSTANT_EXPECTED_TYPE_MISMATCH!>true<!> else {}<!>
}
compiler/testData/diagnostics/tests/controlStructures/kt1075.kt
Vendored
+1 -1
View File
@@ -5,7 +5,7 @@ package kt1075
fun foo(b: String) {
if (<!TYPE_MISMATCH!>b<!> in 1..10) {} //type mismatch
when (b) {
when (<!NI;TYPE_MISMATCH!>b<!>) {
<!TYPE_MISMATCH_IN_RANGE!>in<!> 1..10 -> <!UNUSED_EXPRESSION!>1<!> //no type mismatch, but it should be here
else -> <!UNUSED_EXPRESSION!>2<!>
}
compiler/testData/diagnostics/tests/controlStructures/kt4310.kt
Vendored
+3 -3
View File
@@ -4,9 +4,9 @@ package f
fun test(a: Boolean, b: Boolean): Int {
return if(a) {
1
} else {
<!TYPE_MISMATCH!><!INVALID_IF_AS_EXPRESSION!>if<!> (b) {
} else <!NI;TYPE_MISMATCH!>{
<!OI;TYPE_MISMATCH!><!INVALID_IF_AS_EXPRESSION!>if<!> (b) {
3
}<!>
}
}<!>
}
compiler/testData/diagnostics/tests/controlStructures/kt770.kt351.kt735_StatementType.kt
Vendored
+4 -4
View File
@@ -27,7 +27,7 @@ fun foo() {
z = 34
}
}
val <!UNUSED_VARIABLE!>f<!>: ()-> Int = <!TYPE_MISMATCH!>r<!>
val <!UNUSED_VARIABLE!>f<!>: ()-> Int = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>r<!>
val <!UNUSED_VARIABLE!>g<!>: ()-> Any = r
}
@@ -80,7 +80,7 @@ fun testCoercionToUnit() {
45
}
}
val <!UNUSED_VARIABLE!>f<!> : () -> String = <!TYPE_MISMATCH!>checkType<!>
val <!UNUSED_VARIABLE!>f<!> : () -> String = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>checkType<!>
}
fun doSmth(<!UNUSED_PARAMETER!>i<!>: Int) {}
@@ -107,12 +107,12 @@ fun testImplicitCoercion() {
val <!UNUSED_VARIABLE!>g<!> = <!INVALID_IF_AS_EXPRESSION!>if<!> (true) 4
val <!UNUSED_VARIABLE!>h<!> = if (false) <!IMPLICIT_CAST_TO_ANY!>4<!> else <!IMPLICIT_CAST_TO_ANY!>{}<!>
bar(if (true) {
bar(<!NI;TYPE_MISMATCH!>if (true) {
<!CONSTANT_EXPECTED_TYPE_MISMATCH!>4<!>
}
else {
<!UNUSED_VALUE!>z =<!> 342
})
}<!>)
}
fun fooWithAnyArg(<!UNUSED_PARAMETER!>arg<!>: Any) {}
compiler/testData/diagnostics/tests/controlStructures/lambdasInExclExclAndElvis.kt
Vendored
+2 -2
View File
@@ -9,8 +9,8 @@ fun test() {
// KT-KT-9070
<!TYPE_MISMATCH!>{ }<!> <!USELESS_ELVIS!>?: 1<!>
use({ 2 } <!USELESS_ELVIS_ON_LAMBDA_EXPRESSION!>?:<!> 1);
use(<!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>{ 2 }<!> <!USELESS_ELVIS_ON_LAMBDA_EXPRESSION!>?:<!> 1);
1 <!USELESS_ELVIS!>?: <!TYPE_MISMATCH, UNUSED_LAMBDA_EXPRESSION!>{ }<!><!>
use(1 <!USELESS_ELVIS!>?: { }<!>)
use(1 <!USELESS_ELVIS!>?: <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>{ }<!><!>)
}
compiler/testData/diagnostics/tests/controlStructures/specialConstructsAndPlatformTypes.kt
Vendored
+2 -2
View File
@@ -12,7 +12,7 @@ public class J {
val testImplicitExclExcl1: String = J.s
val testImplicitExclExcl2: String? = J.s
val testImplicitExclExcl3: String = <!TYPE_MISMATCH!>J.m[""]<!>
val testImplicitExclExcl3: String = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>J.m[""]<!>
val testImplicitExclExcl4: String? = J.m[""]
val testExclExcl1: String = J.s!!
@@ -30,7 +30,7 @@ val testSafeCall4: String? = J.m[""]?.let { it.toString() }
val testIf1: String = if (true) J.s else J.s
val testIf2: String? = if (true) J.s else J.s
val testIf3: String = if (true) <!TYPE_MISMATCH!>J.m[""]<!> else <!TYPE_MISMATCH!>J.m[""]<!>
val testIf3: String = if (true) <!TYPE_MISMATCH!>J.m[""]<!> else <!OI;TYPE_MISMATCH!>J.m[""]<!>
val testIf4: String? = if (true) J.m[""] else J.m[""]
val testWhen1: String = when { else -> J.s }
compiler/testData/diagnostics/tests/controlStructures/tryReturnType.kt
Vendored
+1 -1
View File
@@ -15,7 +15,7 @@ fun foo() : Int {
fun bar() : Int =
try {
<!TYPE_MISMATCH!>doSmth()<!>
<!NI;TYPE_MISMATCH, TYPE_MISMATCH!>doSmth()<!>
}
catch (e: Exception) {
<!TYPE_MISMATCH!>""<!>
compiler/testData/diagnostics/tests/controlStructures/typeInferenceForExclExcl.kt
Vendored
+2 -2
View File
@@ -13,9 +13,9 @@ fun <T: Any> exclExcl(t: T?): T = t!!
fun test11() {
// not 'String!'
exclExcl(A.foo()) checkType { _<String>() }
exclExcl(A.foo()) checkType { <!TYPE_MISMATCH!>_<!><String?>() }
exclExcl(A.foo()) checkType { <!NI;DEBUG_INFO_UNRESOLVED_WITH_TARGET, NI;UNRESOLVED_REFERENCE_WRONG_RECEIVER, OI;TYPE_MISMATCH!>_<!><String?>() }
// not 'String!'
A.foo()!! checkType { _<String>() }
A.foo()!! checkType { <!TYPE_MISMATCH!>_<!><String?>() }
A.foo()!! checkType { <!NI;DEBUG_INFO_UNRESOLVED_WITH_TARGET, NI;UNRESOLVED_REFERENCE_WRONG_RECEIVER, OI;TYPE_MISMATCH!>_<!><String?>() }
}
compiler/testData/diagnostics/tests/controlStructures/whenInResultOfLambda.kt
Vendored
+2 -2
View File
@@ -1,7 +1,7 @@
// !WITH_NEW_INFERENCE
val test1 = { when (true) { true -> <!IMPLICIT_CAST_TO_ANY!>1<!>; else -> <!IMPLICIT_CAST_TO_ANY!>""<!> } }
val test1 = { when (true) { true -> <!OI;IMPLICIT_CAST_TO_ANY!>1<!>; else -> <!OI;IMPLICIT_CAST_TO_ANY!>""<!> } }
val test2 = { { when (true) { true -> <!IMPLICIT_CAST_TO_ANY!>1<!>; else -> <!IMPLICIT_CAST_TO_ANY!>""<!> } } }
val test2 = { { when (true) { true -> <!OI;IMPLICIT_CAST_TO_ANY!>1<!>; else -> <!OI;IMPLICIT_CAST_TO_ANY!>""<!> } } }
val test3: (Boolean) -> Any = { when (true) { true -> 1; else -> "" } }
compiler/testData/diagnostics/tests/cyclicHierarchy/kt303.kt
Vendored
+1 -1
View File
@@ -9,4 +9,4 @@ open class Bar() : <!CYCLIC_INHERITANCE_HIERARCHY!>Foo<!>() {
}
val x : Int = <!TYPE_MISMATCH!>Foo()<!>
val x : Int = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>Foo()<!>
compiler/testData/diagnostics/tests/dataClasses/extensionComponentsOnNullable.kt
Vendored
+3 -3
View File
@@ -9,7 +9,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 x + y
return <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!><!NI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>x<!> <!NI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>+<!> <!NI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>y<!><!>
}
data class NormalData<T>(val x: T, val y: T)
@@ -17,6 +17,6 @@ data class NormalData<T>(val x: T, val y: T)
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!>+<!> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>y<!>
val (x, y) = <!NI;COMPONENT_FUNCTION_MISSING, NI;COMPONENT_FUNCTION_MISSING, OI;COMPONENT_FUNCTION_ON_NULLABLE, OI;COMPONENT_FUNCTION_ON_NULLABLE!>d<!>
return <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!><!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>x<!> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>+<!> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>y<!><!>
}
compiler/testData/diagnostics/tests/dataFlowInfoTraversal/BinaryExpression.kt
Vendored
+1 -1
View File
@@ -6,6 +6,6 @@ fun foo() {
val x: Int? = null
bar(1 + (if (x == null) 0 else x))
bar(if (x == null) <!TYPE_MISMATCH, DEBUG_INFO_CONSTANT!>x<!> else x)
bar(<!NI;TYPE_MISMATCH!>if (x == null) <!TYPE_MISMATCH, DEBUG_INFO_CONSTANT!>x<!> else x<!>)
if (x != null) bar(x + x/(x-x*x))
}
compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ExclExcl.kt
Vendored
+1 -1
View File
@@ -4,7 +4,7 @@ fun bar(x: Int) = x + 1
fun f1(x: Int?) {
bar(<!TYPE_MISMATCH!>x<!>)
if (x != null) bar(x<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>)
if (x == null) <!UNREACHABLE_CODE!>bar(<!><!ALWAYS_NULL!>x<!>!!<!UNREACHABLE_CODE!>)<!>
if (x == null) <!OI;UNREACHABLE_CODE!>bar(<!><!ALWAYS_NULL!>x<!>!!<!OI;UNREACHABLE_CODE!>)<!>
}
fun f2(x: Int?) {
compiler/testData/diagnostics/tests/dataFlowInfoTraversal/Return.kt
Vendored
+1 -1
View File
@@ -14,5 +14,5 @@ fun foo(): Int {
val z: Int? = null
if (z != null) return if (<!SENSELESS_COMPARISON!>z == null<!>) z else z
return <!TYPE_MISMATCH, DEBUG_INFO_CONSTANT!>z<!>
return <!NI;TYPE_MISMATCH, DEBUG_INFO_CONSTANT, TYPE_MISMATCH!>z<!>
}
compiler/testData/diagnostics/tests/declarationChecks/ComponentFunctionReturnTypeMismatch.kt
Vendored
+1 -1
View File
@@ -5,5 +5,5 @@ class A {
}
fun a(aa : A) {
val (<!UNUSED_VARIABLE!>a<!>: String, <!UNUSED_VARIABLE!>b1<!>: String) = <!COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH, COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>aa<!>
val (<!NI;TYPE_MISMATCH!><!UNUSED_VARIABLE!>a<!>: String<!>, <!NI;TYPE_MISMATCH!><!UNUSED_VARIABLE!>b1<!>: String<!>) = <!OI;COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH, OI;COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>aa<!>
}
compiler/testData/diagnostics/tests/declarationChecks/MultiDeclarationErrors.kt
Vendored
+1 -1
View File
@@ -11,7 +11,7 @@ class MyClass2 {}
<!CONFLICTING_OVERLOADS!>fun MyClass2.component1()<!> = 1.3
fun test(mc1: MyClass, mc2: MyClass2) {
val (<!OPERATOR_MODIFIER_REQUIRED!>a<!>, b) = <!COMPONENT_FUNCTION_MISSING, COMPONENT_FUNCTION_MISSING!>mc1<!>
val (<!OI;OPERATOR_MODIFIER_REQUIRED!>a<!>, b) = <!COMPONENT_FUNCTION_MISSING, COMPONENT_FUNCTION_MISSING!>mc1<!>
val (c) = <!COMPONENT_FUNCTION_AMBIGUITY!>mc2<!>
//a,b,c are error types
compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/FolLoopTypeComponentTypeMismatch.kt
Vendored
+1 -1
View File
@@ -9,7 +9,7 @@ class C {
}
fun test() {
for ((<!UNUSED_VARIABLE!>x<!>: Double, <!UNUSED_VARIABLE!>y<!>: Int) in <!COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH, COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>C()<!>) {
for ((<!NI;TYPE_MISMATCH!><!UNUSED_VARIABLE!>x<!>: Double<!>, <!NI;TYPE_MISMATCH!><!UNUSED_VARIABLE!>y<!>: Int<!>) in <!OI;COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH, OI;COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>C()<!>) {
}
}
compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/ForLoopMissingLoopParameter.kt
Vendored
+2 -2
View File
@@ -1,8 +1,8 @@
// !WITH_NEW_INFERENCE
fun useDeclaredVariables() {
for ((a, b)<!SYNTAX!><!>) {
<!UNUSED_EXPRESSION, DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>a<!>
<!UNUSED_EXPRESSION, DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>b<!>
<!OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE, UNUSED_EXPRESSION!>a<!>
<!OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE, UNUSED_EXPRESSION!>b<!>
}
}
compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/underscore.kt
Vendored
+1 -1
View File
@@ -26,7 +26,7 @@ fun test() {
foo(<!UNRESOLVED_REFERENCE!>_<!>, <!UNRESOLVED_REFERENCE!>_<!>)
}
for ((_ : String, _ : Int) in <!COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH, COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>C()<!>) {
for ((<!NI;TYPE_MISMATCH!>_ : String<!>, <!NI;TYPE_MISMATCH!>_ : Int<!>) in <!OI;COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH, OI;COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>C()<!>) {
foo(<!UNRESOLVED_REFERENCE!>_<!>, <!UNRESOLVED_REFERENCE!>_<!>)
}
compiler/testData/diagnostics/tests/declarationChecks/namedFunAsLastExpressionInBlock.kt
Vendored
+4 -4
View File
@@ -27,15 +27,15 @@ fun test() {
<!SYNTAX!><!>fun named7() = 1
val x3 = when (1) {
0 -> <!EXPECTED_TYPE_MISMATCH!>fun named8(): Int {return 1}<!>
else -> <!EXPECTED_TYPE_MISMATCH!>fun named9() = 1<!>
0 -> <!OI;EXPECTED_TYPE_MISMATCH!>fun <!NI;ANONYMOUS_FUNCTION_WITH_NAME!>named8<!>(): Int {return 1}<!>
else -> <!OI;EXPECTED_TYPE_MISMATCH!>fun <!NI;ANONYMOUS_FUNCTION_WITH_NAME!>named9<!>() = 1<!>
}
val x31 = when (1) {
0 -> {
<!EXPECTED_TYPE_MISMATCH!>fun named10(): Int {return 1}<!>
<!OI;EXPECTED_TYPE_MISMATCH!>fun <!NI;ANONYMOUS_FUNCTION_WITH_NAME!>named10<!>(): Int {return 1}<!>
}
else -> <!EXPECTED_TYPE_MISMATCH!>fun named11() = 1<!>
else -> <!OI;EXPECTED_TYPE_MISMATCH!>fun <!NI;ANONYMOUS_FUNCTION_WITH_NAME!>named11<!>() = 1<!>
}
val x4 = {
compiler/testData/diagnostics/tests/delegatedProperty/inference/differentDelegatedExpressions.kt
Vendored
+4 -4
View File
@@ -10,10 +10,10 @@ class A(outer: Outer) {
var g: String by outer.getContainer().getMyProperty()
var b: String by foo(<!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getMyProperty<!>())
var r: String by foo(outer.getContainer().<!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getMyProperty<!>())
var e: String by <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>+<!> <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>(<!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getMyProperty<!>())
var f: String by <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>(<!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getMyProperty<!>()) <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>-<!> 1
var b: String by foo(<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getMyProperty<!>())
var r: String by foo(outer.getContainer().<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getMyProperty<!>())
var e: String by <!NI;DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, NI;TYPE_MISMATCH!><!OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>+<!> <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>(<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getMyProperty<!>())<!>
var f: String by <!NI;DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, NI;TYPE_MISMATCH!><!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>(<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getMyProperty<!>()) <!OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>-<!> 1<!>
}
fun <A, B> foo(<!UNUSED_PARAMETER!>a<!>: Any?) = MyProperty<A, B>()
compiler/testData/diagnostics/tests/delegatedProperty/inference/extensionProperty.kt
Vendored
+2 -2
View File
@@ -4,10 +4,10 @@ package foo
import kotlin.reflect.KProperty
open class A {
val B.w: Int by <!TYPE_INFERENCE_UPPER_BOUND_VIOLATED!>MyProperty<!>()
val B.w: Int by <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!><!OI;TYPE_INFERENCE_UPPER_BOUND_VIOLATED!>MyProperty<!>()<!>
}
val B.r: Int by <!TYPE_INFERENCE_UPPER_BOUND_VIOLATED!>MyProperty<!>()
val B.r: Int by <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!><!OI;TYPE_INFERENCE_UPPER_BOUND_VIOLATED!>MyProperty<!>()<!>
val A.e: Int by MyProperty()
compiler/testData/diagnostics/tests/delegatedProperty/inference/genericMethodInGenericClass.kt
Vendored
+3 -3
View File
@@ -8,7 +8,7 @@ class A<R>() {
operator fun <T> setValue(t: Any?, p: KProperty<*>, x: T) = Unit
}
var a1: Int by <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>A<!>()
var a1: Int by <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>A<!>()
var a2: Int by A<String>()
class B<R>() {
@@ -24,5 +24,5 @@ class C<R>() {
operator fun <T> setValue(t: Any?, p: KProperty<*>, x: T) = Unit
}
var c1: Int by C()
var c2: Int by <!DELEGATE_SPECIAL_FUNCTION_RETURN_TYPE_MISMATCH!>C<Number>()<!>
var c1: Int by <!NI;DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, NI;TYPE_MISMATCH!>C()<!>
var c2: Int by <!NI;DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, NI;TYPE_MISMATCH, OI;DELEGATE_SPECIAL_FUNCTION_RETURN_TYPE_MISMATCH!>C<Number>()<!>
compiler/testData/diagnostics/tests/delegatedProperty/inference/manyIncompleteCandidates.kt
Vendored
+1 -1
View File
@@ -5,7 +5,7 @@ package test
import first.*
import second.*
val a12 by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>A()<!>
val a12 by <!NI;DELEGATE_SPECIAL_FUNCTION_AMBIGUITY, OI;DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>A()<!>
// FILE: first.kt
package first
compiler/testData/diagnostics/tests/delegatedProperty/inference/noErrorsForImplicitConstraints.kt
Vendored
+4 -4
View File
@@ -4,8 +4,8 @@ package foo
import kotlin.reflect.KProperty
class A {
var a5: String by <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>MyProperty1<!>()
var b5: String by <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getMyProperty1<!>()
var a5: String by <!NI;DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, NI;DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, NI;TYPE_MISMATCH!><!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>MyProperty1<!>()<!>
var b5: String by <!NI;DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, NI;DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, NI;TYPE_MISMATCH!><!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getMyProperty1<!>()<!>
}
fun <A, B> getMyProperty1() = MyProperty1<A, B>()
@@ -24,8 +24,8 @@ class MyProperty1<T, R> {
// -----------------
class B {
var a5: String by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>MyProperty2()<!>
var b5: String by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>getMyProperty2()<!>
var a5: String by <!NI;DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, NI;TYPE_MISMATCH, DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>MyProperty2()<!>
var b5: String by <!NI;DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, NI;TYPE_MISMATCH, DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>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 <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>MyProperty<!>()
var <!NI;IMPLICIT_NOTHING_PROPERTY_TYPE!>a<!> by <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>MyProperty<!>()
}
class MyProperty<T, R> {
compiler/testData/diagnostics/tests/delegatedProperty/inference/useExpectedType.kt
Vendored
+4 -4
View File
@@ -52,12 +52,12 @@ class MyProperty2<T> {
//--------------------------
class A3 {
var a3: String by MyProperty3()
var b3: String by getMyProperty3()
var a3: String by <!NI;DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>MyProperty3()<!>
var b3: String by <!NI;DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>getMyProperty3()<!>
}
var c3: String by getMyProperty3()
var d3: String by MyProperty3()
var c3: String by <!NI;DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>getMyProperty3()<!>
var d3: String by <!NI;DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>MyProperty3()<!>
fun <A> getMyProperty3() = MyProperty3<A>()
compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/commonCaseForInference.kt
Vendored
+1 -1
View File
@@ -9,6 +9,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 <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>delegate<!>() // common test, not working because of Inference1
val Long.test1: String by <!OI;TYPE_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
@@ -10,5 +10,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 <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>delegate<!>()
val test2: String by <!NI;DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!><!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>delegate<!>()<!>
}
compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/inferenceFromReceiver1.kt
Vendored
+1 -1
View File
@@ -9,7 +9,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!>delegate<!>()
val test1: String by <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>delegate<!>()
val test2: String by delegate<Inference1>()
}

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