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

Don't report the same diagnsotics several times

Browse Source
This commit is contained in:
Victor Petukhov
2021-05-26 12:58:48 +03:00
parent e942052eb6
commit 4a767c597e
62 changed files with 202 additions and 166 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/frontend/src/org/jetbrains/kotlin/diagnostics/diagnosticUtils.kt
+5 -3
View File
@@ -110,7 +110,7 @@ fun ResolutionContext<*>.reportTypeMismatchDueToTypeProjection(
}
fun BindingTrace.reportDiagnosticOnce(diagnostic: Diagnostic) {
if (bindingContext.diagnostics.forElement(diagnostic.psiElement).any { it.factory == diagnostic.factory }) return
if (bindingContext.diagnostics.noSuppression().forElement(diagnostic.psiElement).any { it.factory == diagnostic.factory }) return
report(diagnostic)
}
@@ -119,8 +119,10 @@ fun BindingTrace.reportDiagnosticOnceWrtDiagnosticFactoryList(
diagnosticToReport: Diagnostic,
vararg diagnosticFactories: DiagnosticFactory<*>,
) {
val hasAlreadyReportedDiagnosticFromListOrSameType = bindingContext.diagnostics.forElement(diagnosticToReport.psiElement)
.any { diagnostic -> diagnostic.factory == diagnosticToReport.factory || diagnosticFactories.any { it == diagnostic.factory } }
val hasAlreadyReportedDiagnosticFromListOrSameType =
bindingContext.diagnostics.noSuppression()
.forElement(diagnosticToReport.psiElement)
.any { diagnostic -> diagnostic.factory == diagnosticToReport.factory || diagnosticFactories.any { it == diagnostic.factory } }
if (hasAlreadyReportedDiagnosticFromListOrSameType) return
compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tower/KotlinToResolvedCallTransformer.kt
+3
View File
@@ -48,6 +48,7 @@ import org.jetbrains.kotlin.resolve.constants.IntegerLiteralTypeConstructor
import org.jetbrains.kotlin.resolve.constants.IntegerValueTypeConstant
import org.jetbrains.kotlin.resolve.constants.evaluate.ConstantExpressionEvaluator
import org.jetbrains.kotlin.resolve.deprecation.DeprecationResolver
import org.jetbrains.kotlin.resolve.diagnostics.MutableDiagnosticsWithSuppression
import org.jetbrains.kotlin.resolve.scopes.receivers.CastImplicitClassReceiver
import org.jetbrains.kotlin.resolve.scopes.receivers.ImplicitClassReceiver
import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue
@@ -554,6 +555,8 @@ class TrackingBindingTrace(val trace: BindingTrace) : BindingTrace by trace {
var reported: Boolean = false
override fun report(diagnostic: Diagnostic) {
if (bindingContext.diagnostics.noSuppression().forElement(diagnostic.psiElement).any { it == diagnostic }) return
trace.report(diagnostic)
reported = true
}
compiler/testData/diagnostics/tests/annotations/dontReportWarningAboutChangingExecutionOrderForVararg.kt
Vendored
+1 -1
View File
@@ -7,7 +7,7 @@ fun foo1() {}
@Anno(x = ["a", "b"], y = "a")
fun foo2() {}
@Anno(x = <!TYPE_MISMATCH, TYPE_MISMATCH!>arrayOf(arrayOf("a"), arrayOf("b"))<!>, y = "a")
@Anno(x = <!TYPE_MISMATCH!>arrayOf(arrayOf("a"), arrayOf("b"))<!>, y = "a")
fun foo3() {}
@Anno(x = arrayOf("a", "b"), y = "a")
compiler/testData/diagnostics/tests/callableReference/generic/explicitTypeArguments.kt
Vendored
+3 -2
View File
@@ -1,3 +1,4 @@
// !WITH_NEW_INFERENCE
// !DIAGNOSTICS: -UNUSED_VARIABLE, -UNUSED_PARAMETER
fun <T> takeFun(f: (T) -> Unit) {}
@@ -13,12 +14,12 @@ fun <T> Wrapper<T>.baz(transform: (T) -> Unit): T = TODO()
fun test() {
takeFun<String>(::foo)
takeFun<String>(<!TYPE_MISMATCH, TYPE_MISMATCH!>::fooInt<!>)
takeFun<String>(<!TYPE_MISMATCH{NI}!>::<!TYPE_INFERENCE_UPPER_BOUND_VIOLATED{OI}!>fooInt<!><!>)
callFun<String, Wrapper<String>>(::createWrapper)
callFun<Int, Wrapper<Number>>(::createWrapper)
callFun<String, Wrapper<*>>(::createWrapper)
callFun<String, Wrapper<Int>>(::createWrapper)
callFun<String, Wrapper<Int>>(::<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}!>createWrapper<!>)
callFun<Int, Wrapper<Int>>(::createWrapper).baz(::foo)
}
compiler/testData/diagnostics/tests/callableReference/generic/genericFunctionsWithNullableTypes.kt
Vendored
+4 -3
View File
@@ -1,3 +1,4 @@
// !WITH_NEW_INFERENCE
// !CHECK_TYPE
// !DIAGNOSTICS: -UNUSED_PARAMETER, -UNUSED_VARIABLE
@@ -28,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_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 s3: Pair<Int, String?> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>bar(null, null, ::<!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>foo<!>)<!>
val s4: Pair<Int?, String> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>bar(null, null, ::<!IMPLICIT_NOTHING_TYPE_ARGUMENT_IN_RETURN_POSITION{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>foo<!>)<!>
val s5: Pair<Int, String> = <!TYPE_MISMATCH, TYPE_MISMATCH!>bar(1, "", ::foo)<!>
val s5: Pair<Int, String> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>bar(1, "", ::foo)<!>
val (a1: Int, b1: String) = <!COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>bar(1, "", ::foo)<!>
}
compiler/testData/diagnostics/tests/collectionLiterals/argumentsOfAnnotation.kt
Vendored
+2 -1
View File
@@ -1,3 +1,4 @@
// !WITH_NEW_INFERENCE
// !LANGUAGE: +ArrayLiteralsInAnnotations
annotation class Foo(val a: IntArray, val b: Array<String>, val c: FloatArray)
@@ -8,7 +9,7 @@ fun test1() {}
@Foo([], [], [])
fun test2() {}
@Foo([<!CONSTANT_EXPECTED_TYPE_MISMATCH!>1f<!>], <!TYPE_MISMATCH, TYPE_MISMATCH!>[' ']<!>, [<!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>])
@Foo([<!CONSTANT_EXPECTED_TYPE_MISMATCH!>1f<!>], <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>[' ']<!>, [<!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>])
fun test3() {}
@Foo(c = [1f], b = [""], a = [1])
compiler/testData/diagnostics/tests/collectionLiterals/argumentsOfAnnotationWithKClass.kt
Vendored
+3 -2
View File
@@ -1,3 +1,4 @@
// !WITH_NEW_INFERENCE
// !LANGUAGE: +ArrayLiteralsInAnnotations +BareArrayClassLiteral
import kotlin.reflect.KClass
@@ -20,10 +21,10 @@ fun test3() {}
@Foo([<!CLASS_LITERAL_LHS_NOT_A_CLASS!>Gen<Int>::class<!>])
fun test4() {}
@Foo(<!TYPE_MISMATCH, TYPE_MISMATCH!>[""]<!>)
@Foo(<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>[""]<!>)
fun test5() {}
@Foo(<!TYPE_MISMATCH, TYPE_MISMATCH!>[Int::class, 1]<!>)
@Foo(<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>[Int::class, 1]<!>)
fun test6() {}
@Bar
compiler/testData/diagnostics/tests/collectionLiterals/basicCollectionLiterals.kt
Vendored
+4 -3
View File
@@ -1,12 +1,13 @@
// !WITH_NEW_INFERENCE
// !CHECK_TYPE
// !DIAGNOSTICS: -UNUSED_VARIABLE, -UNSUPPORTED
fun test() {
val a = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>[]<!>
val a = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>[]<!>
val b: Array<Int> = []
val c = [1, 2]
val d: Array<Int> = [1, 2]
val e: Array<String> = <!TYPE_MISMATCH, TYPE_MISMATCH!>[1]<!>
val e: Array<String> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>[1]<!>
val f: IntArray = [1, 2]
val g = [f]
@@ -19,5 +20,5 @@ fun check() {
val f: IntArray = [1]
[f] checkType { _<Array<IntArray>>() }
[1, ""] checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><Array<Any>>() }
[1, ""] checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER{NI}!>_<!><Array<Any>>() }
}
compiler/testData/diagnostics/tests/collectionLiterals/defaultValuesInAnnotation.kt
Vendored
+5 -4
View File
@@ -1,3 +1,4 @@
// !WITH_NEW_INFERENCE
// !LANGUAGE: +ArrayLiteralsInAnnotations
annotation class Foo(
@@ -7,9 +8,9 @@ annotation class Foo(
)
annotation class Bar(
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]<!>
val a: Array<String> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>[' ']<!>,
val b: Array<String> = <!ANNOTATION_PARAMETER_DEFAULT_VALUE_MUST_BE_CONSTANT, TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>["", <!EMPTY_CHARACTER_LITERAL!>''<!>]<!>,
val c: Array<String> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>[1]<!>
)
annotation class Base(
@@ -21,5 +22,5 @@ annotation class Base(
annotation class Err(
val a: IntArray = [<!CONSTANT_EXPECTED_TYPE_MISMATCH!>1L<!>],
val b: Array<String> = <!TYPE_MISMATCH, TYPE_MISMATCH!>[1]<!>
val b: Array<String> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>[1]<!>
)
compiler/testData/diagnostics/tests/delegation/DelegationExpectedType.kt
Vendored
+3 -2
View File
@@ -1,3 +1,4 @@
// !WITH_NEW_INFERENCE
// !DIAGNOSTICS: -UNUSED_PARAMETER
interface A<T> {
@@ -20,6 +21,6 @@ class D : A<Int> by baz({ it + 1 })
fun <T> boo(t: T): A<T> = AImpl()
class E : A<Int> by <!TYPE_MISMATCH, TYPE_MISMATCH!>boo("")<!>
class E : A<Int> by <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>boo("")<!>
class F : A<Int> by <!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>AImpl<String>()<!>
class F : A<Int> by <!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>AImpl<String>()<!>
compiler/testData/diagnostics/tests/functionAsExpression/MissingParameterTypes.kt
Vendored
+2 -2
View File
@@ -18,9 +18,9 @@ fun test1(a: (Int) -> Unit) {
}
fun test2(a: (Int) -> Unit) {
test2(<!TYPE_MISMATCH, TYPE_MISMATCH!>fun (<!EXPECTED_PARAMETER_TYPE_MISMATCH!>x: String<!>) {}<!>)
test2(<!TYPE_MISMATCH!>fun (<!EXPECTED_PARAMETER_TYPE_MISMATCH!>x: String<!>) {}<!>)
}
fun test3(a: (Int, String) -> Unit) {
test3(<!TYPE_MISMATCH, TYPE_MISMATCH!>fun <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!>(<!EXPECTED_PARAMETER_TYPE_MISMATCH!>x: String<!>)<!> {}<!>)
test3(<!TYPE_MISMATCH!>fun <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!>(<!EXPECTED_PARAMETER_TYPE_MISMATCH!>x: String<!>)<!> {}<!>)
}
compiler/testData/diagnostics/tests/functionLiterals/ExpectedParametersTypesMismatch.kt
Vendored
+12 -11
View File
@@ -1,3 +1,4 @@
// !WITH_NEW_INFERENCE
package a
fun foo0(f: () -> String) = f
@@ -8,37 +9,37 @@ fun test1() {
foo0 {
""
}
foo0 <!TYPE_MISMATCH!>{
foo0 <!TYPE_MISMATCH{NI}!>{
<!EXPECTED_PARAMETERS_NUMBER_MISMATCH!>s: String<!>-> ""
}<!>
foo0 <!TYPE_MISMATCH!>{
foo0 <!TYPE_MISMATCH{NI}!>{
<!EXPECTED_PARAMETERS_NUMBER_MISMATCH!><!CANNOT_INFER_PARAMETER_TYPE!>x<!>, <!CANNOT_INFER_PARAMETER_TYPE!>y<!><!> -> ""
}<!>
foo1 {
""
}
foo1 <!TYPE_MISMATCH!>{
foo1 <!TYPE_MISMATCH{NI}!>{
<!EXPECTED_PARAMETER_TYPE_MISMATCH!>s: String<!> -> ""
}<!>
foo1 <!TYPE_MISMATCH!>{
foo1 <!TYPE_MISMATCH{NI}!>{
<!EXPECTED_PARAMETERS_NUMBER_MISMATCH!>x, <!CANNOT_INFER_PARAMETER_TYPE!>y<!><!> -> ""
}<!>
foo1 <!TYPE_MISMATCH!>{
<!EXPECTED_PARAMETERS_NUMBER_MISMATCH!><!>-> <!CONSTANT_EXPECTED_TYPE_MISMATCH, CONSTANT_EXPECTED_TYPE_MISMATCH, CONSTANT_EXPECTED_TYPE_MISMATCH!>42<!>
foo1 <!TYPE_MISMATCH{NI}!>{
<!EXPECTED_PARAMETERS_NUMBER_MISMATCH!><!>-> <!CONSTANT_EXPECTED_TYPE_MISMATCH, CONSTANT_EXPECTED_TYPE_MISMATCH!>42<!>
}<!>
foo2 <!TYPE_MISMATCH!><!EXPECTED_PARAMETERS_NUMBER_MISMATCH!>{<!>
foo2 <!TYPE_MISMATCH{NI}!><!EXPECTED_PARAMETERS_NUMBER_MISMATCH!>{<!>
""
}<!>
foo2 <!TYPE_MISMATCH!>{
foo2 <!TYPE_MISMATCH{NI}!>{
<!EXPECTED_PARAMETERS_NUMBER_MISMATCH, EXPECTED_PARAMETER_TYPE_MISMATCH!>s: String<!> -> ""
}<!>
foo2 <!TYPE_MISMATCH!>{
foo2 <!TYPE_MISMATCH{NI}!>{
<!EXPECTED_PARAMETERS_NUMBER_MISMATCH!>x<!> -> ""
}<!>
foo2 <!TYPE_MISMATCH!>{
<!EXPECTED_PARAMETERS_NUMBER_MISMATCH!><!>-> <!CONSTANT_EXPECTED_TYPE_MISMATCH, CONSTANT_EXPECTED_TYPE_MISMATCH, CONSTANT_EXPECTED_TYPE_MISMATCH!>42<!>
foo2 <!TYPE_MISMATCH{NI}!>{
<!EXPECTED_PARAMETERS_NUMBER_MISMATCH!><!>-> <!CONSTANT_EXPECTED_TYPE_MISMATCH, CONSTANT_EXPECTED_TYPE_MISMATCH!>42<!>
}<!>
}
compiler/testData/diagnostics/tests/functionLiterals/return/LocalReturnsWithExplicitReturnType.kt
Vendored
+2 -2
View File
@@ -1,9 +1,9 @@
fun test(a: Int) {
run<Int>f@{
if (a > 0) return@f <!TYPE_MISMATCH, TYPE_MISMATCH!>""<!>
if (a > 0) return@f <!TYPE_MISMATCH!>""<!>
return@f 1
}
run<Int>{ <!TYPE_MISMATCH, TYPE_MISMATCH!>""<!> }
run<Int>{ <!TYPE_MISMATCH!>""<!> }
run<Int>{ 1 }
}
compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/fromSuperClassesLocal.kt
Vendored
+1 -1
View File
@@ -44,7 +44,7 @@ fun test() {
x().foo().a() checkType { _<A<String, Double, Short, Long>>() }
x().bar() checkType { _<A<String, Double, Short, Char>>() }
x = <!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>foobar<Int>()<!>
x = <!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>foobar<Int>()<!>
var y = noParameters()
y = noParameters()
compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/fromSuperClassesLocalInsideInner.kt
Vendored
+3 -2
View File
@@ -1,3 +1,4 @@
// !WITH_NEW_INFERENCE
// !CHECK_TYPE
// !DIAGNOSTICS: -UNUSED_VALUE -VARIABLE_WITH_REDUNDANT_INITIALIZER -TOPLEVEL_TYPEALIASES_ONLY
@@ -45,8 +46,8 @@ class Outer<T> {
x().foo().a() checkType { _<A<T, F, String, Double, Short, Long>>() }
x().bar() checkType { _<A<T, F, String, Double, Short, Char>>() }
x = <!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>foobar<Int>()<!>
x = <!TYPE_MISMATCH!>z.<!TYPE_MISMATCH!>foobar<String>()<!><!>
x = <!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>foobar<Int>()<!>
x = <!TYPE_MISMATCH!>z.<!TYPE_MISMATCH{NI}!>foobar<String>()<!><!>
var y = noParameters()
y = noParameters()
compiler/testData/diagnostics/tests/generics/innerClasses/innerTP.kt
Vendored
+2 -1
View File
@@ -1,3 +1,4 @@
// !WITH_NEW_INFERENCE
// !CHECK_TYPE
// !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_PARAMETER
@@ -31,7 +32,7 @@ fun main() {
checkSubtype<Outer<*>.Inner<*>>(outer.Inner<Int>())
checkSubtype<Outer<CharSequence>.Inner<CharSequence>>(<!TYPE_MISMATCH!>outer.bar()<!>)
checkSubtype<Outer<CharSequence>.Inner<CharSequence>>(<!TYPE_MISMATCH!>outer.Inner()<!>)
checkSubtype<Outer<CharSequence>.Inner<CharSequence>>(<!TYPE_MISMATCH{NI}!>outer.<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}!>Inner()<!><!>)
outer.set(outer.bar())
outer.set(outer.Inner())
compiler/testData/diagnostics/tests/generics/projectionsScope/typeMismatchInLambda.kt
Vendored
+5 -5
View File
@@ -13,14 +13,14 @@ class A<E> {
fun test(a: A<out CharSequence>, z: Out<CharSequence>) {
a.foo {
val x: String = <!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!> // Should be no TYPE_MISMATCH_DUE_TO_TYPE_PROJECTIONS
<!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>""<!>
<!TYPE_MISMATCH, TYPE_MISMATCH!>""<!>
}
a.bar { <!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>Out<CharSequence>()<!> }
a.bar { <!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>Out<CharSequence>()<!> }
a.bar { Out() }
a.bar { <!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>z.id()<!> }
a.bar { <!TYPE_MISMATCH, TYPE_MISMATCH!>z.id()<!> }
a.foo {
z.foobar(if (1 > 2) return@foo <!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>""<!> else "")
<!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>""<!>
z.foobar(if (1 > 2) return@foo <!TYPE_MISMATCH, TYPE_MISMATCH!>""<!> else "")
<!TYPE_MISMATCH, TYPE_MISMATCH!>""<!>
}
}
compiler/testData/diagnostics/tests/inference/builderInference/constraints/violating.kt
Vendored
+5 -5
View File
@@ -8,26 +8,26 @@ interface A {
@ExperimentalStdlibApi
fun main() {
buildList {
add(<!CONSTANT_EXPECTED_TYPE_MISMATCH, CONSTANT_EXPECTED_TYPE_MISMATCH!>3<!>)
add(<!CONSTANT_EXPECTED_TYPE_MISMATCH!>3<!>)
object : A {
override fun foo(): MutableList<String> = this@buildList
}
}
buildList {
add(<!CONSTANT_EXPECTED_TYPE_MISMATCH, CONSTANT_EXPECTED_TYPE_MISMATCH!>3<!>)
add(<!CONSTANT_EXPECTED_TYPE_MISMATCH!>3<!>)
val x: String = get(0)
}
buildList {
add(<!TYPE_MISMATCH, TYPE_MISMATCH!>"3"<!>)
add(<!TYPE_MISMATCH!>"3"<!>)
val x: MutableList<Int> = this@buildList
}
buildList {
val y: CharSequence = ""
add(<!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>y<!>)
add(<!TYPE_MISMATCH, TYPE_MISMATCH!>y<!>)
val x: MutableList<String> = this@buildList
}
buildList {
add(<!TYPE_MISMATCH, TYPE_MISMATCH!>""<!>)
add(<!TYPE_MISMATCH!>""<!>)
val x: StringBuilder = get(0)
}
}
compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithLambdas.kt
Vendored
+2 -2
View File
@@ -147,7 +147,7 @@ fun poll73(): Flow<String> {
fun poll8(): Flow<String> {
return flow {
val inv = {<!CONSTANT_EXPECTED_TYPE_MISMATCH, CONSTANT_EXPECTED_TYPE_MISMATCH, CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>} in setOf({1f})
val inv = {<!CONSTANT_EXPECTED_TYPE_MISMATCH, CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>} in setOf({1f})
<!DEBUG_INFO_MISSING_UNRESOLVED!>inv()<!>
}
}
@@ -175,7 +175,7 @@ fun poll83(): Flow<String> {
fun poll84(): Flow<String> {
return flow {
val inv = {{<!CONSTANT_EXPECTED_TYPE_MISMATCH, CONSTANT_EXPECTED_TYPE_MISMATCH, CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>}} in setOf({{1f}})
val inv = {{<!CONSTANT_EXPECTED_TYPE_MISMATCH, CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>}} in setOf({{1f}})
<!DEBUG_INFO_MISSING_UNRESOLVED!>inv()<!>
}
}
compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/memberScope.kt
Vendored
+18 -18
View File
@@ -26,7 +26,7 @@ fun test() {
get()?.hashCode()
get()?.equals(1)
// there is `String?.equals` extension
<!TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?")!>get()<!>.equals("")
<!TYPE_MISMATCH("Any; Nothing?")!>get()<!>.equals("")
}
val ret2 = build {
emit(1)
@@ -39,7 +39,7 @@ fun test() {
val x = get()
x?.hashCode()
x?.equals(1)
<!TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?")!>x<!>.equals("")
<!TYPE_MISMATCH("Any; Nothing?")!>x<!>.equals("")
}
val ret3 = build {
emit(1)
@@ -74,7 +74,7 @@ fun test() {
emit(null)
val x = get()
if (x == null) {
<!TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?")!>x<!>.hashCode()
<!TYPE_MISMATCH("Any; Nothing?")!>x<!>.hashCode()
}
""
@@ -84,7 +84,7 @@ fun test() {
emit(null)
val x = get()
if (x == null) {
<!TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?")!>x<!>.equals("")
<!TYPE_MISMATCH("Any; Nothing?")!>x<!>.equals("")
}
""
@@ -104,7 +104,7 @@ fun test() {
emit(null)
val x = get()
if (x == null) {
<!TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?")!>x<!>.test()
<!TYPE_MISMATCH("Any; Nothing?")!>x<!>.test()
}
""
@@ -114,7 +114,7 @@ fun test() {
emit(null)
val x = get()
if (x === null) {
<!TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?")!>x<!>.hashCode()
<!TYPE_MISMATCH("Any; Nothing?")!>x<!>.hashCode()
}
""
@@ -124,7 +124,7 @@ fun test() {
emit(null)
val x = get()
if (x === null) {
<!TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?")!>x<!>.equals("")
<!TYPE_MISMATCH("Any; Nothing?")!>x<!>.equals("")
}
""
@@ -144,7 +144,7 @@ fun test() {
emit(null)
val x = get()
if (x === null) {
<!TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?")!>x<!>.test()
<!TYPE_MISMATCH("Any; Nothing?")!>x<!>.test()
}
""
@@ -153,7 +153,7 @@ fun test() {
emit(1)
emit(null)
val x = get()
<!TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?")!>x<!>.test()
<!TYPE_MISMATCH("Any; Nothing?")!>x<!>.test()
""
}
@@ -211,7 +211,7 @@ fun test() {
emit(null)
val x = get()
if (x == null) {
<!TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?")!>x<!>.equals("")
<!TYPE_MISMATCH("Any; Nothing?")!>x<!>.equals("")
}
""
@@ -221,7 +221,7 @@ fun test() {
emit(null)
val x = get()
if (x == null) {
<!TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?")!>x<!>.hashCode()
<!TYPE_MISMATCH("Any; Nothing?")!>x<!>.hashCode()
}
""
}
@@ -230,7 +230,7 @@ fun test() {
emit(null)
val x = get()
if (x == null) {
<!TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?")!>x<!>.toString()
<!TYPE_MISMATCH("Any; Nothing?")!>x<!>.toString()
}
""
}
@@ -239,7 +239,7 @@ fun test() {
emit(null)
val x = get()
if (x == null) {
<!TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?")!>x<!>.test()
<!TYPE_MISMATCH("Any; Nothing?")!>x<!>.test()
}
""
}
@@ -248,7 +248,7 @@ fun test() {
emit(null)
val x = get()
if (x === null) {
<!TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?")!>x<!>.equals("")
<!TYPE_MISMATCH("Any; Nothing?")!>x<!>.equals("")
}
""
@@ -258,7 +258,7 @@ fun test() {
emit(null)
val x = get()
if (x === null) {
<!TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?")!>x<!>.hashCode()
<!TYPE_MISMATCH("Any; Nothing?")!>x<!>.hashCode()
}
""
}
@@ -267,7 +267,7 @@ fun test() {
emit(null)
val x = get()
if (x === null) {
<!TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?")!>x<!>.toString()
<!TYPE_MISMATCH("Any; Nothing?")!>x<!>.toString()
}
""
}
@@ -276,7 +276,7 @@ fun test() {
emit(null)
val x = get()
if (x === null) {
<!TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?")!>x<!>.test()
<!TYPE_MISMATCH("Any; Nothing?")!>x<!>.test()
}
""
}
@@ -284,7 +284,7 @@ fun test() {
emit(1)
emit(null)
val x = get()
<!TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?")!>x<!>.test()
<!TYPE_MISMATCH("Any; Nothing?")!>x<!>.test()
""
}
val ret51 = build {
compiler/testData/diagnostics/tests/inference/capturedTypes/cannotCaptureInProjection.kt
Vendored
+5 -4
View File
@@ -1,16 +1,17 @@
// !WITH_NEW_INFERENCE
// !DIAGNOSTICS: -UNUSED_VARIABLE -UNUSED_PARAMETER
// !CHECK_TYPE
fun <T: Any> bar(a: Array<T>): Array<T?> = null!!
fun test1(a: Array<in Int>) {
val r: Array<in Int?> = bar(<!TYPE_MISMATCH, TYPE_MISMATCH!>a<!>)
bar(<!TYPE_MISMATCH, TYPE_MISMATCH!>a<!>)
val r: Array<in Int?> = <!TYPE_INFERENCE_CANNOT_CAPTURE_TYPES{OI}!>bar<!>(<!TYPE_MISMATCH{NI}!>a<!>)
<!TYPE_INFERENCE_CANNOT_CAPTURE_TYPES{OI}!>bar<!>(<!TYPE_MISMATCH{NI}!>a<!>)
}
fun <T: Any> foo(l: Array<T>): Array<Array<T?>> = null!!
fun test2(a: Array<in Int>) {
val r: Array<out Array<in Int?>> = foo(<!TYPE_MISMATCH, TYPE_MISMATCH!>a<!>)
foo(<!TYPE_MISMATCH, TYPE_MISMATCH!>a<!>)
val r: Array<out Array<in Int?>> = <!TYPE_INFERENCE_CANNOT_CAPTURE_TYPES{OI}!>foo<!>(<!TYPE_MISMATCH{NI}!>a<!>)
<!TYPE_INFERENCE_CANNOT_CAPTURE_TYPES{OI}!>foo<!>(<!TYPE_MISMATCH{NI}!>a<!>)
}
compiler/testData/diagnostics/tests/inference/capturedTypes/captureTypeOnlyOnTopLevel.kt
Vendored
+3 -2
View File
@@ -1,9 +1,10 @@
// !WITH_NEW_INFERENCE
// !DIAGNOSTICS: -UNUSED_VARIABLE
fun <T> foo(array: Array<Array<T>>): Array<Array<T>> = array
fun test(array: Array<Array<out Int>>) {
foo(<!TYPE_MISMATCH, TYPE_MISMATCH!>array<!>)
<!TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR{OI}!>foo<!>(<!TYPE_MISMATCH{NI}!>array<!>)
val f: Array<out Array<out Int>> = foo(<!TYPE_MISMATCH, TYPE_MISMATCH!>array<!>)
val f: Array<out Array<out Int>> = <!TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR{OI}!>foo<!>(<!TYPE_MISMATCH!>array<!>)
}
compiler/testData/diagnostics/tests/inference/coercionToUnit/kt30242.kt
Vendored
+1 -1
View File
@@ -47,7 +47,7 @@ fun bar(block: () -> String) {}
fun test_5(b: Boolean) {
bar {
<!TYPE_MISMATCH, TYPE_MISMATCH!>if (b) {
<!TYPE_MISMATCH!>if (b) {
println("meh")
}<!>
}
compiler/testData/diagnostics/tests/inference/completion/postponedArgumentsAnalysis/basic.kt
Vendored
+2 -2
View File
@@ -119,8 +119,8 @@ fun main() {
* K <: (A) -> Unit -> TypeVariable(_RP1) >: A
* K >: (C) -> TypeVariable(_R) -> TypeVariable(_RP1) <: C
*/
val x12 = selectC(id <!TYPE_MISMATCH!>{ <!DEBUG_INFO_EXPRESSION_TYPE("C")!>it<!> }<!>, id <!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>{ x: B -> }<!><!NO_VALUE_FOR_PARAMETER!>)<!>
val x13 = selectA(id <!TYPE_MISMATCH!>{ <!DEBUG_INFO_EXPRESSION_TYPE("A")!>it<!> }<!>, id <!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>{ x: C -> }<!><!NO_VALUE_FOR_PARAMETER!>)<!>
val x12 = selectC(id <!TYPE_MISMATCH!>{ <!DEBUG_INFO_EXPRESSION_TYPE("C")!>it<!> }<!>, id <!TYPE_MISMATCH!>{ x: B -> }<!><!NO_VALUE_FOR_PARAMETER!>)<!>
val x13 = selectA(id <!TYPE_MISMATCH!>{ <!DEBUG_INFO_EXPRESSION_TYPE("A")!>it<!> }<!>, id <!TYPE_MISMATCH!>{ x: C -> }<!><!NO_VALUE_FOR_PARAMETER!>)<!>
val x14 = selectC(id { <!DEBUG_INFO_EXPRESSION_TYPE("C")!>it<!> }, id { x: A -> }, { x -> x })
val x15 = selectC(id { <!DEBUG_INFO_EXPRESSION_TYPE("C")!>it<!> }, { x: A -> }, id { x -> x })
/*
compiler/testData/diagnostics/tests/inference/completion/postponedArgumentsAnalysis/notInferableParameterOfAnonymousFunction.kt
Vendored
+2 -2
View File
@@ -4,13 +4,13 @@ fun <T> select(vararg x: T) = x[0]
fun <K> id(x: K) = x
fun main() {
val x1 = select<Any?>(id { <!CANNOT_INFER_PARAMETER_TYPE!>x<!>, <!CANNOT_INFER_PARAMETER_TYPE, CANNOT_INFER_PARAMETER_TYPE!>y<!> -> }, { x: Int, <!CANNOT_INFER_PARAMETER_TYPE!>y<!> -> })
val x1 = select<Any?>(id { <!CANNOT_INFER_PARAMETER_TYPE!>x<!>, <!CANNOT_INFER_PARAMETER_TYPE!>y<!> -> }, { x: Int, <!CANNOT_INFER_PARAMETER_TYPE!>y<!> -> })
val x2 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>select<!>(<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>id<!> { x, <!CANNOT_INFER_PARAMETER_TYPE!>y<!> -> }, { x: Int, <!CANNOT_INFER_PARAMETER_TYPE!>y<!> -> })
val x3 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>select<!>(<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>id<!>(fun (x, <!CANNOT_INFER_PARAMETER_TYPE!>y<!>) {}), fun (x: Int, <!CANNOT_INFER_PARAMETER_TYPE!>y<!>) {})
val x4 = select<Any?>((fun (<!CANNOT_INFER_PARAMETER_TYPE!>x<!>, <!CANNOT_INFER_PARAMETER_TYPE!>y<!>) {}), fun (x: Int, <!CANNOT_INFER_PARAMETER_TYPE!>y<!>) {})
val x5 = select<Any?>(id(fun (<!CANNOT_INFER_PARAMETER_TYPE, CANNOT_INFER_PARAMETER_TYPE!>x<!>, <!CANNOT_INFER_PARAMETER_TYPE, CANNOT_INFER_PARAMETER_TYPE!>y<!>) {}), fun (x: Int, <!CANNOT_INFER_PARAMETER_TYPE!>y<!>) {})
val x5 = select<Any?>(id(fun (<!CANNOT_INFER_PARAMETER_TYPE!>x<!>, <!CANNOT_INFER_PARAMETER_TYPE!>y<!>) {}), fun (x: Int, <!CANNOT_INFER_PARAMETER_TYPE!>y<!>) {})
val x6 = id<Any?>(fun (<!CANNOT_INFER_PARAMETER_TYPE!>x<!>) {})
select<Any?>(fun (<!CANNOT_INFER_PARAMETER_TYPE!>x<!>) {}, fun (<!CANNOT_INFER_PARAMETER_TYPE!>x<!>) {})
compiler/testData/diagnostics/tests/inference/constraints/definitelyNotNullTypeInReturnPosition.kt
Vendored
+2 -2
View File
@@ -262,8 +262,8 @@ class Main<L>(x: L?, y: L) {
val x471 = <!DEBUG_INFO_EXPRESSION_TYPE("OutBar<OutBar<OutBar<L!!>>>")!>foo47(y)<!>
fun <R> takeLambda(block: () -> R): R = materialize()
val x480 = <!DEBUG_INFO_EXPRESSION_TYPE("Bar<L>")!><!DEBUG_INFO_LEAKING_THIS!>takeLambda<!> { foo48 { <!TYPE_MISMATCH("Any; L"), TYPE_MISMATCH("Any; L")!>x<!> } }<!>
val x481 = <!DEBUG_INFO_EXPRESSION_TYPE("Bar<L>")!><!DEBUG_INFO_LEAKING_THIS!>takeLambda<!> { foo48 { <!TYPE_MISMATCH("Any; L"), TYPE_MISMATCH("Any; L")!>y<!> } }<!>
val x480 = <!DEBUG_INFO_EXPRESSION_TYPE("Bar<L>")!><!DEBUG_INFO_LEAKING_THIS!>takeLambda<!> { foo48 { <!TYPE_MISMATCH("Any; L")!>x<!> } }<!>
val x481 = <!DEBUG_INFO_EXPRESSION_TYPE("Bar<L>")!><!DEBUG_INFO_LEAKING_THIS!>takeLambda<!> { foo48 { <!TYPE_MISMATCH("Any; L")!>y<!> } }<!>
val x482 = <!DEBUG_INFO_EXPRESSION_TYPE("Bar<kotlin.Nothing>")!><!DEBUG_INFO_LEAKING_THIS!>takeLambda<!> { foo48 { null } }<!>
}
compiler/testData/diagnostics/tests/inference/dependantOnVariance.kt
Vendored
+11 -10
View File
@@ -1,3 +1,4 @@
// !WITH_NEW_INFERENCE
package a
class MyList<T>(t: T) {}
@@ -13,7 +14,7 @@ fun <T> readFromMyList(l: MyList<out T>, t: T) {}
fun test1(int: Int, any: Any) {
val a0 : MyList<Any> = getMyList(int)
val a1 : MyList<Int> = <!TYPE_MISMATCH, TYPE_MISMATCH!>getMyList(any)<!>
val a1 : MyList<Int> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>getMyList(any)<!>
val a2 : MyList<out Any> = getMyList(int)
@@ -28,23 +29,23 @@ fun test1(int: Int, any: Any) {
val a7 : MyList<in Any> = getMyList(int)
val a8 : MyList<in Any> = <!TYPE_MISMATCH, TYPE_MISMATCH!>getMyListToReadFrom<Int>(int)<!>
val a9 : MyList<in Any> = <!TYPE_MISMATCH, TYPE_MISMATCH!>getMyListToReadFrom(int)<!>
val a9 : MyList<in Any> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>getMyListToReadFrom(int)<!>
val a10 : MyList<out Int> = <!TYPE_MISMATCH, TYPE_MISMATCH!>getMyList<Any>(any)<!>
val a11 : MyList<out Int> = <!TYPE_MISMATCH, TYPE_MISMATCH!>getMyList(any)<!>
val a11 : MyList<out Int> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>getMyList(any)<!>
val a12 : MyList<out Int> = <!TYPE_MISMATCH, TYPE_MISMATCH!>getMyListToWriteTo<Any>(any)<!>
val a13 : MyList<out Int> = <!TYPE_MISMATCH, TYPE_MISMATCH!>getMyListToWriteTo(any)<!>
val a13 : MyList<out Int> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>getMyListToWriteTo(any)<!>
useMyList(getMyList(int), int)
useMyList(getMyList(any), int)
useMyList(getMyList(int), any)
<!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}!>useMyList<!>(getMyList(int), any)
readFromMyList(getMyList(int), any)
readFromMyList(getMyList(any), int)
readFromMyList<Int>(<!TYPE_MISMATCH, TYPE_MISMATCH!>getMyList(any)<!>, int)
readFromMyList<Int>(<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>getMyList(any)<!>, int)
readFromMyList<Int>(<!TYPE_MISMATCH!>getMyListToReadFrom(any)<!>, int)
readFromMyList<Int>(<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>getMyListToReadFrom(any)<!>, int)
readFromMyList(getMyListToReadFrom(any), int)
readFromMyList(getMyListToReadFrom(int), any)
@@ -53,14 +54,14 @@ fun test1(int: Int, any: Any) {
writeToMyList(getMyList(any), int)
writeToMyList<Any>(getMyList(int), any)
writeToMyList(getMyList<Any>(int), any)
writeToMyList(getMyList(int), any)
<!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}!>writeToMyList<!>(getMyList(int), any)
writeToMyList(getMyListToWriteTo(any), int)
writeToMyList(getMyListToWriteTo(int), any)
<!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}!>writeToMyList<!>(getMyListToWriteTo(int), any)
readFromMyList(getMyListToWriteTo(any), any)
writeToMyList(getMyListToReadFrom(any), <!TYPE_MISMATCH!>any<!>)
<!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}!>writeToMyList<!>(getMyListToReadFrom(any), <!TYPE_MISMATCH{NI}!>any<!>)
use(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13)
}
compiler/testData/diagnostics/tests/inference/regressions/kt2283.kt
Vendored
+2 -1
View File
@@ -1,3 +1,4 @@
// !WITH_NEW_INFERENCE
//KT-2283 Bad diagnostics of failed type inference
package a
@@ -9,5 +10,5 @@ fun <A, B> Foo<A>.map(f: (A) -> B): Foo<B> = object : Foo<B> {}
fun foo() {
val l: Foo<String> = object : Foo<String> {}
val m: Foo<String> = l.map { ppp -> <!CONSTANT_EXPECTED_TYPE_MISMATCH, CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!> }
val m: Foo<String> = l.<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}!>map { ppp -> <!CONSTANT_EXPECTED_TYPE_MISMATCH{NI}!>1<!> }<!>
}
compiler/testData/diagnostics/tests/inference/typeInferenceExpectedTypeMismatch.kt
Vendored
+5 -4
View File
@@ -1,9 +1,10 @@
// !WITH_NEW_INFERENCE
package typeInferenceExpectedTypeMismatch
import java.util.*
fun test() {
val s : Set<Int> = <!TYPE_MISMATCH!>newList()<!>
val s : Set<Int> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>newList()<!>
use(s)
}
@@ -25,16 +26,16 @@ fun <T, R> foo(o: Out<T>, i: In<R>): Two<T, R> = throw Exception("$o $i")
fun test1(outA: Out<A>, inB: In<B>) {
foo(outA, inB)
val b: Two<A, C> = <!TYPE_MISMATCH!>foo(outA, inB)<!>
val b: Two<A, C> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>foo(outA, inB)<!>
use(b)
}
fun <T> bar(o: Out<T>, i: In<T>): Two<T, T> = throw Exception("$o $i")
fun test2(outA: Out<A>, inC: In<C>) {
bar(outA, <!TYPE_MISMATCH!>inC<!>)
<!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}!>bar<!>(outA, <!TYPE_MISMATCH{NI}!>inC<!>)
val b: Two<A, B> = <!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>bar(outA, <!TYPE_MISMATCH!>inC<!>)<!>
val b: Two<A, B> = <!TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!><!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}!>bar<!>(outA, <!TYPE_MISMATCH{NI}!>inC<!>)<!>
use(b)
}
compiler/testData/diagnostics/tests/inference/upperBounds/useBoundsToInferTypeParamsSimple.kt
Vendored
+2 -1
View File
@@ -1,3 +1,4 @@
// !WITH_NEW_INFERENCE
package a
fun <V: U, U> foo(v: V, u: U) = u
@@ -15,7 +16,7 @@ fun <T> checkItIsExactlyAny(t: T, l: MutableList<T>) {}
fun <V : U, U> baz(v: V, u: MutableSet<U>) = u
fun test(a: Any, s: MutableSet<String>) {
baz(a, <!TYPE_MISMATCH, TYPE_MISMATCH!>s<!>)
<!TYPE_INFERENCE_UPPER_BOUND_VIOLATED{OI}!>baz<!>(a, <!TYPE_MISMATCH{NI}!>s<!>)
}
//from standard library
compiler/testData/diagnostics/tests/j+k/genericConstructor/innerClass.kt
Vendored
+2 -1
View File
@@ -1,3 +1,4 @@
// !WITH_NEW_INFERENCE
// !CHECK_TYPE
// FILE: Outer.java
@@ -12,6 +13,6 @@ fun test(x: List<Int>, y: List<String>) {
Outer<Int>().Inner("", y, 1) checkType { _<Outer<Int>.Inner<String>>() }
Outer<Int>().Inner<CharSequence, String, Int>("", y, 1) checkType { _<Outer<Int>.Inner<CharSequence>>() }
Outer<Int>().Inner("", x, 1) checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><Outer<Int>.Inner<Any>>() }
Outer<Int>().Inner("", x, 1) checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER{NI}!>_<!><Outer<Int>.Inner<Any>>() }
Outer<Int>().Inner<CharSequence, String, Int>("", <!TYPE_MISMATCH, TYPE_MISMATCH!>x<!>, 1)
}
compiler/testData/diagnostics/tests/j+k/genericConstructor/noClassTypeParametersInvParameter.kt
Vendored
+1 -1
View File
@@ -12,7 +12,7 @@ fun test(x: Inv<Int>, y: Inv<String>) {
A("", <!TYPE_MISMATCH!>x<!>)
A("", y)
A<String>("", <!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>x<!>)
A<String>("", <!TYPE_MISMATCH, TYPE_MISMATCH!>x<!>)
A<Any>("", <!TYPE_MISMATCH, TYPE_MISMATCH!>x<!>)
A<String>("", y)
compiler/testData/diagnostics/tests/j+k/sam/conversionForDerivedGenericClass.kt
Vendored
+1 -1
View File
@@ -18,5 +18,5 @@ fun test(a: A<Runnable>, b: B, c: C<Runnable>) {
b.f { }
c.f { }
C<Runnable>().f { }
C.g<Runnable> <!TYPE_MISMATCH, TYPE_MISMATCH!>{ }<!>
C.g<Runnable> <!TYPE_MISMATCH!>{ }<!>
}
compiler/testData/diagnostics/tests/j+k/sam/enhancedSamConstructor.kt
Vendored
+2 -2
View File
@@ -18,10 +18,10 @@ fun main() {
J <!TYPE_MISMATCH!>{ <!EXPECTED_PARAMETER_TYPE_MISMATCH!>s: String<!> -> s}<!> // should be prohibited, because SAM value parameter has nullable type
J { "" + it<!UNSAFE_CALL!>.<!>length }
J { <!NULL_FOR_NONNULL_TYPE, NULL_FOR_NONNULL_TYPE!>null<!> }
J { <!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>it?.length?.toString()<!> }
J { <!TYPE_MISMATCH, TYPE_MISMATCH!>it?.length?.toString()<!> }
J2 <!TYPE_MISMATCH!>{ <!EXPECTED_PARAMETER_TYPE_MISMATCH!>s: String<!> -> s}<!>
J2 { "" + it<!UNSAFE_CALL!>.<!>length }
J2 { <!NULL_FOR_NONNULL_TYPE, NULL_FOR_NONNULL_TYPE!>null<!> }
J2 { <!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>it?.length?.toString()<!> }
J2 { <!TYPE_MISMATCH, TYPE_MISMATCH!>it?.length?.toString()<!> }
}
compiler/testData/diagnostics/tests/j+k/samByProjectedType/genericInReturnType.kt
Vendored
+1 -1
View File
@@ -33,7 +33,7 @@ fun main() {
}
A.baz {
x -> <!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>x.hashCode()<!>
x -> <!TYPE_MISMATCH, TYPE_MISMATCH!>x.hashCode()<!>
}
val block: (String) -> Any? = {
compiler/testData/diagnostics/tests/regressions/correctResultSubstitutorForErrorCandidate.kt
Vendored
+2 -1
View File
@@ -1,7 +1,8 @@
// !WITH_NEW_INFERENCE
// !DIAGNOSTICS: -UNUSED_PARAMETER
fun test(a: Int, b: Boolean) {
bar(a.foo(<!TYPE_MISMATCH, TYPE_MISMATCH!>b<!>))
<!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>bar<!>(a.<!TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR{OI}!>foo<!>(<!TYPE_MISMATCH!>b<!>))
}
fun <T, R> T.foo(l: (T) -> R): R = TODO()
compiler/testData/diagnostics/tests/regressions/resolveCollectionLiteralInsideLambda.kt
Vendored
+1 -1
View File
@@ -4,4 +4,4 @@ fun foo(l: () -> Unit) {}
fun bar(l: () -> String) {}
val a = foo { <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, UNSUPPORTED!>[]<!> }
val b = bar { <!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH, UNSUPPORTED!>[]<!> }
val b = bar { <!TYPE_MISMATCH, TYPE_MISMATCH, UNSUPPORTED!>[]<!> }
compiler/testData/diagnostics/tests/resolve/specialConstructions/constantsInIf.kt
Vendored
+5 -4
View File
@@ -1,13 +1,14 @@
// !WITH_NEW_INFERENCE
// !DIAGNOSTICS: -USELESS_ELVIS
fun test() {
bar(<!TYPE_MISMATCH, TYPE_MISMATCH!>if (true) {
1
bar(<!TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>if (true) {
<!CONSTANT_EXPECTED_TYPE_MISMATCH{OI}!>1<!>
} else {
2
<!CONSTANT_EXPECTED_TYPE_MISMATCH{OI}!>2<!>
}<!>)
bar(<!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!><!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!> ?: <!CONSTANT_EXPECTED_TYPE_MISMATCH!>2<!><!>)
bar(<!TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!><!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!> ?: <!CONSTANT_EXPECTED_TYPE_MISMATCH!>2<!><!>)
}
fun bar(s: String) = s
compiler/testData/diagnostics/tests/secondaryConstructors/constructorCallType.kt
Vendored
+3 -2
View File
@@ -1,3 +1,4 @@
// !WITH_NEW_INFERENCE
// !DIAGNOSTICS: -UNUSED_PARAMETER
// NI_EXPECTED_FILE
class A(x: Int) {
@@ -20,8 +21,8 @@ val y4: B<Int> = B<Int>("")
val y5: B<String> = B<String>(<!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>)
val y6: B<String> = B<String>("")
val y7: B<String> = <!TYPE_MISMATCH, TYPE_MISMATCH!>B(1)<!>
val y7: B<String> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>B(1)<!>
val y8: B<String> = B("")
val y9 = B(1)
val y10 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>B<!>("")
val y10 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>B<!>("")
compiler/testData/diagnostics/tests/smartCasts/lambdaArgumentWithBoundWithoutType.kt
Vendored
+5 -4
View File
@@ -1,3 +1,4 @@
// !WITH_NEW_INFERENCE
interface Foo
interface Bar : Foo
@@ -12,14 +13,14 @@ val foo: Foo = run {
<!DEBUG_INFO_SMARTCAST!>x<!>
}
val foofoo: Foo = run {
val foofoo: Foo = <!TYPE_INFERENCE_UPPER_BOUND_VIOLATED{OI}!>run<!> {
val x = foo()
if (x == null) throw Exception()
<!DEBUG_INFO_SMARTCAST, TYPE_MISMATCH!>x<!>
<!DEBUG_INFO_SMARTCAST, TYPE_MISMATCH{NI}!>x<!>
}
val bar: Bar = <!TYPE_MISMATCH!>run {
val bar: Bar = <!TYPE_MISMATCH{NI}!><!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}!>run<!> {
val x = foo()
if (x == null) throw Exception()
<!DEBUG_INFO_SMARTCAST, TYPE_MISMATCH, TYPE_MISMATCH!>x<!>
<!DEBUG_INFO_SMARTCAST{NI}, TYPE_MISMATCH!>x<!>
}<!>
compiler/testData/diagnostics/tests/smartCasts/localFunChanges.kt
Vendored
+1 -1
View File
@@ -8,7 +8,7 @@ fun foo() {
return true
}
<!SMARTCAST_IMPOSSIBLE!>i<!>.hashCode()
trans(<!SMARTCAST_IMPOSSIBLE, SMARTCAST_IMPOSSIBLE!>i<!>, ::can)
trans(<!SMARTCAST_IMPOSSIBLE!>i<!>, ::can)
<!SMARTCAST_IMPOSSIBLE!>i<!>.hashCode()
}
}
compiler/testData/diagnostics/tests/smartCasts/objectLiterals/captured.kt
Vendored
+1 -1
View File
@@ -16,7 +16,7 @@ fun foo(): Int {
k.run()
val d: Int = <!DEBUG_INFO_SMARTCAST!>c<!>
// a is captured so smart cast is not possible
return d + <!SMARTCAST_IMPOSSIBLE, SMARTCAST_IMPOSSIBLE!>a<!>
return d + <!SMARTCAST_IMPOSSIBLE!>a<!>
}
else return -1
}
compiler/testData/diagnostics/tests/smartCasts/variables/lambdaBetweenArguments.kt
Vendored
+1 -1
View File
@@ -5,5 +5,5 @@ fun foo(x: Int, f: () -> Unit, y: Int) {}
fun bar() {
var x: Int?
x = 4
foo(<!DEBUG_INFO_SMARTCAST!>x<!>, { x = null; x<!UNSAFE_CALL!>.<!>hashCode() }, <!SMARTCAST_IMPOSSIBLE, SMARTCAST_IMPOSSIBLE!>x<!>)
foo(<!DEBUG_INFO_SMARTCAST!>x<!>, { x = null; x<!UNSAFE_CALL!>.<!>hashCode() }, <!SMARTCAST_IMPOSSIBLE!>x<!>)
}
compiler/testData/diagnostics/tests/smartCasts/variables/property.kt
Vendored
+1 -1
View File
@@ -6,5 +6,5 @@ fun bar(s: String): Int {
fun foo(m: MyClass): Int {
m.p = "xyz"
return bar(<!SMARTCAST_IMPOSSIBLE, SMARTCAST_IMPOSSIBLE!>m.p<!>)
return bar(<!SMARTCAST_IMPOSSIBLE!>m.p<!>)
}
compiler/testData/diagnostics/tests/smartCasts/varnotnull/varCapturedInInlineClosure.kt
Vendored
+1 -1
View File
@@ -8,7 +8,7 @@ fun IntArray.forEachIndexed( op: (i: Int, value: Int) -> Unit) {
fun max(a: IntArray): Int? {
var maxI: Int? = null
a.forEachIndexed { i, value ->
if (maxI == null || value >= a[<!SMARTCAST_IMPOSSIBLE, SMARTCAST_IMPOSSIBLE!>maxI<!>])
if (maxI == null || value >= a[<!SMARTCAST_IMPOSSIBLE!>maxI<!>])
maxI = i
}
return maxI
compiler/testData/diagnostics/tests/typeParameters/implicitNothingInReturnPosition.kt
Vendored
+2 -1
View File
@@ -1,4 +1,5 @@
// !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE -UNCHECKED_CAST
// !WITH_NEW_INFERENCE
// SKIP_TXT
// Issue: KT-20849
@@ -39,7 +40,7 @@ class Context<T>
fun <T> Any.decodeIn(typeFrom: Context<in T>): T = something()
fun <T> Any?.decodeOut1(typeFrom: Context<out T>): T {
return <!TYPE_MISMATCH, TYPE_MISMATCH!>this?.<!IMPLICIT_NOTHING_TYPE_ARGUMENT_IN_RETURN_POSITION!>decodeIn<!>(typeFrom) ?: kotlin.Unit<!>
return <!TYPE_MISMATCH{NI}!>this?.<!IMPLICIT_NOTHING_TYPE_ARGUMENT_IN_RETURN_POSITION!>decodeIn<!>(typeFrom) ?: <!TYPE_MISMATCH{OI}!>kotlin.Unit<!><!>
}
fun <T> Any.decodeOut2(typeFrom: Context<out T>): T {
compiler/testData/diagnostics/tests/typeParameters/kt42042.kt
Vendored
+1 -3
View File
@@ -1,5 +1,3 @@
// !LANGUAGE: -ProperTypeInferenceConstraintsProcessing
sealed class Subtype<A1, B1> {
abstract fun cast(value: A1): B1
class Trivial<A2 : B2, B2> : Subtype<A2, B2>() {
@@ -8,6 +6,6 @@ sealed class Subtype<A1, B1> {
}
fun <A, B> unsafeCast(value: A): B {
val proof: Subtype<A, B> = Subtype.<!TYPE_MISMATCH_WARNING("B; A")!>Trivial()<!>
val proof: Subtype<A, B> = Subtype.<!TYPE_MISMATCH!>Trivial()<!>
return proof.cast(value)
}
compiler/testData/diagnostics/tests/typealias/typeAliasConstructorTypeArgumentsInference.kt
Vendored
+9 -8
View File
@@ -1,18 +1,19 @@
// !WITH_NEW_INFERENCE
// NI_EXPECTED_FILE
class Num<Tn : Number>(val x: Tn)
typealias N<T> = Num<T>
val test0 = N(1)
val test1 = N(<!TYPE_MISMATCH!>"1"<!>)
val test1 = <!TYPE_INFERENCE_UPPER_BOUND_VIOLATED{OI}!>N<!>(<!TYPE_MISMATCH{NI}!>"1"<!>)
class Cons<T>(val head: T, val tail: Cons<T>?)
typealias C<T> = Cons<T>
typealias CC<T> = C<C<T>>
val test2 = C(1, <!CONSTANT_EXPECTED_TYPE_MISMATCH!>2<!>)
val test3 = CC(<!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>, <!CONSTANT_EXPECTED_TYPE_MISMATCH!>2<!>)
val test2 = <!TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR{OI}!>C<!>(1, <!CONSTANT_EXPECTED_TYPE_MISMATCH!>2<!>)
val test3 = <!TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR{OI}!>CC<!>(<!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>, <!CONSTANT_EXPECTED_TYPE_MISMATCH!>2<!>)
val test4 = CC(C(1, null), null)
@@ -20,13 +21,13 @@ class Pair<X, Y>(val x: X, val y: Y)
typealias PL<T> = Pair<T, List<T>>
typealias PN<T> = Pair<T, Num<T>>
val test5 = PL(1, <!NULL_FOR_NONNULL_TYPE!>null<!>)
val test5 = <!TYPE_INFERENCE_INCORPORATION_ERROR{OI}!>PL<!>(1, <!NULL_FOR_NONNULL_TYPE!>null<!>)
class Foo<T>(val p: Pair<T, T>)
typealias F<T> = Foo<T>
fun testProjections1(x: Pair<in Int, out String>) = F(<!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>x<!>)
fun testProjections2(x: Pair<in Int, out Number>) = F(<!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>x<!>)
fun testProjections3(x: Pair<in Number, out Int>) = F(<!TYPE_MISMATCH!>x<!>)
fun testProjections4(x: Pair<in Int, in Int>) = F(<!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>x<!>)
fun testProjections1(x: Pair<in Int, out String>) = <!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}!>F<!>(<!TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>x<!>)
fun testProjections2(x: Pair<in Int, out Number>) = <!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}!>F<!>(<!TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>x<!>)
fun testProjections3(x: Pair<in Number, out Int>) = <!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}!>F<!>(<!TYPE_MISMATCH{NI}!>x<!>)
fun testProjections4(x: Pair<in Int, in Int>) = <!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}!>F<!>(<!TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>x<!>)
compiler/testData/diagnostics/tests/typealias/typeAliasConstructorTypeArgumentsInferenceWithNestedCalls.kt
Vendored
+3 -3
View File
@@ -13,6 +13,6 @@ typealias C<T> = Cons<T>
typealias C2<T> = MapLike<T>
val test1 = C(1, C(2, null))
val test2 = C(1, <!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>C(<!TYPE_MISMATCH, TYPE_MISMATCH!>""<!>, null)<!>)
val test23 = <!UPPER_BOUND_VIOLATED_IN_TYPEALIAS_EXPANSION_BASED_ON_JAVA_ANNOTATIONS!>C2(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>if (true) 1 else null<!>)<!>
val test234 = C2(<!UPPER_BOUND_VIOLATED_IN_TYPEALIAS_EXPANSION_BASED_ON_JAVA_ANNOTATIONS!>C2(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>if (true) 1 else null<!>)<!>)
val test2 = C(1, <!TYPE_MISMATCH!>C(<!TYPE_MISMATCH!>""<!>, null)<!>)
val test23 = <!UPPER_BOUND_VIOLATED_IN_TYPEALIAS_EXPANSION_BASED_ON_JAVA_ANNOTATIONS!>C2(if (true) 1 else null)<!>
val test234 = C2(<!UPPER_BOUND_VIOLATED_IN_TYPEALIAS_EXPANSION_BASED_ON_JAVA_ANNOTATIONS!>C2(if (true) 1 else null)<!>)
compiler/testData/diagnostics/tests/unsignedTypes/conversions/conversionOfSignedToUnsigned.kt
Vendored
+1 -1
View File
@@ -62,7 +62,7 @@ fun test() {
takeUByte(<!TYPE_MISMATCH!>LONG_CONST<!>)
takeUByte(<!TYPE_MISMATCH!>NON_CONST<!>)
takeUByte(<!TYPE_MISMATCH, TYPE_MISMATCH!>BIGGER_THAN_UBYTE<!>)
takeUByte(<!TYPE_MISMATCH!>BIGGER_THAN_UBYTE<!>)
takeUByte(<!TYPE_MISMATCH!>UINT_CONST<!>)
takeUIntWithoutAnnotaion(<!TYPE_MISMATCH!>IMPLICIT_INT<!>)
}
compiler/testData/diagnostics/tests/when/kt9972.kt
Vendored
+6 -5
View File
@@ -1,3 +1,4 @@
// !WITH_NEW_INFERENCE
/*
* KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE)
*
@@ -10,18 +11,18 @@
*/
fun test1(): Int {
val x: String = if (true) <!TYPE_MISMATCH!>{
val x: String = if (true) <!TYPE_MISMATCH{NI}!>{
when {
true -> Any()
else -> null
true -> <!TYPE_MISMATCH{OI}!>Any()<!>
else -> <!NULL_FOR_NONNULL_TYPE{OI}!>null<!>
}
}<!> else ""
return x.hashCode()
}
fun test2(): Int {
val x: String = <!TYPE_MISMATCH, TYPE_MISMATCH!>when {
true -> Any()
val x: String = <!TYPE_MISMATCH{NI}!>when {
true -> <!TYPE_MISMATCH{OI}!>Any()<!>
else -> null
} ?: return 0<!>
return x.hashCode()
compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassArrayInAnnotationsInVariance.kt
Vendored
+4 -2
View File
@@ -1,3 +1,5 @@
// !WITH_NEW_INFERENCE
import kotlin.reflect.KClass
open class A
@@ -12,7 +14,7 @@ class MyClass1
@Ann1(arrayOf(Any::class))
class MyClass1a
@Ann1(<!TYPE_MISMATCH, TYPE_MISMATCH!>arrayOf(<!TYPE_MISMATCH!>B1::class<!>)<!>)
@Ann1(<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>arrayOf(<!TYPE_MISMATCH{NI}!>B1::class<!>)<!>)
class MyClass2
annotation class Ann2(val arg: Array<KClass<in B1>>)
@@ -23,5 +25,5 @@ class MyClass3
@Ann2(arrayOf(B1::class))
class MyClass4
@Ann2(<!TYPE_MISMATCH, TYPE_MISMATCH!>arrayOf(<!TYPE_MISMATCH!>B2::class<!>)<!>)
@Ann2(<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>arrayOf(<!TYPE_MISMATCH{NI}!>B2::class<!>)<!>)
class MyClass5
compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassArrayInAnnotationsOutVariance.kt
Vendored
+4 -3
View File
@@ -1,3 +1,4 @@
// !WITH_NEW_INFERENCE
import kotlin.reflect.KClass
@@ -10,7 +11,7 @@ annotation class Ann1(val arg: Array<KClass<out A>>)
@Ann1(arrayOf(A::class))
class MyClass1
@Ann1(<!TYPE_MISMATCH, TYPE_MISMATCH!>arrayOf(<!TYPE_MISMATCH!>Any::class<!>)<!>)
@Ann1(<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>arrayOf(<!TYPE_MISMATCH{NI}!>Any::class<!>)<!>)
class MyClass1a
@Ann1(arrayOf(B1::class))
@@ -18,11 +19,11 @@ class MyClass2
annotation class Ann2(val arg: Array<KClass<out B1>>)
@Ann2(<!TYPE_MISMATCH, TYPE_MISMATCH!>arrayOf(<!TYPE_MISMATCH!>A::class<!>)<!>)
@Ann2(<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>arrayOf(<!TYPE_MISMATCH{NI}!>A::class<!>)<!>)
class MyClass3
@Ann2(arrayOf(B1::class))
class MyClass4
@Ann2(<!TYPE_MISMATCH, TYPE_MISMATCH!>arrayOf(<!TYPE_MISMATCH!>B2::class<!>)<!>)
@Ann2(<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>arrayOf(<!TYPE_MISMATCH{NI}!>B2::class<!>)<!>)
class MyClass5
compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/plusAssignWithLambda.kt
Vendored
+1 -1
View File
@@ -37,6 +37,6 @@ class B {
}
fun foo3(x: B) = {
x += { <!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>""<!> }
x += { <!TYPE_MISMATCH, TYPE_MISMATCH!>""<!> }
x += id { <!TYPE_MISMATCH, TYPE_MISMATCH!>""<!> }
}
compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/suspendCallsWithErrors.kt
Vendored
+4 -3
View File
@@ -1,5 +1,6 @@
// !USE_EXPERIMENTAL: kotlin.RequiresOptIn
// !DIAGNOSTICS: -UNUSED_PARAMETER
// !WITH_NEW_INFERENCE
// NI_EXPECTED_FILE
@file:OptIn(ExperimentalTypeInference::class)
@@ -14,10 +15,10 @@ fun <S> generate(@BuilderInference g: suspend Controller<S>.() -> Unit): S = TOD
class A
val test1 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>generate<!> {
val test1 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>generate<!> {
yield(<!NO_COMPANION_OBJECT!>A<!>)
}
val test2: Int = <!TYPE_MISMATCH!>generate {
yield(<!TYPE_MISMATCH, TYPE_MISMATCH!>A()<!>)
val test2: Int = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>generate {
yield(<!TYPE_MISMATCH{NI}!>A()<!>)
}<!>
compiler/testData/diagnostics/testsWithStdLib/coroutines/lambdaExpectedType.kt
Vendored
+2 -2
View File
@@ -28,7 +28,7 @@ fun foo() {
i = genericBuilder { 1 }
genericBuilder { 1 }
genericBuilder<Int> { 1 }
genericBuilder<Int> { <!TYPE_MISMATCH, TYPE_MISMATCH!>""<!> }
genericBuilder<Int> { <!TYPE_MISMATCH!>""<!> }
val y = { 1 }
genericBuilder(<!UNSUPPORTED_FEATURE!>y<!>)
@@ -43,7 +43,7 @@ fun foo() {
val s: String = manyArgumentsBuilder({}, { "" }) { 1 }
manyArgumentsBuilder<String>({}, { "" }, { 1 })
manyArgumentsBuilder<String>({}, { <!CONSTANT_EXPECTED_TYPE_MISMATCH, CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!> }, { 2 })
manyArgumentsBuilder<String>({}, { <!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!> }, { 2 })
severalParamsInLambda { <!NAME_SHADOWING!>x<!>, <!NAME_SHADOWING!>y<!> ->
x checkType { _<String>() }
compiler/testData/diagnostics/testsWithStdLib/coroutines/tryCatchLambda.kt
Vendored
+3 -2
View File
@@ -1,4 +1,5 @@
// !DIAGNOSTICS: -UNUSED_PARAMETER -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_VARIABLE
// !WITH_NEW_INFERENCE
suspend fun <V> await(f: V): V = f
@@ -7,10 +8,10 @@ fun <T> genericBuilder(c: suspend () -> T): T = null!!
fun foo() {
var result = ""
genericBuilder<String> {
<!TYPE_MISMATCH, TYPE_MISMATCH!>try {
<!TYPE_MISMATCH{NI}!>try {
await("")
} catch(e: Exception) {
result = "fail"
<!EXPECTED_TYPE_MISMATCH{OI}!>result = "fail"<!>
}<!>
}
}
compiler/testData/diagnostics/testsWithStdLib/elvisOnJavaList.kt
Vendored
+3 -1
View File
@@ -1,3 +1,5 @@
// !WITH_NEW_INFERENCE
// FILE: P.java
import java.util.ArrayList;
@@ -13,5 +15,5 @@ public class P {
fun foo(c: P): MutableList<Int> {
// Error should be here: see KT-8168 Typechecker fails for platform collection type
return <!TYPE_MISMATCH, TYPE_MISMATCH!>c.getList() ?: listOf()<!>
return <!TYPE_MISMATCH{NI}!>c.getList() ?: <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{OI}!>listOf()<!><!>
}
compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis/suspendFunctions.kt
Vendored
+3 -3
View File
@@ -19,7 +19,7 @@ fun main() {
val x1: suspend (Int) -> Unit = takeSuspend(<!DEBUG_INFO_EXPRESSION_TYPE("suspend (kotlin.Int) -> kotlin.Unit")!>id { it }<!>, <!DEBUG_INFO_EXPRESSION_TYPE("suspend (kotlin.Int) -> kotlin.Unit")!>{ x -> x }<!>)
// Here, the error should be
val x2: (Int) -> Unit = <!TYPE_MISMATCH!>takeSuspend(<!DEBUG_INFO_EXPRESSION_TYPE("suspend (kotlin.Int) -> kotlin.Unit")!>id <!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>{ it }<!><!>, <!DEBUG_INFO_EXPRESSION_TYPE("suspend (kotlin.Int) -> kotlin.Unit"), TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>{ x -> x }<!>)<!>
val x3: suspend (Int) -> Unit = takeSimpleFunction(<!DEBUG_INFO_EXPRESSION_TYPE("suspend (kotlin.Int) -> kotlin.Unit")!>id <!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>{ it }<!><!>, <!DEBUG_INFO_EXPRESSION_TYPE("suspend (kotlin.Int) -> kotlin.Unit"), TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>{ x -> x }<!>)
val x4: (Int) -> Unit = <!TYPE_MISMATCH, TYPE_MISMATCH!>takeSimpleFunction(<!TYPE_MISMATCH!>id<suspend (Int) -> Unit> {}<!>, <!DEBUG_INFO_EXPRESSION_TYPE("suspend (kotlin.Int) -> kotlin.Unit"), TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>{}<!>)<!>
val x2: (Int) -> Unit = <!TYPE_MISMATCH!>takeSuspend(<!DEBUG_INFO_EXPRESSION_TYPE("suspend (kotlin.Int) -> kotlin.Unit")!>id <!TYPE_MISMATCH!>{ it }<!><!>, <!DEBUG_INFO_EXPRESSION_TYPE("suspend (kotlin.Int) -> kotlin.Unit"), TYPE_MISMATCH!>{ x -> x }<!>)<!>
val x3: suspend (Int) -> Unit = takeSimpleFunction(<!DEBUG_INFO_EXPRESSION_TYPE("suspend (kotlin.Int) -> kotlin.Unit")!>id <!TYPE_MISMATCH!>{ it }<!><!>, <!DEBUG_INFO_EXPRESSION_TYPE("suspend (kotlin.Int) -> kotlin.Unit"), TYPE_MISMATCH!>{ x -> x }<!>)
val x4: (Int) -> Unit = <!TYPE_MISMATCH, TYPE_MISMATCH!>takeSimpleFunction(<!TYPE_MISMATCH!>id<suspend (Int) -> Unit> {}<!>, <!DEBUG_INFO_EXPRESSION_TYPE("suspend (kotlin.Int) -> kotlin.Unit"), TYPE_MISMATCH!>{}<!>)<!>
}
compiler/testData/diagnostics/testsWithStdLib/resolve/kt4711.kt
Vendored
+4 -3
View File
@@ -1,3 +1,4 @@
// !WITH_NEW_INFERENCE
//KT-4711 Error type with no error reported from type inference
fun main() {
@@ -6,15 +7,15 @@ fun main() {
val startTimeNanos = System.nanoTime()
// the problem sits on the next line:
val pi = 4.0.toDouble() * delta * (1..n).reduce(
val pi = 4.0.toDouble() * delta <!OVERLOAD_RESOLUTION_AMBIGUITY{OI}!>*<!> (1..n).<!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}!>reduce<!>(
{t, i ->
val x = (i - 0.5) * delta
<!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>t + 1.0 / (1.0 + x * x)<!>
<!TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>t + 1.0 / (1.0 + x * x)<!>
})
// !!! pi has error type here
val elapseTime = (System.nanoTime() - startTimeNanos) / 1e9
println("pi_sequential_reduce $pi $n $elapseTime")
println("pi_sequential_reduce $<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{OI}!>pi<!> $n $elapseTime")
}
compiler/testData/diagnostics/testsWithStdLib/smartcasts/forEachSafe.kt
Vendored
+1 -1
View File
@@ -3,7 +3,7 @@
fun indexOfMax(a: IntArray): Int? {
var maxI: Int? = null
a.forEachIndexed { i, value ->
if (maxI == null || value >= a[<!SMARTCAST_IMPOSSIBLE, SMARTCAST_IMPOSSIBLE!>maxI<!>]) {
if (maxI == null || value >= a[<!SMARTCAST_IMPOSSIBLE!>maxI<!>]) {
maxI = i
}
}
compiler/testData/diagnostics/testsWithStdLib/tryCatch/tryExpression.kt
Vendored
+3 -2
View File
@@ -1,3 +1,4 @@
// !WITH_NEW_INFERENCE
// SKIP_TXT
class ExcA : Exception()
@@ -26,9 +27,9 @@ fun test1(): Map<Int, Int> = run {
}
fun test2(): Map<Int, Int> = run {
<!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>try {
<!TYPE_MISMATCH{NI}!>try {
emptyMap()
} catch (e: ExcA) {
<!TYPE_MISMATCH!>mapOf(<!TYPE_MISMATCH!>"" to ""<!>)<!>
<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>mapOf(<!TYPE_MISMATCH{NI}!>"" to ""<!>)<!>
}<!>
}