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

FIR: introduce & use REFERENCE_BY_QUALIFIER positioning strategy

Browse Source
This commit is contained in:
Mikhail Glukhikh
2021-02-18 11:54:22 +03:00
parent 0accaf0f30
commit 34c90aab3b
138 changed files with 415 additions and 372 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/fir/analysis-tests/testData/resolve/arguments/ambiguityOnJavaOverride.kt
Vendored
+1 -1
View File
@@ -15,5 +15,5 @@ class B : A() {
} }
fun test(b: B) { fun test(b: B) {
b.<!HIDDEN{LT}!><!HIDDEN{PSI}!>foo<!>("")<!> b.<!HIDDEN!>foo<!>("")
} }
compiler/fir/analysis-tests/testData/resolve/arguments/default.kt
Vendored
+4 -4
View File
@@ -8,19 +8,19 @@ fun test() {
foo(1, 2.0, true) foo(1, 2.0, true)
foo(1, third = true) foo(1, third = true)
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>()<!> <!INAPPLICABLE_CANDIDATE!>foo<!>()
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>(0, 0.0, false, "")<!> <!INAPPLICABLE_CANDIDATE!>foo<!>(0, 0.0, false, "")
bar(1, third = true) bar(1, third = true)
bar(1, 2.0, true) bar(1, 2.0, true)
bar(1, 2.0, true, "my") bar(1, 2.0, true, "my")
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>bar<!>(1, true)<!> <!INAPPLICABLE_CANDIDATE!>bar<!>(1, true)
baz(1) baz(1)
baz(1, "my", "yours") baz(1, "my", "yours")
baz(1, z = true) baz(1, z = true)
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>baz<!>(0, "", false)<!> <!INAPPLICABLE_CANDIDATE!>baz<!>(0, "", false)
} }
compiler/fir/analysis-tests/testData/resolve/arguments/defaultFromOverrides.kt
Vendored
+2 -2
View File
@@ -15,8 +15,8 @@ fun foo(a: A) {
a.foo() a.foo()
a.foo(1) a.foo(1)
a.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>bar<!>()<!> a.<!INAPPLICABLE_CANDIDATE!>bar<!>()
a.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>bar<!>("")<!> a.<!INAPPLICABLE_CANDIDATE!>bar<!>("")
a.bar(y = 1) a.bar(y = 1)
a.bar("", 2) a.bar("", 2)
} }
compiler/fir/analysis-tests/testData/resolve/arguments/integerLiteralTypes.kt
Vendored
+4 -4
View File
@@ -17,9 +17,9 @@ fun test_1() {
} }
fun test_2() { fun test_2() {
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeInt<!>(10000000000)<!> <!INAPPLICABLE_CANDIDATE!>takeInt<!>(10000000000)
takeLong(10000000000) takeLong(10000000000)
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(1000)<!> <!INAPPLICABLE_CANDIDATE!>takeByte<!>(1000)
} }
fun test_3() { fun test_3() {
@@ -35,8 +35,8 @@ fun test_4() {
} }
fun test_5() { fun test_5() {
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeString<!>(1)<!> <!INAPPLICABLE_CANDIDATE!>takeString<!>(1)
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeString<!>(run { 1 })<!> <!INAPPLICABLE_CANDIDATE!>takeString<!>(run { 1 })
} }
annotation class Ann(val x: Byte) annotation class Ann(val x: Byte)
compiler/fir/analysis-tests/testData/resolve/arguments/javaArrayVariance.kt
Vendored
+1 -1
View File
@@ -13,6 +13,6 @@ fun takeOutA(array: Array<out A>) {}
fun test(array: Array<B>) { fun test(array: Array<B>) {
A.take(array) A.take(array)
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeA<!>(array)<!> <!INAPPLICABLE_CANDIDATE!>takeA<!>(array)
takeOutA(array) takeOutA(array)
} }
compiler/fir/analysis-tests/testData/resolve/arguments/lambda.kt
Vendored
+7 -7
View File
@@ -10,8 +10,8 @@ fun test() {
foo({}) foo({})
// Bad // Bad
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>(1) {}<!> <!INAPPLICABLE_CANDIDATE!>foo<!>(1) {}
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>(f = {}) {}<!> <!INAPPLICABLE_CANDIDATE!>foo<!>(f = {}) {}
// OK // OK
bar(1) {} bar(1) {}
@@ -20,15 +20,15 @@ fun test() {
bar(x = 1, f = {}) bar(x = 1, f = {})
// Bad // Bad
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>bar<!> {}<!> <!INAPPLICABLE_CANDIDATE!>bar<!> {}
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>bar<!>({})<!> <!INAPPLICABLE_CANDIDATE!>bar<!>({})
// OK // OK
baz(other = false, f = {}) baz(other = false, f = {})
baz({}, false) baz({}, false)
// Bad // Bad
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>baz<!> {}<!> <!INAPPLICABLE_CANDIDATE!>baz<!> {}
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>baz<!>() {}<!> <!INAPPLICABLE_CANDIDATE!>baz<!>() {}
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>baz<!>(other = false) {}<!> <!INAPPLICABLE_CANDIDATE!>baz<!>(other = false) {}
} }
compiler/fir/analysis-tests/testData/resolve/arguments/lambdaInUnresolvedCall.kt
Vendored
+4 -4
View File
@@ -1,14 +1,14 @@
fun <R> materialize(): R = null!! fun <R> materialize(): R = null!!
fun test_1() { fun test_1() {
<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>myRun<!> { <!UNRESOLVED_REFERENCE!>myRun<!> {
val x = 1 val x = 1
x * 2 x * 2
}<!> }
} }
fun test_2() { fun test_2() {
<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>myRun<!> { <!UNRESOLVED_REFERENCE!>myRun<!> {
materialize() materialize()
}<!> }
} }
compiler/fir/analysis-tests/testData/resolve/arguments/operatorsOverLiterals.kt
Vendored
+19 -19
View File
@@ -31,33 +31,33 @@ fun test_3() {
fun takeByte(b: Byte) {} fun takeByte(b: Byte) {}
fun test_4() { fun test_4() {
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(1 + 1)<!> <!INAPPLICABLE_CANDIDATE!>takeByte<!>(1 + 1)
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(1 + 127)<!> <!INAPPLICABLE_CANDIDATE!>takeByte<!>(1 + 127)
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(1 - 1)<!> <!INAPPLICABLE_CANDIDATE!>takeByte<!>(1 - 1)
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(-100 - 100)<!> <!INAPPLICABLE_CANDIDATE!>takeByte<!>(-100 - 100)
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(10 * 10)<!> <!INAPPLICABLE_CANDIDATE!>takeByte<!>(10 * 10)
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(100 * 100)<!> <!INAPPLICABLE_CANDIDATE!>takeByte<!>(100 * 100)
<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>taleByte<!>(10 / 10)<!> <!UNRESOLVED_REFERENCE!>taleByte<!>(10 / 10)
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(100 % 10)<!> <!INAPPLICABLE_CANDIDATE!>takeByte<!>(100 % 10)
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(1000 % 10)<!> <!INAPPLICABLE_CANDIDATE!>takeByte<!>(1000 % 10)
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(1000 and 100)<!> <!INAPPLICABLE_CANDIDATE!>takeByte<!>(1000 and 100)
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(128 and 511)<!> <!INAPPLICABLE_CANDIDATE!>takeByte<!>(128 and 511)
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(100 or 100)<!> <!INAPPLICABLE_CANDIDATE!>takeByte<!>(100 or 100)
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(1000 or 0)<!> <!INAPPLICABLE_CANDIDATE!>takeByte<!>(1000 or 0)
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(511 xor 511)<!> <!INAPPLICABLE_CANDIDATE!>takeByte<!>(511 xor 511)
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(512 xor 511)<!> <!INAPPLICABLE_CANDIDATE!>takeByte<!>(512 xor 511)
} }
fun test_5() { fun test_5() {
takeByte(-1) takeByte(-1)
takeByte(+1) takeByte(+1)
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(1.inv())<!> <!INAPPLICABLE_CANDIDATE!>takeByte<!>(1.inv())
} }
fun test_6() { fun test_6() {
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(run { 127 + 1 })<!> <!INAPPLICABLE_CANDIDATE!>takeByte<!>(run { 127 + 1 })
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(1 + run { 1 })<!> <!INAPPLICABLE_CANDIDATE!>takeByte<!>(1 + run { 1 })
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(run { 1 + 1 })<!> <!INAPPLICABLE_CANDIDATE!>takeByte<!>(run { 1 + 1 })
1 + 1 1 + 1
run { 1 } run { 1 }
1 + run { 1 } 1 + run { 1 }
compiler/fir/analysis-tests/testData/resolve/arguments/simple.kt
Vendored
+6 -6
View File
@@ -7,11 +7,11 @@ fun test() {
foo(1, second = 3.14, third = false, fourth = "!?") foo(1, second = 3.14, third = false, fourth = "!?")
foo(third = false, second = 2.71, fourth = "?!", first = 0) foo(third = false, second = 2.71, fourth = "?!", first = 0)
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>()<!> <!INAPPLICABLE_CANDIDATE!>foo<!>()
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>(0.0, false, 0, "")<!> <!INAPPLICABLE_CANDIDATE!>foo<!>(0.0, false, 0, "")
foo(1, 2.0, third = true, "") foo(1, 2.0, third = true, "")
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>(second = 0.0, first = 0, fourth = "")<!> <!INAPPLICABLE_CANDIDATE!>foo<!>(second = 0.0, first = 0, fourth = "")
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>(first = 0.0, second = 0, third = "", fourth = false)<!> <!INAPPLICABLE_CANDIDATE!>foo<!>(first = 0.0, second = 0, third = "", fourth = false)
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>(first = 0, second = 0.0, third = false, fourth = "", first = 1)<!> <!INAPPLICABLE_CANDIDATE!>foo<!>(first = 0, second = 0.0, third = false, fourth = "", first = 1)
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>(0, 0.0, false, foth = "")<!> <!INAPPLICABLE_CANDIDATE!>foo<!>(0, 0.0, false, foth = "")
} }
compiler/fir/analysis-tests/testData/resolve/arguments/vararg.kt
Vendored
+4 -4
View File
@@ -7,11 +7,11 @@ fun test() {
foo(1, "my", "yours") foo(1, "my", "yours")
foo(1, *arrayOf("my", "yours")) foo(1, *arrayOf("my", "yours"))
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>("")<!> <!INAPPLICABLE_CANDIDATE!>foo<!>("")
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>(1, 2)<!> <!INAPPLICABLE_CANDIDATE!>foo<!>(1, 2)
bar(1, z = true, y = *arrayOf("my", "yours")) bar(1, z = true, y = *arrayOf("my", "yours"))
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>bar<!>(0, z = false, y = "", y = "other")<!> <!INAPPLICABLE_CANDIDATE!>bar<!>(0, z = false, y = "", y = "other")
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>bar<!>(0, "", true)<!> <!INAPPLICABLE_CANDIDATE!>bar<!>(0, "", true)
} }
compiler/fir/analysis-tests/testData/resolve/asImports.kt
Vendored
+2 -2
View File
@@ -11,9 +11,9 @@ class A {
import foo.A as B import foo.A as B
fun test_1() { fun test_1() {
val a = <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>A<!>()<!> val a = <!UNRESOLVED_REFERENCE!>A<!>()
val b = B() // should be OK val b = B() // should be OK
val c: B = <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>A<!>()<!> val c: B = <!UNRESOLVED_REFERENCE!>A<!>()
} }
fun test_2(b: B) { fun test_2(b: B) {
compiler/fir/analysis-tests/testData/resolve/callResolution/errorCandidates.kt
Vendored
+3 -3
View File
@@ -9,11 +9,11 @@ fun bar(x: B) {}
fun test(c: C) { fun test(c: C) {
// Argument mapping error // Argument mapping error
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>("")<!> <!INAPPLICABLE_CANDIDATE!>foo<!>("")
// Ambiguity // Ambiguity
<!AMBIGUITY{LT}!><!AMBIGUITY{PSI}!>bar<!>(c)<!> <!AMBIGUITY!>bar<!>(c)
// Unresolved reference // Unresolved reference
<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>baz<!>()<!> <!UNRESOLVED_REFERENCE!>baz<!>()
} }
compiler/fir/analysis-tests/testData/resolve/callResolution/lambdaAsReceiver.kt
Vendored
+1 -1
View File
@@ -9,6 +9,6 @@ fun main1() {
} }
fun main2() { fun main2() {
{ "" }.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>bar<!>()<!> { "" }.<!INAPPLICABLE_CANDIDATE!>bar<!>()
"".bar() "".bar()
} }
compiler/fir/analysis-tests/testData/resolve/cfg/flowFromInplaceLambda.kt
Vendored
+6 -6
View File
@@ -19,7 +19,7 @@ fun test_2(x: Any, y: Any) {
val a = select( val a = select(
id( id(
run { run {
y.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>inc<!>()<!> // Bad y.<!UNRESOLVED_REFERENCE!>inc<!>() // Bad
x as Int x as Int
} }
), ),
@@ -39,14 +39,14 @@ fun test_3(x: Any, y: Any) {
val a = select( val a = select(
id( id(
run { run {
y.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>inc<!>()<!> // Bad y.<!UNRESOLVED_REFERENCE!>inc<!>() // Bad
x as Int x as Int
materialize() materialize()
} }
), ),
run { run {
y as Int y as Int
x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>inc<!>()<!> // Bad x.<!UNRESOLVED_REFERENCE!>inc<!>() // Bad
y.inc() // OK y.inc() // OK
1 1
} }
@@ -60,19 +60,19 @@ fun test_4(x: Any, y: Any) {
val a = select( val a = select(
id( id(
myRun { myRun {
y.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>inc<!>()<!> // Bad y.<!UNRESOLVED_REFERENCE!>inc<!>() // Bad
x as Int x as Int
} }
), ),
y as Int, y as Int,
myRun { myRun {
x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>inc<!>()<!> // Bad x.<!UNRESOLVED_REFERENCE!>inc<!>() // Bad
y.inc() // OK y.inc() // OK
1 1
} }
) )
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeInt<!>(x)<!> // Bad <!INAPPLICABLE_CANDIDATE!>takeInt<!>(x) // Bad
takeInt(y) // OK takeInt(y) // OK
takeInt(a) // Bad takeInt(a) // Bad
} }
compiler/fir/analysis-tests/testData/resolve/diagnostics/abstractSuperCall.kt
Vendored
+2 -2
View File
@@ -22,7 +22,7 @@ class B : A() {
} }
fun g() { fun g() {
super.<!ABSTRACT_SUPER_CALL{LT}!><!ABSTRACT_SUPER_CALL{PSI}!>f<!>()<!> super.<!ABSTRACT_SUPER_CALL!>f<!>()
super.t() super.t()
super.x super.x
@@ -32,7 +32,7 @@ class B : A() {
abstract class J : A() { abstract class J : A() {
fun r() { fun r() {
super.<!ABSTRACT_SUPER_CALL{LT}!><!ABSTRACT_SUPER_CALL{PSI}!>f<!>()<!> super.<!ABSTRACT_SUPER_CALL!>f<!>()
super.t() super.t()
super.x super.x
compiler/fir/analysis-tests/testData/resolve/diagnostics/abstractSuperCallInPresenseOfNonAbstractMethodInParent.kt
Vendored
+1 -1
View File
@@ -13,5 +13,5 @@ open class B {
class A : IWithToString, B() { class A : IWithToString, B() {
override fun toString(): String = super.toString() // resolve to Any.toString override fun toString(): String = super.toString() // resolve to Any.toString
override fun foo(): String = super.foo() // resolve to B.foo() override fun foo(): String = super.foo() // resolve to B.foo()
override fun bar(): String = super.<!ABSTRACT_SUPER_CALL{LT}!><!ABSTRACT_SUPER_CALL{PSI}!>bar<!>()<!> // should be an error override fun bar(): String = super.<!ABSTRACT_SUPER_CALL!>bar<!>() // should be an error
} }
compiler/fir/analysis-tests/testData/resolve/diagnostics/cyclicConstructorDelegationCall.kt
Vendored
+1 -1
View File
@@ -63,5 +63,5 @@ class M {
} }
class U : M { class U : M {
<!INAPPLICABLE_CANDIDATE!>constructor()<!> constructor()<!INAPPLICABLE_CANDIDATE!><!>
} }
compiler/fir/analysis-tests/testData/resolve/diagnostics/explicitDelegationCallRequired.kt
Vendored
+3 -3
View File
@@ -3,16 +3,16 @@ class A(x: Int) {
} }
class B : A { class B : A {
<!EXPLICIT_DELEGATION_CALL_REQUIRED, NONE_APPLICABLE!>constructor()<!> <!EXPLICIT_DELEGATION_CALL_REQUIRED!>constructor()<!><!NONE_APPLICABLE!><!>
constructor(z: String) : this() constructor(z: String) : this()
} }
<!SUPERTYPE_INITIALIZED_WITHOUT_PRIMARY_CONSTRUCTOR!>class C : A(20) { <!SUPERTYPE_INITIALIZED_WITHOUT_PRIMARY_CONSTRUCTOR!>class C : A(20) {
<!EXPLICIT_DELEGATION_CALL_REQUIRED, NONE_APPLICABLE!>constructor()<!> <!EXPLICIT_DELEGATION_CALL_REQUIRED!>constructor()<!><!NONE_APPLICABLE!><!>
constructor(z: String) : this() constructor(z: String) : this()
}<!> }<!>
class D() : A(20) { class D() : A(20) {
<!NONE_APPLICABLE, PRIMARY_CONSTRUCTOR_DELEGATION_CALL_EXPECTED!>constructor(x: Int)<!> <!PRIMARY_CONSTRUCTOR_DELEGATION_CALL_EXPECTED!>constructor(x: Int)<!><!NONE_APPLICABLE!><!>
constructor(z: String) : this() constructor(z: String) : this()
} }
compiler/fir/analysis-tests/testData/resolve/diagnostics/instanceAccessBeforeSuperCall.kt
Vendored
+1 -1
View File
@@ -1,5 +1,5 @@
class A { class A {
constructor(x: Int = <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>getSomeInt<!>()<!>, other: A = <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>, header: String = <!UNRESOLVED_REFERENCE!>keker<!>) {} constructor(x: Int = <!UNRESOLVED_REFERENCE!>getSomeInt<!>(), other: A = <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>, header: String = <!UNRESOLVED_REFERENCE!>keker<!>) {}
fun getSomeInt() = 10 fun getSomeInt() = 10
var keker = "test" var keker = "test"
} }
compiler/fir/analysis-tests/testData/resolve/diagnostics/notASupertype.kt
Vendored
+1 -1
View File
@@ -4,7 +4,7 @@ class A {
class B : A { class B : A {
fun g() { fun g() {
<!NOT_A_SUPERTYPE!>super<String><!>.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>f<!>()<!> <!NOT_A_SUPERTYPE!>super<String><!>.<!UNRESOLVED_REFERENCE!>f<!>()
super<A>.f() super<A>.f()
} }
} }
compiler/fir/analysis-tests/testData/resolve/diagnostics/sealedClassConstructorCall.kt
Vendored
+1 -1
View File
@@ -1,3 +1,3 @@
sealed class A sealed class A
val b = <!HIDDEN{LT}!><!HIDDEN{PSI}!>A<!>()<!> val b = <!HIDDEN!>A<!>()
compiler/fir/analysis-tests/testData/resolve/diagnostics/superIsNotAnExpression.kt
Vendored
+1 -1
View File
@@ -4,7 +4,7 @@ class B: A() {
fun act() { fun act() {
<!SUPER_IS_NOT_AN_EXPRESSION!>super<!>() <!SUPER_IS_NOT_AN_EXPRESSION!>super<!>()
<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>invoke<!>()<!> <!UNRESOLVED_REFERENCE!>invoke<!>()
<!SUPER_IS_NOT_AN_EXPRESSION!>super<!> { <!SUPER_IS_NOT_AN_EXPRESSION!>super<!> {
<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>println<!>(<!ILLEGAL_CONST_EXPRESSION!>'weird'<!>)<!> <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>println<!>(<!ILLEGAL_CONST_EXPRESSION!>'weird'<!>)<!>
compiler/fir/analysis-tests/testData/resolve/diagnostics/superNotAvailable.kt
Vendored
+6 -6
View File
@@ -1,20 +1,20 @@
fun String.f() { fun String.f() {
<!SUPER_NOT_AVAILABLE!>super@f<!>.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>compareTo<!>("")<!> <!SUPER_NOT_AVAILABLE!>super@f<!>.<!UNRESOLVED_REFERENCE!>compareTo<!>("")
<!SUPER_NOT_AVAILABLE!>super<!>.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>compareTo<!>("")<!> <!SUPER_NOT_AVAILABLE!>super<!>.<!UNRESOLVED_REFERENCE!>compareTo<!>("")
} }
fun foo() { fun foo() {
<!SUPER_NOT_AVAILABLE!>super<!> <!SUPER_NOT_AVAILABLE!>super<!>
<!SUPER_NOT_AVAILABLE!>super<!>.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!> <!SUPER_NOT_AVAILABLE!>super<!>.<!UNRESOLVED_REFERENCE!>foo<!>()
<!SUPER_NOT_AVAILABLE!>super<Nothing><!>.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!> <!SUPER_NOT_AVAILABLE!>super<Nothing><!>.<!UNRESOLVED_REFERENCE!>foo<!>()
} }
class A { class A {
fun act() { fun act() {
<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>println<!>("Test")<!> <!UNRESOLVED_REFERENCE!>println<!>("Test")
} }
fun String.fact() { fun String.fact() {
<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>println<!>("Fest")<!> <!UNRESOLVED_REFERENCE!>println<!>("Fest")
} }
} }
compiler/fir/analysis-tests/testData/resolve/diagnostics/typeArgumentsNotAllowed.kt
Vendored
+2 -2
View File
@@ -17,8 +17,8 @@ object Best {
} }
val a = <!TYPE_ARGUMENTS_NOT_ALLOWED!>rest<Int><!>.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>MyClass<!><String><!> val a = <!TYPE_ARGUMENTS_NOT_ALLOWED!>rest<Int><!>.<!UNRESOLVED_REFERENCE!>MyClass<!><String>
val b = Best.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>MyClass<!><String><!> val b = Best.<!UNRESOLVED_REFERENCE!>MyClass<!><String>
class B<E> class B<E>
class C<F<!SYNTAX{PSI}!><<!><!SYNTAX{PSI}!>Boolean<!><!SYNTAX{PSI}!>><!><!SYNTAX{PSI}!>><!> <!SYNTAX{PSI}!>:<!> <!SYNTAX{PSI}!>B<!><!SYNTAX{PSI}!><<!><!SYNTAX{PSI}!>F<!><!SYNTAX{PSI}!><<!><!SYNTAX{PSI}!>Boolean<!><!SYNTAX{PSI}!>><!><!SYNTAX{PSI}!>><!><!SYNTAX{PSI}!>(<!><!SYNTAX{PSI}!>)<!> class C<F<!SYNTAX{PSI}!><<!><!SYNTAX{PSI}!>Boolean<!><!SYNTAX{PSI}!>><!><!SYNTAX{PSI}!>><!> <!SYNTAX{PSI}!>:<!> <!SYNTAX{PSI}!>B<!><!SYNTAX{PSI}!><<!><!SYNTAX{PSI}!>F<!><!SYNTAX{PSI}!><<!><!SYNTAX{PSI}!>Boolean<!><!SYNTAX{PSI}!>><!><!SYNTAX{PSI}!>><!><!SYNTAX{PSI}!>(<!><!SYNTAX{PSI}!>)<!>
compiler/fir/analysis-tests/testData/resolve/diagnostics/upperBoundViolated.kt
Vendored
+1 -1
View File
@@ -45,4 +45,4 @@ val test8 = NL<String>()
class NumberPhile<T: Number>(x: T) class NumberPhile<T: Number>(x: T)
val np1 = NumberPhile(10) val np1 = NumberPhile(10)
val np2 = <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>NumberPhile<!>("Test")<!> val np2 = <!INAPPLICABLE_CANDIDATE!>NumberPhile<!>("Test")
compiler/fir/analysis-tests/testData/resolve/exhaustiveness/positive/exhaustiveness_enumJava.kt
Vendored
+3 -3
View File
@@ -10,13 +10,13 @@ fun test_1(e: JavaEnum) {
val a = <!NO_ELSE_IN_WHEN!>when<!> (e) { val a = <!NO_ELSE_IN_WHEN!>when<!> (e) {
JavaEnum.A -> 1 JavaEnum.A -> 1
JavaEnum.B -> 2 JavaEnum.B -> 2
}.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>plus<!>(0)<!> }.<!UNRESOLVED_REFERENCE!>plus<!>(0)
val b = <!NO_ELSE_IN_WHEN!>when<!> (e) { val b = <!NO_ELSE_IN_WHEN!>when<!> (e) {
JavaEnum.A -> 1 JavaEnum.A -> 1
JavaEnum.B -> 2 JavaEnum.B -> 2
is String -> 3 is String -> 3
}.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>plus<!>(0)<!> }.<!UNRESOLVED_REFERENCE!>plus<!>(0)
val c = when (e) { val c = when (e) {
JavaEnum.A -> 1 JavaEnum.A -> 1
@@ -35,7 +35,7 @@ fun test_2(e: JavaEnum?) {
JavaEnum.A -> 1 JavaEnum.A -> 1
JavaEnum.B -> 2 JavaEnum.B -> 2
JavaEnum.C -> 3 JavaEnum.C -> 3
}.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>plus<!>(0)<!> }.<!UNRESOLVED_REFERENCE!>plus<!>(0)
val a = when (e) { val a = when (e) {
JavaEnum.A -> 1 JavaEnum.A -> 1
compiler/fir/analysis-tests/testData/resolve/exhaustiveness/positive/exhaustiveness_sealedSubClass.kt
Vendored
+3 -3
View File
@@ -35,18 +35,18 @@ fun test_2(e: A) {
val a = <!NO_ELSE_IN_WHEN!>when<!> (e) { val a = <!NO_ELSE_IN_WHEN!>when<!> (e) {
is D -> 1 is D -> 1
is E -> 2 is E -> 2
}.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>plus<!>(0)<!> }.<!UNRESOLVED_REFERENCE!>plus<!>(0)
val b = <!NO_ELSE_IN_WHEN!>when<!> (e) { val b = <!NO_ELSE_IN_WHEN!>when<!> (e) {
is B -> 1 is B -> 1
is D -> 2 is D -> 2
is E -> 3 is E -> 3
}.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>plus<!>(0)<!> }.<!UNRESOLVED_REFERENCE!>plus<!>(0)
val c = <!NO_ELSE_IN_WHEN!>when<!> (e) { val c = <!NO_ELSE_IN_WHEN!>when<!> (e) {
is B -> 1 is B -> 1
is D -> 2 is D -> 2
}.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>plus<!>(0)<!> }.<!UNRESOLVED_REFERENCE!>plus<!>(0)
val d = when (e) { val d = when (e) {
is C -> 1 is C -> 1
compiler/fir/analysis-tests/testData/resolve/expresssions/CallBasedInExpressionGenerator.kt
Vendored
+7 -7
View File
@@ -14,27 +14,27 @@ class CallBasedInExpressionGenerator(
val codegen: ExpressionCodegen, val codegen: ExpressionCodegen,
operatorReference: KtSimpleNameExpression operatorReference: KtSimpleNameExpression
) : InExpressionGenerator { ) : InExpressionGenerator {
private val resolvedCall = operatorReference.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>getResolvedCallWithAssert<!>(codegen.<!UNRESOLVED_REFERENCE!>bindingContext<!>)<!> private val resolvedCall = operatorReference.<!UNRESOLVED_REFERENCE!>getResolvedCallWithAssert<!>(codegen.<!UNRESOLVED_REFERENCE!>bindingContext<!>)
private val isInverted = operatorReference.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>getReferencedNameElementType<!>()<!> == <!UNRESOLVED_REFERENCE!>KtTokens<!>.<!UNRESOLVED_REFERENCE!>NOT_IN<!> private val isInverted = operatorReference.<!UNRESOLVED_REFERENCE!>getReferencedNameElementType<!>() == <!UNRESOLVED_REFERENCE!>KtTokens<!>.<!UNRESOLVED_REFERENCE!>NOT_IN<!>
override fun generate(argument: StackValue): BranchedValue = override fun generate(argument: StackValue): BranchedValue =
gen(argument).let { if (isInverted) <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>Invert<!>(it)<!> else it } gen(argument).let { if (isInverted) <!UNRESOLVED_REFERENCE!>Invert<!>(it) else it }
private fun gen(argument: StackValue): BranchedValue = private fun gen(argument: StackValue): BranchedValue =
object : <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>BranchedValue<!>(argument, null, argument.<!UNRESOLVED_REFERENCE!>type<!>, <!UNRESOLVED_REFERENCE!>Opcodes<!>.<!UNRESOLVED_REFERENCE!>IFEQ<!>)<!> { object : <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>BranchedValue<!>(argument, null, argument.<!UNRESOLVED_REFERENCE!>type<!>, <!UNRESOLVED_REFERENCE!>Opcodes<!>.<!UNRESOLVED_REFERENCE!>IFEQ<!>)<!> {
override fun putSelector(type: Type, kotlinType: KotlinType?, v: InstructionAdapter) { override fun putSelector(type: Type, kotlinType: KotlinType?, v: InstructionAdapter) {
invokeFunction(v) invokeFunction(v)
<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>coerceTo<!>(type, kotlinType, v)<!> <!UNRESOLVED_REFERENCE!>coerceTo<!>(type, kotlinType, v)
} }
override fun condJump(jumpLabel: Label, v: InstructionAdapter, jumpIfFalse: Boolean) { override fun condJump(jumpLabel: Label, v: InstructionAdapter, jumpIfFalse: Boolean) {
invokeFunction(v) invokeFunction(v)
v.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>visitJumpInsn<!>(if (jumpIfFalse) <!UNRESOLVED_REFERENCE!>Opcodes<!>.<!UNRESOLVED_REFERENCE!>IFEQ<!> else <!UNRESOLVED_REFERENCE!>Opcodes<!>.<!UNRESOLVED_REFERENCE!>IFNE<!>, jumpLabel)<!> v.<!UNRESOLVED_REFERENCE!>visitJumpInsn<!>(if (jumpIfFalse) <!UNRESOLVED_REFERENCE!>Opcodes<!>.<!UNRESOLVED_REFERENCE!>IFEQ<!> else <!UNRESOLVED_REFERENCE!>Opcodes<!>.<!UNRESOLVED_REFERENCE!>IFNE<!>, jumpLabel)
} }
private fun invokeFunction(v: InstructionAdapter) { private fun invokeFunction(v: InstructionAdapter) {
val result = codegen.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>invokeFunction<!>(resolvedCall.<!UNRESOLVED_REFERENCE!>call<!>, resolvedCall, <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>none<!>()<!>)<!> val result = codegen.<!UNRESOLVED_REFERENCE!>invokeFunction<!>(resolvedCall.<!UNRESOLVED_REFERENCE!>call<!>, resolvedCall, <!UNRESOLVED_REFERENCE!>none<!>())
result.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>put<!>(result.<!UNRESOLVED_REFERENCE!>type<!>, result.<!UNRESOLVED_REFERENCE!>kotlinType<!>, v)<!> result.<!UNRESOLVED_REFERENCE!>put<!>(result.<!UNRESOLVED_REFERENCE!>type<!>, result.<!UNRESOLVED_REFERENCE!>kotlinType<!>, v)
} }
} }
} }
compiler/fir/analysis-tests/testData/resolve/expresssions/access.kt
Vendored
+2 -2
View File
@@ -43,7 +43,7 @@ fun f() {
val d = "" val d = ""
val c = <!UNRESOLVED_REFERENCE!>c<!> val c = <!UNRESOLVED_REFERENCE!>c<!>
<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>abc<!>()<!> <!UNRESOLVED_REFERENCE!>abc<!>()
fun bcd() {} fun bcd() {}
@@ -57,7 +57,7 @@ fun f() {
dcb() dcb()
} }
<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>dcb<!>()<!> <!UNRESOLVED_REFERENCE!>dcb<!>()
abc() abc()
} }
compiler/fir/analysis-tests/testData/resolve/expresssions/baseQualifier.kt
Vendored
+2 -2
View File
@@ -20,6 +20,6 @@ fun test() {
JavaClass.bar() JavaClass.bar()
val errC = BB.<!UNRESOLVED_REFERENCE!>C<!> val errC = BB.<!UNRESOLVED_REFERENCE!>C<!>
val errBarViaBB = BB.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>bar<!>()<!> val errBarViaBB = BB.<!UNRESOLVED_REFERENCE!>bar<!>()
val errBarViaAA = AA.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>bar<!>()<!> val errBarViaAA = AA.<!UNRESOLVED_REFERENCE!>bar<!>()
} }
compiler/fir/analysis-tests/testData/resolve/expresssions/enumEntryUse.kt
Vendored
+1 -1
View File
@@ -18,5 +18,5 @@ fun test() {
useEnum(TestEnum.THIRD) useEnum(TestEnum.THIRD)
useVararg(TestEnum.FIRST, TestEnum.SECOND) useVararg(TestEnum.FIRST, TestEnum.SECOND)
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>useVararg<!>(1, 2, 3, 4, 5)<!> <!INAPPLICABLE_CANDIDATE!>useVararg<!>(1, 2, 3, 4, 5)
} }
compiler/fir/analysis-tests/testData/resolve/expresssions/inference/typeParameters.kt
Vendored
+1 -1
View File
@@ -7,5 +7,5 @@ fun <T : Foo> foo(t: T) = t
fun main(fooImpl: FooImpl, bar: Bar) { fun main(fooImpl: FooImpl, bar: Bar) {
val a = foo(fooImpl) val a = foo(fooImpl)
val b = <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>(bar)<!> val b = <!INAPPLICABLE_CANDIDATE!>foo<!>(bar)
} }
compiler/fir/analysis-tests/testData/resolve/expresssions/inference/typeParameters2.kt
Vendored
+1 -1
View File
@@ -6,6 +6,6 @@ fun <T : Foo> foo(t: T) = t
fun main(fooImpl: FooImpl, fooBarImpl: FooBarImpl) { fun main(fooImpl: FooImpl, fooBarImpl: FooBarImpl) {
val a = <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!><FooImpl>(fooBarImpl)<!> val a = <!INAPPLICABLE_CANDIDATE!>foo<!><FooImpl>(fooBarImpl)
val b = foo<Foo>(fooImpl) val b = foo<Foo>(fooImpl)
} }
compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/threeReceivers.kt
Vendored
+1 -1
View File
@@ -17,6 +17,6 @@ class Foo {
// this@Foo is dispatch receiver of foobar // this@Foo is dispatch receiver of foobar
// Foo/foobar is dispatch receiver of invoke // Foo/foobar is dispatch receiver of invoke
// this@chk is extension receiver of invoke // this@chk is extension receiver of invoke
buz.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foobar<!>()<!> buz.<!UNRESOLVED_REFERENCE!>foobar<!>()
} }
} }
compiler/fir/analysis-tests/testData/resolve/expresssions/localObjects.kt
Vendored
+1 -1
View File
@@ -18,4 +18,4 @@ fun test() {
B.foo() B.foo()
} }
val bb = <!UNRESOLVED_REFERENCE!>B<!>.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!> val bb = <!UNRESOLVED_REFERENCE!>B<!>.<!UNRESOLVED_REFERENCE!>foo<!>()
compiler/fir/analysis-tests/testData/resolve/expresssions/nestedVisibility.kt
Vendored
+6 -6
View File
@@ -11,8 +11,8 @@ open class Outer {
class Derived : Outer() { class Derived : Outer() {
fun foo() { fun foo() {
Outer.<!HIDDEN{LT}!><!HIDDEN{PSI}!>PrivateNested<!>()<!> Outer.<!HIDDEN!>PrivateNested<!>()
super.<!HIDDEN{LT}!><!HIDDEN{PSI}!>PrivateInner<!>()<!> super.<!HIDDEN!>PrivateInner<!>()
Outer.ProtectedNested() Outer.ProtectedNested()
super.ProtectedInner() super.ProtectedInner()
@@ -23,11 +23,11 @@ class Derived : Outer() {
} }
fun foo() { fun foo() {
Outer.<!HIDDEN{LT}!><!HIDDEN{PSI}!>PrivateNested<!>()<!> Outer.<!HIDDEN!>PrivateNested<!>()
Outer().<!HIDDEN{LT}!><!HIDDEN{PSI}!>PrivateInner<!>()<!> Outer().<!HIDDEN!>PrivateInner<!>()
Outer.<!HIDDEN{LT}!><!HIDDEN{PSI}!>ProtectedNested<!>()<!> Outer.<!HIDDEN!>ProtectedNested<!>()
Outer().<!HIDDEN{LT}!><!HIDDEN{PSI}!>ProtectedInner<!>()<!> Outer().<!HIDDEN!>ProtectedInner<!>()
Outer.PublicNested() Outer.PublicNested()
Outer().PublicInner() Outer().PublicInner()
compiler/fir/analysis-tests/testData/resolve/expresssions/privateVisibility.kt
Vendored
+9 -9
View File
@@ -9,21 +9,21 @@ private class Private {
bar() bar()
Nested() Nested()
fromCompanion() fromCompanion()
NotCompanion.<!HIDDEN{LT}!><!HIDDEN{PSI}!>foo<!>()<!> // hidden NotCompanion.<!HIDDEN!>foo<!>() // hidden
} }
inner class Inner { inner class Inner {
fun foo() { fun foo() {
bar() bar()
fromCompanion() fromCompanion()
NotCompanion.<!HIDDEN{LT}!><!HIDDEN{PSI}!>foo<!>()<!> // hidden NotCompanion.<!HIDDEN!>foo<!>() // hidden
} }
} }
private class Nested { private class Nested {
fun foo() { fun foo() {
fromCompanion() fromCompanion()
NotCompanion.<!HIDDEN{LT}!><!HIDDEN{PSI}!>foo<!>()<!> // hidden NotCompanion.<!HIDDEN!>foo<!>() // hidden
} }
} }
@@ -54,7 +54,7 @@ fun withLocals() {
Local().baz() Local().baz()
Local().<!HIDDEN{LT}!><!HIDDEN{PSI}!>bar<!>()<!> // hidden Local().<!HIDDEN!>bar<!>() // hidden
} }
fun test() { fun test() {
@@ -62,14 +62,14 @@ fun test() {
Private().baz() Private().baz()
Private().Inner() Private().Inner()
Private().<!HIDDEN{LT}!><!HIDDEN{PSI}!>bar<!>()<!> // hidden Private().<!HIDDEN!>bar<!>() // hidden
Private.<!HIDDEN{LT}!><!HIDDEN{PSI}!>Nested<!>()<!> // hidden Private.<!HIDDEN!>Nested<!>() // hidden
Private.<!HIDDEN{LT}!><!HIDDEN{PSI}!>fromCompanion<!>()<!> // hidden Private.<!HIDDEN!>fromCompanion<!>() // hidden
} }
// FILE: second.kt // FILE: second.kt
fun secondTest() { fun secondTest() {
<!HIDDEN{LT}!><!HIDDEN{PSI}!>foo<!>()<!> // hidden <!HIDDEN!>foo<!>() // hidden
<!HIDDEN{LT}!><!HIDDEN{PSI}!>Private<!>()<!> // hidden <!HIDDEN!>Private<!>() // hidden
} }
compiler/fir/analysis-tests/testData/resolve/expresssions/protectedVisibility.kt
Vendored
+3 -3
View File
@@ -31,7 +31,7 @@ class Derived : Protected() {
fun foo() { fun foo() {
bar() bar()
Nested().foo() Nested().foo()
Nested().<!HIDDEN{LT}!><!HIDDEN{PSI}!>bar<!>()<!> // hidden Nested().<!HIDDEN!>bar<!>() // hidden
fromCompanion() fromCompanion()
protectedFromCompanion() protectedFromCompanion()
@@ -48,8 +48,8 @@ fun test() {
Protected().baz() Protected().baz()
Protected().Inner() Protected().Inner()
Protected().<!HIDDEN{LT}!><!HIDDEN{PSI}!>bar<!>()<!> // hidden Protected().<!HIDDEN!>bar<!>() // hidden
Protected.<!HIDDEN{LT}!><!HIDDEN{PSI}!>Nested<!>()<!> // hidden Protected.<!HIDDEN!>Nested<!>() // hidden
} }
open class Generic<T>(val x: T) { open class Generic<T>(val x: T) {
compiler/fir/analysis-tests/testData/resolve/expresssions/receiverConsistency.kt
Vendored
+2 -2
View File
@@ -6,7 +6,7 @@ class C {
class Nested { class Nested {
fun test() { fun test() {
<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>err<!>()<!> <!UNRESOLVED_REFERENCE!>err<!>()
} }
} }
} }
@@ -17,5 +17,5 @@ fun test() {
c.bar() c.bar()
val err = C() val err = C()
err.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!> err.<!UNRESOLVED_REFERENCE!>foo<!>()
} }
compiler/fir/analysis-tests/testData/resolve/fromBuilder/enums.kt
Vendored
+3 -3
View File
@@ -9,17 +9,17 @@ enum class Order {
enum class Planet(val m: Double, internal val r: Double) { enum class Planet(val m: Double, internal val r: Double) {
MERCURY(1.0, 2.0) { MERCURY(1.0, 2.0) {
override fun sayHello() { override fun sayHello() {
<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>println<!>("Hello!!!")<!> <!UNRESOLVED_REFERENCE!>println<!>("Hello!!!")
} }
}, },
VENERA(3.0, 4.0) { VENERA(3.0, 4.0) {
override fun sayHello() { override fun sayHello() {
<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>println<!>("Ola!!!")<!> <!UNRESOLVED_REFERENCE!>println<!>("Ola!!!")
} }
}, },
EARTH(5.0, 6.0) { EARTH(5.0, 6.0) {
override fun sayHello() { override fun sayHello() {
<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>println<!>("Privet!!!")<!> <!UNRESOLVED_REFERENCE!>println<!>("Privet!!!")
} }
}; };
compiler/fir/analysis-tests/testData/resolve/incorrectSuperCall.kt
Vendored
+1 -1
View File
@@ -15,7 +15,7 @@ class C : A, B() {
override fun foo() { override fun foo() {
super.foo() super.foo()
super.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>bar<!>()<!> // should be ambiguity (NB: really we should have overridden bar in C) super.<!UNRESOLVED_REFERENCE!>bar<!>() // should be ambiguity (NB: really we should have overridden bar in C)
super.baz() // Ok super.baz() // Ok
baz() // Ok baz() // Ok
compiler/fir/analysis-tests/testData/resolve/inference/nullableIntegerLiteralType.kt
Vendored
+2 -2
View File
@@ -4,10 +4,10 @@ fun takeInt(x: Int) {}
fun test_1(b: Boolean) { fun test_1(b: Boolean) {
val x = if (b) 1 else null val x = if (b) 1 else null
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeInt<!>(x)<!> <!INAPPLICABLE_CANDIDATE!>takeInt<!>(x)
} }
fun test_2(b: Boolean, y: Int) { fun test_2(b: Boolean, y: Int) {
val x = if (b) y else null val x = if (b) y else null
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeInt<!>(x)<!> <!INAPPLICABLE_CANDIDATE!>takeInt<!>(x)
} }
compiler/fir/analysis-tests/testData/resolve/inference/receiverWithCapturedType.kt
Vendored
+1 -1
View File
@@ -24,7 +24,7 @@ fun test_1_3(resolvedCall: ResolvedCall<CallableDescriptor>) {
} }
fun test_2_1(resolvedCall: ResolvedCall<out CallableDescriptor>, d: CallableDescriptor) { fun test_2_1(resolvedCall: ResolvedCall<out CallableDescriptor>, d: CallableDescriptor) {
val x = resolvedCall.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>updateD<!>(d)<!> // should fail val x = resolvedCall.<!INAPPLICABLE_CANDIDATE!>updateD<!>(d) // should fail
} }
fun test_2_2(resolvedCall: ResolvedCall<in CallableDescriptor>, d: CallableDescriptor) { fun test_2_2(resolvedCall: ResolvedCall<in CallableDescriptor>, d: CallableDescriptor) {
compiler/fir/analysis-tests/testData/resolve/innerClasses/inner.kt
Vendored
+3 -3
View File
@@ -23,7 +23,7 @@ class Owner {
o.foo() o.foo()
foo() foo()
this@Owner.foo() this@Owner.foo()
this.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>err<!>()<!> this.<!UNRESOLVED_REFERENCE!>err<!>()
} }
} }
} }
@@ -31,8 +31,8 @@ class Owner {
fun test() { fun test() {
val o = Owner() val o = Owner()
o.foo() o.foo()
val err = Owner.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>Inner<!>()<!> val err = Owner.<!UNRESOLVED_REFERENCE!>Inner<!>()
err.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>baz<!>()<!> err.<!UNRESOLVED_REFERENCE!>baz<!>()
val i = o.Inner() val i = o.Inner()
i.gau() i.gau()
} }
compiler/fir/analysis-tests/testData/resolve/innerClasses/innerTypes.kt
Vendored
+3 -3
View File
@@ -12,10 +12,10 @@ val rr = Outer<String>().Inner<Int>()
val rrq = Boxed<String>().substitute() val rrq = Boxed<String>().substitute()
fun check() { fun check() {
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>accept<!>(Outer<Int>().Inner<Int>())<!> // illegal <!INAPPLICABLE_CANDIDATE!>accept<!>(Outer<Int>().Inner<Int>()) // illegal
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>accept<!>(Outer<String>().Inner<String>())<!> // illegal <!INAPPLICABLE_CANDIDATE!>accept<!>(Outer<String>().Inner<String>()) // illegal
accept(Outer<String>().Inner<Int>()) // ok accept(Outer<String>().Inner<Int>()) // ok
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>accept<!>(Boxed<Int>().substitute())<!> // illegal <!INAPPLICABLE_CANDIDATE!>accept<!>(Boxed<Int>().substitute()) // illegal
accept(Boxed<String>().substitute()) // ok accept(Boxed<String>().substitute()) // ok
} }
compiler/fir/analysis-tests/testData/resolve/innerClasses/simple.kt
Vendored
+2 -2
View File
@@ -22,8 +22,8 @@ class Owner {
} }
fun err() { fun err() {
<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!> <!UNRESOLVED_REFERENCE!>foo<!>()
this.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!> this.<!UNRESOLVED_REFERENCE!>foo<!>()
} }
} }
} }
compiler/fir/analysis-tests/testData/resolve/kt41984.kt
Vendored
+1 -1
View File
@@ -26,6 +26,6 @@ open class B<V> : A<Any, V>() {
fun test_1(b: B<Int>, x: Int, inv: Inv<Int>) { fun test_1(b: B<Int>, x: Int, inv: Inv<Int>) {
b.take(x) b.take(x)
b.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>take<!>(null)<!> b.<!INAPPLICABLE_CANDIDATE!>take<!>(null)
b.takeInv(inv) b.takeInv(inv)
} }
compiler/fir/analysis-tests/testData/resolve/lambdaArgInScopeFunction.kt
Vendored
+2 -2
View File
@@ -21,7 +21,7 @@ fun case1(kotlinClass: KotlinClass?) {
{it} {it}
} }
lambda.checkType { <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>_<!><Function1<Unit, KotlinClass?>>()<!> } lambda.checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Function1<Unit, KotlinClass?>>() }
} }
// TESTCASE NUMBER: 2 // TESTCASE NUMBER: 2
fun case2(kotlinClass: KotlinClass) { fun case2(kotlinClass: KotlinClass) {
@@ -36,5 +36,5 @@ fun case2(kotlinClass: KotlinClass) {
{it} {it}
} }
lambda.checkType { <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>_<!><Function1<Unit, KotlinClass?>>()<!> } lambda.checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Function1<Unit, KotlinClass?>>() }
} }
compiler/fir/analysis-tests/testData/resolve/lambdaPropertyTypeInference.kt
Vendored
+4 -4
View File
@@ -26,9 +26,9 @@ fun case1(javaClass: JavaClass?) {
validType.checkType { _<Function1<JavaClass, Boolean>>() } //ok validType.checkType { _<Function1<JavaClass, Boolean>>() } //ok
invalidType.checkType { <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>_<!><Function1<Nothing, Boolean>>()<!> } //(!!!) invalidType.checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Function1<Nothing, Boolean>>() } //(!!!)
Case1(javaClass).x.checkType { <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>_<!><Function1<Nothing, Boolean>>()<!> } //(!!!) Case1(javaClass).x.checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Function1<Nothing, Boolean>>() } //(!!!)
} }
class Case1(val javaClass: JavaClass?) { class Case1(val javaClass: JavaClass?) {
@@ -55,9 +55,9 @@ fun case2(kotlinClass: KotlinClass?) {
validType.checkType { _<Function1<KotlinClass, Boolean>>() } //ok validType.checkType { _<Function1<KotlinClass, Boolean>>() } //ok
invalidType.checkType { <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>_<!><Function1<Nothing, Boolean>>()<!> } //(!!!) invalidType.checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Function1<Nothing, Boolean>>() } //(!!!)
Case2(kotlinClass).x.checkType { <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>_<!><Function1<Nothing, Boolean>>()<!> } //(!!!) Case2(kotlinClass).x.checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Function1<Nothing, Boolean>>() } //(!!!)
} }
class Case2(val kotlinClass: KotlinClass?) { class Case2(val kotlinClass: KotlinClass?) {
compiler/fir/analysis-tests/testData/resolve/nestedClassContructor.kt
Vendored
+1 -1
View File
@@ -17,7 +17,7 @@ class D : A.C() {
val a = A() val a = A()
val ac = A.C() val ac = A.C()
val c = <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>C<!>()<!> // shouldn't resolve val c = <!UNRESOLVED_REFERENCE!>C<!>() // shouldn't resolve
} }
} }
compiler/fir/analysis-tests/testData/resolve/overrides/simple.kt
Vendored
+1 -1
View File
@@ -14,7 +14,7 @@ class B : A() {
fun test() { fun test() {
foo() foo()
bar() bar()
<!NONE_APPLICABLE{LT}!><!NONE_APPLICABLE{PSI}!>buz<!>()<!> <!NONE_APPLICABLE!>buz<!>()
} }
} }
compiler/fir/analysis-tests/testData/resolve/overrides/supertypeGenericsComplex.kt
Vendored
+1 -1
View File
@@ -10,5 +10,5 @@ class C : Base<CharSequence>()
fun f(list: MutableList<X>, s: MutableList<CharSequence>) { fun f(list: MutableList<X>, s: MutableList<CharSequence>) {
C().f(list, s) C().f(list, s)
C().<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>f<!>(s, list)<!> C().<!INAPPLICABLE_CANDIDATE!>f<!>(s, list)
} }
compiler/fir/analysis-tests/testData/resolve/problems/definitelyNotNullAndOriginalType.kt
Vendored
+1 -1
View File
@@ -11,5 +11,5 @@ public interface SLRUMap<V> {
// FILE: main.kt // FILE: main.kt
fun <V> SLRUMap<V>.getOrPut(value: V) { fun <V> SLRUMap<V>.getOrPut(value: V) {
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeV<!>(value)<!> <!INAPPLICABLE_CANDIDATE!>takeV<!>(value)
} }
compiler/fir/analysis-tests/testData/resolve/problems/inaccessibleJavaGetter.kt
Vendored
+2 -2
View File
@@ -20,7 +20,7 @@ class WrappedPropertyDescriptor : PropertyDescriptor {
fun test() { fun test() {
val descriptor = WrappedPropertyDescriptor() val descriptor = WrappedPropertyDescriptor()
val res1 = descriptor.setter val res1 = descriptor.setter
val res2 = descriptor.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>getSetter<!>()<!> // Should be error val res2 = descriptor.<!UNRESOLVED_REFERENCE!>getSetter<!>() // Should be error
val res3 = descriptor.isDelegated val res3 = descriptor.isDelegated
val res4 = descriptor.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>isDelegated<!>()<!> // Should be error val res4 = descriptor.<!UNRESOLVED_REFERENCE!>isDelegated<!>() // Should be error
} }
compiler/fir/analysis-tests/testData/resolve/problems/multipleJavaClassesInOneFile.kt
Vendored
+1 -1
View File
@@ -10,5 +10,5 @@ class Another {}
fun test() { fun test() {
val some = Some() val some = Some()
val another = <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>Another<!>()<!> val another = <!UNRESOLVED_REFERENCE!>Another<!>()
} }
compiler/fir/analysis-tests/testData/resolve/properties/syntheticPropertiesForJavaAnnotations.kt
Vendored
+1 -1
View File
@@ -10,5 +10,5 @@ public @interface Ann {
fun test(ann: Ann) { fun test(ann: Ann) {
ann.value ann.value
ann.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>value<!>()<!> // should be an error ann.<!UNRESOLVED_REFERENCE!>value<!>() // should be an error
} }
compiler/fir/analysis-tests/testData/resolve/samConstructors/genericSamInferenceFromExpectType.kt
Vendored
+2 -2
View File
@@ -18,9 +18,9 @@ fun main() {
x.toInt().toString() x.toInt().toString()
}) })
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo2<!>(MyFunction { x: Int -> <!INAPPLICABLE_CANDIDATE!>foo2<!>(MyFunction { x: Int ->
x.toString() x.toString()
})<!> })
foo3( foo3(
MyFunction { x -> MyFunction { x ->
compiler/fir/analysis-tests/testData/resolve/samConstructors/realConstructorFunction.kt
Vendored
+4 -4
View File
@@ -10,13 +10,13 @@ fun foo(m: MyRunnable) {}
fun MyRunnable(x: (Int) -> Boolean) = 1 fun MyRunnable(x: (Int) -> Boolean) = 1
fun main() { fun main() {
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>(MyRunnable { x -> <!INAPPLICABLE_CANDIDATE!>foo<!>(MyRunnable { x ->
x > 1 x > 1
})<!> })
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>(MyRunnable({ it > 1 }))<!> <!INAPPLICABLE_CANDIDATE!>foo<!>(MyRunnable({ it > 1 }))
val x = { x: Int -> x > 1 } val x = { x: Int -> x > 1 }
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>(MyRunnable(x))<!> <!INAPPLICABLE_CANDIDATE!>foo<!>(MyRunnable(x))
} }
compiler/fir/analysis-tests/testData/resolve/samConversions/genericSam.kt
Vendored
+2 -2
View File
@@ -21,9 +21,9 @@ fun main() {
x.toInt().toString() x.toInt().toString()
} }
JavaUsage.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo2<!> { x: Int -> JavaUsage.<!INAPPLICABLE_CANDIDATE!>foo2<!> { x: Int ->
x.toString() x.toString()
}<!> }
JavaUsage.foo3( JavaUsage.foo3(
{ x -> { x ->
compiler/fir/analysis-tests/testData/resolve/samConversions/kotlinSam.kt
Vendored
+4 -4
View File
@@ -29,11 +29,11 @@ fun main() {
foo1 { x -> x > 1 } foo1 { x -> x > 1 }
foo1(f) foo1(f)
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo2<!> { x -> x <!UNRESOLVED_REFERENCE!>><!> 1 }<!> <!INAPPLICABLE_CANDIDATE!>foo2<!> { x -> x <!UNRESOLVED_REFERENCE!>><!> 1 }
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo2<!>(f)<!> <!INAPPLICABLE_CANDIDATE!>foo2<!>(f)
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo3<!> { x -> x <!UNRESOLVED_REFERENCE!>><!> 1 }<!> <!INAPPLICABLE_CANDIDATE!>foo3<!> { x -> x <!UNRESOLVED_REFERENCE!>><!> 1 }
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo3<!>(f)<!> <!INAPPLICABLE_CANDIDATE!>foo3<!>(f)
foo4 { x -> x > 1 } foo4 { x -> x > 1 }
foo4(f) foo4(f)
compiler/fir/analysis-tests/testData/resolve/samConversions/notSamBecauseOfSupertype.kt
Vendored
+4 -4
View File
@@ -18,14 +18,14 @@ public class JavaUsage {
fun foo(m: MyRunnable) {} fun foo(m: MyRunnable) {}
fun main() { fun main() {
JavaUsage.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!> { JavaUsage.<!INAPPLICABLE_CANDIDATE!>foo<!> {
x -> x ->
x <!UNRESOLVED_REFERENCE!>><!> 1 x <!UNRESOLVED_REFERENCE!>><!> 1
}<!> }
JavaUsage.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>({ <!UNRESOLVED_REFERENCE!>it<!> <!UNRESOLVED_REFERENCE!>><!> 1 })<!> JavaUsage.<!INAPPLICABLE_CANDIDATE!>foo<!>({ <!UNRESOLVED_REFERENCE!>it<!> <!UNRESOLVED_REFERENCE!>><!> 1 })
val x = { x: Int -> x > 1 } val x = { x: Int -> x > 1 }
JavaUsage.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>(x)<!> JavaUsage.<!INAPPLICABLE_CANDIDATE!>foo<!>(x)
} }
compiler/fir/analysis-tests/testData/resolve/smartcasts/booleans/booleanOperators.kt
Vendored
+7 -7
View File
@@ -24,8 +24,8 @@ fun test_1(x: Any) {
fun test_2(x: Any) { fun test_2(x: Any) {
if (x is B || x is C) { if (x is B || x is C) {
x.foo() x.foo()
x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>bar<!>()<!> x.<!UNRESOLVED_REFERENCE!>bar<!>()
x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>baz<!>()<!> x.<!UNRESOLVED_REFERENCE!>baz<!>()
} }
} }
@@ -59,26 +59,26 @@ fun test_6(x: Any) {
fun test_7(x: Any) { fun test_7(x: Any) {
if (x is A || false) { if (x is A || false) {
// TODO: should be smartcast // TODO: should be smartcast
x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!> x.<!UNRESOLVED_REFERENCE!>foo<!>()
} }
} }
fun test_8(x: Any) { fun test_8(x: Any) {
if (false || x is A) { if (false || x is A) {
// TODO: should be smartcast // TODO: should be smartcast
x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!> x.<!UNRESOLVED_REFERENCE!>foo<!>()
} }
} }
fun test_9(x: Any) { fun test_9(x: Any) {
if (x is A || true) { if (x is A || true) {
x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!> x.<!UNRESOLVED_REFERENCE!>foo<!>()
} }
} }
fun test_10(x: Any) { fun test_10(x: Any) {
if (true || x is A) { if (true || x is A) {
x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!> x.<!UNRESOLVED_REFERENCE!>foo<!>()
} }
} }
@@ -86,7 +86,7 @@ fun test_10(x: Any) {
fun test_11(x: Any, b: Boolean) { fun test_11(x: Any, b: Boolean) {
if (false && x is A) { if (false && x is A) {
x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!> x.<!UNRESOLVED_REFERENCE!>foo<!>()
} }
} }
compiler/fir/analysis-tests/testData/resolve/smartcasts/boundSmartcasts/boundSmartcasts.kt
Vendored
+2 -2
View File
@@ -30,7 +30,7 @@ fun test_3(x: Any, y: Any) {
} }
z = y z = y
if (y is B) { if (y is B) {
z.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!> z.<!UNRESOLVED_REFERENCE!>foo<!>()
z.bar() z.bar()
} }
} }
@@ -40,7 +40,7 @@ fun test_4(y: Any) {
x as Int x as Int
x.inc() x.inc()
x = y x = y
x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>inc<!>()<!> x.<!UNRESOLVED_REFERENCE!>inc<!>()
if (y is A) { if (y is A) {
x.foo() x.foo()
y.foo() y.foo()
compiler/fir/analysis-tests/testData/resolve/smartcasts/casts.kt
Vendored
+8 -8
View File
@@ -15,31 +15,31 @@ fun test_3(b: Boolean, x: Any?) {
if (b && x as Boolean) { if (b && x as Boolean) {
x.not() x.not()
} }
x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>not<!>()<!> x.<!UNRESOLVED_REFERENCE!>not<!>()
if (b && x as Boolean == true) { if (b && x as Boolean == true) {
x.not() x.not()
} }
x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>not<!>()<!> x.<!UNRESOLVED_REFERENCE!>not<!>()
if (b || x as Boolean) { if (b || x as Boolean) {
x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>not<!>()<!> x.<!UNRESOLVED_REFERENCE!>not<!>()
} }
x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>not<!>()<!> x.<!UNRESOLVED_REFERENCE!>not<!>()
} }
fun test_4(b: Any) { fun test_4(b: Any) {
if (b as? Boolean != null) { if (b as? Boolean != null) {
b.not() b.not()
} else { } else {
b.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>not<!>()<!> b.<!UNRESOLVED_REFERENCE!>not<!>()
} }
b.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>not<!>()<!> b.<!UNRESOLVED_REFERENCE!>not<!>()
if (b as? Boolean == null) { if (b as? Boolean == null) {
b.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>not<!>()<!> b.<!UNRESOLVED_REFERENCE!>not<!>()
} else { } else {
b.not() b.not()
} }
b.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>not<!>()<!> b.<!UNRESOLVED_REFERENCE!>not<!>()
} }
compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures/returns.kt
Vendored
+5 -5
View File
@@ -36,8 +36,8 @@ fun test_2(x: Any) {
else -> return else -> return
} }
x.foo() x.foo()
x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>bar<!>()<!> x.<!UNRESOLVED_REFERENCE!>bar<!>()
x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>baz<!>()<!> x.<!UNRESOLVED_REFERENCE!>baz<!>()
} }
fun test_3(x: Any) { fun test_3(x: Any) {
@@ -45,9 +45,9 @@ fun test_3(x: Any) {
x is B -> x.bar() x is B -> x.bar()
x is C -> x.baz() x is C -> x.baz()
} }
x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!> x.<!UNRESOLVED_REFERENCE!>foo<!>()
x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>bar<!>()<!> x.<!UNRESOLVED_REFERENCE!>bar<!>()
x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>baz<!>()<!> x.<!UNRESOLVED_REFERENCE!>baz<!>()
} }
fun <T> runHigherOrder(f: () -> T): T = f() fun <T> runHigherOrder(f: () -> T): T = f()
compiler/fir/analysis-tests/testData/resolve/smartcasts/loops/endlessLoops.kt
Vendored
+1 -1
View File
@@ -44,7 +44,7 @@ fun test_4(x: Any, b: Boolean) {
} }
break break
} }
x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!> // No smartcast x.<!UNRESOLVED_REFERENCE!>foo<!>() // No smartcast
} }
fun test_5(x: Any, b: Boolean) { fun test_5(x: Any, b: Boolean) {
compiler/fir/analysis-tests/testData/resolve/smartcasts/orInWhenBranch.kt
Vendored
+3 -3
View File
@@ -4,19 +4,19 @@ fun String.foo() {}
fun test_1(a: Any?) { fun test_1(a: Any?) {
when (a) { when (a) {
is String, is Any -> a.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>()<!> // Should be Bad is String, is Any -> a.<!INAPPLICABLE_CANDIDATE!>foo<!>() // Should be Bad
} }
} }
fun test_2(a: Any?) { fun test_2(a: Any?) {
if (a is String || a is Any) { if (a is String || a is Any) {
a.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>()<!> // Should be Bad a.<!INAPPLICABLE_CANDIDATE!>foo<!>() // Should be Bad
} }
} }
fun test_3(a: Any?, b: Boolean) { fun test_3(a: Any?, b: Boolean) {
when (a) { when (a) {
is String, b -> a.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>()<!> // Should be Bad is String, b -> a.<!INAPPLICABLE_CANDIDATE!>foo<!>() // Should be Bad
} }
} }
compiler/fir/analysis-tests/testData/resolve/smartcasts/receivers/implicitReceivers.kt
Vendored
+18 -18
View File
@@ -14,23 +14,23 @@ fun Any?.test_1() {
this.foo() this.foo()
foo() foo()
} else { } else {
this.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!> this.<!UNRESOLVED_REFERENCE!>foo<!>()
<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!> <!UNRESOLVED_REFERENCE!>foo<!>()
} }
this.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!> this.<!UNRESOLVED_REFERENCE!>foo<!>()
<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!> <!UNRESOLVED_REFERENCE!>foo<!>()
} }
fun Any?.test_2() { fun Any?.test_2() {
if (this !is A) { if (this !is A) {
this.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!> this.<!UNRESOLVED_REFERENCE!>foo<!>()
<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!> <!UNRESOLVED_REFERENCE!>foo<!>()
} else { } else {
this.foo() this.foo()
foo() foo()
} }
this.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!> this.<!UNRESOLVED_REFERENCE!>foo<!>()
<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!> <!UNRESOLVED_REFERENCE!>foo<!>()
} }
fun test_3(a: Any, b: Any, c: Any) { fun test_3(a: Any, b: Any, c: Any) {
@@ -49,13 +49,13 @@ fun test_3(a: Any, b: Any, c: Any) {
fun Any?.test_4() { fun Any?.test_4() {
if (this !is A) { if (this !is A) {
this.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!> this.<!UNRESOLVED_REFERENCE!>foo<!>()
<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!> <!UNRESOLVED_REFERENCE!>foo<!>()
this.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>bar<!>()<!> this.<!UNRESOLVED_REFERENCE!>bar<!>()
<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>bar<!>()<!> <!UNRESOLVED_REFERENCE!>bar<!>()
} else if (this !is B) { } else if (this !is B) {
this.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>bar<!>()<!> this.<!UNRESOLVED_REFERENCE!>bar<!>()
<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>bar<!>()<!> <!UNRESOLVED_REFERENCE!>bar<!>()
this.foo() this.foo()
foo() foo()
} else { } else {
@@ -64,10 +64,10 @@ fun Any?.test_4() {
this.bar() this.bar()
bar() bar()
} }
this.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!> this.<!UNRESOLVED_REFERENCE!>foo<!>()
<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!> <!UNRESOLVED_REFERENCE!>foo<!>()
this.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>bar<!>()<!> this.<!UNRESOLVED_REFERENCE!>bar<!>()
<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>bar<!>()<!> <!UNRESOLVED_REFERENCE!>bar<!>()
} }
fun Any.test_5(): Int = when { fun Any.test_5(): Int = when {
compiler/fir/analysis-tests/testData/resolve/smartcasts/safeCalls/safeCalls.kt
Vendored
+1 -1
View File
@@ -22,7 +22,7 @@ fun test_3(x: Any) {
(x as? A)?.bar(x)?.foo(x.bool())?.let { (x as? A)?.bar(x)?.foo(x.bool())?.let {
x.bool() x.bool()
} }
x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>bool<!>()<!> x.<!UNRESOLVED_REFERENCE!>bool<!>()
} }
fun test_4(x: A?) { fun test_4(x: A?) {
compiler/fir/analysis-tests/testData/resolve/typeAliasWithTypeArguments.kt
Vendored
+5 -5
View File
@@ -42,7 +42,7 @@ fun test_2(inv: Inv2<A, B>) {
fun test_3(inv: Inv3<A, B, C>) { fun test_3(inv: Inv3<A, B, C>) {
inv.k().foo() inv.k().foo()
inv.t().<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>bar<!>()<!> inv.t().<!UNRESOLVED_REFERENCE!>bar<!>()
inv.t().baz() inv.t().baz()
} }
@@ -74,21 +74,21 @@ typealias Invariant1<X> = Invariant<X>
fun test_5(a: A, in1: In1<A>, in2: In1<in A>, in3: In1<out A>) { fun test_5(a: A, in1: In1<A>, in2: In1<in A>, in3: In1<out A>) {
in1.take(a) in1.take(a)
in2.take(a) in2.take(a)
in3.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>take<!>(a)<!> in3.<!UNRESOLVED_REFERENCE!>take<!>(a)
} }
fun test_6(a: A, out1: Out1<A>, out2: Out1<in A>, out3: Out1<out A>) { fun test_6(a: A, out1: Out1<A>, out2: Out1<in A>, out3: Out1<out A>) {
out1.value().foo() out1.value().foo()
out2.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>value<!>()<!>.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!> out2.<!UNRESOLVED_REFERENCE!>value<!>().<!UNRESOLVED_REFERENCE!>foo<!>()
out3.value().foo() out3.value().foo()
} }
fun test_7(a: A, inv1: Invariant1<A>, inv2: Invariant1<in A>, inv3: Invariant1<out A>) { fun test_7(a: A, inv1: Invariant1<A>, inv2: Invariant1<in A>, inv3: Invariant1<out A>) {
inv1.value().foo() inv1.value().foo()
inv2.value().<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!> inv2.value().<!UNRESOLVED_REFERENCE!>foo<!>()
inv3.value().foo() inv3.value().foo()
inv1.take(a) inv1.take(a)
inv2.take(a) inv2.take(a)
inv3.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>take<!>(a)<!> inv3.<!INAPPLICABLE_CANDIDATE!>take<!>(a)
} }
compiler/fir/analysis-tests/testData/resolve/visibility/singletonConstructors.kt
Vendored
+3 -3
View File
@@ -2,12 +2,12 @@ class A {
companion object Comp {} companion object Comp {}
fun foo() { fun foo() {
<!HIDDEN{LT}!><!HIDDEN{PSI}!>Comp<!>()<!> <!HIDDEN!>Comp<!>()
} }
} }
object B { object B {
private val x = <!HIDDEN{LT}!><!HIDDEN{PSI}!>B<!>()<!> private val x = <!HIDDEN!>B<!>()
} }
class D { class D {
@@ -26,6 +26,6 @@ enum class E {
}; };
fun foo() { fun foo() {
<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>X<!>()<!> <!UNRESOLVED_REFERENCE!>X<!>()
} }
} }
compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/companions.kt
Vendored
+3 -3
View File
@@ -31,16 +31,16 @@ fun main() {
foo1(KotlinClass::baz) foo1(KotlinClass::baz)
foo2(KotlinClass::baz) foo2(KotlinClass::baz)
// Ambiguity (companion/class) // Ambiguity (companion/class)
<!AMBIGUITY{LT}!><!AMBIGUITY{PSI}!>foo3<!>(KotlinClass::baz)<!> <!AMBIGUITY!>foo3<!>(KotlinClass::baz)
// Type mismatch // Type mismatch
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo1<!>(<!UNRESOLVED_REFERENCE!>KotlinClass::bar<!>)<!> <!INAPPLICABLE_CANDIDATE!>foo1<!>(<!UNRESOLVED_REFERENCE!>KotlinClass::bar<!>)
foo2(KotlinClass::bar) foo2(KotlinClass::bar)
foo3(KotlinClass::bar) foo3(KotlinClass::bar)
foo1(KotlinClass2::bar) foo1(KotlinClass2::bar)
// Type mismatch // Type mismatch
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo2<!>(<!UNRESOLVED_REFERENCE!>KotlinClass2::bar<!>)<!> <!INAPPLICABLE_CANDIDATE!>foo2<!>(<!UNRESOLVED_REFERENCE!>KotlinClass2::bar<!>)
foo3(KotlinClass2::bar) foo3(KotlinClass2::bar)
} }
compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/fromBasicDiagnosticTests/resolveCallableReferencesAfterAllSimpleArguments.kt
Vendored
+2 -2
View File
@@ -7,6 +7,6 @@ fun <T> bar(f: (T) -> Unit, e: T) {}
fun <T> baz(e: T, f: (T) -> Unit) {} fun <T> baz(e: T, f: (T) -> Unit) {}
fun test(a: A, b: B) { fun test(a: A, b: B) {
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>baz<!>(a, <!UNRESOLVED_REFERENCE!>::fooB<!>)<!> <!INAPPLICABLE_CANDIDATE!>baz<!>(a, <!UNRESOLVED_REFERENCE!>::fooB<!>)
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>bar<!>(<!UNRESOLVED_REFERENCE!>::fooB<!>, a)<!> <!INAPPLICABLE_CANDIDATE!>bar<!>(<!UNRESOLVED_REFERENCE!>::fooB<!>, a)
} }
compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/implicitTypes.kt
Vendored
+1 -1
View File
@@ -3,5 +3,5 @@ fun <T, R> use(x: (T) -> R): (T) -> R = x
fun foo() = use(::bar) fun foo() = use(::bar)
fun bar(x: String) = 1 fun bar(x: String) = 1
fun loop1() = <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>use<!>(<!UNRESOLVED_REFERENCE!>::loop2<!>)<!> fun loop1() = <!INAPPLICABLE_CANDIDATE!>use<!>(<!UNRESOLVED_REFERENCE!>::loop2<!>)
fun loop2() = loop1() fun loop2() = loop1()
compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/javaStatic.kt
Vendored
+1 -1
View File
@@ -16,5 +16,5 @@ fun foo3(x: (String) -> Int) {}
fun main() { fun main() {
foo1(JavaClass::bar) foo1(JavaClass::bar)
foo2(JavaClass::bar) foo2(JavaClass::bar)
<!AMBIGUITY{LT}!><!AMBIGUITY{PSI}!>foo3<!>(JavaClass::bar)<!> <!AMBIGUITY!>foo3<!>(JavaClass::bar)
} }
compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/manyInnermanyOuterCandidatesAmbiguity.kt
Vendored
+1 -1
View File
@@ -6,5 +6,5 @@ fun bar(): Int = 1
fun bar(x: String): Int = 1 fun bar(x: String): Int = 1
fun main() { fun main() {
<!AMBIGUITY{LT}!><!AMBIGUITY{PSI}!>foo<!>(<!UNRESOLVED_REFERENCE!>::bar<!>)<!> <!AMBIGUITY!>foo<!>(<!UNRESOLVED_REFERENCE!>::bar<!>)
} }
compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/good/returnsImplies/booleanOperators.kt
Vendored
+2 -2
View File
@@ -59,8 +59,8 @@ fun test_2(x: Any) {
fun test_3(x: Any) { fun test_3(x: Any) {
myRequireOr(x is B, x is C) myRequireOr(x is B, x is C)
x.foo() // OK x.foo() // OK
x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>bar<!>()<!> // Error x.<!UNRESOLVED_REFERENCE!>bar<!>() // Error
x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>baz<!>()<!> // Error x.<!UNRESOLVED_REFERENCE!>baz<!>() // Error
} }
fun test_4(x: Any) { fun test_4(x: Any) {
compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/JavaVisibility2.kt
Vendored
+3 -3
View File
@@ -27,8 +27,8 @@ class A {
val p3 = JavaProtected().<!HIDDEN!>javaPProtectedPackage<!> val p3 = JavaProtected().<!HIDDEN!>javaPProtectedPackage<!>
fun test() { fun test() {
JavaProtected.<!HIDDEN{LT}!><!HIDDEN{PSI}!>javaMProtectedStatic<!>()<!> JavaProtected.<!HIDDEN!>javaMProtectedStatic<!>()
JavaPackageLocal.<!HIDDEN{LT}!><!HIDDEN{PSI}!>javaMPackage<!>()<!> JavaPackageLocal.<!HIDDEN!>javaMPackage<!>()
} }
} }
@@ -39,7 +39,7 @@ class B : JavaProtected() {
fun test() { fun test() {
JavaProtected.javaMProtectedStatic() JavaProtected.javaMProtectedStatic()
JavaPackageLocal.<!HIDDEN{LT}!><!HIDDEN{PSI}!>javaMPackage<!>()<!> JavaPackageLocal.<!HIDDEN!>javaMPackage<!>()
} }
} }
compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/KJKComplexHierarchyWithNested.kt
Vendored
+2 -2
View File
@@ -5,9 +5,9 @@ fun main(k: KSub, vString: SuperClass<String>.NestedInSuperClass, vInt: SuperCla
k.getImpl().nestedI(vString) k.getImpl().nestedI(vString)
// TODO: Support parametrisized inner classes // TODO: Support parametrisized inner classes
k.getImpl().<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>nestedI<!>(vInt)<!> k.getImpl().<!INAPPLICABLE_CANDIDATE!>nestedI<!>(vInt)
k.getNestedSubClass().nested("") k.getNestedSubClass().nested("")
k.getNestedSubClass().<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>nested<!>(1)<!> k.getNestedSubClass().<!INAPPLICABLE_CANDIDATE!>nested<!>(1)
} }
// FILE: J1.java // FILE: J1.java
compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/KotlinClassParameter.kt
Vendored
+1 -1
View File
@@ -9,5 +9,5 @@ public class JavaClass {
// FILE: K2.kt // FILE: K2.kt
fun main() { fun main() {
JavaClass.baz(KotlinClass()) JavaClass.baz(KotlinClass())
JavaClass.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>baz<!>("")<!> JavaClass.<!INAPPLICABLE_CANDIDATE!>baz<!>("")
} }
compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/KotlinClassParameterGeneric.kt
Vendored
+2 -2
View File
@@ -10,6 +10,6 @@ public class JavaClass {
fun main() { fun main() {
JavaClass.baz(KotlinClass()) JavaClass.baz(KotlinClass())
JavaClass.baz(KotlinClass<Int>()) JavaClass.baz(KotlinClass<Int>())
JavaClass.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>baz<!>(KotlinClass<String>())<!> JavaClass.<!INAPPLICABLE_CANDIDATE!>baz<!>(KotlinClass<String>())
JavaClass.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>baz<!>("")<!> JavaClass.<!INAPPLICABLE_CANDIDATE!>baz<!>("")
} }
compiler/fir/analysis-tests/testData/resolveWithStdlib/problems/KJKComplexHierarchyNestedLoop.kt
Vendored
+4 -4
View File
@@ -2,11 +2,11 @@
class K2: J1() { class K2: J1() {
class Q : <!UNRESOLVED_REFERENCE!>Nested<!>() class Q : <!UNRESOLVED_REFERENCE!>Nested<!>()
fun bar() { fun bar() {
<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!> <!UNRESOLVED_REFERENCE!>foo<!>()
<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>baz<!>()<!> <!UNRESOLVED_REFERENCE!>baz<!>()
<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>superClass<!>()<!> <!UNRESOLVED_REFERENCE!>superClass<!>()
<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>superI<!>()<!> <!UNRESOLVED_REFERENCE!>superI<!>()
} }
} }
compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/diagnostics/DiagnosticData.kt
+1
View File
@@ -43,6 +43,7 @@ enum class PositioningStrategy(private val strategy: String) {
VARIANCE_MODIFIER("VARIANCE_MODIFIER"), VARIANCE_MODIFIER("VARIANCE_MODIFIER"),
LATEINIT_MODIFIER("LATEINIT_MODIFIER"), LATEINIT_MODIFIER("LATEINIT_MODIFIER"),
SELECTOR_BY_QUALIFIED("SELECTOR_BY_QUALIFIED"), SELECTOR_BY_QUALIFIED("SELECTOR_BY_QUALIFIED"),
REFERENCE_BY_QUALIFIED("REFERENCE_BY_QUALIFIED"),
; ;
compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/diagnostics/FirDiagnosticsList.kt
+8 -7
View File
@@ -45,10 +45,10 @@ object DIAGNOSTICS_LIST : DiagnosticList() {
} }
val UNRESOLVED by object : DiagnosticGroup("Unresolved") { val UNRESOLVED by object : DiagnosticGroup("Unresolved") {
val HIDDEN by error<FirSourceElement, PsiElement> { val HIDDEN by error<FirSourceElement, PsiElement>(PositioningStrategy.REFERENCE_BY_QUALIFIED) {
parameter<AbstractFirBasedSymbol<*>>("hidden") parameter<AbstractFirBasedSymbol<*>>("hidden")
} }
val UNRESOLVED_REFERENCE by error<FirSourceElement, PsiElement> { val UNRESOLVED_REFERENCE by error<FirSourceElement, PsiElement>(PositioningStrategy.REFERENCE_BY_QUALIFIED) {
parameter<String>("reference") parameter<String>("reference")
} }
val UNRESOLVED_LABEL by error<FirSourceElement, PsiElement>() val UNRESOLVED_LABEL by error<FirSourceElement, PsiElement>()
@@ -62,7 +62,7 @@ object DIAGNOSTICS_LIST : DiagnosticList() {
val SUPER by object : DiagnosticGroup("Super") { val SUPER by object : DiagnosticGroup("Super") {
val SUPER_IS_NOT_AN_EXPRESSION by error<FirSourceElement, PsiElement>() val SUPER_IS_NOT_AN_EXPRESSION by error<FirSourceElement, PsiElement>()
val SUPER_NOT_AVAILABLE by error<FirSourceElement, PsiElement>() val SUPER_NOT_AVAILABLE by error<FirSourceElement, PsiElement>()
val ABSTRACT_SUPER_CALL by error<FirSourceElement, PsiElement>() val ABSTRACT_SUPER_CALL by error<FirSourceElement, PsiElement>(PositioningStrategy.REFERENCE_BY_QUALIFIED)
val INSTANCE_ACCESS_BEFORE_SUPER_CALL by error<FirSourceElement, PsiElement> { val INSTANCE_ACCESS_BEFORE_SUPER_CALL by error<FirSourceElement, PsiElement> {
parameter<String>("target") parameter<String>("target")
} }
@@ -152,20 +152,21 @@ object DIAGNOSTICS_LIST : DiagnosticList() {
} }
val APPLICABILITY by object : DiagnosticGroup("Applicability") { val APPLICABILITY by object : DiagnosticGroup("Applicability") {
val NONE_APPLICABLE by error<FirSourceElement, PsiElement> { val NONE_APPLICABLE by error<FirSourceElement, PsiElement>(PositioningStrategy.REFERENCE_BY_QUALIFIED) {
parameter<Collection<AbstractFirBasedSymbol<*>>>("candidates") parameter<Collection<AbstractFirBasedSymbol<*>>>("candidates")
} }
val INAPPLICABLE_CANDIDATE by error<FirSourceElement, PsiElement> { val INAPPLICABLE_CANDIDATE by error<FirSourceElement, PsiElement>(PositioningStrategy.REFERENCE_BY_QUALIFIED) {
parameter<AbstractFirBasedSymbol<*>>("candidate") parameter<AbstractFirBasedSymbol<*>>("candidate")
} }
val INAPPLICABLE_LATEINIT_MODIFIER by error<FirSourceElement, KtModifierListOwner>(PositioningStrategy.LATEINIT_MODIFIER) { val INAPPLICABLE_LATEINIT_MODIFIER by error<FirSourceElement, KtModifierListOwner>(PositioningStrategy.LATEINIT_MODIFIER) {
parameter<String>("reason") parameter<String>("reason")
} }
} }
val AMBIGUIRY by object : DiagnosticGroup("Ambiguity") { val AMBIGUIRY by object : DiagnosticGroup("Ambiguity") {
val AMBIGUITY by error<FirSourceElement, PsiElement> { val AMBIGUITY by error<FirSourceElement, PsiElement>(PositioningStrategy.REFERENCE_BY_QUALIFIED) {
parameter<Collection<AbstractFirBasedSymbol<*>>>("candidates") parameter<Collection<AbstractFirBasedSymbol<*>>>("candidates")
} }
val ASSIGN_OPERATOR_AMBIGUITY by error<FirSourceElement, PsiElement> { val ASSIGN_OPERATOR_AMBIGUITY by error<FirSourceElement, PsiElement> {
@@ -364,7 +365,7 @@ object DIAGNOSTICS_LIST : DiagnosticList() {
val UNSAFE_CALL by error<FirSourceElement, PsiElement>(PositioningStrategy.DOT_BY_QUALIFIED) { val UNSAFE_CALL by error<FirSourceElement, PsiElement>(PositioningStrategy.DOT_BY_QUALIFIED) {
parameter<ConeKotlinType>("receiverType") parameter<ConeKotlinType>("receiverType")
} }
val UNSAFE_IMPLICIT_INVOKE_CALL by error<FirSourceElement, PsiElement> { val UNSAFE_IMPLICIT_INVOKE_CALL by error<FirSourceElement, PsiElement>(PositioningStrategy.REFERENCE_BY_QUALIFIED) {
parameter<ConeKotlinType>("receiverType") parameter<ConeKotlinType>("receiverType")
} }
val UNSAFE_INFIX_CALL by error<FirSourceElement, KtExpression> { val UNSAFE_INFIX_CALL by error<FirSourceElement, KtExpression> {
compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrors.kt
+7 -7
View File
@@ -63,8 +63,8 @@ object FirErrors {
val DELEGATION_IN_INTERFACE by error0<FirSourceElement, PsiElement>() val DELEGATION_IN_INTERFACE by error0<FirSourceElement, PsiElement>()
// Unresolved // Unresolved
val HIDDEN by error1<FirSourceElement, PsiElement, AbstractFirBasedSymbol<*>>() val HIDDEN by error1<FirSourceElement, PsiElement, AbstractFirBasedSymbol<*>>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
val UNRESOLVED_REFERENCE by error1<FirSourceElement, PsiElement, String>() val UNRESOLVED_REFERENCE by error1<FirSourceElement, PsiElement, String>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
val UNRESOLVED_LABEL by error0<FirSourceElement, PsiElement>() val UNRESOLVED_LABEL by error0<FirSourceElement, PsiElement>()
val DESERIALIZATION_ERROR by error0<FirSourceElement, PsiElement>() val DESERIALIZATION_ERROR by error0<FirSourceElement, PsiElement>()
val ERROR_FROM_JAVA_RESOLUTION by error0<FirSourceElement, PsiElement>() val ERROR_FROM_JAVA_RESOLUTION by error0<FirSourceElement, PsiElement>()
@@ -75,7 +75,7 @@ object FirErrors {
// Super // Super
val SUPER_IS_NOT_AN_EXPRESSION by error0<FirSourceElement, PsiElement>() val SUPER_IS_NOT_AN_EXPRESSION by error0<FirSourceElement, PsiElement>()
val SUPER_NOT_AVAILABLE by error0<FirSourceElement, PsiElement>() val SUPER_NOT_AVAILABLE by error0<FirSourceElement, PsiElement>()
val ABSTRACT_SUPER_CALL by error0<FirSourceElement, PsiElement>() val ABSTRACT_SUPER_CALL by error0<FirSourceElement, PsiElement>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
val INSTANCE_ACCESS_BEFORE_SUPER_CALL by error1<FirSourceElement, PsiElement, String>() val INSTANCE_ACCESS_BEFORE_SUPER_CALL by error1<FirSourceElement, PsiElement, String>()
// Supertypes // Supertypes
@@ -139,12 +139,12 @@ object FirErrors {
val REDUNDANT_OPEN_IN_INTERFACE by warning0<FirSourceElement, KtModifierListOwner>(SourceElementPositioningStrategies.OPEN_MODIFIER) val REDUNDANT_OPEN_IN_INTERFACE by warning0<FirSourceElement, KtModifierListOwner>(SourceElementPositioningStrategies.OPEN_MODIFIER)
// Applicability // Applicability
val NONE_APPLICABLE by error1<FirSourceElement, PsiElement, Collection<AbstractFirBasedSymbol<*>>>() val NONE_APPLICABLE by error1<FirSourceElement, PsiElement, Collection<AbstractFirBasedSymbol<*>>>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
val INAPPLICABLE_CANDIDATE by error1<FirSourceElement, PsiElement, AbstractFirBasedSymbol<*>>() val INAPPLICABLE_CANDIDATE by error1<FirSourceElement, PsiElement, AbstractFirBasedSymbol<*>>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
val INAPPLICABLE_LATEINIT_MODIFIER by error1<FirSourceElement, KtModifierListOwner, String>(SourceElementPositioningStrategies.LATEINIT_MODIFIER) val INAPPLICABLE_LATEINIT_MODIFIER by error1<FirSourceElement, KtModifierListOwner, String>(SourceElementPositioningStrategies.LATEINIT_MODIFIER)
// Ambiguity // Ambiguity
val AMBIGUITY by error1<FirSourceElement, PsiElement, Collection<AbstractFirBasedSymbol<*>>>() val AMBIGUITY by error1<FirSourceElement, PsiElement, Collection<AbstractFirBasedSymbol<*>>>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
val ASSIGN_OPERATOR_AMBIGUITY by error1<FirSourceElement, PsiElement, Collection<AbstractFirBasedSymbol<*>>>() val ASSIGN_OPERATOR_AMBIGUITY by error1<FirSourceElement, PsiElement, Collection<AbstractFirBasedSymbol<*>>>()
// Types & type parameters // Types & type parameters
@@ -235,7 +235,7 @@ object FirErrors {
// Nullability // Nullability
val UNSAFE_CALL by error1<FirSourceElement, PsiElement, ConeKotlinType>(SourceElementPositioningStrategies.DOT_BY_QUALIFIED) val UNSAFE_CALL by error1<FirSourceElement, PsiElement, ConeKotlinType>(SourceElementPositioningStrategies.DOT_BY_QUALIFIED)
val UNSAFE_IMPLICIT_INVOKE_CALL by error1<FirSourceElement, PsiElement, ConeKotlinType>() val UNSAFE_IMPLICIT_INVOKE_CALL by error1<FirSourceElement, PsiElement, ConeKotlinType>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
val UNSAFE_INFIX_CALL by error3<FirSourceElement, KtExpression, FirExpression, String, FirExpression>() val UNSAFE_INFIX_CALL by error3<FirSourceElement, KtExpression, FirExpression, String, FirExpression>()
val UNSAFE_OPERATOR_CALL by error3<FirSourceElement, KtExpression, FirExpression, String, FirExpression>() val UNSAFE_OPERATOR_CALL by error3<FirSourceElement, KtExpression, FirExpression, String, FirExpression>()
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/LightTreePositioningStrategies.kt
+34
View File
@@ -347,6 +347,32 @@ object LightTreePositioningStrategies {
} }
} }
val REFERENCE_BY_QUALIFIED: LightTreePositioningStrategy = object : LightTreePositioningStrategy() {
override fun mark(
node: LighterASTNode,
startOffset: Int,
endOffset: Int,
tree: FlyweightCapableTreeStructure<LighterASTNode>
): List<TextRange> {
if (node.tokenType == KtNodeTypes.CALL_EXPRESSION || node.tokenType == KtNodeTypes.CONSTRUCTOR_DELEGATION_CALL) {
return markElement(tree.referenceExpression(node) ?: node, startOffset, endOffset, tree, node)
}
if (node.tokenType != KtNodeTypes.DOT_QUALIFIED_EXPRESSION && node.tokenType != KtNodeTypes.SAFE_ACCESS_EXPRESSION) {
return super.mark(node, startOffset, endOffset, tree)
}
val selector = tree.selector(node)
if (selector != null) {
when (selector.tokenType) {
KtNodeTypes.REFERENCE_EXPRESSION ->
return markElement(selector, startOffset, endOffset, tree, node)
KtNodeTypes.CALL_EXPRESSION, KtNodeTypes.CONSTRUCTOR_DELEGATION_CALL ->
return markElement(tree.referenceExpression(selector) ?: selector, startOffset, endOffset, tree, node)
}
}
return super.mark(node, startOffset, endOffset, tree)
}
}
val WHEN_EXPRESSION = object : LightTreePositioningStrategy() { val WHEN_EXPRESSION = object : LightTreePositioningStrategy() {
override fun mark( override fun mark(
node: LighterASTNode, node: LighterASTNode,
@@ -400,6 +426,14 @@ private fun FlyweightCapableTreeStructure<LighterASTNode>.nameIdentifier(node: L
private fun FlyweightCapableTreeStructure<LighterASTNode>.operationReference(node: LighterASTNode): LighterASTNode? = private fun FlyweightCapableTreeStructure<LighterASTNode>.operationReference(node: LighterASTNode): LighterASTNode? =
findChildByType(node, KtNodeTypes.OPERATION_REFERENCE) findChildByType(node, KtNodeTypes.OPERATION_REFERENCE)
private fun FlyweightCapableTreeStructure<LighterASTNode>.referenceExpression(node: LighterASTNode): LighterASTNode? {
val childrenRef = Ref<Array<LighterASTNode?>>()
getChildren(node, childrenRef)
return childrenRef.get()?.firstOrNull {
it?.tokenType == KtNodeTypes.REFERENCE_EXPRESSION || it?.tokenType == KtNodeTypes.CONSTRUCTOR_DELEGATION_REFERENCE
}
}
private fun FlyweightCapableTreeStructure<LighterASTNode>.rightParenthesis(node: LighterASTNode): LighterASTNode? = private fun FlyweightCapableTreeStructure<LighterASTNode>.rightParenthesis(node: LighterASTNode): LighterASTNode? =
findChildByType(node, KtTokens.RPAR) findChildByType(node, KtTokens.RPAR)
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/SourceElementPositioningStrategies.kt
+5
View File
@@ -108,6 +108,11 @@ object SourceElementPositioningStrategies {
PositioningStrategies.SELECTOR_BY_QUALIFIED PositioningStrategies.SELECTOR_BY_QUALIFIED
) )
val REFERENCE_BY_QUALIFIED = SourceElementPositioningStrategy(
LightTreePositioningStrategies.REFERENCE_BY_QUALIFIED,
PositioningStrategies.REFERENCE_BY_QUALIFIED
)
val WHEN_EXPRESSION = SourceElementPositioningStrategy( val WHEN_EXPRESSION = SourceElementPositioningStrategy(
LightTreePositioningStrategies.WHEN_EXPRESSION, LightTreePositioningStrategies.WHEN_EXPRESSION,
PositioningStrategies.WHEN_EXPRESSION PositioningStrategies.WHEN_EXPRESSION
compiler/frontend/src/org/jetbrains/kotlin/diagnostics/PositioningStrategies.kt
+16
View File
@@ -732,4 +732,20 @@ object PositioningStrategies {
return super.mark(element) return super.mark(element)
} }
} }
val REFERENCE_BY_QUALIFIED: PositioningStrategy<PsiElement> = object : PositioningStrategy<PsiElement>() {
override fun mark(element: PsiElement): List<TextRange> {
when (element) {
is KtQualifiedExpression -> {
when (val selectorExpression = element.selectorExpression) {
is KtCallExpression -> return mark(selectorExpression.calleeExpression ?: selectorExpression)
is KtReferenceExpression -> return mark(selectorExpression)
}
}
is KtCallExpression -> return mark(element.calleeExpression ?: element)
is KtConstructorDelegationCall -> return mark(element.calleeExpression ?: element)
}
return super.mark(element)
}
}
} }
compiler/testData/diagnostics/tests/DeprecatedGetSetPropertyDelegateConvention.fir.kt
Vendored
+2 -2
View File
@@ -33,8 +33,8 @@ operator fun CustomDelegate3.setValue(thisRef: Any?, prop: KProperty<*>, value:
class Example { class Example {
var a by <!INAPPLICABLE_CANDIDATE!>CustomDelegate()<!> var a by <!INAPPLICABLE_CANDIDATE!>CustomDelegate<!>()
val aval by <!INAPPLICABLE_CANDIDATE!>CustomDelegate()<!> val aval by <!INAPPLICABLE_CANDIDATE!>CustomDelegate<!>()
var b by OkDelegate() var b by OkDelegate()
var c by CustomDelegate2() var c by CustomDelegate2()
var d by CustomDelegate3() var d by CustomDelegate3()
compiler/testData/diagnostics/tests/FunctionCalleeExpressions.fir.kt
Vendored
+23 -23
View File
@@ -28,20 +28,20 @@ fun <T> fooT2() : (t : T) -> T {
fun main(args : Array<String>) { fun main(args : Array<String>) {
args.foo()() args.foo()()
<!INAPPLICABLE_CANDIDATE!>args.foo1()()<!> args.<!INAPPLICABLE_CANDIDATE!>foo1<!>()()
<!INAPPLICABLE_CANDIDATE!><!UNRESOLVED_REFERENCE!>a<!>.foo1()()<!> <!UNRESOLVED_REFERENCE!>a<!>.<!INAPPLICABLE_CANDIDATE!>foo1<!>()()
<!UNRESOLVED_REFERENCE!>a<!>.foo1()(<!UNRESOLVED_REFERENCE!>a<!>) <!UNRESOLVED_REFERENCE!>a<!>.foo1()(<!UNRESOLVED_REFERENCE!>a<!>)
args.foo1()(1) args.foo1()(1)
<!INAPPLICABLE_CANDIDATE!>args.foo1()("1")<!> args.<!INAPPLICABLE_CANDIDATE!>foo1<!>()("1")
<!INAPPLICABLE_CANDIDATE!><!UNRESOLVED_REFERENCE!>a<!>.foo1()("1")<!> <!UNRESOLVED_REFERENCE!>a<!>.<!INAPPLICABLE_CANDIDATE!>foo1<!>()("1")
<!UNRESOLVED_REFERENCE!>a<!>.foo1()(<!UNRESOLVED_REFERENCE!>a<!>) <!UNRESOLVED_REFERENCE!>a<!>.foo1()(<!UNRESOLVED_REFERENCE!>a<!>)
foo2()({}) foo2()({})
<!INAPPLICABLE_CANDIDATE!>foo2<!>(){} <!INAPPLICABLE_CANDIDATE!>foo2<!>(){}
(foo2()){} (foo2()){}
<!INAPPLICABLE_CANDIDATE!>(foo2()){x -> }<!> <!INAPPLICABLE_CANDIDATE!>(foo2())<!>{x -> }
<!INAPPLICABLE_CANDIDATE!>foo2()({x -> })<!> <!INAPPLICABLE_CANDIDATE!>foo2<!>()({x -> })
val a = fooT1(1)() val a = fooT1(1)()
checkSubtype<Int>(a) checkSubtype<Int>(a)
@@ -50,25 +50,25 @@ fun main(args : Array<String>) {
checkSubtype<Int>(b) checkSubtype<Int>(b)
fooT2()(1) // : Any? fooT2()(1) // : Any?
<!UNRESOLVED_REFERENCE!>1()<!> <!UNRESOLVED_REFERENCE!>1<!>()
<!UNRESOLVED_REFERENCE!>1{}<!> <!UNRESOLVED_REFERENCE!>1<!>{}
<!UNRESOLVED_REFERENCE!>1(){}<!> <!UNRESOLVED_REFERENCE!>1<!>(){}
} }
fun f() : Int.() -> Unit = {} fun f() : Int.() -> Unit = {}
fun main1() { fun main1() {
1.<!UNRESOLVED_REFERENCE!>(fun Int.() = 1)()<!>; 1.<!UNRESOLVED_REFERENCE!>(fun Int.() = 1)<!>();
{1}(); {1}();
(fun (x : Int) = x)(1) (fun (x : Int) = x)(1)
1.<!UNRESOLVED_REFERENCE!>(fun Int.(x : Int) = x)(1)<!>; 1.<!UNRESOLVED_REFERENCE!>(fun Int.(x : Int) = x)<!>(1);
l@{1}() l@{1}()
1.<!UNRESOLVED_REFERENCE!>((fun Int.() = 1))()<!> 1.<!UNRESOLVED_REFERENCE!>((fun Int.() = 1))<!>()
1.<!UNRESOLVED_REFERENCE!>(f())()<!> 1.<!UNRESOLVED_REFERENCE!>(f())<!>()
1.<!UNRESOLVED_REFERENCE!>if(true){f()}else{f()}()<!> 1.<!UNRESOLVED_REFERENCE!>if(true){f()}else{f()}<!>()
1.<!UNRESOLVED_REFERENCE!>if(true)(fun Int.() {})else{f()}()<!> 1.<!UNRESOLVED_REFERENCE!>if(true)(fun Int.() {})else{f()}<!>()
1.<!UNRESOLVED_REFERENCE!>"sdf"()<!> 1.<!UNRESOLVED_REFERENCE!>"sdf"<!>()
1."sdf" 1."sdf"
1.{} 1.{}
@@ -76,12 +76,12 @@ fun main1() {
} }
fun test() { fun test() {
<!INAPPLICABLE_CANDIDATE!>{x : Int -> 1}()<!>; <!INAPPLICABLE_CANDIDATE!>{x : Int -> 1}<!>();
<!INAPPLICABLE_CANDIDATE!>(fun Int.() = 1)()<!> <!INAPPLICABLE_CANDIDATE!>(fun Int.() = 1)<!>()
"sd".<!UNRESOLVED_REFERENCE!>(fun Int.() = 1)()<!> "sd".<!UNRESOLVED_REFERENCE!>(fun Int.() = 1)<!>()
val i : Int? = null val i : Int? = null
i.<!UNRESOLVED_REFERENCE!>(fun Int.() = 1)()<!>; i.<!UNRESOLVED_REFERENCE!>(fun Int.() = 1)<!>();
<!INAPPLICABLE_CANDIDATE!>{}<Int>()<!> <!INAPPLICABLE_CANDIDATE!>{}<!><Int>()
1?.<!UNRESOLVED_REFERENCE!>(fun Int.() = 1)()<!> 1?.<!UNRESOLVED_REFERENCE!>(fun Int.() = 1)<!>()
1.<!UNRESOLVED_REFERENCE!>{}()<!> 1.<!UNRESOLVED_REFERENCE!>{}<!>()
} }
compiler/testData/diagnostics/tests/annotations/options/targets/field.fir.kt
Vendored
+1 -1
View File
@@ -28,7 +28,7 @@ abstract class My(@Field arg: Int, @Field val w: Int) {
fun foo() {} fun foo() {}
@Field @Field
val v: Int by <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>Delegates<!>.<!UNRESOLVED_REFERENCE!>lazy<!> { 42 }<!> val v: Int by <!UNRESOLVED_REFERENCE!>Delegates<!>.<!UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE!>lazy<!> { 42 }
} }
enum class Your { enum class Your {
compiler/testData/diagnostics/tests/callableReference/function/fakeOverrideType.fir.kt
Vendored
+1 -1
View File
@@ -13,5 +13,5 @@ class B : A() {
fun test() { fun test() {
B::foo checkType { _<KFunction2<B, String, String>>() } B::foo checkType { _<KFunction2<B, String, String>>() }
<!INAPPLICABLE_CANDIDATE!>(B::hashCode)("No.")<!> <!INAPPLICABLE_CANDIDATE!>(B::hashCode)<!>("No.")
} }
compiler/testData/diagnostics/tests/controlFlowAnalysis/fieldAsClassDelegate.fir.kt
Vendored
+1 -1
View File
@@ -29,7 +29,7 @@ private fun <T> lazy(init: () -> T): <!UNRESOLVED_REFERENCE!>kotlin.Lazy<T><!> {
} }
object DefaultHttpClientWithBy : HttpClient by client { object DefaultHttpClientWithBy : HttpClient by client {
val client by <!UNRESOLVED_REFERENCE!>lazy { HttpClientImpl() }<!> val client by <!UNRESOLVED_REFERENCE!>lazy<!> { HttpClientImpl() }
} }
object DefaultFqHttpClient : HttpClient by DefaultFqHttpClient.client { object DefaultFqHttpClient : HttpClient by DefaultFqHttpClient.client {
compiler/testData/diagnostics/tests/declarationChecks/localVariablesWithTypeParameters_1_3.fir.kt
Vendored
+1 -1
View File
@@ -11,7 +11,7 @@ fun test() {
const val <T> a3 = 0 const val <T> a3 = 0
<!INAPPLICABLE_LATEINIT_MODIFIER!>lateinit<!> val <T> a4 = 0 <!INAPPLICABLE_LATEINIT_MODIFIER!>lateinit<!> val <T> a4 = 0
val <T> a5 by Delegate<Int>() val <T> a5 by Delegate<Int>()
val <T> a6 by <!INAPPLICABLE_CANDIDATE!>Delegate<<!UNRESOLVED_REFERENCE!>T<!>>()<!> val <T> a6 by <!INAPPLICABLE_CANDIDATE!>Delegate<!><<!UNRESOLVED_REFERENCE!>T<!>>()
} }
class Delegate<F> { class Delegate<F> {
compiler/testData/diagnostics/tests/declarationChecks/localVariablesWithTypeParameters_1_4.fir.kt
Vendored
+1 -1
View File
@@ -11,7 +11,7 @@ fun test() {
const val <T> a3 = 0 const val <T> a3 = 0
<!INAPPLICABLE_LATEINIT_MODIFIER!>lateinit<!> val <T> a4 = 0 <!INAPPLICABLE_LATEINIT_MODIFIER!>lateinit<!> val <T> a4 = 0
val <T> a5 by Delegate<Int>() val <T> a5 by Delegate<Int>()
val <T> a6 by <!INAPPLICABLE_CANDIDATE!>Delegate<<!UNRESOLVED_REFERENCE!>T<!>>()<!> val <T> a6 by <!INAPPLICABLE_CANDIDATE!>Delegate<!><<!UNRESOLVED_REFERENCE!>T<!>>()
} }
class Delegate<F> { class Delegate<F> {
compiler/testData/diagnostics/tests/declarationChecks/namedFunAsLastExpressionInBlock.fir.kt
Vendored
+1 -1
View File
@@ -45,7 +45,7 @@ fun test() {
x4 checkType { _<Function1<Int, Unit>>() } x4 checkType { _<Function1<Int, Unit>>() }
{ y: Int -> fun named14(): Int {return 1} } { y: Int -> fun named14(): Int {return 1} }
val b = <!UNRESOLVED_REFERENCE!>(<!EXPRESSION_REQUIRED!>fun named15(): Boolean { return true }<!>)()<!> val b = <!UNRESOLVED_REFERENCE!>(<!EXPRESSION_REQUIRED!>fun named15(): Boolean { return true }<!>)<!>()
baz(<!EXPRESSION_REQUIRED!>fun named16(){}<!>) baz(<!EXPRESSION_REQUIRED!>fun named16(){}<!>)
} }
compiler/testData/diagnostics/tests/delegatedProperty/incompleteTypeInference.fir.kt
Vendored
+2 -2
View File
@@ -5,10 +5,10 @@ import kotlin.reflect.KProperty
class A class A
class D { class D {
val c: Int by <!UNRESOLVED_REFERENCE!>IncorrectThis<A>()<!> val c: Int by <!UNRESOLVED_REFERENCE!>IncorrectThis<!><A>()
} }
val cTopLevel: Int by <!UNRESOLVED_REFERENCE!>IncorrectThis<A>()<!> val cTopLevel: Int by <!UNRESOLVED_REFERENCE!>IncorrectThis<!><A>()
class IncorrectThis<T> { class IncorrectThis<T> {
fun <R> get(t: Any?, p: KProperty<*>): Int { fun <R> get(t: Any?, p: KProperty<*>): Int {
compiler/testData/diagnostics/tests/delegatedProperty/inference/extensionProperty.fir.kt
Vendored
+2 -2
View File
@@ -4,10 +4,10 @@ package foo
import kotlin.reflect.KProperty import kotlin.reflect.KProperty
open class A { open class A {
val B.w: Int by <!INAPPLICABLE_CANDIDATE!>MyProperty()<!> val B.w: Int by <!INAPPLICABLE_CANDIDATE!>MyProperty<!>()
} }
val B.r: Int by <!INAPPLICABLE_CANDIDATE!>MyProperty()<!> val B.r: Int by <!INAPPLICABLE_CANDIDATE!>MyProperty<!>()
val A.e: Int by MyProperty() val A.e: Int by MyProperty()
compiler/testData/diagnostics/tests/delegatedProperty/inference/manyIncompleteCandidates.fir.kt
Vendored
+1 -1
View File
@@ -5,7 +5,7 @@ package test
import first.* import first.*
import second.* import second.*
val a12 by <!AMBIGUITY!>A()<!> val a12 by <!AMBIGUITY!>A<!>()
// FILE: first.kt // FILE: first.kt
package first package first
compiler/testData/diagnostics/tests/delegatedProperty/kt4640.fir.kt
Vendored
+1 -1
View File
@@ -8,4 +8,4 @@ class ValueWrapper()
fun setValue(v: Int) { backingValue = v } fun setValue(v: Int) { backingValue = v }
} }
val foo by <!INAPPLICABLE_CANDIDATE!>ValueWrapper()<!> val foo by <!INAPPLICABLE_CANDIDATE!>ValueWrapper<!>()

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