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

[FIR] Improve diagnostic reporting & don't use error symbol for candidate if possible

Browse Source 
Also introduce few new diagnostics:
- NONE_APPLICABLE more many inapplicable candidates
- HIDDEN for visible candidates
This commit is contained in:
Dmitriy Novozhilov
2020-07-22 16:40:14 +03:00
committed by Mikhail Glukhikh
parent 5c0528b61e
commit f283f2db43
365 changed files with 1400 additions and 1451 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/testData/diagnostics/tests/BinaryCallsOnNullableValues.fir.kt
Vendored
+4 -4
View File
@@ -6,9 +6,9 @@ class A() {
fun f(): Unit {
var x: Int? = 1
x = null
x <!INAPPLICABLE_CANDIDATE!>+<!> 1
x <!INAPPLICABLE_CANDIDATE!>plus<!> 1
x <!INAPPLICABLE_CANDIDATE!><<!> 1
x <!NONE_APPLICABLE!>+<!> 1
x <!NONE_APPLICABLE!>plus<!> 1
x <!NONE_APPLICABLE!><<!> 1
<!UNRESOLVED_REFERENCE!>x += 1<!>
x == 1
@@ -22,7 +22,7 @@ fun f(): Unit {
x === 1
x !== 1
x<!INAPPLICABLE_CANDIDATE!>..<!>2
x<!NONE_APPLICABLE!>..<!>2
x <!INAPPLICABLE_CANDIDATE!>in<!> 1..2
val y : Boolean? = true
compiler/testData/diagnostics/tests/ConstructorsOfPrimitives.fir.kt
Vendored
+2 -2
View File
@@ -5,6 +5,6 @@ fun test() {
<!INAPPLICABLE_CANDIDATE!>Int<!>()
<!INAPPLICABLE_CANDIDATE!>Short<!>()
<!INAPPLICABLE_CANDIDATE!>Byte<!>()
<!INAPPLICABLE_CANDIDATE!>Char<!>()
<!HIDDEN!>Char<!>()
<!INAPPLICABLE_CANDIDATE!>Boolean<!>()
}
}
compiler/testData/diagnostics/tests/DeprecatedGetSetPropertyDelegateConvention.fir.kt
Vendored
+2 -2
View File
@@ -40,8 +40,8 @@ class Example {
var d by CustomDelegate3()
fun test() {
requireString(a)
requireString(aval)
<!INAPPLICABLE_CANDIDATE!>requireString<!>(a)
<!INAPPLICABLE_CANDIDATE!>requireString<!>(aval)
requireString(b)
requireInt(c)
requireInt(d)
compiler/testData/diagnostics/tests/DeprecatedUnaryOperatorConventions.fir.kt
Vendored
+1 -1
View File
@@ -16,7 +16,7 @@ operator fun String.unaryPlus(): Int = 0
fun test() {
requireInt(+ "")
requireInt(+ Example())
requireString(<!INAPPLICABLE_CANDIDATE!>+<!> ExampleDeprecated())
<!INAPPLICABLE_CANDIDATE!>requireString<!>(<!INAPPLICABLE_CANDIDATE!>+<!> ExampleDeprecated())
}
fun requireInt(n: Int) {}
compiler/testData/diagnostics/tests/Nullability.fir.kt
Vendored
+4 -4
View File
@@ -38,7 +38,7 @@ fun test() {
if (out != null && ins != null || out != null) {
ins?.read();
ins.<!INAPPLICABLE_CANDIDATE!>read<!>();
ins.<!NONE_APPLICABLE!>read<!>();
out.println();
}
@@ -114,12 +114,12 @@ fun test() {
}
else {
out?.println();
out.<!INAPPLICABLE_CANDIDATE!>println<!>();
out.<!NONE_APPLICABLE!>println<!>();
}
if (out == null || out.println() == Unit) {
out?.println();
out.<!INAPPLICABLE_CANDIDATE!>println<!>();
out.<!NONE_APPLICABLE!>println<!>();
}
else {
out.println();
@@ -149,7 +149,7 @@ fun test() {
while (out2 == null) {
out2?.println();
out2.<!INAPPLICABLE_CANDIDATE!>println<!>();
out2.<!NONE_APPLICABLE!>println<!>();
}
out2.println()
compiler/testData/diagnostics/tests/ObjectWithConstructor.fir.kt
Vendored
+3 -3
View File
@@ -1,11 +1,11 @@
object A1<!CONSTRUCTOR_IN_OBJECT!>()<!> {
<!CONSTRUCTOR_IN_OBJECT!>constructor(x: Int = "", y: Int)<!> : <!INAPPLICABLE_CANDIDATE!>this<!>() {
<!CONSTRUCTOR_IN_OBJECT!>constructor(x: Int = "", y: Int)<!> : <!NONE_APPLICABLE!>this<!>() {
x + y
}
}
object A2 public <!CONSTRUCTOR_IN_OBJECT!>constructor(private val prop: Int)<!> {
<!CONSTRUCTOR_IN_OBJECT!>constructor(x: Int = "", y: Int)<!> : <!INAPPLICABLE_CANDIDATE!>this<!>(x * y) {
<!CONSTRUCTOR_IN_OBJECT!>constructor(x: Int = "", y: Int)<!> : <!NONE_APPLICABLE!>this<!>(x * y) {
x + y
}
}
@@ -19,6 +19,6 @@ val x = object <!CONSTRUCTOR_IN_OBJECT!>(val prop: Int)<!> {
class A3 {
companion object B<!CONSTRUCTOR_IN_OBJECT!>(val prop: Int)<!> {
public <!CONSTRUCTOR_IN_OBJECT!>constructor()<!> : <!INAPPLICABLE_CANDIDATE!>this<!>(2)
public <!CONSTRUCTOR_IN_OBJECT!>constructor()<!> : <!NONE_APPLICABLE!>this<!>(2)
}
}
compiler/testData/diagnostics/tests/PackageInExpressionPosition.fir.kt
Vendored
+2 -2
View File
@@ -19,8 +19,8 @@ fun main() {
java.lang.System = null
java.lang.System!!
System is Int
<!INAPPLICABLE_CANDIDATE!>System<!>()
<!HIDDEN!>System<!>()
(System)
foo@ System
null <!UNRESOLVED_REFERENCE!>in<!> System
}
}
compiler/testData/diagnostics/tests/PrivateFromOuterPackage.fir.kt
Vendored
+5 -5
View File
@@ -10,8 +10,8 @@ package outer.p1
import outer.a
fun use() {
<!INAPPLICABLE_CANDIDATE!>a<!>()
outer.<!INAPPLICABLE_CANDIDATE!>B<!>()
<!HIDDEN!>a<!>()
outer.<!HIDDEN!>B<!>()
}
// FILE: c.kt
@@ -20,6 +20,6 @@ package outer.p1.p2
import outer.a
fun use() {
<!INAPPLICABLE_CANDIDATE!>a<!>()
outer.<!INAPPLICABLE_CANDIDATE!>B<!>()
}
<!HIDDEN!>a<!>()
outer.<!HIDDEN!>B<!>()
}
compiler/testData/diagnostics/tests/annotations/annotationRenderingInTypes.fir.kt
Vendored
+1 -1
View File
@@ -4,7 +4,7 @@
fun f1(x: String) {}
fun f2(f: () -> Unit) {}
fun test1() = <!INAPPLICABLE_CANDIDATE!>f2<!>(::f1)
fun test1() = <!INAPPLICABLE_CANDIDATE!>f2<!>(<!UNRESOLVED_REFERENCE!>::f1<!>)
@Target(AnnotationTarget.TYPE_PARAMETER, AnnotationTarget.TYPE)
compiler/testData/diagnostics/tests/callableReference/compatibilityResolveWithVarargAndOperatorCall.fir.kt
Vendored
-18
View File
@@ -1,18 +0,0 @@
// !DIAGNOSTICS: -UNUSED_PARAMETER
fun interface IFoo {
fun foo(i: Int)
}
fun interface IFoo2 : IFoo
object A
operator fun A.get(i: IFoo) = 1
operator fun A.set(i: IFoo, newValue: Int) {}
fun withVararg(vararg xs: Int) = 42
fun test1() {
<!UNRESOLVED_REFERENCE!><!INAPPLICABLE_CANDIDATE!>A[::withVararg]<!> += 1<!>
}
compiler/testData/diagnostics/tests/callableReference/compatibilityResolveWithVarargAndOperatorCall.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
// !DIAGNOSTICS: -UNUSED_PARAMETER
fun interface IFoo {
compiler/testData/diagnostics/tests/callableReference/constraintFromLHSWithCorrectDirection.fir.kt
Vendored
+2 -2
View File
@@ -19,6 +19,6 @@ fun <K, V> B<K>.star(p: KProperty1<*, V>): B<V> = TODO()
fun <R : A> B<R>.test(){
foo(A::bla)
bar(A::bla)
<!INAPPLICABLE_CANDIDATE!>baz<!>(A::bla)
<!INAPPLICABLE_CANDIDATE!>baz<!>(<!UNRESOLVED_REFERENCE!>A::bla<!>)
star(A::bla)
}
}
compiler/testData/diagnostics/tests/callableReference/constraintFromLHSWithCorrectDirectionError.fir.kt
Vendored
+1 -1
View File
@@ -15,5 +15,5 @@ fun <K, V> B<K>.foo(p: KProperty1<K, V>) {}
class C : A
fun <R : A> B<R>.test(){
<!INAPPLICABLE_CANDIDATE!>foo<!>(C::bla)
<!INAPPLICABLE_CANDIDATE!>foo<!>(<!UNRESOLVED_REFERENCE!>C::bla<!>)
}
compiler/testData/diagnostics/tests/callableReference/expectedTypeAsSubtypeOfFunctionType.fir.kt
Vendored
+1 -1
View File
@@ -8,6 +8,6 @@ fun <T> takeIt(x: T, f: SubFunction) {}
fun cr() {}
fun test() {
<!INAPPLICABLE_CANDIDATE!>takeIt<!>(42, ::cr)
<!INAPPLICABLE_CANDIDATE!>takeIt<!>(42, <!UNRESOLVED_REFERENCE!>::cr<!>)
<!INAPPLICABLE_CANDIDATE!>takeIt<!>(42, { })
}
compiler/testData/diagnostics/tests/callableReference/function/extensionToSupertype.fir.kt
Vendored
-19
View File
@@ -1,19 +0,0 @@
// !WITH_NEW_INFERENCE
// !CHECK_TYPE
// !DIAGNOSTICS: -UNUSED_PARAMETER
import kotlin.reflect.*
interface A
interface B : A
fun A.foo() {}
fun take(f: (A) -> Unit) {}
fun take(f: () -> Unit) {}
fun test() {
B::foo checkType { _<KFunction1<B, Unit>>() }
<!INAPPLICABLE_CANDIDATE!>take<!>(B::foo)
}
compiler/testData/diagnostics/tests/callableReference/function/extensionToSupertype.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
// !WITH_NEW_INFERENCE
// !CHECK_TYPE
// !DIAGNOSTICS: -UNUSED_PARAMETER
compiler/testData/diagnostics/tests/callableReference/function/noAmbiguityMemberVsTopLevel.fir.kt
Vendored
+2 -2
View File
@@ -25,7 +25,7 @@ class A {
expectFunction0Unit(::foo)
expectFunction0String(::foo)
<!INAPPLICABLE_CANDIDATE!>expectFunction1Unit<!>(::foo)
<!INAPPLICABLE_CANDIDATE!>expectFunction1String<!>(::foo)
<!INAPPLICABLE_CANDIDATE!>expectFunction1Unit<!>(<!UNRESOLVED_REFERENCE!>::foo<!>)
<!INAPPLICABLE_CANDIDATE!>expectFunction1String<!>(<!UNRESOLVED_REFERENCE!>::foo<!>)
}
}
compiler/testData/diagnostics/tests/callableReference/generic/dependOnArgumentType.fir.kt
Vendored
+3 -3
View File
@@ -16,15 +16,15 @@ fun <T> bar(s: T) {}
fun <T> complex(t: T, f: (T) -> Unit) {}
fun test1() {
<!INAPPLICABLE_CANDIDATE!>foo<!>(1, A::invokeLater) // KT-24507 SAM conversion accidentally applied to callable reference and incorrectly handled via BE
<!INAPPLICABLE_CANDIDATE!>foo<!>(1, <!UNRESOLVED_REFERENCE!>A::invokeLater<!>) // KT-24507 SAM conversion accidentally applied to callable reference and incorrectly handled via BE
foo(1, ::bar)
complex(1, ::bar)
}
fun <R> test2(x: R) {
<!INAPPLICABLE_CANDIDATE!>foo<!>(x, A::invokeLater) // KT-24507 SAM conversion accidentally applied to callable reference and incorrectly handled via BE
<!INAPPLICABLE_CANDIDATE!>foo<!>(x, <!UNRESOLVED_REFERENCE!>A::invokeLater<!>) // KT-24507 SAM conversion accidentally applied to callable reference and incorrectly handled via BE
foo(x, ::bar)
complex(x, ::bar)
}
}
compiler/testData/diagnostics/tests/callableReference/generic/explicitTypeArguments.fir.kt
Vendored
+1 -1
View File
@@ -14,7 +14,7 @@ fun <T> Wrapper<T>.baz(transform: (T) -> Unit): T = TODO()
fun test() {
takeFun<String>(::foo)
<!INAPPLICABLE_CANDIDATE!>takeFun<!><String>(::fooInt)
<!INAPPLICABLE_CANDIDATE!>takeFun<!><String>(<!UNRESOLVED_REFERENCE!>::fooInt<!>)
callFun<String, Wrapper<String>>(::createWrapper)
callFun<Int, Wrapper<Number>>(::createWrapper)
compiler/testData/diagnostics/tests/callableReference/generic/genericExtensionFunction.fir.kt
Vendored
+3 -3
View File
@@ -23,9 +23,9 @@ fun test1() {
fun <T> test2() {
bar<Wrapper, Int, String>(Wrapper::fooReturnString).checkType { _<Tripple<Wrapper, Int, String>>() }
bar<Wrapper, T, String>(Wrapper::fooReturnString).checkType { _<Tripple<Wrapper, T, String>>() }
<!INAPPLICABLE_CANDIDATE!>bar<!><Wrapper, T, T>(Wrapper::fooReturnString)
<!INAPPLICABLE_CANDIDATE!>bar<!><Wrapper, Int, Int>(Wrapper::fooReturnString)
<!INAPPLICABLE_CANDIDATE!>bar<!><Wrapper, T, T>(<!UNRESOLVED_REFERENCE!>Wrapper::fooReturnString<!>)
<!INAPPLICABLE_CANDIDATE!>bar<!><Wrapper, Int, Int>(<!UNRESOLVED_REFERENCE!>Wrapper::fooReturnString<!>)
bar<Wrapper, Int, T>(Wrapper::fooTakeInt).checkType { _<Tripple<Wrapper, Int, T>>() }
bar<Wrapper, Int, String>(Wrapper::fooTakeInt).checkType { _<Tripple<Wrapper, Int, String>>() }
}
}
compiler/testData/diagnostics/tests/callableReference/genericCallWithReferenceAgainstVararg.fir.kt
Vendored
+2 -2
View File
@@ -5,9 +5,9 @@ fun foo(vararg ints: Int) {}
fun test(i: IntArray) {
myLet(i, ::foo)
myLet(::foo)
<!INAPPLICABLE_CANDIDATE!>myLet<!><Int>(::foo)
<!INAPPLICABLE_CANDIDATE!>myLet<!><Int>(<!UNRESOLVED_REFERENCE!>::foo<!>)
myLet<IntArray>(::foo)
<!INAPPLICABLE_CANDIDATE!>myLetExplicit1<!>(::foo)
<!INAPPLICABLE_CANDIDATE!>myLetExplicit1<!>(<!UNRESOLVED_REFERENCE!>::foo<!>)
myLetExplicit2(::foo)
}
compiler/testData/diagnostics/tests/callableReference/referenceAdaptationHasDependencyOnApi14.fir.kt
Vendored
+2 -2
View File
@@ -12,7 +12,7 @@ fun allOfTheAbove(f: (A) -> Unit): Any = f
fun test() {
coercionToUnit(A::foo)
<!INAPPLICABLE_CANDIDATE!>varargToElement<!>(A::foo)
<!INAPPLICABLE_CANDIDATE!>varargToElement<!>(<!UNRESOLVED_REFERENCE!>A::foo<!>)
defaultAndVararg(A::foo)
allOfTheAbove(A::foo)
}
}
compiler/testData/diagnostics/tests/callableReference/resolve/intersectionTypeOverloadWithWrongParameter.fir.kt
Vendored
+2 -2
View File
@@ -11,9 +11,9 @@ class Foo {
}
fun foo() {
<!INAPPLICABLE_CANDIDATE!>installRoute<!><Any>(::route)
<!NONE_APPLICABLE!>installRoute<!><Any>(::route)
}
}
fun route(s: String): Any? = null
fun route(s: String): Any? = null
compiler/testData/diagnostics/tests/callableReference/resolve/kt35887_simple.fir.kt
Vendored
+1 -1
View File
@@ -6,4 +6,4 @@ import kotlin.reflect.KProperty0
object A
fun <TProperty> property0(property: KProperty0<TProperty>) = A
val <K> K.key get() : A = <!INAPPLICABLE_CANDIDATE!>property0<!>(Map.Entry<K, *>::key) // should be forbidden
val <K> K.key get() : A = <!INAPPLICABLE_CANDIDATE!>property0<!>(<!UNRESOLVED_REFERENCE!>Map.Entry<K, *>::key<!>) // should be forbidden
compiler/testData/diagnostics/tests/callableReference/resolve/resolveCallableReferencesAfterAllSimpleArguments.fir.kt
Vendored
+3 -3
View File
@@ -11,6 +11,6 @@ fun <T> baz(e: T, f: (T) -> Unit) {}
fun test(a: A, b: B) {
// Note that diagnostic is always on callable references as they are resolved after simple arguments
<!INAPPLICABLE_CANDIDATE!>baz<!>(a, ::fooB)
<!INAPPLICABLE_CANDIDATE!>bar<!>(::fooB, a)
}
<!INAPPLICABLE_CANDIDATE!>baz<!>(a, <!UNRESOLVED_REFERENCE!>::fooB<!>)
<!INAPPLICABLE_CANDIDATE!>bar<!>(<!UNRESOLVED_REFERENCE!>::fooB<!>, a)
}
compiler/testData/diagnostics/tests/callableReference/resolve/resolveTwoReferencesAgainstGenerics.fir.kt
Vendored
+2 -2
View File
@@ -3,8 +3,8 @@
// WITH_RUNTIME
fun <T> List<Option<T>>.flatten(): List<T> = <!AMBIGUITY!>flatMap<!> { <!UNRESOLVED_REFERENCE!>it<!>.<!INAPPLICABLE_CANDIDATE!>fold<!>(::emptyList, <!UNRESOLVED_REFERENCE!>::listOf<!>) }
fun <T> List<Option<T>>.flatten(): List<T> = <!AMBIGUITY!>flatMap<!> { <!UNRESOLVED_REFERENCE!>it<!>.<!NONE_APPLICABLE!>fold<!>(::emptyList, <!UNRESOLVED_REFERENCE!>::listOf<!>) }
class Option<out T> {
fun <R> fold(ifEmpty: () -> R, ifSome: (T) -> R): R = TODO()
}
}
compiler/testData/diagnostics/tests/checkArguments/SpreadVarargs.fir.kt
Vendored
+2 -2
View File
@@ -58,7 +58,7 @@ fun main() {
val x1 = joinT(1, "2")
checkSubtype<String?>(x1)
val x2 = <!INAPPLICABLE_CANDIDATE!>joinT<!>(*1, "2")
<!INAPPLICABLE_CANDIDATE!>checkSubtype<!><String?>(x2)
checkSubtype<String?>(x2)
val x6 = joinT(1, *a)
checkSubtype<String?>(x6)
val x7 = joinT(1, *a, "3")
@@ -93,4 +93,4 @@ fun <T> joinG(x : Int, vararg a : T) : String {
fun <T: Any> joinT(x : Int, vararg a : T) : T? {
return null
}
}
compiler/testData/diagnostics/tests/checkArguments/overloadedFunction.fir.kt
Vendored
+4 -4
View File
@@ -9,9 +9,9 @@ fun bar(a: Any) {}
fun bar(a: Int) {}
fun test() {
<!INAPPLICABLE_CANDIDATE!>foo<!>(1, 2)
<!NONE_APPLICABLE!>foo<!>(1, 2)
<!INAPPLICABLE_CANDIDATE!>foo<!>("")
<!INAPPLICABLE_CANDIDATE!>bar<!>(1, 2)
<!INAPPLICABLE_CANDIDATE!>bar<!>()
}
<!NONE_APPLICABLE!>bar<!>(1, 2)
<!NONE_APPLICABLE!>bar<!>()
}
compiler/testData/diagnostics/tests/classObjects/ClassObjectVisibility.fir.kt
Vendored
+2 -2
View File
@@ -2,7 +2,7 @@ package foo
fun test() {
A.d
A.Companion.<!INAPPLICABLE_CANDIDATE!>f<!>
A.Companion.f
B.D
CCC
CCC.classObjectVar
@@ -27,4 +27,4 @@ class CCC() {
private companion object {
val classObjectVar = 3
}
}
}
compiler/testData/diagnostics/tests/classObjects/nestedClassInPrivateClassObject.fir.kt
Vendored
+2 -2
View File
@@ -10,6 +10,6 @@ class A {
}
}
fun f1() = A.<!INAPPLICABLE_CANDIDATE!>Companion<!>.<!UNRESOLVED_REFERENCE!>B<!>.<!UNRESOLVED_REFERENCE!>C<!>
fun <!EXPOSED_FUNCTION_RETURN_TYPE!>f1<!>() = A.Companion.B.C
fun f2() = A.<!INAPPLICABLE_CANDIDATE!>Companion<!>.<!UNRESOLVED_REFERENCE!>B<!>.<!UNRESOLVED_REFERENCE!>C<!>.<!UNRESOLVED_REFERENCE!>foo<!>()
fun f2() = A.Companion.B.C.foo()
compiler/testData/diagnostics/tests/controlFlowAnalysis/unnecessaryLateinit/lateinitWithErroneousDelegation.fir.kt
Vendored
+2 -2
View File
@@ -7,5 +7,5 @@ class Foo {
x = "Foo"
}
constructor(x: String, y: String): <!INAPPLICABLE_CANDIDATE!>this<!>(y.hashCode())
}
constructor(x: String, y: String): <!NONE_APPLICABLE!>this<!>(y.hashCode())
}
compiler/testData/diagnostics/tests/controlStructures/ForLoopWithExtensionIteratorOnNullable.fir.kt
Vendored
+2 -2
View File
@@ -9,7 +9,7 @@ fun test() {
// Error
container.<!INAPPLICABLE_CANDIDATE!>iterator<!>()
// for extension iterator, this code compiles, but should not
<!INAPPLICABLE_CANDIDATE, UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE!>for (s in container) {}<!>
<!INAPPLICABLE_CANDIDATE!>for (s in container) {}<!>
}
class OtherContainer<K>(val k: K) {
operator fun iterator(): Iterator<K> = null!!
@@ -18,5 +18,5 @@ class OtherContainer<K>(val k: K) {
fun test2() {
val other: OtherContainer<String>? = null
// Error
<!INAPPLICABLE_CANDIDATE, UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE!>for (s in other) {}<!>
<!INAPPLICABLE_CANDIDATE!>for (s in other) {}<!>
}
compiler/testData/diagnostics/tests/controlStructures/forLoopWithNullableRange.fir.kt
Vendored
+2 -2
View File
@@ -8,9 +8,9 @@ class It {
}
fun test(c: Coll?) {
<!INAPPLICABLE_CANDIDATE, UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE!>for (x in c) {}<!>
<!INAPPLICABLE_CANDIDATE!>for (x in c) {}<!>
if (c != null) {
for(x in c) {}
}
}
}
compiler/testData/diagnostics/tests/dataFlow/IsExpression.fir.kt
Vendored
+2 -2
View File
@@ -2,5 +2,5 @@ fun f(a: Boolean, b: Int) {}
fun foo(a: Any) {
<!INAPPLICABLE_CANDIDATE!>f<!>(a is Int, a)
1 <!INAPPLICABLE_CANDIDATE!>+<!> a
}
1 <!NONE_APPLICABLE!>+<!> a
}
compiler/testData/diagnostics/tests/declarationChecks/namedFunAsLastExpressionInBlock.fir.kt
Vendored
+1 -1
View File
@@ -5,7 +5,7 @@ fun foo(block: () -> (() -> Int)) {}
fun test() {
val x = <!EXPRESSION_REQUIRED!>fun named1(x: Int): Int { return 1 }<!>
x <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><Function1<Int, Int>>() }
x <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Function1<Int, Int>>() }
foo { fun named2(): Int {return 1} }
foo({ fun named3() = 1 })
compiler/testData/diagnostics/tests/delegatedProperty/propertyDefferedType.fir.kt
Vendored
+1 -1
View File
@@ -5,7 +5,7 @@
import kotlin.reflect.KProperty
class B {
val c by <!UNRESOLVED_REFERENCE!><!INAPPLICABLE_CANDIDATE!>Delegate<!>(<!UNRESOLVED_REFERENCE!>ag<!>)<!>
val c by <!INAPPLICABLE_CANDIDATE!><!INAPPLICABLE_CANDIDATE!>Delegate<!>(<!UNRESOLVED_REFERENCE!>ag<!>)<!>
}
class Delegate<T: Any>(val init: T) {
compiler/testData/diagnostics/tests/delegatedProperty/thisInDelegate.fir.kt
Vendored
+1 -1
View File
@@ -5,7 +5,7 @@ import kotlin.reflect.KProperty
val Int.a by Delegate(this)
class A {
val Int.a by <!UNRESOLVED_REFERENCE!><!INAPPLICABLE_CANDIDATE!>Delegate<!>(this)<!>
val Int.a by <!INAPPLICABLE_CANDIDATE!>Delegate<!>(this)
}
class Delegate(i: Int) {
compiler/testData/diagnostics/tests/delegatedProperty/twoGetMethods.fir.kt
Vendored
+1 -1
View File
@@ -3,7 +3,7 @@
import kotlin.reflect.KProperty
class A {
val c: Int by <!INAPPLICABLE_CANDIDATE!>Delegate()<!>
val c: Int by <!NONE_APPLICABLE!>Delegate()<!>
}
class Delegate {
compiler/testData/diagnostics/tests/deparenthesize/checkDeparenthesizedType.fir.kt
Vendored
+1 -1
View File
@@ -20,7 +20,7 @@ fun test(i: Int?) {
<!INAPPLICABLE_CANDIDATE!>foo<!>(l4@ "")
<!INAPPLICABLE_CANDIDATE!>foo<!>((""))
foo(<!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Int>(""))
foo(<!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Long>(""))
<!INAPPLICABLE_CANDIDATE!>foo<!>(<!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Long>(""))
use(a, b, c, d)
}
compiler/testData/diagnostics/tests/dynamicTypes/withInvisibleSynthesized.fir.kt
Vendored
+4 -4
View File
@@ -21,15 +21,15 @@ import p.*
class K: J.C() {
fun dynamic.test() {
<!INAPPLICABLE_CANDIDATE!>sam<!>(null)
<!INAPPLICABLE_CANDIDATE!>sam<!>(
<!HIDDEN!>sam<!>(null)
<!HIDDEN!>sam<!>(
name = null,
name = null
)
}
fun test() {
<!INAPPLICABLE_CANDIDATE!>sam<!>(null)
<!HIDDEN!>sam<!>(null)
}
}
}
compiler/testData/diagnostics/tests/enum/ConstructorCallFromOutside.fir.kt
Vendored
+1 -1
View File
@@ -6,5 +6,5 @@ enum class A(val c: Int) {
fun createA(): A {
// Error should be here!
return <!INAPPLICABLE_CANDIDATE!>A<!>(10)
return <!HIDDEN!>A<!>(10)
}
compiler/testData/diagnostics/tests/enum/inheritanceFromEnum.fir.kt
Vendored
+1 -1
View File
@@ -8,6 +8,6 @@ open enum class MyEnum() {
enum class MyEnum2() {}
class MyClass(): <!INAPPLICABLE_CANDIDATE!>MyEnum2<!>() {}
class MyClass(): <!HIDDEN!>MyEnum2<!>() {}
class MyClass2(): <!UNRESOLVED_REFERENCE!>MyJavaEnum<!>() {}
compiler/testData/diagnostics/tests/exposed/exceptionOnFakeInvisible.fir.kt
Vendored
+1 -1
View File
@@ -7,6 +7,6 @@ fun bar(arg: String) = arg
class Derived : Base("123") {
private inline fun foo() {
bar(<!INAPPLICABLE_CANDIDATE!>v<!>)
bar(<!HIDDEN!>v<!>)
}
}
compiler/testData/diagnostics/tests/extensions/kt1875.fir.kt
Vendored
+1 -1
View File
@@ -16,6 +16,6 @@ fun test(t: T) {
fun test1(t: T?) {
t.<!UNRESOLVED_REFERENCE!>f<!>(1) // todo resolve f as value and report UNSAFE_CALL
t?.<!INAPPLICABLE_CANDIDATE!>f<!>(1)
t.<!INAPPLICABLE_CANDIDATE!>f<!>?.<!UNRESOLVED_REFERENCE!>invoke<!>(1)
t.<!INAPPLICABLE_CANDIDATE!>f<!>?.invoke(1)
t?.f?.invoke(1)
}
compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/complexInference.fir.kt
Vendored
+8 -8
View File
@@ -10,8 +10,8 @@ fun <X, Y> foo(y: Y, x: (X, Y) -> Unit) {}
fun bar(aInstance: A, bInstance: B) {
foo("") {
(<!UNRESOLVED_REFERENCE!>a<!>, <!UNRESOLVED_REFERENCE!>b<!>): A, c ->
a <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><Int>() }
b <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><String>() }
a <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
b <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
c checkType { _<String>() }
}
@@ -24,24 +24,24 @@ fun bar(aInstance: A, bInstance: B) {
foo(bInstance) {
(a, b): A, (c, d) ->
<!UNRESOLVED_REFERENCE!>a<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><Int>() }
<!UNRESOLVED_REFERENCE!>b<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><String>() }
<!UNRESOLVED_REFERENCE!>a<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
<!UNRESOLVED_REFERENCE!>b<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
c checkType { _<Double>() }
d checkType { _<Short>() }
}
foo(bInstance) {
(a, b), (c, d) ->
<!UNRESOLVED_REFERENCE!>a<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><Int>() }
<!UNRESOLVED_REFERENCE!>b<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><String>() }
<!UNRESOLVED_REFERENCE!>a<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
<!UNRESOLVED_REFERENCE!>b<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
c checkType { _<Double>() }
d checkType { _<Short>() }
}
foo<A, B>(bInstance) {
(a, b), (c, d) ->
<!UNRESOLVED_REFERENCE!>a<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><Int>() }
<!UNRESOLVED_REFERENCE!>b<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><String>() }
<!UNRESOLVED_REFERENCE!>a<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
<!UNRESOLVED_REFERENCE!>b<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
c checkType { _<Double>() }
d checkType { _<Short>() }
}
compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/noExpectedType.fir.kt
Vendored
+4 -4
View File
@@ -5,22 +5,22 @@ data class A(val x: Int, val y: String)
fun bar() {
val x = { (<!UNRESOLVED_REFERENCE!>a<!>, <!UNRESOLVED_REFERENCE!>b<!>): A ->
a <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><Int>() }
b <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><String>() }
a <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
b <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
}
x checkType { _<(A) -> Unit>() }
val y = { (<!UNRESOLVED_REFERENCE!>a: Int<!>, <!UNRESOLVED_REFERENCE!>b<!>): A ->
a checkType { _<Int>() }
b <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><String>() }
b <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
}
y checkType { _<(A) -> Unit>() }
val y2 = { (<!UNRESOLVED_REFERENCE!>a: Number<!>, <!UNRESOLVED_REFERENCE!>b<!>): A ->
a checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
b <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><String>() }
b <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
}
y2 checkType { _<(A) -> Unit>() }
compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/redeclaration.fir.kt
Vendored
+1 -1
View File
@@ -23,7 +23,7 @@ fun bar() {
}
foo { (a, b), (c, b) ->
<!UNRESOLVED_REFERENCE!>a<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><Int>() }
<!UNRESOLVED_REFERENCE!>a<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
b checkType { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
c checkType { <!INAPPLICABLE_CANDIDATE!>_<!><B>() }
}
compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/simple.fir.kt
Vendored
+2 -2
View File
@@ -36,8 +36,8 @@ fun bar() {
}
foobar { (a, b), (c, d) ->
<!UNRESOLVED_REFERENCE!>a<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><Int>() }
<!UNRESOLVED_REFERENCE!>b<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><String>() }
<!UNRESOLVED_REFERENCE!>a<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
<!UNRESOLVED_REFERENCE!>b<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
c checkType { _<Double>() }
d checkType { _<Short>() }
}
compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/unusedParameters.fir.kt
Vendored
+2 -2
View File
@@ -32,12 +32,12 @@ fun bar() {
}
foobar { (a, b), (c, d) ->
<!UNRESOLVED_REFERENCE!>a<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><Int>() }
<!UNRESOLVED_REFERENCE!>a<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
d checkType { _<Short>() }
}
foobar { (a, b), (c, d) ->
<!UNRESOLVED_REFERENCE!>b<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><String>() }
<!UNRESOLVED_REFERENCE!>b<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
c checkType { _<Double>() }
}
}
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<!> { <!UNRESOLVED_REFERENCE!>_<!><Map<Char, String>>() }
Derived().baz() <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Map<Char, String>>() }
A.B().bar() checkType { _<Outer<Float, Long>.Inner<String>>() }
A.B().x() <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><Map<String, Float>>() }
A.B().x() <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Map<String, Float>>() }
}
compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/fromSuperClassesLocal.fir.kt
Vendored
+2 -2
View File
@@ -43,7 +43,7 @@ fun test() {
x = foobar<String>()
x().foo().a() checkType { <!INAPPLICABLE_CANDIDATE!>_<!><A<String, Double, Short, Long>>() }
x().bar() <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><A<String, Double, Short, Char>>() }
x().bar() <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><A<String, Double, Short, Char>>() }
x = foobar<Int>()
@@ -51,5 +51,5 @@ fun test() {
y = noParameters()
y().foo().a() checkType { _<A<Any, Double, Short, Long>>() }
y().bar() <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><A<Any, Double, Short, Char>>() }
y().bar() <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><A<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<!> { <!UNRESOLVED_REFERENCE!>_<!><Map<Char, Int>>() }
Derived().baz() <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Map<Char, Int>>() }
}
compiler/testData/diagnostics/tests/generics/wrongNumberOfTypeArgumentsDiagnostic.fir.kt
Vendored
+3 -3
View File
@@ -5,12 +5,12 @@ fun myFun(i : String) {}
fun myFun(i : Int) {}
fun test1() {
<!INAPPLICABLE_CANDIDATE!>myFun<!><Int>(3)
<!INAPPLICABLE_CANDIDATE!>myFun<!><String>('a')
<!NONE_APPLICABLE!>myFun<!><Int>(3)
<!NONE_APPLICABLE!>myFun<!><String>('a')
}
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>()
}
}
compiler/testData/diagnostics/tests/imports/CheckJavaVisibility2.fir.kt
Vendored
+8 -8
View File
@@ -22,24 +22,24 @@ import j.JavaProtected
import j.JavaPackageLocal
class A {
val p1 = JavaPackageLocal.<!INAPPLICABLE_CANDIDATE!>javaPPackage<!>
val p2 = JavaProtected.<!INAPPLICABLE_CANDIDATE!>javaPProtectedStatic<!>
val p3 = JavaProtected().<!INAPPLICABLE_CANDIDATE!>javaPProtectedPackage<!>
val p1 = JavaPackageLocal.<!HIDDEN!>javaPPackage<!>
val p2 = JavaProtected.<!HIDDEN!>javaPProtectedStatic<!>
val p3 = JavaProtected().<!HIDDEN!>javaPProtectedPackage<!>
fun test() {
JavaProtected.<!INAPPLICABLE_CANDIDATE!>javaMProtectedStatic<!>()
JavaPackageLocal.<!INAPPLICABLE_CANDIDATE!>javaMPackage<!>()
JavaProtected.<!HIDDEN!>javaMProtectedStatic<!>()
JavaPackageLocal.<!HIDDEN!>javaMPackage<!>()
}
}
class B : JavaProtected() {
val p1 = JavaPackageLocal.<!INAPPLICABLE_CANDIDATE!>javaPPackage<!>
val p1 = JavaPackageLocal.<!HIDDEN!>javaPPackage<!>
val p2 = JavaProtected.javaPProtectedStatic
val p3 = javaPProtectedPackage
fun test() {
JavaProtected.javaMProtectedStatic()
JavaPackageLocal.<!INAPPLICABLE_CANDIDATE!>javaMPackage<!>()
JavaPackageLocal.<!HIDDEN!>javaMPackage<!>()
}
}
@@ -59,4 +59,4 @@ class C {
JavaProtected.javaMProtectedStatic()
JavaPackageLocal.javaMPackage()
}
}
}
compiler/testData/diagnostics/tests/imports/ImportOverloadFunctions.fir.kt
Vendored
+4 -4
View File
@@ -27,9 +27,9 @@ import k.two
import k.all
fun test() {
<!INAPPLICABLE_CANDIDATE!>zero<!>()
<!INAPPLICABLE_CANDIDATE!>zero<!>(1)
<!INAPPLICABLE_CANDIDATE!>zero<!>("")
<!NONE_APPLICABLE!>zero<!>()
<!NONE_APPLICABLE!>zero<!>(1)
<!NONE_APPLICABLE!>zero<!>("")
one()
<!INAPPLICABLE_CANDIDATE!>one<!>(1)
@@ -42,4 +42,4 @@ fun test() {
all()
all(1)
all("")
}
}
compiler/testData/diagnostics/tests/imports/ImportPrivateMember.fir.kt
Vendored
+2 -2
View File
@@ -29,9 +29,9 @@ private object TopLevelObject {
}
fun testAccess() {
<!INAPPLICABLE_CANDIDATE!>NestedClass<!>()
<!HIDDEN!>NestedClass<!>()
E1
InNested()
NestedEntry
inObject()
}
}
compiler/testData/diagnostics/tests/imports/InaccessiblePrivateClass.fir.kt
Vendored
+1 -1
View File
@@ -15,4 +15,4 @@ package p1
import p2.*
val <!EXPOSED_PROPERTY_TYPE!>x<!>: X = X()
val <!EXPOSED_PROPERTY_TYPE!>y<!>: Y = <!INAPPLICABLE_CANDIDATE!>Y<!>()
val <!EXPOSED_PROPERTY_TYPE!>y<!>: Y = <!HIDDEN!>Y<!>()
compiler/testData/diagnostics/tests/imports/PackageLocalClassNotImported.fir.kt
Vendored
+1 -1
View File
@@ -14,4 +14,4 @@ package a
import pack1.*
import pack2.*
class X : <!EXPOSED_SUPER_CLASS, INAPPLICABLE_CANDIDATE!>SomeClass<!>()
class X : <!EXPOSED_SUPER_CLASS, HIDDEN!>SomeClass<!>()
compiler/testData/diagnostics/tests/imports/PackageLocalClassReferencedError.fir.kt
Vendored
+1 -1
View File
@@ -8,4 +8,4 @@ package a
import pack1.*
private class X : <!INAPPLICABLE_CANDIDATE!>SomeClass<!>()
private class X : <!HIDDEN!>SomeClass<!>()
compiler/testData/diagnostics/tests/imports/PrivateClassNotImported.fir.kt
Vendored
+1 -1
View File
@@ -17,5 +17,5 @@ package a
import pack1.SomeClass.*
import pack2.*
class X : <!EXPOSED_SUPER_CLASS, INAPPLICABLE_CANDIDATE!>N<!>()
class X : <!EXPOSED_SUPER_CLASS, HIDDEN!>N<!>()
class Y : PublicNested()
compiler/testData/diagnostics/tests/imports/PrivateClassReferencedError.fir.kt
Vendored
+1 -1
View File
@@ -11,4 +11,4 @@ package a
import pack1.SomeClass.*
private class X : <!INAPPLICABLE_CANDIDATE!>N<!>()
private class X : <!HIDDEN!>N<!>()
compiler/testData/diagnostics/tests/imports/invisibleFakeReferenceInImport.fir.kt
Vendored
+2 -2
View File
@@ -3,7 +3,7 @@
import B.foo
fun test() {
<!INAPPLICABLE_CANDIDATE!>foo<!>
<!HIDDEN!>foo<!>
}
// FILE: B.kt
@@ -13,4 +13,4 @@ object B : C<String>()
open class C<T> {
private var foo: String = "abc"
}
}
compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/completeFunctionArgumentsOfNestedCalls.fir.kt
Vendored
-8
View File
@@ -1,8 +0,0 @@
package c
fun demo() {
val bar = 51
fun map(f : <!SYNTAX!><!SYNTAX!><!>fun<!>
val foo = 3;
bar <!INAPPLICABLE_CANDIDATE!>+<!> map { foo }
}
compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/completeFunctionArgumentsOfNestedCalls.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
package c
fun demo() {
compiler/testData/diagnostics/tests/incompleteCode/kt2014.fir.kt
Vendored
+2 -2
View File
@@ -14,7 +14,7 @@ fun x(f : Foo) {
f.<!UNRESOLVED_REFERENCE!>a<!>()
<!UNRESOLVED_REFERENCE!>c<!>()
<!INAPPLICABLE_CANDIDATE!>R<!>()
<!HIDDEN!>R<!>()
}
object R {}
object R {}
compiler/testData/diagnostics/tests/inference/cannotCompleteResolveNoneApplicable.fir.kt
Vendored
+1 -1
View File
@@ -4,5 +4,5 @@ fun <T> f(i: Int, t: T, c: MutableCollection<T>) {}
fun <T> f(a: Any, t: T, l: MutableList<T>) {}
fun test(l: List<Int>) {
<!INAPPLICABLE_CANDIDATE!>f<!>(1, "", l)
<!NONE_APPLICABLE!>f<!>(1, "", l)
}
compiler/testData/diagnostics/tests/inference/capturedTypes/captureFromNullableTypeVariable.fir.kt
Vendored
+3 -3
View File
@@ -5,10 +5,10 @@ fun <T : Any> Array<T?>.filterNotNull(): List<T> = throw Exception()
fun test1(a: Array<out Int?>) {
val list = a.<!INAPPLICABLE_CANDIDATE!>filterNotNull<!>()
list <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><List<Int>>() }
list checkType { _<List<Int>>() }
}
fun test2(vararg a: Int?) {
val list = a.<!INAPPLICABLE_CANDIDATE!>filterNotNull<!>()
list <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><List<Int>>() }
}
list checkType { <!INAPPLICABLE_CANDIDATE!>_<!><List<Int>>() }
}
compiler/testData/diagnostics/tests/inference/capturedTypes/captureFromTypeParameterUpperBound.fir.kt
Vendored
+3 -3
View File
@@ -2,10 +2,10 @@ interface Inv<T>
fun <Y: X, X : Inv<out String>> foo(x: X, y: Y) {
val rX = <!INAPPLICABLE_CANDIDATE!>bar<!>(x)
rX.<!UNRESOLVED_REFERENCE!>length<!>
rX.length
val rY = <!INAPPLICABLE_CANDIDATE!>bar<!>(y)
rY.<!UNRESOLVED_REFERENCE!>length<!>
rY.length
}
fun <Y> bar(l: Inv<Y>): Y = TODO()
fun <Y> bar(l: Inv<Y>): Y = TODO()
compiler/testData/diagnostics/tests/inference/capturedTypes/kt2872.fir.kt
Vendored
+2 -2
View File
@@ -3,5 +3,5 @@ fun <T> Array<T>.foo() {}
fun test(array: Array<out Int>) {
array.foo()
array.<!INAPPLICABLE_CANDIDATE!>foo<!><out Int>()
}
array.<!INAPPLICABLE_CANDIDATE!>foo<!><<!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>out Int<!>>()
}
compiler/testData/diagnostics/tests/inference/completeInferenceIfManyFailed.fir.kt
Vendored
+2 -2
View File
@@ -12,6 +12,6 @@ fun <T: Any> joinT(x: Comparable<*>, y: T): T? {
}
fun test() {
val x2 = <!INAPPLICABLE_CANDIDATE!>joinT<!>(Unit, "2")
val x2 = <!NONE_APPLICABLE!>joinT<!>(Unit, "2")
<!INAPPLICABLE_CANDIDATE!>checkSubtype<!><String?>(x2)
}
}
compiler/testData/diagnostics/tests/inference/completion/postponedArgumentsAnalysis/basic.fir.kt
Vendored
+3 -3
View File
@@ -119,8 +119,8 @@ fun main() {
* K <: (A) -> Unit -> TypeVariable(_RP1) >: A
* K >: (C) -> TypeVariable(_R) -> TypeVariable(_RP1) <: C
*/
val x12 = <!INAPPLICABLE_CANDIDATE!>selectC<!>(id { <!DEBUG_INFO_EXPRESSION_TYPE("ERROR CLASS: Unresolved name: it"), UNRESOLVED_REFERENCE!>it<!> }, id { x: B -> })
val x13 = <!INAPPLICABLE_CANDIDATE!>selectA<!>(id { <!DEBUG_INFO_EXPRESSION_TYPE("ERROR CLASS: Unresolved name: it"), UNRESOLVED_REFERENCE!>it<!> }, id { x: C -> })
val x12 = <!INAPPLICABLE_CANDIDATE!>selectC<!>(id { <!DEBUG_INFO_EXPRESSION_TYPE("C")!>it<!> }, id { x: B -> })
val x13 = <!INAPPLICABLE_CANDIDATE!>selectA<!>(id { <!DEBUG_INFO_EXPRESSION_TYPE("A")!>it<!> }, id { x: C -> })
val x14 = selectC(id { <!DEBUG_INFO_EXPRESSION_TYPE("ERROR CLASS: Unresolved name: it"), UNRESOLVED_REFERENCE!>it<!> }, id { x: A -> }, { x -> x })
val x15 = selectC(id { <!DEBUG_INFO_EXPRESSION_TYPE("C")!>it<!> }, { x: A -> }, id { x -> x })
/*
@@ -152,7 +152,7 @@ fun main() {
select(id(fun String.(x: String) {}), id(fun(x: String, y: String) { }), { x: String, y: String -> x })
// Convert to extension lambda is impossible because the lambda parameter types aren't specified explicitly
select(id(fun String.(x: String) {}), id(fun(x: String, y: String) { }), { x, y -> x })
<!INAPPLICABLE_CANDIDATE!>select<!>(<!INAPPLICABLE_CANDIDATE!>id<!>(id(fun(x: String, y: String) { }), fun String.(x: String) {}), { x, y -> x })
select(<!INAPPLICABLE_CANDIDATE!>id<!>(id(fun(x: String, y: String) { }), fun String.(x: String) {}), { x, y -> x })
val x26: Int.(String) -> Int = fun (x: String) = 10 // it must be error, see KT-38439
// Receiver must be specified in anonymous function declaration
val x27: Int.(String) -> Int = id(fun (x: String) = 10)
compiler/testData/diagnostics/tests/inference/constraints/constraintOnFunctionLiteral.fir.kt
Vendored
+1 -1
View File
@@ -3,7 +3,7 @@ package c
import java.util.ArrayList
fun Array<Int>.toIntArray(): IntArray = this.<!INAPPLICABLE_CANDIDATE!>mapTo<!>(IntArray(size), {<!UNRESOLVED_REFERENCE!>it<!>})
fun Array<Int>.toIntArray(): IntArray = this.<!INAPPLICABLE_CANDIDATE!>mapTo<!>(IntArray(size), {it})
fun Array<Int>.toArrayList(): ArrayList<Int> = this.mapTo(ArrayList<Int>(size), {it})
compiler/testData/diagnostics/tests/inference/kt39220.fir.kt
Vendored
+4 -4
View File
@@ -114,14 +114,14 @@ fun <T : Foo, R: Number, D: Int> main() {
bar7(Foo::resolve) // OK
// with LHS and sentension function expected type
<!INAPPLICABLE_CANDIDATE!>bar10<!><D>(Int::x1) // ERROR before the fix in NI
<!INAPPLICABLE_CANDIDATE!>bar10<!><D>(<!UNRESOLVED_REFERENCE!>Int::x1<!>) // ERROR before the fix in NI
bar10<Int>(Int::x1) // OK
bar10(Int::x1) // OK
fun Int.ext() {
// with LHS and sentension function expected type
<!INAPPLICABLE_CANDIDATE!>bar10<!><D>(::x1) // ERROR before the fix in NI
<!INAPPLICABLE_CANDIDATE!>bar10<!><Int>(::x1) // OK
<!INAPPLICABLE_CANDIDATE!>bar10<!>(::x1) // OK
<!INAPPLICABLE_CANDIDATE!>bar10<!><D>(<!UNRESOLVED_REFERENCE!>::x1<!>) // ERROR before the fix in NI
<!INAPPLICABLE_CANDIDATE!>bar10<!><Int>(<!UNRESOLVED_REFERENCE!>::x1<!>) // OK
<!INAPPLICABLE_CANDIDATE!>bar10<!>(<!UNRESOLVED_REFERENCE!>::x1<!>) // OK
}
}
compiler/testData/diagnostics/tests/inference/regressions/kt36342.fir.kt
Vendored
+6 -6
View File
@@ -5,21 +5,21 @@ import java.lang.Exception
fun <K> id(arg: K): K = arg
fun test() {
<!INAPPLICABLE_CANDIDATE!>id<!>(<!UNRESOLVED_REFERENCE!>unresolved<!>)!!
id(<!UNRESOLVED_REFERENCE!>unresolved<!>)!!
<!UNRESOLVED_REFERENCE!>unresolved<!>!!!!
try {
<!INAPPLICABLE_CANDIDATE!>id<!>(<!UNRESOLVED_REFERENCE!>unresolved<!>)
id(<!UNRESOLVED_REFERENCE!>unresolved<!>)
} catch (e: Exception) {
<!INAPPLICABLE_CANDIDATE!>id<!>(<!UNRESOLVED_REFERENCE!>unresolved<!>)
id(<!UNRESOLVED_REFERENCE!>unresolved<!>)
}
if (true)
<!INAPPLICABLE_CANDIDATE!>id<!>(<!UNRESOLVED_REFERENCE!>unresolved<!>)
id(<!UNRESOLVED_REFERENCE!>unresolved<!>)
else
<!INAPPLICABLE_CANDIDATE!>id<!>(<!UNRESOLVED_REFERENCE!>unresolved<!>)
id(<!UNRESOLVED_REFERENCE!>unresolved<!>)
when {
true -> <!INAPPLICABLE_CANDIDATE!>id<!>(<!UNRESOLVED_REFERENCE!>unresolved<!>)
}
<!INAPPLICABLE_CANDIDATE!>id<!>(<!UNRESOLVED_REFERENCE!>unresolved<!>) ?: <!INAPPLICABLE_CANDIDATE!>id<!>(<!UNRESOLVED_REFERENCE!>unresolved<!>)
id(<!UNRESOLVED_REFERENCE!>unresolved<!>) ?: id(<!UNRESOLVED_REFERENCE!>unresolved<!>)
}
compiler/testData/diagnostics/tests/inference/regressions/kt742.fir.kt
Vendored
+1 -1
View File
@@ -10,4 +10,4 @@ fun <T, Q> List<T>.map1(f: (T)-> Q): List<T>? = tail!!.map1(f)
fun <T, Q> List<T>.map2(f: (T)-> Q): List<T>? = tail.sure().map2(f)
fun <T, Q> List<T>.map3(f: (T)-> Q): List<T>? = tail.<!INAPPLICABLE_CANDIDATE!>sure<!><T>().map3(f)
fun <T, Q> List<T>.map3(f: (T)-> Q): List<T>? = tail.<!INAPPLICABLE_CANDIDATE!>sure<!><T>().<!INAPPLICABLE_CANDIDATE!>map3<!>(f)
compiler/testData/diagnostics/tests/inference/reportingImprovements/reportUnresolvedReferenceWrongReceiverForManyCandidates.fir.kt
Vendored
+2 -2
View File
@@ -1,8 +1,8 @@
fun test() {
val a = <!INAPPLICABLE_CANDIDATE!>-<!>false
val a = <!NONE_APPLICABLE!>-<!>false
}
operator fun A.unaryMinus() {}
operator fun B.unaryMinus() {}
class A
class B
class B
compiler/testData/diagnostics/tests/inference/tooEagerSmartcast.fir.kt
Vendored
+2 -2
View File
@@ -36,7 +36,7 @@ fun Number.num() {}
fun main(b: Base<out Number>) {
b.foo().num()
if (b is Derived<*>) {
b.<!INAPPLICABLE_CANDIDATE!>foo<!>().num()
b.<!INAPPLICABLE_CANDIDATE!>baz<!>().<!UNRESOLVED_REFERENCE!>length<!>
b.<!INAPPLICABLE_CANDIDATE!>foo<!>().<!INAPPLICABLE_CANDIDATE!>num<!>()
b.<!INAPPLICABLE_CANDIDATE!>baz<!>().length
}
}
compiler/testData/diagnostics/tests/inner/visibility.fir.kt
Vendored
+6 -6
View File
@@ -11,8 +11,8 @@ open class Outer {
class Derived : Outer() {
fun foo() {
Outer.<!INAPPLICABLE_CANDIDATE!>PrivateNested<!>()
super.<!INAPPLICABLE_CANDIDATE!>PrivateInner<!>()
Outer.<!HIDDEN!>PrivateNested<!>()
super.<!HIDDEN!>PrivateInner<!>()
Outer.ProtectedNested()
super.ProtectedInner()
@@ -23,11 +23,11 @@ class Derived : Outer() {
}
fun foo() {
Outer.<!INAPPLICABLE_CANDIDATE!>PrivateNested<!>()
Outer().<!INAPPLICABLE_CANDIDATE!>PrivateInner<!>()
Outer.<!HIDDEN!>PrivateNested<!>()
Outer().<!HIDDEN!>PrivateInner<!>()
Outer.<!INAPPLICABLE_CANDIDATE!>ProtectedNested<!>()
Outer().<!INAPPLICABLE_CANDIDATE!>ProtectedInner<!>()
Outer.<!HIDDEN!>ProtectedNested<!>()
Outer().<!HIDDEN!>ProtectedInner<!>()
Outer.PublicNested()
Outer().PublicInner()
compiler/testData/diagnostics/tests/j+k/invisiblePackagePrivateInheritedMember.fir.kt
Vendored
+1 -1
View File
@@ -19,5 +19,5 @@ package c
import b.F
fun f() {
F().<!INAPPLICABLE_CANDIDATE!>m<!>
F().<!HIDDEN!>m<!>
}
compiler/testData/diagnostics/tests/j+k/packageVisibility.fir.kt
Vendored
+8 -8
View File
@@ -26,19 +26,19 @@ package b
import a.MyJavaClass
val mc1 = <!INAPPLICABLE_CANDIDATE!>MyJavaClass<!>()
val mc1 = <!HIDDEN!>MyJavaClass<!>()
val x = <!INAPPLICABLE_CANDIDATE!>MyJavaClass<!>.<!UNRESOLVED_REFERENCE!>staticMethod<!>()
val y = <!INAPPLICABLE_CANDIDATE!>MyJavaClass<!>.<!UNRESOLVED_REFERENCE!>NestedClass<!>.<!UNRESOLVED_REFERENCE!>staticMethodOfNested<!>()
val z = <!INAPPLICABLE_CANDIDATE!>MyJavaClass<!>.<!UNRESOLVED_REFERENCE!>NestedClass<!>()
val x = MyJavaClass.<!HIDDEN!>staticMethod<!>()
val y = MyJavaClass.NestedClass.<!HIDDEN!>staticMethodOfNested<!>()
val z = MyJavaClass.<!HIDDEN!>NestedClass<!>()
//FILE: c.kt
package a.c
import a.MyJavaClass
val mc1 = <!INAPPLICABLE_CANDIDATE!>MyJavaClass<!>()
val mc1 = <!HIDDEN!>MyJavaClass<!>()
val x = <!INAPPLICABLE_CANDIDATE!>MyJavaClass<!>.<!UNRESOLVED_REFERENCE!>staticMethod<!>()
val y = <!INAPPLICABLE_CANDIDATE!>MyJavaClass<!>.<!UNRESOLVED_REFERENCE!>NestedClass<!>.<!UNRESOLVED_REFERENCE!>staticMethodOfNested<!>()
val z = <!INAPPLICABLE_CANDIDATE!>MyJavaClass<!>.<!UNRESOLVED_REFERENCE!>NestedClass<!>()
val x = MyJavaClass.<!HIDDEN!>staticMethod<!>()
val y = MyJavaClass.NestedClass.<!HIDDEN!>staticMethodOfNested<!>()
val z = MyJavaClass.<!HIDDEN!>NestedClass<!>()
compiler/testData/diagnostics/tests/j+k/properties/fieldPropertyOverloads.fir.kt
Vendored
+4 -4
View File
@@ -19,9 +19,9 @@ public abstract class CollectionWithSize implements java.util.Collection<String>
// FILE: main.kt
fun main(c: CollectionWithSize) {
CompressionType.ZIP.<!AMBIGUITY!>name<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><Double>() }
c.<!AMBIGUITY!>size<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><String>() }
CompressionType.ZIP.<!AMBIGUITY!>name<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Double>() }
c.<!AMBIGUITY!>size<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
<!UNRESOLVED_REFERENCE!>CompressionType.ZIP::name<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><kotlin.reflect.KProperty0<Double>>() }
<!UNRESOLVED_REFERENCE!>c::size<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><kotlin.reflect.KProperty0<String>>() }
<!UNRESOLVED_REFERENCE!>CompressionType.ZIP::name<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><kotlin.reflect.KProperty0<Double>>() }
<!UNRESOLVED_REFERENCE!>c::size<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><kotlin.reflect.KProperty0<String>>() }
}
compiler/testData/diagnostics/tests/j+k/properties/fieldPropertyOverloadsDisabled.fir.kt
Vendored
+4 -4
View File
@@ -20,9 +20,9 @@ public abstract class CollectionWithSize implements java.util.Collection<String>
// FILE: main.kt
fun main(c: CollectionWithSize) {
CompressionType.ZIP.<!AMBIGUITY!>name<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><Double>() }
c.<!AMBIGUITY!>size<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><String>() }
CompressionType.ZIP.<!AMBIGUITY!>name<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Double>() }
c.<!AMBIGUITY!>size<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
<!UNRESOLVED_REFERENCE!>CompressionType.ZIP::name<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><kotlin.reflect.KProperty0<Double>>() }
<!UNRESOLVED_REFERENCE!>c::size<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><kotlin.reflect.KProperty0<String>>() }
<!UNRESOLVED_REFERENCE!>CompressionType.ZIP::name<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><kotlin.reflect.KProperty0<Double>>() }
<!UNRESOLVED_REFERENCE!>c::size<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><kotlin.reflect.KProperty0<String>>() }
}
compiler/testData/diagnostics/tests/j+k/properties/fieldPropertyOverloadsNI.fir.kt
Vendored
+4 -4
View File
@@ -19,9 +19,9 @@ public abstract class CollectionWithSize implements java.util.Collection<String>
// FILE: main.kt
fun main(c: CollectionWithSize) {
CompressionType.ZIP.<!AMBIGUITY!>name<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><Double>() }
c.<!AMBIGUITY!>size<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><String>() }
CompressionType.ZIP.<!AMBIGUITY!>name<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Double>() }
c.<!AMBIGUITY!>size<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
<!UNRESOLVED_REFERENCE!>CompressionType.ZIP::name<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><kotlin.reflect.KProperty0<Double>>() }
<!UNRESOLVED_REFERENCE!>c::size<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><kotlin.reflect.KProperty0<String>>() }
<!UNRESOLVED_REFERENCE!>CompressionType.ZIP::name<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><kotlin.reflect.KProperty0<Double>>() }
<!UNRESOLVED_REFERENCE!>c::size<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><kotlin.reflect.KProperty0<String>>() }
}
compiler/testData/diagnostics/tests/j+k/sam/privateCandidatesWithWrongArguments.fir.kt
Vendored
+2 -2
View File
@@ -17,5 +17,5 @@ public class A {
package bar
fun main() {
foo.A.<!INAPPLICABLE_CANDIDATE!>f<!> {}
}
foo.A.<!HIDDEN!>f<!> {}
}
compiler/testData/diagnostics/tests/j+k/sam/referenceToSamFunctionAgainstExpectedType.fir.kt
Vendored
+2 -2
View File
@@ -18,7 +18,7 @@ public class Inv<T> {
fun test(inv: Inv<String>) {
val m: ((String) -> String) -> Inv<String> = inv::map
<!INAPPLICABLE_CANDIDATE!>take<!>(inv::map)
<!INAPPLICABLE_CANDIDATE!>take<!>(<!UNRESOLVED_REFERENCE!>inv::map<!>)
}
fun take(f: ((String) -> String) -> Inv<String>) {}
fun take(f: ((String) -> String) -> Inv<String>) {}
compiler/testData/diagnostics/tests/j+k/selectMoreSpecific.fir.kt
Vendored
+2 -2
View File
@@ -11,6 +11,6 @@ public class A {
// FILE: main.kt
fun foo(a: A) {
a.<!AMBIGUITY!>foo<!>() <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><String>() }
A.<!AMBIGUITY!>bar<!>() <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><String>() }
a.<!AMBIGUITY!>foo<!>() <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
A.<!AMBIGUITY!>bar<!>() <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
}
compiler/testData/diagnostics/tests/multimodule/duplicateMethod/functionGenericsInParamsBoundsMismatch.fir.kt
Vendored
-40
View File
@@ -1,40 +0,0 @@
// !DIAGNOSTICS: -UNNECESSARY_SAFE_CALL
// MODULE: m1
// FILE: a.kt
package p
public interface B {
public fun <T> foo(a: T): B?
}
// MODULE: m2(m1)
// FILE: b.kt
package p
public interface C : B {
override fun <T> foo(a: T): B?
}
// MODULE: m3
// FILE: b.kt
package p
public interface Tr
public interface B {
public fun <T: Tr?> foo(a: T): B?
}
// MODULE: m4(m3, m2)
// FILE: c.kt
import p.*
fun test(b: B?) {
if (b is C) {
// hard to find parameters for an ambiguous call, so we rely on NONE_APPLICABLE here
// as opposed to diagnostics for a single unmatched candidate
b?.<!INAPPLICABLE_CANDIDATE!>foo<!>()
}
}
compiler/testData/diagnostics/tests/multimodule/duplicateMethod/functionGenericsInParamsBoundsMismatch.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
// !DIAGNOSTICS: -UNNECESSARY_SAFE_CALL
// MODULE: m1
compiler/testData/diagnostics/tests/multimodule/duplicateMethod/incompleteCodeNoNoneApplicable.fir.kt
Vendored
+1 -1
View File
@@ -16,5 +16,5 @@ import p.f
fun test() {
// There should be no "none applicable" error here
<!INAPPLICABLE_CANDIDATE!>f<!>(
<!NONE_APPLICABLE!>f<!>(
<!SYNTAX!><!>}
compiler/testData/diagnostics/tests/multimodule/internal.fir.kt
Vendored
+9 -9
View File
@@ -22,14 +22,14 @@ internal class B
import p.*
fun test() {
val _a = <!INAPPLICABLE_CANDIDATE!>a<!>
val _v = <!INAPPLICABLE_CANDIDATE!>v<!>
<!INAPPLICABLE_CANDIDATE!>a<!>()
<!INAPPLICABLE_CANDIDATE!>B<!>()
val _a = <!HIDDEN!>a<!>
val _v = <!HIDDEN!>v<!>
<!HIDDEN!>a<!>()
<!HIDDEN!>B<!>()
val inst = A()
val ia = inst.<!INAPPLICABLE_CANDIDATE!>a<!>
val iv = inst.<!INAPPLICABLE_CANDIDATE!>v<!>
inst.<!INAPPLICABLE_CANDIDATE!>a<!>()
inst.<!INAPPLICABLE_CANDIDATE!>B<!>()
}
val ia = inst.<!HIDDEN!>a<!>
val iv = inst.<!HIDDEN!>v<!>
inst.<!HIDDEN!>a<!>()
inst.<!HIDDEN!>B<!>()
}
compiler/testData/diagnostics/tests/multimodule/packagePrivate.fir.kt
Vendored
+2 -2
View File
@@ -9,11 +9,11 @@ private val a = 1
package p
val b = <!INAPPLICABLE_CANDIDATE!>a<!> // same package, same module
val b = <!HIDDEN!>a<!> // same package, same module
// MODULE: m2(m1)
// FILE: c.kt
package p
val c = <!INAPPLICABLE_CANDIDATE!>a<!> // same package, another module
val c = <!HIDDEN!>a<!> // same package, another module
compiler/testData/diagnostics/tests/multimodule/publishedApiInternal.fir.kt
Vendored
+17 -17
View File
@@ -30,27 +30,27 @@ internal class B
import p.*
fun test() {
val _a = <!INAPPLICABLE_CANDIDATE!>a<!>
val _v = <!INAPPLICABLE_CANDIDATE!>v<!>
<!INAPPLICABLE_CANDIDATE!>a<!>()
<!INAPPLICABLE_CANDIDATE!>B<!>()
val _a = <!HIDDEN!>a<!>
val _v = <!HIDDEN!>v<!>
<!HIDDEN!>a<!>()
<!HIDDEN!>B<!>()
val inst = A()
val ia = inst.<!INAPPLICABLE_CANDIDATE!>a<!>
val iv = inst.<!INAPPLICABLE_CANDIDATE!>v<!>
inst.<!INAPPLICABLE_CANDIDATE!>a<!>()
inst.<!INAPPLICABLE_CANDIDATE!>B<!>()
val ia = inst.<!HIDDEN!>a<!>
val iv = inst.<!HIDDEN!>v<!>
inst.<!HIDDEN!>a<!>()
inst.<!HIDDEN!>B<!>()
}
inline fun testInline() {
val _a = <!INAPPLICABLE_CANDIDATE!>a<!>
val _v = <!INAPPLICABLE_CANDIDATE!>v<!>
<!INAPPLICABLE_CANDIDATE!>a<!>()
<!INAPPLICABLE_CANDIDATE!>B<!>()
val _a = <!HIDDEN!>a<!>
val _v = <!HIDDEN!>v<!>
<!HIDDEN!>a<!>()
<!HIDDEN!>B<!>()
val inst = A()
val ia = inst.<!INAPPLICABLE_CANDIDATE!>a<!>
val iv = inst.<!INAPPLICABLE_CANDIDATE!>v<!>
inst.<!INAPPLICABLE_CANDIDATE!>a<!>()
inst.<!INAPPLICABLE_CANDIDATE!>B<!>()
}
val ia = inst.<!HIDDEN!>a<!>
val iv = inst.<!HIDDEN!>v<!>
inst.<!HIDDEN!>a<!>()
inst.<!HIDDEN!>B<!>()
}
compiler/testData/diagnostics/tests/multiplatform/enum/constructorInHeaderEnum.fir.kt
Vendored
+2 -2
View File
@@ -3,11 +3,11 @@
// FILE: common.kt
expect enum class En(x: Int) {
<!INAPPLICABLE_CANDIDATE!>E1,<!>
<!NONE_APPLICABLE!>E1,<!>
E2(42),
;
<!INAPPLICABLE_CANDIDATE!>constructor(s: String)<!>
<!NONE_APPLICABLE!>constructor(s: String)<!>
}
expect enum class En2 {
compiler/testData/diagnostics/tests/multiplatform/headerClass/explicitConstructorDelegation.fir.kt
Vendored
+1 -1
View File
@@ -8,7 +8,7 @@ expect open class A {
}
expect class B : A {
<!INAPPLICABLE_CANDIDATE!>constructor(i: Int)<!>
<!NONE_APPLICABLE!>constructor(i: Int)<!>
constructor() : super("B")
}
compiler/testData/diagnostics/tests/multiplatform/namedArguments.fir.kt
Vendored
+1 -1
View File
@@ -4,7 +4,7 @@
// FILE: common.kt
expect class Foo(zzz: Int) {
<!INAPPLICABLE_CANDIDATE!>constructor(aaa: Boolean)<!>
<!NONE_APPLICABLE!>constructor(aaa: Boolean)<!>
fun f1(xxx: String): String
}
compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/InfixCallNullability.fir.kt
Vendored
+2 -2
View File
@@ -9,9 +9,9 @@ operator infix fun A.div(i : Int) {}
operator infix fun A?.times(i : Int) {}
fun test(x : Int?, a : A?) {
x.<!INAPPLICABLE_CANDIDATE!>plus<!>(1)
x.<!NONE_APPLICABLE!>plus<!>(1)
x?.plus(1)
x <!INAPPLICABLE_CANDIDATE!>+<!> 1
x <!NONE_APPLICABLE!>+<!> 1
<!INAPPLICABLE_CANDIDATE!>-<!>x
x.<!INAPPLICABLE_CANDIDATE!>unaryMinus<!>()
x?.unaryMinus()
compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/NullableNothingIsExactlyNull.fir.kt
Vendored
+2 -2
View File
@@ -2,7 +2,7 @@ fun test() {
val out : Int? = null
val x : Nothing? = null
if (out != x)
out.<!INAPPLICABLE_CANDIDATE!>plus<!>(1)
out.<!NONE_APPLICABLE!>plus<!>(1)
if (out == x) return
out.<!INAPPLICABLE_CANDIDATE!>plus<!>(1)
out.<!NONE_APPLICABLE!>plus<!>(1)
}
compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt2216.fir.kt
Vendored
+1 -1
View File
@@ -16,7 +16,7 @@ fun foo() {
val y: Int? = 0
val z: Int? = 0
<!INAPPLICABLE_CANDIDATE!>bar<!>(if (y != null) y else z, y)
y <!INAPPLICABLE_CANDIDATE!>+<!> 2
y <!NONE_APPLICABLE!>+<!> 2
<!INAPPLICABLE_CANDIDATE!>baz<!>(y, y, if (y == null) return else y, y)
baz(y, z!!, z, y)
}
compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt362.fir.kt
Vendored
+2 -2
View File
@@ -6,11 +6,11 @@ package example
fun test() {
val p = test.Public()
if (p.public is Int) p.public + 1
if (p.<!INAPPLICABLE_CANDIDATE!>protected<!> is Int) p.<!INAPPLICABLE_CANDIDATE!>protected<!> + 1
if (p.<!HIDDEN!>protected<!> is Int) p.<!HIDDEN!>protected<!> <!NONE_APPLICABLE!>+<!> 1
if (p.internal is Int) p.internal + 1
val i = test.Internal()
if (i.public is Int) i.public + 1
if (i.<!INAPPLICABLE_CANDIDATE!>protected<!> is Int) i.<!INAPPLICABLE_CANDIDATE!>protected<!> + 1
if (i.<!HIDDEN!>protected<!> is Int) i.<!HIDDEN!>protected<!> <!NONE_APPLICABLE!>+<!> 1
if (i.internal is Int) i.internal + 1
}
compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/nullableReceiverWithOverloadedMethod.fir.kt
Vendored
+5 -5
View File
@@ -13,17 +13,17 @@ class B {
fun f() {
a = A()
a.<!INAPPLICABLE_CANDIDATE!>f<!>(true)
takeInt(a.<!INAPPLICABLE_CANDIDATE!>f<!>(""))
a.<!INAPPLICABLE_CANDIDATE!>f<!>()
a.<!NONE_APPLICABLE!>f<!>(true)
takeInt(a.<!NONE_APPLICABLE!>f<!>(""))
a.<!NONE_APPLICABLE!>f<!>()
}
fun g() {
takeInt(if (3 > 2) {
a = A()
a.<!INAPPLICABLE_CANDIDATE!>f<!>(true)
a.<!NONE_APPLICABLE!>f<!>(true)
} else {
6
})
}
}
}

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