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

FIR: Adjust test data after introduction of INFERENCE_NO_INFORMATION_FOR_PARAMETER

Browse Source 
See previous commits for details
This commit is contained in:
Denis.Zharkov
2021-05-26 12:36:15 +03:00
committed by TeamCityServer
parent c420957eac
commit 0aca3a3737
160 changed files with 363 additions and 348 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/fir/analysis-tests/testData/resolve/arguments/lambdaInUnresolvedCall.fir.txt
Vendored
+2 -2
View File
@@ -10,8 +10,8 @@ FILE: lambdaInUnresolvedCall.kt
)
}
public final fun test_2(): R|kotlin/Unit| {
<Unresolved name: myRun>#(<L> = myRun@fun <anonymous>(): R|kotlin/Any?| <inline=Unknown> {
^ R|/materialize|<R|kotlin/Any?|>()
<Unresolved name: myRun>#(<L> = myRun@fun <anonymous>(): <ERROR TYPE REF: Cannot infer argument for type parameter R> <inline=Unknown> {
^ R|/materialize|<R|ERROR CLASS: Cannot infer argument for type parameter R|>()
}
)
}
compiler/fir/analysis-tests/testData/resolve/diagnostics/conflictingProjection.fir.txt
Vendored
+2 -2
View File
@@ -148,13 +148,13 @@ FILE: conflictingProjection.kt
^test15 R|/InOuter.InOuter|<R|kotlin/Int|>().R|SubstitutionOverride</InOuter.OutIntermediate.OutIntermediate>|<R|kotlin/String|>().R|SubstitutionOverride</InOuter.OutIntermediate.InInner.InInner>|<R|kotlin/Char|>()
}
public final fun test16(): R|InOuter.OutIntermediate.InInner<out kotlin/Char, kotlin/String, kotlin/Int>| {
^test16 R|/InOuter.InOuter|<R|kotlin/Int|>().R|SubstitutionOverride</InOuter.OutIntermediate.OutIntermediate>|<R|kotlin/String|>().R|SubstitutionOverride</InOuter.OutIntermediate.InInner.InInner>|<R|kotlin/Any?|>()
^test16 R|/InOuter.InOuter|<R|kotlin/Int|>().R|SubstitutionOverride</InOuter.OutIntermediate.OutIntermediate>|<R|kotlin/String|>().<CS errors: /InOuter.OutIntermediate.InInner.InInner>#<R|ERROR CLASS: Cannot infer argument for type parameter G|>()
}
public final fun test17(): R|InOuter.OutIntermediate.InInner<kotlin/Char, out kotlin/String, in kotlin/Int>| {
^test17 R|/InOuter.InOuter|<R|kotlin/Int|>().R|SubstitutionOverride</InOuter.OutIntermediate.OutIntermediate>|<R|kotlin/String|>().R|SubstitutionOverride</InOuter.OutIntermediate.InInner.InInner>|<R|kotlin/Char|>()
}
public final fun test18(): R|InOuter.OutIntermediate.InInner<out kotlin/Char, in kotlin/String, kotlin/Int>| {
^test18 R|/InOuter.InOuter|<R|kotlin/Int|>().R|SubstitutionOverride</InOuter.OutIntermediate.OutIntermediate>|<R|kotlin/String|>().R|SubstitutionOverride</InOuter.OutIntermediate.InInner.InInner>|<R|kotlin/Any?|>()
^test18 R|/InOuter.InOuter|<R|kotlin/Int|>().R|SubstitutionOverride</InOuter.OutIntermediate.OutIntermediate>|<R|kotlin/String|>().<CS errors: /InOuter.OutIntermediate.InInner.InInner>#<R|ERROR CLASS: Cannot infer argument for type parameter G|>()
}
public final class TwoParametersOuter<T, in T1> : R|kotlin/Any| {
public constructor<T, in T1>(): R|TwoParametersOuter<T, T1>| {
compiler/fir/analysis-tests/testData/resolve/diagnostics/conflictingProjection.kt
Vendored
+2 -2
View File
@@ -89,10 +89,10 @@ fun test13(): InOuter<Int>.OutIntermediate<<!CONFLICTING_PROJECTION!>in<!> Strin
fun test14(): InOuter<Int>.OutIntermediate<<!REDUNDANT_PROJECTION!>out<!> String>.InInner<Char> = InOuter<Int>().OutIntermediate<String>().InInner()
fun test15(): InOuter<Int>.OutIntermediate<String>.InInner<<!REDUNDANT_PROJECTION!>in<!> Char> = InOuter<Int>().OutIntermediate<String>().InInner()
fun test16(): InOuter<Int>.OutIntermediate<String>.InInner<<!CONFLICTING_PROJECTION!>out<!> Char> = InOuter<Int>().OutIntermediate<String>().InInner()
fun test16(): InOuter<Int>.OutIntermediate<String>.InInner<<!CONFLICTING_PROJECTION!>out<!> Char> = InOuter<Int>().OutIntermediate<String>().<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>InInner<!>()
fun test17(): InOuter<<!REDUNDANT_PROJECTION!>in<!> Int>.OutIntermediate<<!REDUNDANT_PROJECTION!>out<!> String>.InInner<Char> = InOuter<Int>().OutIntermediate<String>().InInner()
fun test18(): InOuter<Int>.OutIntermediate<<!CONFLICTING_PROJECTION!>in<!> String>.InInner<<!CONFLICTING_PROJECTION!>out<!> Char> = InOuter<Int>().OutIntermediate<String>().InInner()
fun test18(): InOuter<Int>.OutIntermediate<<!CONFLICTING_PROJECTION!>in<!> String>.InInner<<!CONFLICTING_PROJECTION!>out<!> Char> = InOuter<Int>().OutIntermediate<String>().<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>InInner<!>()
class TwoParametersOuter<T, in T1> {
inner class TwoParametersIntermediate<out K, K1> {
compiler/fir/analysis-tests/testData/resolve/diagnostics/upperBoundViolated.fir.txt
Vendored
+2 -2
View File
@@ -70,5 +70,5 @@ FILE: upperBoundViolated.kt
}
public final val np1: R|NumberPhile<kotlin/Int>| = R|/NumberPhile.NumberPhile|<R|kotlin/Int|>(Int(10))
public get(): R|NumberPhile<kotlin/Int>|
public final val np2: R|NumberPhile<kotlin/Number>| = <Inapplicable(INAPPLICABLE): /NumberPhile.NumberPhile>#<R|kotlin/Number|>(String(Test))
public get(): R|NumberPhile<kotlin/Number>|
public final val np2: R|NumberPhile<ERROR CLASS: Cannot infer argument for type parameter T>| = <Inapplicable(INAPPLICABLE): /NumberPhile.NumberPhile>#<R|ERROR CLASS: Cannot infer argument for type parameter T|>(String(Test))
public get(): R|NumberPhile<ERROR CLASS: Cannot infer argument for type parameter T>|
compiler/fir/analysis-tests/testData/resolve/expresssions/inference/typeParameters.fir.txt
Vendored
+1 -1
View File
@@ -18,5 +18,5 @@ FILE: typeParameters.kt
}
public final fun main(fooImpl: R|FooImpl|, bar: R|Bar|): R|kotlin/Unit| {
lval a: R|FooImpl| = R|/foo|<R|FooImpl|>(R|<local>/fooImpl|)
lval b: R|Foo| = <Inapplicable(INAPPLICABLE): /foo>#<R|Foo|>(R|<local>/bar|)
lval b: <ERROR TYPE REF: Cannot infer argument for type parameter T> = <Inapplicable(INAPPLICABLE): /foo>#<R|ERROR CLASS: Cannot infer argument for type parameter T|>(R|<local>/bar|)
}
compiler/fir/analysis-tests/testData/resolve/overrides/supertypeGenericsComplex.fir.txt
Vendored
+1 -1
View File
@@ -24,5 +24,5 @@ FILE: supertypeGenericsComplex.kt
}
public final fun f(list: R|kotlin/collections/MutableList<X>|, s: R|kotlin/collections/MutableList<kotlin/CharSequence>|): R|kotlin/Unit| {
R|/C.C|().R|SubstitutionOverride</C.f: R|kotlin/Unit|>|<R|X|>(R|<local>/list|, R|<local>/s|)
R|/C.C|().<Inapplicable(INAPPLICABLE): /C.f>#<R|Out<kotlin/CharSequence>|>(R|<local>/s|, R|<local>/list|)
R|/C.C|().<Inapplicable(INAPPLICABLE): /C.f>#<R|ERROR CLASS: Cannot infer argument for type parameter D|>(R|<local>/s|, R|<local>/list|)
}
compiler/fir/analysis-tests/testData/resolve/samConstructors/genericSam.fir.txt
Vendored
+1 -1
View File
@@ -8,7 +8,7 @@ FILE: main.kt
^ R|<local>/x|.R|kotlin/Any.toString|()
}
)
R|/MyFunction|<R|kotlin/Nothing|, R|kotlin/Any?|>(<L> = MyFunction@fun <anonymous>(x: R|ft<kotlin/Nothing, kotlin/Nothing?>|): R|kotlin/Any?| <inline=NoInline> {
<CS errors: /MyFunction>#<R|ERROR CLASS: Cannot infer argument for type parameter T|, R|ERROR CLASS: Cannot infer argument for type parameter R|>(<L> = MyFunction@fun <anonymous>(x: <ERROR TYPE REF: Cannot infer argument for type parameter T>): <ERROR TYPE REF: Cannot infer argument for type parameter R> <inline=NoInline> {
^ String()
}
)
compiler/fir/analysis-tests/testData/resolve/samConstructors/genericSam.kt
Vendored
+1 -1
View File
@@ -14,7 +14,7 @@ fun main() {
x.toString()
}
MyFunction { x ->
<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>MyFunction<!> { <!CANNOT_INFER_PARAMETER_TYPE!>x<!> ->
""
}
}
compiler/fir/analysis-tests/testData/resolve/tryInference.fir.txt
Vendored
+1 -1
View File
@@ -14,7 +14,7 @@ FILE: tryInference.kt
R|/materialize|<R|A|>()
}
finally {
R|/materialize|<R|kotlin/Nothing|>()
<CS errors: /materialize>#<R|ERROR CLASS: Cannot infer argument for type parameter T|>()
}
)
}
compiler/fir/analysis-tests/testData/resolve/tryInference.kt
Vendored
+1 -1
View File
@@ -11,7 +11,7 @@ fun test() {
} catch (e: Exception) {
materialize()
} finally {
materialize() // Should be an errror
<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>materialize<!>() // Should be an errror
}
)
}
compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/fromBasicDiagnosticTests/ambiguityWhenNoApplicableCallableReferenceCandidate.fir.txt
Vendored
+1 -1
View File
@@ -6,5 +6,5 @@ FILE: ambiguityWhenNoApplicableCallableReferenceCandidate.kt
public final fun <T> bar(f: R|(T) -> kotlin/Unit|): R|kotlin/Unit| {
}
public final fun test(): R|kotlin/Unit| {
R|/bar|<R|kotlin/Any?|>(::<Ambiguity: foo, [/foo, /foo]>#)
<CS errors: /bar>#<R|ERROR CLASS: Cannot infer argument for type parameter T|>(::<Ambiguity: foo, [/foo, /foo]>#)
}
compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/fromBasicDiagnosticTests/ambiguityWhenNoApplicableCallableReferenceCandidate.kt
Vendored
+1 -1
View File
@@ -4,5 +4,5 @@ fun foo(y: String) {}
fun <T> bar(f: (T) -> Unit) {}
fun test() {
bar(::<!OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!>)
<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>bar<!>(::<!OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!>)
}
compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/fromBasicDiagnosticTests/chooseCallableReferenceDependingOnInferredReceiver.fir.txt
Vendored
+3 -3
View File
@@ -30,14 +30,14 @@ FILE: chooseCallableReferenceDependingOnInferredReceiver.kt
^bar R|kotlin/TODO|()
}
public final fun test(): R|kotlin/Unit| {
R|/myWith|<R|A|, R|kotlin/Nothing|>(R|/A.A|(), <L> = myWith@fun R|A|.<anonymous>(): R|kotlin/Nothing| <inline=Inline, kind=UNKNOWN> {
<CS errors: /myWith>#<R|A|, R|ERROR CLASS: Cannot infer argument for type parameter R|>(R|/A.A|(), <L> = myWith@fun R|A|.<anonymous>(): <ERROR TYPE REF: Cannot infer argument for type parameter R> <inline=Inline, kind=UNKNOWN> {
lval t1: R|A| = R|/bar|<R|A|>(::R|/A.foo|)
lval t2: R|A| = R|/bar|<R|A|>(::R|/A.baz|)
^ R|/myWith|<R|B|, R|kotlin/Nothing|>(R|/B.B|(), <L> = myWith@fun R|B|.<anonymous>(): R|kotlin/Nothing| <inline=Inline, kind=UNKNOWN> {
^ R|/myWith|<R|B|, R|ERROR CLASS: Cannot infer argument for type parameter R|>(R|/B.B|(), <L> = myWith@fun R|B|.<anonymous>(): <ERROR TYPE REF: Cannot infer argument for type parameter R> <inline=Inline, kind=UNKNOWN> {
lval a: R|A| = R|/bar|<R|A|>(::R|/A.foo|)
lval b: R|B| = R|/bar|<R|B|>(::R|/B.foo|)
lval t3: R|B| = R|/bar|<R|B|>(::R|/B.baz|)
^ R|/bar|<R|kotlin/Nothing|>(::<Ambiguity: foo, [/B.foo, /B.foo]>#)
^ R|/bar|<R|ERROR CLASS: Cannot infer argument for type parameter T|>(::<Ambiguity: foo, [/B.foo, /B.foo]>#)
}
)
}
compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/fromBasicDiagnosticTests/chooseCallableReferenceDependingOnInferredReceiver.kt
Vendored
+1 -1
View File
@@ -14,7 +14,7 @@ class B {
fun <T> bar(f: (T) -> Unit): T = TODO()
fun test() {
myWith(A()) {
<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>myWith<!>(A()) {
val t1 = bar(::foo)
val t2 = bar(::baz)
compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/fromBasicDiagnosticTests/eagerAndPostponedCallableReferences.fir.txt
Vendored
+1 -1
View File
@@ -21,5 +21,5 @@ FILE: eagerAndPostponedCallableReferences.kt
lval a4: R|B| = R|/foo|<R|B|>(::R|/multiple|, ::R|/singleB|)
lval a5: R|A| = R|/foo|<R|A|>(::R|/singleA|, ::R|/singleA|)
lval a6: R|it(A & B)| = R|/foo|<R|it(A & B)|>(::R|/singleA|, ::R|/singleB|)
R|/foo|<R|kotlin/Nothing|>(::<Ambiguity: multiple, [/multiple, /multiple]>#, ::<Ambiguity: multiple, [/multiple, /multiple]>#)
<CS errors: /foo>#<R|ERROR CLASS: Cannot infer argument for type parameter T|>(::<Ambiguity: multiple, [/multiple, /multiple]>#, ::<Ambiguity: multiple, [/multiple, /multiple]>#)
}
compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/fromBasicDiagnosticTests/eagerAndPostponedCallableReferences.kt
Vendored
+1 -1
View File
@@ -22,5 +22,5 @@ fun test() {
val a6 = foo(::singleA, ::singleB)
foo(::<!OVERLOAD_RESOLUTION_AMBIGUITY!>multiple<!>, ::<!OVERLOAD_RESOLUTION_AMBIGUITY!>multiple<!>)
<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>(::<!OVERLOAD_RESOLUTION_AMBIGUITY!>multiple<!>, ::<!OVERLOAD_RESOLUTION_AMBIGUITY!>multiple<!>)
}
compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/implicitTypes.fir.txt
Vendored
+2 -2
View File
@@ -8,8 +8,8 @@ FILE: implicitTypes.kt
public final fun bar(x: R|kotlin/String|): R|kotlin/Int| {
^bar Int(1)
}
public final fun loop1(): R|(kotlin/Any?) -> kotlin/Nothing| {
^loop1 <Inapplicable(INAPPLICABLE): /use>#<R|kotlin/Any?|, R|kotlin/Nothing|>(::<Unresolved reference: loop2>#)
public final fun loop1(): R|(ERROR CLASS: Cannot infer argument for type parameter T) -> ERROR CLASS: Cannot infer argument for type parameter R| {
^loop1 <Inapplicable(INAPPLICABLE): /use>#<R|ERROR CLASS: Cannot infer argument for type parameter T|, R|ERROR CLASS: Cannot infer argument for type parameter R|>(::<Unresolved reference: loop2>#)
}
public final fun loop2(): <ERROR TYPE REF: cycle> {
^loop2 R|/loop1|()
compiler/testData/diagnostics/tests/EnumEntryAsType.fir.kt
Vendored
+1 -1
View File
@@ -47,7 +47,7 @@ fun <T> bar(a: Any): T = a as T
fun <T> foo() {
foo<<!UNRESOLVED_REFERENCE!>Color.RED<!>>()
foo<RedAlias>()
foo<<!CANNOT_INFER_PARAMETER_TYPE!>RedAlias<!>>()
bar<<!UNRESOLVED_REFERENCE!>Color.RED<!>>(<!ARGUMENT_TYPE_MISMATCH!>Color.RED<!>)
}
compiler/testData/diagnostics/tests/FunctionCalleeExpressions.fir.kt
Vendored
+1 -1
View File
@@ -48,7 +48,7 @@ fun main(args : Array<String>) {
val b = fooT2<Int>()(1)
checkSubtype<Int>(b)
fooT2()(1) // : Any?
<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>fooT2<!>()(1) // : Any?
<!UNRESOLVED_REFERENCE!>1<!>()
<!UNRESOLVED_REFERENCE!>1<!>{}
compiler/testData/diagnostics/tests/ResolveOfJavaGenerics.fir.kt
Vendored
+1 -1
View File
@@ -4,7 +4,7 @@ fun test(a : java.lang.annotation.RetentionPolicy) {
}
fun test() {
java.util.Collections.emptyList()
java.util.Collections.<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>emptyList<!>()
val a : Collection<String>? = java.util.Collections.emptyList()
}
compiler/testData/diagnostics/tests/ResolveToJava.fir.kt
Vendored
+1 -1
View File
@@ -24,7 +24,7 @@ fun test(l : java.util.List<Int>) {
Collections.<!UNRESOLVED_REFERENCE!>emptyList<!>
Collections.<!UNRESOLVED_REFERENCE!>emptyList<!><Int>
Collections.emptyList<Int>()
Collections.emptyList()
Collections.<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>emptyList<!>()
checkSubtype<Set<Int>?>(Collections.singleton<Int>(1))
Collections.singleton<Int>(<!ARGUMENT_TYPE_MISMATCH!>1.0<!>)
compiler/testData/diagnostics/tests/TypeInference.fir.kt
Vendored
+2 -2
View File
@@ -9,10 +9,10 @@ fun main() {
val a : C<Int> = C();
val x : C<in String> = C()
val y : C<out String> = C()
val z : C<*> = C()
val z : C<*> = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>C<!>()
val ba : C<Int> = bar();
val bx : C<in String> = bar()
val by : C<out String> = bar()
val bz : C<*> = bar()
val bz : C<*> = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>bar<!>()
}
compiler/testData/diagnostics/tests/callableReference/kt34314.fir.kt
Vendored
+1 -1
View File
@@ -1,5 +1,5 @@
// !DIAGNOSTICS: -UNUSED_VARIABLE
fun main() {
val x = <!NEW_INFERENCE_ERROR!>run { ::run }<!> // no error
val x = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>run<!> { ::run } // no error
}
compiler/testData/diagnostics/tests/callableReference/kt34314_lambda.fir.kt
Vendored
+1 -1
View File
@@ -3,5 +3,5 @@
fun <T> materialize(): T = TODO()
fun main() {
val x = run { materialize() }
val x = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>run<!> { materialize() }
}
compiler/testData/diagnostics/tests/callableReference/resolve/ambiguityWhenNoApplicableCallableReferenceCandidate.fir.kt
Vendored
+1 -1
View File
@@ -7,5 +7,5 @@ fun foo(y: String) {}
fun <T> bar(f: (T) -> Unit) {}
fun test() {
bar(::<!OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!>)
<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>bar<!>(::<!OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!>)
}
compiler/testData/diagnostics/tests/callableReference/resolve/ambiguityWithBoundExtensionReceiver.fir.kt
Vendored
+1 -1
View File
@@ -10,6 +10,6 @@ fun A.foo() = ""
class A {
fun main() {
bar(::<!OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!>) checkType { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>bar<!>(::<!OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!>) <!INAPPLICABLE_CANDIDATE!>checkType<!> { _<String>() }
}
}
compiler/testData/diagnostics/tests/callableReference/resolve/chooseCallableReferenceDependingOnInferredReceiver.fir.kt
Vendored
+1 -1
View File
@@ -17,7 +17,7 @@ class B {
fun <T> bar(f: (T) -> Unit): T = TODO()
fun test() {
myWith(A()) {
<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>myWith<!>(A()) {
val t1 = bar(::foo)
t1
compiler/testData/diagnostics/tests/callableReference/resolve/eagerAndPostponedCallableReferences.fir.kt
Vendored
+1 -1
View File
@@ -31,5 +31,5 @@ fun test() {
val a6 = foo(::singleA, ::singleB)
a6
foo(::<!OVERLOAD_RESOLUTION_AMBIGUITY!>multiple<!>, ::<!OVERLOAD_RESOLUTION_AMBIGUITY!>multiple<!>)
<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>(::<!OVERLOAD_RESOLUTION_AMBIGUITY!>multiple<!>, ::<!OVERLOAD_RESOLUTION_AMBIGUITY!>multiple<!>)
}
compiler/testData/diagnostics/tests/callableReference/resolve/resolveEqualsOperatorWithAnyExpectedType.fir.kt
Vendored
+11
View File
@@ -0,0 +1,11 @@
// !LANGUAGE: +NewInference
interface Base
fun <K> materialize(): K = TODO()
fun <T : Base> Base.transform(): T = materialize()
fun test(child: Base) {
child == child.<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>transform<!>()
}
compiler/testData/diagnostics/tests/callableReference/resolve/resolveEqualsOperatorWithAnyExpectedType.kt
Vendored
+1 -2
View File
@@ -1,4 +1,3 @@
// FIR_IDENTICAL
// !LANGUAGE: +NewInference
interface Base
@@ -9,4 +8,4 @@ fun <T : Base> Base.transform(): T = materialize()
fun test(child: Base) {
child == child.transform()
}
}
compiler/testData/diagnostics/tests/callableReference/unsupported/localVariableWithSubstitution.fir.kt
Vendored
+1 -1
View File
@@ -9,6 +9,6 @@ class Foo {
fun main() {
val f = Foo()
val a: Int
<!VARIABLE_EXPECTED!>get()<!> = f.getValue(null, ::<!UNSUPPORTED!>a<!>) // no exception after fix
<!VARIABLE_EXPECTED!>get()<!> = f.<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getValue<!>(null, ::<!UNSUPPORTED!>a<!>) // no exception after fix
<!UNRESOLVED_REFERENCE!>print<!>(<!UNINITIALIZED_VARIABLE!>a<!>)
}
compiler/testData/diagnostics/tests/callableReference/unsupported/parameterWithSubstitution.fir.kt
Vendored
+1 -1
View File
@@ -9,6 +9,6 @@ class Foo {
fun main(x: Int) {
val f = Foo()
val a: Int
<!VARIABLE_EXPECTED!>get()<!> = f.getValue(null, ::<!UNSUPPORTED!>x<!>) // no exception after fix
<!VARIABLE_EXPECTED!>get()<!> = f.<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getValue<!>(null, ::<!UNSUPPORTED!>x<!>) // no exception after fix
<!UNRESOLVED_REFERENCE!>print<!>(<!UNINITIALIZED_VARIABLE!>a<!>)
}
compiler/testData/diagnostics/tests/declarationChecks/namedFunAsLastExpressionInBlock.fir.kt
Vendored
+1 -1
View File
@@ -4,7 +4,7 @@ fun foo(block: () -> (() -> Int)) {}
fun test() {
val x = <!ANONYMOUS_FUNCTION_WITH_NAME!>fun named1(x: Int): Int { return 1 }<!>
x <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Function1<Int, Int>>() }
x <!INAPPLICABLE_CANDIDATE!>checkType<!> { _<Function1<Int, Int>>() }
foo { fun named2(): Int {return 1} }
foo({ fun named3() = 1 })
compiler/testData/diagnostics/tests/delegatedProperty/inference/differentDelegatedExpressions.fir.kt
Vendored
+4 -4
View File
@@ -9,10 +9,10 @@ class A(outer: Outer) {
var g: String by outer.getContainer().getMyProperty()
var b: String by foo(getMyProperty())
var r: String by foo(outer.getContainer().getMyProperty())
var e: String by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, DELEGATE_SPECIAL_FUNCTION_RETURN_TYPE_MISMATCH, TYPE_MISMATCH!>+ foo(getMyProperty())<!>
var f: String by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, DELEGATE_SPECIAL_FUNCTION_RETURN_TYPE_MISMATCH, TYPE_MISMATCH!>foo(getMyProperty()) - 1<!>
var b: String by <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!><!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>(getMyProperty())<!>
var r: String by <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!><!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>(outer.getContainer().getMyProperty())<!>
var e: String by + <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>(getMyProperty())
var f: String by <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>(getMyProperty()) - 1
}
fun <A, B> foo(a: Any?) = MyProperty<A, B>()
compiler/testData/diagnostics/tests/delegatedProperty/inference/genericMethodInGenericClass.fir.kt
Vendored
+3 -3
View File
@@ -7,7 +7,7 @@ class A<R>() {
operator fun <T> setValue(t: Any?, p: KProperty<*>, x: T) = Unit
}
var a1: Int by A()
var a1: Int by <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!><!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>A<!>()<!>
var a2: Int by A<String>()
class B<R>() {
@@ -16,7 +16,7 @@ class B<R>() {
}
var b1: Int by B()
var b2: Int by B<Number>()
var b2: Int by <!NEW_INFERENCE_ERROR, NEW_INFERENCE_ERROR!>B<Number>()<!>
class C<R>() {
operator fun getValue(t: Any?, p: KProperty<*>): R = null!!
@@ -24,4 +24,4 @@ class C<R>() {
}
var c1: Int by C()
var c2: Int by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, DELEGATE_SPECIAL_FUNCTION_RETURN_TYPE_MISMATCH, TYPE_MISMATCH!>C<Number>()<!>
var c2: Int by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, DELEGATE_SPECIAL_FUNCTION_RETURN_TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>C<Number>()<!>
compiler/testData/diagnostics/tests/delegatedProperty/inference/genericMethods.fir.kt
Vendored
+1 -1
View File
@@ -3,7 +3,7 @@
import kotlin.reflect.KProperty
var a: Int by A()
var a1 by A()
var a1 by <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>A()<!>
var b: Int by B()
compiler/testData/diagnostics/tests/delegatedProperty/inference/noErrorsForImplicitConstraints.fir.kt
Vendored
+2 -2
View File
@@ -3,8 +3,8 @@ package foo
import kotlin.reflect.KProperty
class A {
var a5: String by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>MyProperty1()<!>
var b5: String by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>getMyProperty1()<!>
var a5: String by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, NEW_INFERENCE_ERROR, NEW_INFERENCE_ERROR!>MyProperty1()<!>
var b5: String by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, NEW_INFERENCE_ERROR, NEW_INFERENCE_ERROR!>getMyProperty1()<!>
}
fun <A, B> getMyProperty1() = MyProperty1<A, B>()
compiler/testData/diagnostics/tests/delegatedProperty/inference/noExpectedTypeForSupertypeConstraint.fir.kt
Vendored
+1 -1
View File
@@ -2,7 +2,7 @@
import kotlin.reflect.KProperty
class A {
var a by MyProperty()
var a by <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!><!NEW_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 <!NEW_INFERENCE_ERROR, NEW_INFERENCE_ERROR, NEW_INFERENCE_ERROR!>MyProperty3()<!>
var b3: String by <!NEW_INFERENCE_ERROR, NEW_INFERENCE_ERROR, NEW_INFERENCE_ERROR!>getMyProperty3()<!>
}
var c3: String by getMyProperty3()
var d3: String by MyProperty3()
var c3: String by <!NEW_INFERENCE_ERROR, NEW_INFERENCE_ERROR, NEW_INFERENCE_ERROR!>getMyProperty3()<!>
var d3: String by <!NEW_INFERENCE_ERROR, NEW_INFERENCE_ERROR, NEW_INFERENCE_ERROR!>MyProperty3()<!>
fun <A> getMyProperty3() = MyProperty3<A>()
compiler/testData/diagnostics/tests/delegatedProperty/nonDefaultAccessors.kt
Vendored
+1 -1
View File
@@ -5,7 +5,7 @@ class A {
val p1 by this
get
var p2 by this
var p2 by <!NEW_INFERENCE_ERROR!>this<!>
<!ACCESSOR_FOR_DELEGATED_PROPERTY!>get() = ""<!>
operator fun getValue(a: Any?, p: Any?) = ""
compiler/testData/diagnostics/tests/delegatedProperty/propertyDefferedType.fir.kt
Vendored
+1 -1
View File
@@ -4,7 +4,7 @@
import kotlin.reflect.KProperty
class B {
val c by Delegate(<!ARGUMENT_TYPE_MISMATCH, UNRESOLVED_REFERENCE!>ag<!>)
val c by <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>Delegate(<!ARGUMENT_TYPE_MISMATCH, UNRESOLVED_REFERENCE!>ag<!>)<!>
}
class Delegate<T: Any>(val init: T) {
compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/hostAndReceiver2.fir.kt
Vendored
+2 -2
View File
@@ -8,6 +8,6 @@ object T2 {
operator fun <T> Foo<T>.provideDelegate(host: T2, p: Any?): Foo<T> = TODO()
operator fun <T> Foo<T>.getValue(receiver: String, p: Any?): T = TODO()
val String.test1: String by <!TYPE_MISMATCH!>delegate()<!>
val test2: String by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>delegate()<!>
val String.test1: String by <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>delegate<!>()
val test2: String by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, NEW_INFERENCE_ERROR!><!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>delegate<!>()<!>
}
compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/hostAndReceiver3.fir.kt
Vendored
+1 -1
View File
@@ -8,5 +8,5 @@ object T3 {
operator fun <T> Foo<T>.provideDelegate(host: T3, p: Any?): Foo<T> = TODO()
operator fun <T> Foo<T>.getValue(receiver: T3, p: Any?): T = TODO()
val test1: String by <!TYPE_MISMATCH!>delegate()<!>
val test1: String by <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>delegate<!>()
}
compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/inferenceFromReceiver2.fir.kt
Vendored
+1 -1
View File
@@ -8,6 +8,6 @@ object Inference2 {
operator fun <T> Foo<T>.provideDelegate(host: T, p: Any?): Foo<T> = TODO()
operator fun <T> Foo<T>.getValue(receiver: Inference2, p: Any?): String = TODO()
val test1: String by delegate() // same story like in Inference1
val test1: String by <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>delegate<!>() // same story like in Inference1
val test2: String by delegate<Inference2>()
}
compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/kt38714.fir.kt
Vendored
+1 -1
View File
@@ -4,7 +4,7 @@
import kotlin.reflect.KProperty
abstract class MainActivity : DIAware1() {
val bar: Bar by <!TYPE_MISMATCH!>instance1()<!>
val bar: Bar by <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>instance1<!>()
}
class Bar
compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/noOperatorModifierOnProvideDelegate.fir.kt
Vendored
+1 -1
View File
@@ -12,5 +12,5 @@ fun String.provideDelegate(a: Any?, p: KProperty<*>) = StringDelegate(this)
operator fun String.getValue(a: Any?, p: KProperty<*>) = this
val test1: String by "OK"
val test2: Int by <!DELEGATE_SPECIAL_FUNCTION_RETURN_TYPE_MISMATCH, TYPE_MISMATCH!>"OK"<!>
val test2: Int by <!DELEGATE_SPECIAL_FUNCTION_RETURN_TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>"OK"<!>
val test3 by "OK"
compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/provideDelegateResolutionWithStubTypes.fir.kt
Vendored
-9
View File
@@ -1,9 +0,0 @@
val test: String by <!TYPE_MISMATCH!>materializeDelegate()<!>
fun <T> materializeDelegate(): Delegate<T> = Delegate()
operator fun <K> K.provideDelegate(receiver: Any?, property: kotlin.reflect.KProperty<*>): K = this
class Delegate<V> {
operator fun getValue(thisRef: Any?, property: kotlin.reflect.KProperty<*>): V = TODO()
}
compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/provideDelegateResolutionWithStubTypes.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
val test: String by materializeDelegate()
fun <T> materializeDelegate(): Delegate<T> = Delegate()
compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/unsupportedOperatorProvideDelegate.fir.kt
Vendored
+1 -1
View File
@@ -9,6 +9,6 @@ operator fun String.provideDelegate(thisRef: Any?, prop: Any) = WrongDelegate(th
operator fun String.getValue(thisRef: Any?, prop: Any) = this
val test1: String by <!TYPE_MISMATCH!>"OK"<!>
val test1: String by <!TYPE_MISMATCH, TYPE_MISMATCH!>"OK"<!>
val test2: Int by "OK"
val test3 by "OK"
compiler/testData/diagnostics/tests/delegatedProperty/setterThisTypeMismatch.kt
Vendored
+2 -2
View File
@@ -4,10 +4,10 @@
import kotlin.reflect.KProperty
class D {
var c: Int by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>Delegate()<!>
var c: Int by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, NEW_INFERENCE_ERROR!>Delegate()<!>
}
var cTopLevel: Int by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>Delegate()<!>
var cTopLevel: Int by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, NEW_INFERENCE_ERROR!>Delegate()<!>
class A
compiler/testData/diagnostics/tests/delegatedProperty/setterWithSupertype.kt
Vendored
+1 -1
View File
@@ -6,7 +6,7 @@ import kotlin.reflect.KProperty
open class Base
class Derived: Base()
var a: Derived by A()
var a: Derived by <!NEW_INFERENCE_ERROR, NEW_INFERENCE_ERROR!>A()<!>
class A {
operator fun getValue(t: Any?, p: KProperty<*>): Derived {
compiler/testData/diagnostics/tests/delegatedProperty/typeMismatchForGetReturnType.fir.kt
Vendored
+1 -1
View File
@@ -2,7 +2,7 @@
import kotlin.reflect.KProperty
val c: Int by <!DELEGATE_SPECIAL_FUNCTION_RETURN_TYPE_MISMATCH, TYPE_MISMATCH!>Delegate()<!>
val c: Int by <!DELEGATE_SPECIAL_FUNCTION_RETURN_TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>Delegate()<!>
class Delegate {
operator fun getValue(t: Any?, p: KProperty<*>): String {
compiler/testData/diagnostics/tests/delegatedProperty/typeMismatchForSetParameter.kt
Vendored
+2 -2
View File
@@ -4,10 +4,10 @@
import kotlin.reflect.KProperty
class A {
var a: Int by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>Delegate()<!>
var a: Int by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, NEW_INFERENCE_ERROR!>Delegate()<!>
}
var aTopLevel: Int by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>Delegate()<!>
var aTopLevel: Int by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, NEW_INFERENCE_ERROR!>Delegate()<!>
class Delegate {
operator fun getValue(t: Any?, p: KProperty<*>): Int {
compiler/testData/diagnostics/tests/deprecated/typealiasConstructor.fir.kt
Vendored
+1 -1
View File
@@ -14,4 +14,4 @@ class Test1 : DeprecatedClassAlias()
class Test2 : WithDeprecatedCtorAlias()
val test3 = ArrayListOfDeprecatedClass()
val test3 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>ArrayListOfDeprecatedClass<!>()
compiler/testData/diagnostics/tests/functionAsExpression/NameDeprecation.fir.kt
Vendored
+1 -1
View File
@@ -5,5 +5,5 @@ fun foo() {
fun A.foo() {}
(fun A.foo() {})
run(<!ANONYMOUS_FUNCTION_WITH_NAME!>fun foo() {}<!>)
<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>run<!>(<!ANONYMOUS_FUNCTION_WITH_NAME!>fun foo() {}<!>)
}
compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/complexInference.fir.kt
Vendored
+4 -4
View File
@@ -29,10 +29,10 @@ fun bar(aInstance: A, bInstance: B) {
d checkType { _<Short>() }
}
foo(bInstance) {
<!COMPONENT_FUNCTION_MISSING, COMPONENT_FUNCTION_MISSING!>(a, b)<!>, (c, d) ->
a <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
b <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>(bInstance) {
<!CANNOT_INFER_PARAMETER_TYPE, COMPONENT_FUNCTION_MISSING, COMPONENT_FUNCTION_MISSING!>(a, b)<!>, (c, d) ->
a <!INAPPLICABLE_CANDIDATE!>checkType<!> { _<Int>() }
b <!INAPPLICABLE_CANDIDATE!>checkType<!> { _<String>() }
c checkType { _<Double>() }
d checkType { _<Short>() }
}
compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/fromSuperClasses.fir.kt
Vendored
+2 -2
View File
@@ -20,7 +20,7 @@ class A : Outer<Double, Short>() {
fun foo() {
Derived().foo() checkType { _<Outer<String, Int>.Inner<Char>>() }
Derived().baz() <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Map<Char, String>>() }
Derived().baz() <!INAPPLICABLE_CANDIDATE!>checkType<!> { _<Map<Char, String>>() }
A.B().bar() checkType { _<Outer<Float, Long>.Inner<String>>() }
A.B().x() <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Map<String, Float>>() }
A.B().x() <!INAPPLICABLE_CANDIDATE!>checkType<!> { _<Map<String, Float>>() }
}
compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/fromSuperClassesLocal.fir.kt
Vendored
+2 -2
View File
@@ -42,7 +42,7 @@ fun test() {
x = foobar<String>()
x().foo().a() checkType { <!INAPPLICABLE_CANDIDATE!>_<!><A<String, Double, Short, Long>>() }
x().bar() <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><A<String, Double, Short, Char>>() }
x().bar() <!INAPPLICABLE_CANDIDATE!>checkType<!> { _<A<String, Double, Short, Char>>() }
x = foobar<Int>()
@@ -50,5 +50,5 @@ fun test() {
y = noParameters()
y().foo().a() checkType { _<A<Any, Double, Short, Long>>() }
y().bar() <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><A<Any, Double, Short, Char>>() }
y().bar() <!INAPPLICABLE_CANDIDATE!>checkType<!> { _<A<Any, Double, Short, Char>>() }
}
compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/fromSuperClassesLocalInsideInner.fir.kt
Vendored
+2 -2
View File
@@ -43,7 +43,7 @@ class Outer<T> {
x = foobar<String>()
x().foo().a() checkType { <!INAPPLICABLE_CANDIDATE!>_<!><A<T, F, String, Double, Short, Long>>() }
x().bar() <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><A<T, F, String, Double, Short, Char>>() }
x().bar() <!INAPPLICABLE_CANDIDATE!>checkType<!> { _<A<T, F, String, Double, Short, Char>>() }
x = foobar<Int>()
x = z.foobar<String>()
@@ -52,7 +52,7 @@ class Outer<T> {
y = noParameters()
y().foo().a() checkType { _<A<T, F, Any, Double, Short, Long>>() }
y().bar() <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><A<T, F, Any, Double, Short, Char>>() }
y().bar() <!INAPPLICABLE_CANDIDATE!>checkType<!> { _<A<T, F, Any, Double, Short, Char>>() }
}
}
}
compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/fromSuperClassesTransitive.fir.kt
Vendored
+1 -1
View File
@@ -15,5 +15,5 @@ class Derived : BaseDerived2<Int>() {
fun foo() {
Derived().foo() checkType { _<Outer<Int, String>.Inner<Char>>() }
Derived().baz() <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Map<Char, Int>>() }
Derived().baz() <!INAPPLICABLE_CANDIDATE!>checkType<!> { _<Map<Char, Int>>() }
}
compiler/testData/diagnostics/tests/generics/kt30590.fir.kt
Vendored
+1 -1
View File
@@ -5,4 +5,4 @@ interface A
fun <T: A, R: T> emptyStrangeMap(): Map<T, R> = TODO()
fun test7() : Map<A, A> = emptyStrangeMap()
fun test() = emptyStrangeMap()
fun test() = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>emptyStrangeMap<!>()
compiler/testData/diagnostics/tests/generics/tpAsReified/InConstructor.fir.kt
Vendored
+1 -1
View File
@@ -3,7 +3,7 @@ class C<<!REIFIED_TYPE_PARAMETER_NO_INLINE!>reified<!> T>
fun <T> id(p: T): T = p
fun <A> main() {
C()
<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>C<!>()
val a: C<A> = C()
C<A>()
compiler/testData/diagnostics/tests/generics/tpAsReified/InFunction.fir.kt
Vendored
+1 -1
View File
@@ -9,7 +9,7 @@ inline fun <reified T> f(): T = throw UnsupportedOperationException()
fun <T> id(p: T): T = p
fun <A> main() {
f()
<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>f<!>()
val a: A = f()
f<A>()
compiler/testData/diagnostics/tests/generics/wrongNumberOfTypeArgumentsDiagnostic.fir.kt
Vendored
+3 -3
View File
@@ -9,7 +9,7 @@ fun test1() {
}
fun test2() {
val m0 = java.util.HashMap()
val m1 = java.util.<!INAPPLICABLE_CANDIDATE!>HashMap<!><String, String, String>()
val m2 = java.util.<!INAPPLICABLE_CANDIDATE!>HashMap<!><String>()
val m0 = java.util.<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>HashMap<!>()
val m1 = java.util.<!INAPPLICABLE_CANDIDATE!>HashMap<!><<!CANNOT_INFER_PARAMETER_TYPE!>String<!>, <!CANNOT_INFER_PARAMETER_TYPE!>String<!>, String>()
val m2 = java.util.<!INAPPLICABLE_CANDIDATE!>HashMap<!><<!CANNOT_INFER_PARAMETER_TYPE!>String<!>>()
}
compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/noTypeParamsInReturnType.fir.kt
Vendored
+1 -1
View File
@@ -5,5 +5,5 @@ fun <T, R> foo(map: Map<T, R>) : R = throw Exception()
fun <F, G> getMap() : Map<F, G> = throw Exception()
fun bar123() {
foo(<!TOO_MANY_ARGUMENTS!>getMap<!>(
<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>(<!TOO_MANY_ARGUMENTS!>getMap<!>(
<!SYNTAX!><!>}
compiler/testData/diagnostics/tests/inference/builderInference/simpleLambdaInCallWithAnotherLambdaWithBuilderInference.fir.kt
Vendored
+2 -2
View File
@@ -14,7 +14,7 @@ interface TestInterface<R> {
}
fun test() {
val ret = combined({ }) {
emit(<!ARGUMENT_TYPE_MISMATCH!>1<!>)
val ret = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>combined<!>({ }) {
emit(1)
}
}
compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferences.fir.kt
Vendored
+4 -4
View File
@@ -80,7 +80,7 @@ fun poll05(): Flow<String> {
fun poll06(): Flow<String> {
return flow {
val inv = select(foo7(), ::Foo7)
val inv = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>select<!>(foo7(), ::Foo7)
inv
}
}
@@ -479,21 +479,21 @@ fun poll85(): Flow<String> {
fun poll86(): Flow<String> {
return flow {
val inv = <!NEW_INFERENCE_ERROR!>::Foo7 in <!NEW_INFERENCE_ERROR!>setOf(::Foo7)<!><!>
val inv = ::Foo7 <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>in<!> <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>setOf<!>(::Foo7)
inv
}
}
fun poll87(): Flow<String> {
return flow {
val inv = ::Foo7 in setOf(foo7())
val inv = ::Foo7 <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>in<!> setOf(foo7())
inv
}
}
fun poll88(): Flow<String> {
return flow {
val inv = foo7() in <!NEW_INFERENCE_ERROR!>setOf(::Foo7)<!>
val inv = foo7() in <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>setOf<!>(::Foo7)
inv
}
}
compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesUnrestricted.fir.kt
Vendored
+4 -4
View File
@@ -81,7 +81,7 @@ fun poll05(): Flow<String> {
fun poll06(): Flow<String> {
return flow {
val inv = select(foo7(), ::Foo7)
val inv = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>select<!>(foo7(), ::Foo7)
inv
}
}
@@ -480,21 +480,21 @@ fun poll85(): Flow<String> {
fun poll86(): Flow<String> {
return flow {
val inv = <!NEW_INFERENCE_ERROR!>::Foo7 in <!NEW_INFERENCE_ERROR!>setOf(::Foo7)<!><!>
val inv = ::Foo7 <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>in<!> <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>setOf<!>(::Foo7)
inv
}
}
fun poll87(): Flow<String> {
return flow {
val inv = ::Foo7 in setOf(foo7())
val inv = ::Foo7 <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>in<!> setOf(foo7())
inv
}
}
fun poll88(): Flow<String> {
return flow {
val inv = foo7() in <!NEW_INFERENCE_ERROR!>setOf(::Foo7)<!>
val inv = foo7() in <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>setOf<!>(::Foo7)
inv
}
}
compiler/testData/diagnostics/tests/inference/capturedTypes/substituteCapturedTypesWithTypeVariables.fir.kt
Vendored
+12
View File
@@ -0,0 +1,12 @@
// !DIAGNOSTICS: -CAST_NEVER_SUCCEEDS -UNUSED_PARAMETER
class Foo<K>
fun <T> getFoo(value: T) = null as Foo<out Foo<T>>
fun <R> takeLambda(block: () -> R) {}
fun main(x: Int) {
<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>takeLambda<!> {
getFoo(x)
}
}
compiler/testData/diagnostics/tests/inference/capturedTypes/substituteCapturedTypesWithTypeVariables.kt
Vendored
+1 -2
View File
@@ -1,4 +1,3 @@
// FIR_IDENTICAL
// !DIAGNOSTICS: -CAST_NEVER_SUCCEEDS -UNUSED_PARAMETER
class Foo<K>
@@ -10,4 +9,4 @@ fun main(x: Int) {
takeLambda {
getFoo(x)
}
}
}
compiler/testData/diagnostics/tests/inference/coercionToUnit/coercionWithoutExpectedType.fir.kt
Vendored
+1 -1
View File
@@ -13,6 +13,6 @@ fun implicitCoercion() {
val c = l@{
// Error: block doesn't have an expected type, so call can't be inferred!
return@l materialize()
return@l <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>materialize<!>()
}
}
compiler/testData/diagnostics/tests/inference/coercionToUnit/coersionWithAnonymousFunctionsAndUnresolved.fir.kt
Vendored
+1 -1
View File
@@ -53,7 +53,7 @@ fun testParameter() {
takeFnToParameter { Unit }
takeFnToParameter { <!ARGUMENT_TYPE_MISMATCH!><!UNRESOLVED_REFERENCE!>unresolved<!>()<!> }
takeFnToParameter { if (true) <!UNRESOLVED_REFERENCE!>unresolved<!>() }
takeFnToParameter {
<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>takeFnToParameter<!> {
if (true) <!UNRESOLVED_REFERENCE!>unresolved<!>() else <!UNRESOLVED_REFERENCE!>unresolved<!>()
}
takeFnToParameter(fun() = Unit)
compiler/testData/diagnostics/tests/inference/completion/basic.fir.kt
Vendored
+1 -1
View File
@@ -57,7 +57,7 @@ fun test7(cls: Cls) {
}
fun test8(cls: Cls) {
id(
<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>id<!>(
wrapIn(cls)
)
}
compiler/testData/diagnostics/tests/inference/completion/postponedArgumentsAnalysis/basic.fir.kt
Vendored
+5 -5
View File
@@ -78,11 +78,11 @@ fun main() {
// Interdependent lambdas by input-output types aren't supported
takeInterdependentLambdas({}, {})
takeInterdependentLambdas({ it }, { <!ARGUMENT_TYPE_MISMATCH!>10<!> })
takeInterdependentLambdas({ <!ARGUMENT_TYPE_MISMATCH!>10<!> }, { it })
takeInterdependentLambdas({ <!ARGUMENT_TYPE_MISMATCH!>10<!> }, { x -> x })
takeInterdependentLambdas({ x -> <!ARGUMENT_TYPE_MISMATCH!>10<!> }, { it })
takeInterdependentLambdas({ it }, { x -> <!ARGUMENT_TYPE_MISMATCH!>10<!> })
<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>takeInterdependentLambdas<!>({ it }, { 10 })
<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>takeInterdependentLambdas<!>({ 10 }, { it })
<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>takeInterdependentLambdas<!>({ 10 }, { <!CANNOT_INFER_PARAMETER_TYPE!>x<!> -> x })
<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>takeInterdependentLambdas<!>({ <!CANNOT_INFER_PARAMETER_TYPE!>x<!> -> 10 }, { it })
<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>takeInterdependentLambdas<!>({ it }, { <!CANNOT_INFER_PARAMETER_TYPE!>x<!> -> 10 })
// Dependent lambdas by input-output types
takeDependentLambdas({ <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int")!>it<!> }, { it })
compiler/testData/diagnostics/tests/inference/completion/postponedArgumentsAnalysis/notInferableParameterOfAnonymousFunction.fir.kt
Vendored
+3 -3
View File
@@ -1,13 +1,13 @@
// !DIAGNOSTICS: -UNUSED_ANONYMOUS_PARAMETER -UNUSED_VARIABLE
fun <T> select(vararg x: T) = x[0]
fun <T> select(vararg x: <!CANNOT_INFER_PARAMETER_TYPE, CANNOT_INFER_PARAMETER_TYPE!>T<!>) = x[0]
fun <K> id(x: K) = x
fun main() {
val x1 = select<Any?>(id { x, y -> }, { x: Int, y -> })
val x2 = <!NEW_INFERENCE_ERROR!>select(id { x, y -> }, { x: Int, y -> })<!>
val x2 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>select<!>(id { x, y -> }, { x: Int, y -> })
val x3 = <!NEW_INFERENCE_ERROR!>select(id(fun (x, y) {}), fun (x: Int, y) {})<!>
val x3 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>select<!>(id(fun (x, y) {}), fun (x: Int, y) {})
val x4 = select<Any?>((fun (x, y) {}), fun (x: Int, y) {})
val x5 = select<Any?>(id(fun (x, y) {}), fun (x: Int, y) {})
compiler/testData/diagnostics/tests/inference/constraints/constraintFromVariantTypeWithNestedProjection.fir.kt
Vendored
+1 -1
View File
@@ -10,6 +10,6 @@ fun <R> choose3(c: Inv<Inv<R>>) {}
fun f(o: Out<Out<*>>, i: In<In<*>>, inv: Inv<Inv<*>>) {
choose1(o)
choose2(i)
<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>choose2<!>(i)
choose3(<!ARGUMENT_TYPE_MISMATCH!>inv<!>)
}
compiler/testData/diagnostics/tests/inference/constraints/definitelyNotNullTypeInArguments.fir.kt
Vendored
+2 -2
View File
@@ -114,8 +114,8 @@ fun <L> main(x: L?, y: L) {
foo16(y, Bar())
}
Bar().foo18(x)
Bar().foo18(y)
<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>Bar<!>().foo18(x)
<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>Bar<!>().foo18(y)
foo21(x, Foo(Foo(OutBar())))
foo21(y, Foo(Foo(OutBar())))
compiler/testData/diagnostics/tests/inference/constraints/definitelyNotNullTypeInReturnPosition.fir.kt
Vendored
+6 -6
View File
@@ -164,11 +164,11 @@ class Main<L>(x: L?, y: L) {
val x170 = foo17(x)
val x171 = foo17(y)
val x180 = Bar().<!UNRESOLVED_REFERENCE!>foo18<!>(x)
val x181 = Bar().<!UNRESOLVED_REFERENCE!>foo18<!>(y)
val x180 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>Bar<!>().<!UNRESOLVED_REFERENCE!>foo18<!>(x)
val x181 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>Bar<!>().<!UNRESOLVED_REFERENCE!>foo18<!>(y)
val x200: L = Bar().<!UNRESOLVED_REFERENCE!>foo19<!>()
val x201: L = Bar().<!UNRESOLVED_REFERENCE!>foo19<!>()
val x200: L = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>Bar<!>().<!UNRESOLVED_REFERENCE!>foo19<!>()
val x201: L = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>Bar<!>().<!UNRESOLVED_REFERENCE!>foo19<!>()
val x210 = foo21(x)
val x211 = foo21(y)
@@ -262,8 +262,8 @@ class Main<L>(x: L?, y: L) {
val x471 = foo47(y)
fun <R> takeLambda(block: () -> R): R = materialize()
val x480 = <!NEW_INFERENCE_ERROR!>takeLambda { foo48 { <!ARGUMENT_TYPE_MISMATCH!>x<!> } }<!>
val x481 = <!NEW_INFERENCE_ERROR!>takeLambda { foo48 { <!ARGUMENT_TYPE_MISMATCH!>y<!> } }<!>
val x480 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>takeLambda<!> { foo48 { <!ARGUMENT_TYPE_MISMATCH!>x<!> } }
val x481 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>takeLambda<!> { foo48 { <!ARGUMENT_TYPE_MISMATCH!>y<!> } }
val x482 = takeLambda { foo48 { null } }
}
compiler/testData/diagnostics/tests/inference/constraints/errorUpperBoundConstraint.fir.kt
Vendored
+2 -2
View File
@@ -20,7 +20,7 @@ public class Foo {
// FILE: test.kt
fun test(e: <!UNRESOLVED_REFERENCE!>ErrorType<!>) {
Foo.foo {
Foo.<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!> {
Sam.Result.create(<!ARGUMENT_TYPE_MISMATCH!>e<!>)
}
}
}
compiler/testData/diagnostics/tests/inference/constraints/kt8879.fir.kt
Vendored
+1 -1
View File
@@ -8,5 +8,5 @@ fun <T: Inv2<T>> foo(klass: Inv<T>): String? = null
fun <X> bar(): Inv<X> = null!!
fun test() {
<!NEW_INFERENCE_ERROR!>foo(bar())<!>
<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>(bar())
}
compiler/testData/diagnostics/tests/inference/errorsOnImplicitInvokeInSimpleCall.fir.kt
Vendored
+2 -2
View File
@@ -1,4 +1,4 @@
inline operator fun <reified T> Int.invoke() = this
val a2 = 1()
val a3 = 1.invoke()
val a2 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>1()<!>
val a3 = 1.<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>invoke<!>()
compiler/testData/diagnostics/tests/inference/expectedTypeAdditionalTest.fir.kt
Vendored
+1 -1
View File
@@ -6,7 +6,7 @@ fun <T> foo() = foo() as T
fun <T> foo2(): T = TODO()
val test = foo2().plus("") <!USELESS_CAST!>as String<!>
val test = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo2<!>().plus("") <!USELESS_CAST!>as String<!>
fun <T> T.bar() = this
val barTest = "".bar() as Number
compiler/testData/diagnostics/tests/inference/expectedTypeDoubleReceiver.fir.kt
Vendored
+6 -7
View File
@@ -8,12 +8,11 @@ class A {
fun <V> id(value: V) = value
val asA = foo().<!UNRESOLVED_REFERENCE!>fooA<!>() as A
val asA = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>().<!UNRESOLVED_REFERENCE!>fooA<!>() as A
val receiverParenthesized = (foo()).<!UNRESOLVED_REFERENCE!>fooA<!>() as A
val no2A = A().fooA().<!UNRESOLVED_REFERENCE!>fooA<!>() as A
val correct1 = A().fooA() as A
val correct2 = foo<A>().fooA() as A
val correct3 = A().fooA<A>().fooA() as A
val receiverParenthesized = (<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>()).<!UNRESOLVED_REFERENCE!>fooA<!>() as A
val no2A = A().<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>fooA<!>().<!UNRESOLVED_REFERENCE!>fooA<!>() as A
val correct1 = A().<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>fooA<!>() as A
val correct2 = foo<A>().<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>fooA<!>() as A
val correct3 = A().fooA<A>().<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>fooA<!>() as A
compiler/testData/diagnostics/tests/inference/expectedTypeFromCast.fir.kt
Vendored
+8 -8
View File
@@ -4,17 +4,17 @@ fun <T> foo(): T = TODO()
fun <V> id(value: V) = value
val asString = foo() as String
val asString = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>() as String
val viaId = id(foo()) as String
val viaId = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>id<!>(foo()) as String
val insideId = id(foo() as String)
val insideId = id(<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>() as String)
val asList = foo() as List<String>
val asList = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>() as List<String>
val asStarList = foo() as List<*>
val asStarList = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>() as List<*>
val safeAs = foo() as? String
val safeAs = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>() as? String
val fromIs = <!USELESS_IS_CHECK!>foo() is String<!>
val fromNoIs = <!USELESS_IS_CHECK!>foo() !is String<!>
val fromIs = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>() is String
val fromNoIs = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>() !is String
compiler/testData/diagnostics/tests/inference/expectedTypeFromCastComplexExpression.kt
Vendored
+3 -4
View File
@@ -11,7 +11,6 @@ class A {
}
}
val x = A().foo() as String
val y = A.foo2() as String
val z = pp.A.foo2() as String
val x = A().<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>() as String
val y = A.<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo2<!>() as String
val z = pp.A.<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo2<!>() as String
compiler/testData/diagnostics/tests/inference/expectedTypeFromCastParenthesized.fir.kt
Vendored
+5 -5
View File
@@ -8,15 +8,15 @@ fun <T> foo(): T = TODO()
fun <V> id(value: V) = value
val par1 = (foo()) as String
val par2 = ((foo())) as String
val par1 = (<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>()) as String
val par2 = ((<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>())) as String
val par3 = (dd@ (foo())) as String
val par3 = (dd@ (<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>())) as String
val par4 = ( @bar() (foo())) as String
val par4 = ( @bar() (<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>())) as String
object X {
fun <T> foo(): T = TODO()
}
val par5 = ( @bar() X.foo()) as String
val par5 = ( @bar() X.<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>()) as String
compiler/testData/diagnostics/tests/inference/expectedTypeWithGenerics.fir.kt
Vendored
+3 -3
View File
@@ -5,13 +5,13 @@ class X<S> {
}
fun test(x: X<Number>) {
val y = x.foo() as Int
val y = x.<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>() as Int
}
fun <S, D: S> g() {
fun <T : S> foo(): T = TODO()
val y = foo() as Int
val y = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>() as Int
val y2 = foo() as D
val y2 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>() as D
}
compiler/testData/diagnostics/tests/inference/findViewById.kt
Vendored
+8 -8
View File
@@ -25,35 +25,35 @@ class X : View()
class Y<T> : View()
val xExplicit: X = Test().findViewById(0)
val xCast = Test().findViewById(0) as X
val xCast = Test().<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>findViewById<!>(0) as X
val xCastExplicitType = Test().findViewById<X>(0) as X
val xSafeCastExplicitType = Test().findViewById<X>(0) <!USELESS_CAST!>as? X<!>
val yExplicit: Y<String> = Test().findViewById(0)
val yCast = Test().findViewById(0) as Y<String>
val yCast = Test().<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>findViewById<!>(0) as Y<String>
class TestChild : Test() {
val xExplicit: X = findViewById(0)
val xCast = findViewById(0) as X
val xCast = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>findViewById<!>(0) as X
val yExplicit: Y<String> = findViewById(0)
val yCast = findViewById(0) as Y<String>
val yCast = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>findViewById<!>(0) as Y<String>
}
fun test(t: Test) {
val xExplicit: X = t.findViewById(0)
val xCast = t.findViewById(0) as X
val xCast = t.<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>findViewById<!>(0) as X
val yExplicit: Y<String> = t.findViewById(0)
val yCast = t.findViewById(0) as Y<String>
val yCast = t.<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>findViewById<!>(0) as Y<String>
}
fun test2(t: Test?) {
val xSafeCallSafeCast = t?.findViewById(0) as? X
val xSafeCallSafeCast = t?.<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>findViewById<!>(0) as? X
val xSafeCallSafeCastExplicitType = t?.findViewById<X>(0) <!USELESS_CAST!>as? X<!>
val xSafeCallCast = t?.findViewById(0) as X
val xSafeCallCast = t?.<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>findViewById<!>(0) as X
val xSafeCallCastExplicitType = t<!UNNECESSARY_SAFE_CALL!>?.<!>findViewById<X>(0) as X
}
compiler/testData/diagnostics/tests/inference/functionPlaceholderError.fir.kt
Vendored
+1 -1
View File
@@ -12,5 +12,5 @@ fun test() {
val q = foo(fun Int.() {}, emptyList()) //type inference no information for parameter error
checkSubtype<Int>(q)
foo({}, emptyList())
<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>({}, emptyList())
}
compiler/testData/diagnostics/tests/inference/kt28654.fir.kt
Vendored
+1 -1
View File
@@ -5,5 +5,5 @@ fun <K> select(): K = <!RETURN_TYPE_MISMATCH, TYPE_MISMATCH!>run { }<!>
fun test() {
val x: Int = select()
val t = select()
val t = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>select<!>()
}
compiler/testData/diagnostics/tests/inference/kt30405.kt
Vendored
+3 -3
View File
@@ -8,9 +8,9 @@ inline fun <reified T> foo(): T {
}
fun test() {
val fooCall = foo() as String // T in foo should be inferred to String
val fooCall = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>() as String // T in foo should be inferred to String
fooCall checkType { _<String>() }
val safeFooCall = foo() as? String
val safeFooCall = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>() as? String
safeFooCall checkType { _<String?>() }
}
}
compiler/testData/diagnostics/tests/inference/kt39220.fir.kt
Vendored
+2 -2
View File
@@ -86,12 +86,12 @@ fun <T : Foo, R: Number, D: Int> main() {
// with LHS and conflicting projection
bar2<T>(Foo::<!OVERLOAD_RESOLUTION_AMBIGUITY!>resolve<!>)
bar2<Foo>(Foo::<!OVERLOAD_RESOLUTION_AMBIGUITY!>resolve<!>)
bar2(Foo::<!OVERLOAD_RESOLUTION_AMBIGUITY!>resolve<!>)
<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>bar2<!>(Foo::<!OVERLOAD_RESOLUTION_AMBIGUITY!>resolve<!>)
// with LHS and Any? expected type
bar3<T>(Foo::<!OVERLOAD_RESOLUTION_AMBIGUITY!>resolve<!>)
bar3<Foo>(Foo::<!OVERLOAD_RESOLUTION_AMBIGUITY!>resolve<!>)
bar3(Foo::<!OVERLOAD_RESOLUTION_AMBIGUITY!>resolve<!>)
<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>bar3<!>(Foo::<!OVERLOAD_RESOLUTION_AMBIGUITY!>resolve<!>)
// with LHS and `Function` expected type
bar4<T>(Foo::resolve) // ERROR before the fix in NI
compiler/testData/diagnostics/tests/inference/kt40396.fir.kt
Vendored
+2 -2
View File
@@ -8,6 +8,6 @@ class Foo<K> {
}
class Bar {
val bar = foo {}
val bar = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!> {}
val baz = foo<Int> {}
}
}
compiler/testData/diagnostics/tests/inference/kt6175.fir.kt
Vendored
+16 -16
View File
@@ -3,11 +3,11 @@
fun <T, R : Any> foo(body: (R?) -> T): T = fail()
fun test1() {
foo {
<!ARGUMENT_TYPE_MISMATCH!>true<!>
<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!> {
true
}
foo { x ->
<!ARGUMENT_TYPE_MISMATCH!>true<!>
<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!> { <!CANNOT_INFER_PARAMETER_TYPE!>x<!> ->
true
}
}
@@ -15,33 +15,33 @@ fun test1() {
fun <T, R> bar(body: (R) -> T): T = fail()
fun test2() {
bar {
<!ARGUMENT_TYPE_MISMATCH!>true<!>
<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>bar<!> {
true
}
bar { x ->
<!ARGUMENT_TYPE_MISMATCH!>true<!>
<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>bar<!> { <!CANNOT_INFER_PARAMETER_TYPE!>x<!> ->
true
}
}
fun <T, R> baz(body: (List<R>) -> T): T = fail()
fun test3() {
baz {
<!ARGUMENT_TYPE_MISMATCH!>true<!>
<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>baz<!> {
true
}
baz { x ->
<!ARGUMENT_TYPE_MISMATCH!>true<!>
<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>baz<!> { x ->
true
}
}
fun <T, R : Any> brr(body: (List<R?>) -> T): T = fail()
fun test4() {
brr {
<!ARGUMENT_TYPE_MISMATCH!>true<!>
<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>brr<!> {
true
}
brr { x ->
<!ARGUMENT_TYPE_MISMATCH!>true<!>
<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>brr<!> { x ->
true
}
}
compiler/testData/diagnostics/tests/inference/nestedCalls/binaryExpressions.fir.kt
Vendored
+8 -8
View File
@@ -13,7 +13,7 @@ fun <T> id(t: T): T = t
infix fun <T> Z.foo(a: A<T>): A<T> = a
fun test(z: Z) {
z foo newA()
z <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!> newA()
val a: A<Int> = id(z foo newA())
val b: A<Int> = id(z.foo(newA()))
use(a, b)
@@ -23,7 +23,7 @@ fun test(z: Z) {
operator fun <T> Z.plus(a: A<T>): A<T> = a
fun test1(z: Z) {
<!NEW_INFERENCE_ERROR!>id(z + newA())<!>
<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>id<!>(z + newA())
val a: A<Z> = z + newA()
val b: A<Z> = z.plus(newA())
val c: A<Z> = id(z + newA())
@@ -35,7 +35,7 @@ fun test1(z: Z) {
operator fun <T> Z.compareTo(a: A<T>): Int { use(a); return 1 }
fun test2(z: Z) {
val a: Boolean = id(z < newA())
val a: Boolean = id(z <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!><<!> newA())
val b: Boolean = id(z < newA<Z>())
use(a, b)
}
@@ -44,18 +44,18 @@ fun test2(z: Z) {
fun Z.equals(any: Any): Int { use(any); return 1 }
fun test3(z: Z) {
z == newA()
z == <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>newA<!>()
z == newA<Z>()
id(z == newA())
id(z == <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>newA<!>())
id(z == newA<Z>())
id(z === newA())
id(z === <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>newA<!>())
id(z === newA<Z>())
}
//'in' operation
fun test4(collection: Collection<A<*>>) {
id(newA() in collection)
id(newA() <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>in<!> collection)
id(newA<Int>() in collection)
}
@@ -63,7 +63,7 @@ fun test4(collection: Collection<A<*>>) {
fun <T> toBeOrNot(): Boolean = throw Exception()
fun test5() {
if (toBeOrNot() && toBeOrNot()) {}
if (<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>toBeOrNot<!>() && <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>toBeOrNot<!>()) {}
if (toBeOrNot<Int>() && toBeOrNot<Int>()) {}
}
compiler/testData/diagnostics/tests/inference/nonFunctionalExpectedTypeForLambdaArgument.fir.kt
Vendored
+1 -1
View File
@@ -19,7 +19,7 @@ fun testAnyCall() {
}
fun testParam() {
callParam {
<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>callParam<!> {
param -> param
}
}
compiler/testData/diagnostics/tests/inference/nothingType/implicitInferenceTToFlexibleNothing.fir.kt
Vendored
+1 -1
View File
@@ -7,5 +7,5 @@ import java.util.*
fun <T> foo (f: () -> List<T>): T = null as T
fun main() {
val x = foo { Collections.emptyList() }
val x = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!> { Collections.emptyList() }
}
compiler/testData/diagnostics/tests/inference/nothingType/kt34335.fir.kt
Vendored
+1 -1
View File
@@ -14,5 +14,5 @@ fun test1() {
}
fun test2() {
::foo.call({ x -> println(x::class) })
::foo.<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>call<!>({ x -> println(x::class) })
}
compiler/testData/diagnostics/tests/inference/nothingType/notEnoughInformationAndNothing.fir.kt
Vendored
+6 -6
View File
@@ -5,7 +5,7 @@
class Inv<I>
fun <T> materialize(): Inv<T> = TODO()
fun <K> id(arg: K) = arg
fun <S> select(vararg args: S): S = TODO()
fun <S> select(vararg args: <!CANNOT_INFER_PARAMETER_TYPE, CANNOT_INFER_PARAMETER_TYPE!>S<!>): S = TODO()
fun test1(b: Boolean?) {
val v = when(b) {
@@ -17,20 +17,20 @@ fun test1(b: Boolean?) {
}
fun test2() {
<!NEW_INFERENCE_ERROR!>select(
<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>select<!>(
materialize()
)<!>
)
select(materialize(), materialize<String>())
select(materialize(), null, Inv<String>())
<!NEW_INFERENCE_ERROR!>select(
materialize(),
null
)<!>
<!NEW_INFERENCE_ERROR!>select(
<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>select<!>(
materialize(),
materialize()
)<!>
select(
)
<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>select<!>(
materialize(),
materialize(),
null
compiler/testData/diagnostics/tests/inference/nothingType/notEnoughInformationFromNullabilityConstraint.fir.kt
Vendored
+1 -1
View File
@@ -5,7 +5,7 @@ fun <I> id(arg: I): I = arg
fun <S> select(vararg args: S): S = TODO()
fun test() {
id(
<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>id<!>(
make()
)

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