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) {
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, third = true)
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>()<!>
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>(0, 0.0, false, "")<!>
<!INAPPLICABLE_CANDIDATE!>foo<!>()
<!INAPPLICABLE_CANDIDATE!>foo<!>(0, 0.0, false, "")
bar(1, third = true)
bar(1, 2.0, true)
bar(1, 2.0, true, "my")
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>bar<!>(1, true)<!>
<!INAPPLICABLE_CANDIDATE!>bar<!>(1, true)
baz(1)
baz(1, "my", "yours")
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(1)
a.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>bar<!>()<!>
a.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>bar<!>("")<!>
a.<!INAPPLICABLE_CANDIDATE!>bar<!>()
a.<!INAPPLICABLE_CANDIDATE!>bar<!>("")
a.bar(y = 1)
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() {
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeInt<!>(10000000000)<!>
<!INAPPLICABLE_CANDIDATE!>takeInt<!>(10000000000)
takeLong(10000000000)
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(1000)<!>
<!INAPPLICABLE_CANDIDATE!>takeByte<!>(1000)
}
fun test_3() {
@@ -35,8 +35,8 @@ fun test_4() {
}
fun test_5() {
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeString<!>(1)<!>
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeString<!>(run { 1 })<!>
<!INAPPLICABLE_CANDIDATE!>takeString<!>(1)
<!INAPPLICABLE_CANDIDATE!>takeString<!>(run { 1 })
}
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>) {
A.take(array)
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeA<!>(array)<!>
<!INAPPLICABLE_CANDIDATE!>takeA<!>(array)
takeOutA(array)
}
compiler/fir/analysis-tests/testData/resolve/arguments/lambda.kt
Vendored
+7 -7
View File
@@ -10,8 +10,8 @@ fun test() {
foo({})
// Bad
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>(1) {}<!>
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>(f = {}) {}<!>
<!INAPPLICABLE_CANDIDATE!>foo<!>(1) {}
<!INAPPLICABLE_CANDIDATE!>foo<!>(f = {}) {}
// OK
bar(1) {}
@@ -20,15 +20,15 @@ fun test() {
bar(x = 1, f = {})
// Bad
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>bar<!> {}<!>
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>bar<!>({})<!>
<!INAPPLICABLE_CANDIDATE!>bar<!> {}
<!INAPPLICABLE_CANDIDATE!>bar<!>({})
// OK
baz(other = false, f = {})
baz({}, false)
// Bad
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>baz<!> {}<!>
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>baz<!>() {}<!>
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>baz<!>(other = false) {}<!>
<!INAPPLICABLE_CANDIDATE!>baz<!> {}
<!INAPPLICABLE_CANDIDATE!>baz<!>() {}
<!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 test_1() {
<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>myRun<!> {
<!UNRESOLVED_REFERENCE!>myRun<!> {
val x = 1
x * 2
}<!>
}
}
fun test_2() {
<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>myRun<!> {
<!UNRESOLVED_REFERENCE!>myRun<!> {
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 test_4() {
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(1 + 1)<!>
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(1 + 127)<!>
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(1 - 1)<!>
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(-100 - 100)<!>
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(10 * 10)<!>
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(100 * 100)<!>
<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>taleByte<!>(10 / 10)<!>
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(100 % 10)<!>
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(1000 % 10)<!>
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(1000 and 100)<!>
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(128 and 511)<!>
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(100 or 100)<!>
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(1000 or 0)<!>
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(511 xor 511)<!>
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(512 xor 511)<!>
<!INAPPLICABLE_CANDIDATE!>takeByte<!>(1 + 1)
<!INAPPLICABLE_CANDIDATE!>takeByte<!>(1 + 127)
<!INAPPLICABLE_CANDIDATE!>takeByte<!>(1 - 1)
<!INAPPLICABLE_CANDIDATE!>takeByte<!>(-100 - 100)
<!INAPPLICABLE_CANDIDATE!>takeByte<!>(10 * 10)
<!INAPPLICABLE_CANDIDATE!>takeByte<!>(100 * 100)
<!UNRESOLVED_REFERENCE!>taleByte<!>(10 / 10)
<!INAPPLICABLE_CANDIDATE!>takeByte<!>(100 % 10)
<!INAPPLICABLE_CANDIDATE!>takeByte<!>(1000 % 10)
<!INAPPLICABLE_CANDIDATE!>takeByte<!>(1000 and 100)
<!INAPPLICABLE_CANDIDATE!>takeByte<!>(128 and 511)
<!INAPPLICABLE_CANDIDATE!>takeByte<!>(100 or 100)
<!INAPPLICABLE_CANDIDATE!>takeByte<!>(1000 or 0)
<!INAPPLICABLE_CANDIDATE!>takeByte<!>(511 xor 511)
<!INAPPLICABLE_CANDIDATE!>takeByte<!>(512 xor 511)
}
fun test_5() {
takeByte(-1)
takeByte(+1)
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(1.inv())<!>
<!INAPPLICABLE_CANDIDATE!>takeByte<!>(1.inv())
}
fun test_6() {
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(run { 127 + 1 })<!>
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(1 + run { 1 })<!>
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(run { 1 + 1 })<!>
<!INAPPLICABLE_CANDIDATE!>takeByte<!>(run { 127 + 1 })
<!INAPPLICABLE_CANDIDATE!>takeByte<!>(1 + run { 1 })
<!INAPPLICABLE_CANDIDATE!>takeByte<!>(run { 1 + 1 })
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(third = false, second = 2.71, fourth = "?!", first = 0)
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>()<!>
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>(0.0, false, 0, "")<!>
<!INAPPLICABLE_CANDIDATE!>foo<!>()
<!INAPPLICABLE_CANDIDATE!>foo<!>(0.0, false, 0, "")
foo(1, 2.0, third = true, "")
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>(second = 0.0, first = 0, fourth = "")<!>
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>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{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>(0, 0.0, false, foth = "")<!>
<!INAPPLICABLE_CANDIDATE!>foo<!>(second = 0.0, first = 0, fourth = "")
<!INAPPLICABLE_CANDIDATE!>foo<!>(first = 0.0, second = 0, third = "", fourth = false)
<!INAPPLICABLE_CANDIDATE!>foo<!>(first = 0, second = 0.0, third = false, fourth = "", first = 1)
<!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, *arrayOf("my", "yours"))
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>("")<!>
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>(1, 2)<!>
<!INAPPLICABLE_CANDIDATE!>foo<!>("")
<!INAPPLICABLE_CANDIDATE!>foo<!>(1, 2)
bar(1, z = true, y = *arrayOf("my", "yours"))
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>bar<!>(0, z = false, y = "", y = "other")<!>
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>bar<!>(0, "", true)<!>
<!INAPPLICABLE_CANDIDATE!>bar<!>(0, z = false, y = "", y = "other")
<!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
fun test_1() {
val a = <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>A<!>()<!>
val a = <!UNRESOLVED_REFERENCE!>A<!>()
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) {
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) {
// Argument mapping error
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>("")<!>
<!INAPPLICABLE_CANDIDATE!>foo<!>("")
// Ambiguity
<!AMBIGUITY{LT}!><!AMBIGUITY{PSI}!>bar<!>(c)<!>
<!AMBIGUITY!>bar<!>(c)
// 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() {
{ "" }.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>bar<!>()<!>
{ "" }.<!INAPPLICABLE_CANDIDATE!>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(
id(
run {
y.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>inc<!>()<!> // Bad
y.<!UNRESOLVED_REFERENCE!>inc<!>() // Bad
x as Int
}
),
@@ -39,14 +39,14 @@ fun test_3(x: Any, y: Any) {
val a = select(
id(
run {
y.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>inc<!>()<!> // Bad
y.<!UNRESOLVED_REFERENCE!>inc<!>() // Bad
x as Int
materialize()
}
),
run {
y as Int
x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>inc<!>()<!> // Bad
x.<!UNRESOLVED_REFERENCE!>inc<!>() // Bad
y.inc() // OK
1
}
@@ -60,19 +60,19 @@ fun test_4(x: Any, y: Any) {
val a = select(
id(
myRun {
y.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>inc<!>()<!> // Bad
y.<!UNRESOLVED_REFERENCE!>inc<!>() // Bad
x as Int
}
),
y as Int,
myRun {
x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>inc<!>()<!> // Bad
x.<!UNRESOLVED_REFERENCE!>inc<!>() // Bad
y.inc() // OK
1
}
)
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeInt<!>(x)<!> // Bad
<!INAPPLICABLE_CANDIDATE!>takeInt<!>(x) // Bad
takeInt(y) // OK
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() {
super.<!ABSTRACT_SUPER_CALL{LT}!><!ABSTRACT_SUPER_CALL{PSI}!>f<!>()<!>
super.<!ABSTRACT_SUPER_CALL!>f<!>()
super.t()
super.x
@@ -32,7 +32,7 @@ class B : A() {
abstract class J : A() {
fun r() {
super.<!ABSTRACT_SUPER_CALL{LT}!><!ABSTRACT_SUPER_CALL{PSI}!>f<!>()<!>
super.<!ABSTRACT_SUPER_CALL!>f<!>()
super.t()
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() {
override fun toString(): String = super.toString() // resolve to Any.toString
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 {
<!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 {
<!EXPLICIT_DELEGATION_CALL_REQUIRED, NONE_APPLICABLE!>constructor()<!>
<!EXPLICIT_DELEGATION_CALL_REQUIRED!>constructor()<!><!NONE_APPLICABLE!><!>
constructor(z: String) : this()
}
<!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()
}<!>
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()
}
compiler/fir/analysis-tests/testData/resolve/diagnostics/instanceAccessBeforeSuperCall.kt
Vendored
+1 -1
View File
@@ -1,5 +1,5 @@
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
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 {
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()
}
}
compiler/fir/analysis-tests/testData/resolve/diagnostics/sealedClassConstructorCall.kt
Vendored
+1 -1
View File
@@ -1,3 +1,3 @@
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() {
<!SUPER_IS_NOT_AN_EXPRESSION!>super<!>()
<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>invoke<!>()<!>
<!UNRESOLVED_REFERENCE!>invoke<!>()
<!SUPER_IS_NOT_AN_EXPRESSION!>super<!> {
<!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() {
<!SUPER_NOT_AVAILABLE!>super@f<!>.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>compareTo<!>("")<!>
<!SUPER_NOT_AVAILABLE!>super<!>.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>compareTo<!>("")<!>
<!SUPER_NOT_AVAILABLE!>super@f<!>.<!UNRESOLVED_REFERENCE!>compareTo<!>("")
<!SUPER_NOT_AVAILABLE!>super<!>.<!UNRESOLVED_REFERENCE!>compareTo<!>("")
}
fun foo() {
<!SUPER_NOT_AVAILABLE!>super<!>
<!SUPER_NOT_AVAILABLE!>super<!>.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
<!SUPER_NOT_AVAILABLE!>super<Nothing><!>.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
<!SUPER_NOT_AVAILABLE!>super<!>.<!UNRESOLVED_REFERENCE!>foo<!>()
<!SUPER_NOT_AVAILABLE!>super<Nothing><!>.<!UNRESOLVED_REFERENCE!>foo<!>()
}
class A {
fun act() {
<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>println<!>("Test")<!>
<!UNRESOLVED_REFERENCE!>println<!>("Test")
}
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 b = Best.<!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!>MyClass<!><String>
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}!>)<!>
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)
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) {
JavaEnum.A -> 1
JavaEnum.B -> 2
}.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>plus<!>(0)<!>
}.<!UNRESOLVED_REFERENCE!>plus<!>(0)
val b = <!NO_ELSE_IN_WHEN!>when<!> (e) {
JavaEnum.A -> 1
JavaEnum.B -> 2
is String -> 3
}.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>plus<!>(0)<!>
}.<!UNRESOLVED_REFERENCE!>plus<!>(0)
val c = when (e) {
JavaEnum.A -> 1
@@ -35,7 +35,7 @@ fun test_2(e: JavaEnum?) {
JavaEnum.A -> 1
JavaEnum.B -> 2
JavaEnum.C -> 3
}.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>plus<!>(0)<!>
}.<!UNRESOLVED_REFERENCE!>plus<!>(0)
val a = when (e) {
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) {
is D -> 1
is E -> 2
}.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>plus<!>(0)<!>
}.<!UNRESOLVED_REFERENCE!>plus<!>(0)
val b = <!NO_ELSE_IN_WHEN!>when<!> (e) {
is B -> 1
is D -> 2
is E -> 3
}.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>plus<!>(0)<!>
}.<!UNRESOLVED_REFERENCE!>plus<!>(0)
val c = <!NO_ELSE_IN_WHEN!>when<!> (e) {
is B -> 1
is D -> 2
}.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>plus<!>(0)<!>
}.<!UNRESOLVED_REFERENCE!>plus<!>(0)
val d = when (e) {
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,
operatorReference: KtSimpleNameExpression
) : InExpressionGenerator {
private val resolvedCall = operatorReference.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>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 resolvedCall = operatorReference.<!UNRESOLVED_REFERENCE!>getResolvedCallWithAssert<!>(codegen.<!UNRESOLVED_REFERENCE!>bindingContext<!>)
private val isInverted = operatorReference.<!UNRESOLVED_REFERENCE!>getReferencedNameElementType<!>() == <!UNRESOLVED_REFERENCE!>KtTokens<!>.<!UNRESOLVED_REFERENCE!>NOT_IN<!>
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 =
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) {
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) {
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) {
val result = codegen.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>invokeFunction<!>(resolvedCall.<!UNRESOLVED_REFERENCE!>call<!>, resolvedCall, <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>none<!>()<!>)<!>
result.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>put<!>(result.<!UNRESOLVED_REFERENCE!>type<!>, result.<!UNRESOLVED_REFERENCE!>kotlinType<!>, v)<!>
val result = codegen.<!UNRESOLVED_REFERENCE!>invokeFunction<!>(resolvedCall.<!UNRESOLVED_REFERENCE!>call<!>, resolvedCall, <!UNRESOLVED_REFERENCE!>none<!>())
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 c = <!UNRESOLVED_REFERENCE!>c<!>
<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>abc<!>()<!>
<!UNRESOLVED_REFERENCE!>abc<!>()
fun bcd() {}
@@ -57,7 +57,7 @@ fun f() {
dcb()
}
<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>dcb<!>()<!>
<!UNRESOLVED_REFERENCE!>dcb<!>()
abc()
}
compiler/fir/analysis-tests/testData/resolve/expresssions/baseQualifier.kt
Vendored
+2 -2
View File
@@ -20,6 +20,6 @@ fun test() {
JavaClass.bar()
val errC = BB.<!UNRESOLVED_REFERENCE!>C<!>
val errBarViaBB = BB.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>bar<!>()<!>
val errBarViaAA = AA.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>bar<!>()<!>
val errBarViaBB = BB.<!UNRESOLVED_REFERENCE!>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)
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) {
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) {
val a = <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!><FooImpl>(fooBarImpl)<!>
val a = <!INAPPLICABLE_CANDIDATE!>foo<!><FooImpl>(fooBarImpl)
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
// Foo/foobar is dispatch 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()
}
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() {
fun foo() {
Outer.<!HIDDEN{LT}!><!HIDDEN{PSI}!>PrivateNested<!>()<!>
super.<!HIDDEN{LT}!><!HIDDEN{PSI}!>PrivateInner<!>()<!>
Outer.<!HIDDEN!>PrivateNested<!>()
super.<!HIDDEN!>PrivateInner<!>()
Outer.ProtectedNested()
super.ProtectedInner()
@@ -23,11 +23,11 @@ class Derived : Outer() {
}
fun foo() {
Outer.<!HIDDEN{LT}!><!HIDDEN{PSI}!>PrivateNested<!>()<!>
Outer().<!HIDDEN{LT}!><!HIDDEN{PSI}!>PrivateInner<!>()<!>
Outer.<!HIDDEN!>PrivateNested<!>()
Outer().<!HIDDEN!>PrivateInner<!>()
Outer.<!HIDDEN{LT}!><!HIDDEN{PSI}!>ProtectedNested<!>()<!>
Outer().<!HIDDEN{LT}!><!HIDDEN{PSI}!>ProtectedInner<!>()<!>
Outer.<!HIDDEN!>ProtectedNested<!>()
Outer().<!HIDDEN!>ProtectedInner<!>()
Outer.PublicNested()
Outer().PublicInner()
compiler/fir/analysis-tests/testData/resolve/expresssions/privateVisibility.kt
Vendored
+9 -9
View File
@@ -9,21 +9,21 @@ private class Private {
bar()
Nested()
fromCompanion()
NotCompanion.<!HIDDEN{LT}!><!HIDDEN{PSI}!>foo<!>()<!> // hidden
NotCompanion.<!HIDDEN!>foo<!>() // hidden
}
inner class Inner {
fun foo() {
bar()
fromCompanion()
NotCompanion.<!HIDDEN{LT}!><!HIDDEN{PSI}!>foo<!>()<!> // hidden
NotCompanion.<!HIDDEN!>foo<!>() // hidden
}
}
private class Nested {
fun foo() {
fromCompanion()
NotCompanion.<!HIDDEN{LT}!><!HIDDEN{PSI}!>foo<!>()<!> // hidden
NotCompanion.<!HIDDEN!>foo<!>() // hidden
}
}
@@ -54,7 +54,7 @@ fun withLocals() {
Local().baz()
Local().<!HIDDEN{LT}!><!HIDDEN{PSI}!>bar<!>()<!> // hidden
Local().<!HIDDEN!>bar<!>() // hidden
}
fun test() {
@@ -62,14 +62,14 @@ fun test() {
Private().baz()
Private().Inner()
Private().<!HIDDEN{LT}!><!HIDDEN{PSI}!>bar<!>()<!> // hidden
Private.<!HIDDEN{LT}!><!HIDDEN{PSI}!>Nested<!>()<!> // hidden
Private.<!HIDDEN{LT}!><!HIDDEN{PSI}!>fromCompanion<!>()<!> // hidden
Private().<!HIDDEN!>bar<!>() // hidden
Private.<!HIDDEN!>Nested<!>() // hidden
Private.<!HIDDEN!>fromCompanion<!>() // hidden
}
// FILE: second.kt
fun secondTest() {
<!HIDDEN{LT}!><!HIDDEN{PSI}!>foo<!>()<!> // hidden
<!HIDDEN{LT}!><!HIDDEN{PSI}!>Private<!>()<!> // hidden
<!HIDDEN!>foo<!>() // 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() {
bar()
Nested().foo()
Nested().<!HIDDEN{LT}!><!HIDDEN{PSI}!>bar<!>()<!> // hidden
Nested().<!HIDDEN!>bar<!>() // hidden
fromCompanion()
protectedFromCompanion()
@@ -48,8 +48,8 @@ fun test() {
Protected().baz()
Protected().Inner()
Protected().<!HIDDEN{LT}!><!HIDDEN{PSI}!>bar<!>()<!> // hidden
Protected.<!HIDDEN{LT}!><!HIDDEN{PSI}!>Nested<!>()<!> // hidden
Protected().<!HIDDEN!>bar<!>() // hidden
Protected.<!HIDDEN!>Nested<!>() // hidden
}
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 {
fun test() {
<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>err<!>()<!>
<!UNRESOLVED_REFERENCE!>err<!>()
}
}
}
@@ -17,5 +17,5 @@ fun test() {
c.bar()
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) {
MERCURY(1.0, 2.0) {
override fun sayHello() {
<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>println<!>("Hello!!!")<!>
<!UNRESOLVED_REFERENCE!>println<!>("Hello!!!")
}
},
VENERA(3.0, 4.0) {
override fun sayHello() {
<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>println<!>("Ola!!!")<!>
<!UNRESOLVED_REFERENCE!>println<!>("Ola!!!")
}
},
EARTH(5.0, 6.0) {
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() {
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
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) {
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) {
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) {
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) {
compiler/fir/analysis-tests/testData/resolve/innerClasses/inner.kt
Vendored
+3 -3
View File
@@ -23,7 +23,7 @@ class Owner {
o.foo()
foo()
this@Owner.foo()
this.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>err<!>()<!>
this.<!UNRESOLVED_REFERENCE!>err<!>()
}
}
}
@@ -31,8 +31,8 @@ class Owner {
fun test() {
val o = Owner()
o.foo()
val err = Owner.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>Inner<!>()<!>
err.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>baz<!>()<!>
val err = Owner.<!UNRESOLVED_REFERENCE!>Inner<!>()
err.<!UNRESOLVED_REFERENCE!>baz<!>()
val i = o.Inner()
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()
fun check() {
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>accept<!>(Outer<Int>().Inner<Int>())<!> // illegal
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>accept<!>(Outer<String>().Inner<String>())<!> // illegal
<!INAPPLICABLE_CANDIDATE!>accept<!>(Outer<Int>().Inner<Int>()) // illegal
<!INAPPLICABLE_CANDIDATE!>accept<!>(Outer<String>().Inner<String>()) // illegal
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
}
compiler/fir/analysis-tests/testData/resolve/innerClasses/simple.kt
Vendored
+2 -2
View File
@@ -22,8 +22,8 @@ class Owner {
}
fun err() {
<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
this.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
<!UNRESOLVED_REFERENCE!>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>) {
b.take(x)
b.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>take<!>(null)<!>
b.<!INAPPLICABLE_CANDIDATE!>take<!>(null)
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}
}
lambda.checkType { <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>_<!><Function1<Unit, KotlinClass?>>()<!> }
lambda.checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Function1<Unit, KotlinClass?>>() }
}
// TESTCASE NUMBER: 2
fun case2(kotlinClass: KotlinClass) {
@@ -36,5 +36,5 @@ fun case2(kotlinClass: KotlinClass) {
{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
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?) {
@@ -55,9 +55,9 @@ fun case2(kotlinClass: KotlinClass?) {
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?) {
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 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() {
foo()
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>) {
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
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() {
val descriptor = WrappedPropertyDescriptor()
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 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() {
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) {
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()
})
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo2<!>(MyFunction { x: Int ->
<!INAPPLICABLE_CANDIDATE!>foo2<!>(MyFunction { x: Int ->
x.toString()
})<!>
})
foo3(
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 main() {
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>(MyRunnable { x ->
<!INAPPLICABLE_CANDIDATE!>foo<!>(MyRunnable { x ->
x > 1
})<!>
})
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>(MyRunnable({ it > 1 }))<!>
<!INAPPLICABLE_CANDIDATE!>foo<!>(MyRunnable({ it > 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()
}
JavaUsage.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo2<!> { x: Int ->
JavaUsage.<!INAPPLICABLE_CANDIDATE!>foo2<!> { x: Int ->
x.toString()
}<!>
}
JavaUsage.foo3(
{ 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(f)
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo2<!> { x -> x <!UNRESOLVED_REFERENCE!>><!> 1 }<!>
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo2<!>(f)<!>
<!INAPPLICABLE_CANDIDATE!>foo2<!> { x -> x <!UNRESOLVED_REFERENCE!>><!> 1 }
<!INAPPLICABLE_CANDIDATE!>foo2<!>(f)
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo3<!> { x -> x <!UNRESOLVED_REFERENCE!>><!> 1 }<!>
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo3<!>(f)<!>
<!INAPPLICABLE_CANDIDATE!>foo3<!> { x -> x <!UNRESOLVED_REFERENCE!>><!> 1 }
<!INAPPLICABLE_CANDIDATE!>foo3<!>(f)
foo4 { x -> x > 1 }
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 main() {
JavaUsage.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!> {
JavaUsage.<!INAPPLICABLE_CANDIDATE!>foo<!> {
x ->
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 }
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) {
if (x is B || x is C) {
x.foo()
x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>bar<!>()<!>
x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>baz<!>()<!>
x.<!UNRESOLVED_REFERENCE!>bar<!>()
x.<!UNRESOLVED_REFERENCE!>baz<!>()
}
}
@@ -59,26 +59,26 @@ fun test_6(x: Any) {
fun test_7(x: Any) {
if (x is A || false) {
// TODO: should be smartcast
x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
x.<!UNRESOLVED_REFERENCE!>foo<!>()
}
}
fun test_8(x: Any) {
if (false || x is A) {
// TODO: should be smartcast
x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
x.<!UNRESOLVED_REFERENCE!>foo<!>()
}
}
fun test_9(x: Any) {
if (x is A || true) {
x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
x.<!UNRESOLVED_REFERENCE!>foo<!>()
}
}
fun test_10(x: Any) {
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) {
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
if (y is B) {
z.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
z.<!UNRESOLVED_REFERENCE!>foo<!>()
z.bar()
}
}
@@ -40,7 +40,7 @@ fun test_4(y: Any) {
x as Int
x.inc()
x = y
x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>inc<!>()<!>
x.<!UNRESOLVED_REFERENCE!>inc<!>()
if (y is A) {
x.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) {
x.not()
}
x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>not<!>()<!>
x.<!UNRESOLVED_REFERENCE!>not<!>()
if (b && x as Boolean == true) {
x.not()
}
x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>not<!>()<!>
x.<!UNRESOLVED_REFERENCE!>not<!>()
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) {
if (b as? Boolean != null) {
b.not()
} 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) {
b.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>not<!>()<!>
b.<!UNRESOLVED_REFERENCE!>not<!>()
} else {
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
}
x.foo()
x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>bar<!>()<!>
x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>baz<!>()<!>
x.<!UNRESOLVED_REFERENCE!>bar<!>()
x.<!UNRESOLVED_REFERENCE!>baz<!>()
}
fun test_3(x: Any) {
@@ -45,9 +45,9 @@ fun test_3(x: Any) {
x is B -> x.bar()
x is C -> x.baz()
}
x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>bar<!>()<!>
x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>baz<!>()<!>
x.<!UNRESOLVED_REFERENCE!>foo<!>()
x.<!UNRESOLVED_REFERENCE!>bar<!>()
x.<!UNRESOLVED_REFERENCE!>baz<!>()
}
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
}
x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!> // No smartcast
x.<!UNRESOLVED_REFERENCE!>foo<!>() // No smartcast
}
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?) {
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?) {
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) {
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()
foo()
} else {
this.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
this.<!UNRESOLVED_REFERENCE!>foo<!>()
<!UNRESOLVED_REFERENCE!>foo<!>()
}
this.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
this.<!UNRESOLVED_REFERENCE!>foo<!>()
<!UNRESOLVED_REFERENCE!>foo<!>()
}
fun Any?.test_2() {
if (this !is A) {
this.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
this.<!UNRESOLVED_REFERENCE!>foo<!>()
<!UNRESOLVED_REFERENCE!>foo<!>()
} else {
this.foo()
foo()
}
this.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
this.<!UNRESOLVED_REFERENCE!>foo<!>()
<!UNRESOLVED_REFERENCE!>foo<!>()
}
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() {
if (this !is A) {
this.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
this.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>bar<!>()<!>
<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>bar<!>()<!>
this.<!UNRESOLVED_REFERENCE!>foo<!>()
<!UNRESOLVED_REFERENCE!>foo<!>()
this.<!UNRESOLVED_REFERENCE!>bar<!>()
<!UNRESOLVED_REFERENCE!>bar<!>()
} else if (this !is B) {
this.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>bar<!>()<!>
<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>bar<!>()<!>
this.<!UNRESOLVED_REFERENCE!>bar<!>()
<!UNRESOLVED_REFERENCE!>bar<!>()
this.foo()
foo()
} else {
@@ -64,10 +64,10 @@ fun Any?.test_4() {
this.bar()
bar()
}
this.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
this.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>bar<!>()<!>
<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>bar<!>()<!>
this.<!UNRESOLVED_REFERENCE!>foo<!>()
<!UNRESOLVED_REFERENCE!>foo<!>()
this.<!UNRESOLVED_REFERENCE!>bar<!>()
<!UNRESOLVED_REFERENCE!>bar<!>()
}
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.bool()
}
x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>bool<!>()<!>
x.<!UNRESOLVED_REFERENCE!>bool<!>()
}
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>) {
inv.k().foo()
inv.t().<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>bar<!>()<!>
inv.t().<!UNRESOLVED_REFERENCE!>bar<!>()
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>) {
in1.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>) {
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()
}
fun test_7(a: A, inv1: Invariant1<A>, inv2: Invariant1<in A>, inv3: Invariant1<out A>) {
inv1.value().foo()
inv2.value().<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
inv2.value().<!UNRESOLVED_REFERENCE!>foo<!>()
inv3.value().foo()
inv1.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 {}
fun foo() {
<!HIDDEN{LT}!><!HIDDEN{PSI}!>Comp<!>()<!>
<!HIDDEN!>Comp<!>()
}
}
object B {
private val x = <!HIDDEN{LT}!><!HIDDEN{PSI}!>B<!>()<!>
private val x = <!HIDDEN!>B<!>()
}
class D {
@@ -26,6 +26,6 @@ enum class E {
};
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)
foo2(KotlinClass::baz)
// Ambiguity (companion/class)
<!AMBIGUITY{LT}!><!AMBIGUITY{PSI}!>foo3<!>(KotlinClass::baz)<!>
<!AMBIGUITY!>foo3<!>(KotlinClass::baz)
// Type mismatch
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo1<!>(<!UNRESOLVED_REFERENCE!>KotlinClass::bar<!>)<!>
<!INAPPLICABLE_CANDIDATE!>foo1<!>(<!UNRESOLVED_REFERENCE!>KotlinClass::bar<!>)
foo2(KotlinClass::bar)
foo3(KotlinClass::bar)
foo1(KotlinClass2::bar)
// Type mismatch
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo2<!>(<!UNRESOLVED_REFERENCE!>KotlinClass2::bar<!>)<!>
<!INAPPLICABLE_CANDIDATE!>foo2<!>(<!UNRESOLVED_REFERENCE!>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 test(a: A, b: B) {
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>baz<!>(a, <!UNRESOLVED_REFERENCE!>::fooB<!>)<!>
<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>bar<!>(<!UNRESOLVED_REFERENCE!>::fooB<!>, a)<!>
<!INAPPLICABLE_CANDIDATE!>baz<!>(a, <!UNRESOLVED_REFERENCE!>::fooB<!>)
<!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 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()
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() {
foo1(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 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) {
myRequireOr(x is B, x is C)
x.foo() // OK
x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>bar<!>()<!> // Error
x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>baz<!>()<!> // Error
x.<!UNRESOLVED_REFERENCE!>bar<!>() // Error
x.<!UNRESOLVED_REFERENCE!>baz<!>() // Error
}
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<!>
fun test() {
JavaProtected.<!HIDDEN{LT}!><!HIDDEN{PSI}!>javaMProtectedStatic<!>()<!>
JavaPackageLocal.<!HIDDEN{LT}!><!HIDDEN{PSI}!>javaMPackage<!>()<!>
JavaProtected.<!HIDDEN!>javaMProtectedStatic<!>()
JavaPackageLocal.<!HIDDEN!>javaMPackage<!>()
}
}
@@ -39,7 +39,7 @@ class B : JavaProtected() {
fun test() {
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)
// 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().<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>nested<!>(1)<!>
k.getNestedSubClass().<!INAPPLICABLE_CANDIDATE!>nested<!>(1)
}
// 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
fun main() {
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() {
JavaClass.baz(KotlinClass())
JavaClass.baz(KotlinClass<Int>())
JavaClass.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>baz<!>(KotlinClass<String>())<!>
JavaClass.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>baz<!>("")<!>
JavaClass.<!INAPPLICABLE_CANDIDATE!>baz<!>(KotlinClass<String>())
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 Q : <!UNRESOLVED_REFERENCE!>Nested<!>()
fun bar() {
<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>baz<!>()<!>
<!UNRESOLVED_REFERENCE!>foo<!>()
<!UNRESOLVED_REFERENCE!>baz<!>()
<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>superClass<!>()<!>
<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>superI<!>()<!>
<!UNRESOLVED_REFERENCE!>superClass<!>()
<!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"),
LATEINIT_MODIFIER("LATEINIT_MODIFIER"),
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 HIDDEN by error<FirSourceElement, PsiElement> {
val HIDDEN by error<FirSourceElement, PsiElement>(PositioningStrategy.REFERENCE_BY_QUALIFIED) {
parameter<AbstractFirBasedSymbol<*>>("hidden")
}
val UNRESOLVED_REFERENCE by error<FirSourceElement, PsiElement> {
val UNRESOLVED_REFERENCE by error<FirSourceElement, PsiElement>(PositioningStrategy.REFERENCE_BY_QUALIFIED) {
parameter<String>("reference")
}
val UNRESOLVED_LABEL by error<FirSourceElement, PsiElement>()
@@ -62,7 +62,7 @@ object DIAGNOSTICS_LIST : DiagnosticList() {
val SUPER by object : DiagnosticGroup("Super") {
val SUPER_IS_NOT_AN_EXPRESSION 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> {
parameter<String>("target")
}
@@ -152,20 +152,21 @@ object DIAGNOSTICS_LIST : DiagnosticList() {
}
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")
}
val INAPPLICABLE_CANDIDATE by error<FirSourceElement, PsiElement> {
val INAPPLICABLE_CANDIDATE by error<FirSourceElement, PsiElement>(PositioningStrategy.REFERENCE_BY_QUALIFIED) {
parameter<AbstractFirBasedSymbol<*>>("candidate")
}
val INAPPLICABLE_LATEINIT_MODIFIER by error<FirSourceElement, KtModifierListOwner>(PositioningStrategy.LATEINIT_MODIFIER) {
parameter<String>("reason")
}
}
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")
}
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) {
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")
}
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>()
// Unresolved
val HIDDEN by error1<FirSourceElement, PsiElement, AbstractFirBasedSymbol<*>>()
val UNRESOLVED_REFERENCE by error1<FirSourceElement, PsiElement, String>()
val HIDDEN by error1<FirSourceElement, PsiElement, AbstractFirBasedSymbol<*>>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
val UNRESOLVED_REFERENCE by error1<FirSourceElement, PsiElement, String>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
val UNRESOLVED_LABEL by error0<FirSourceElement, PsiElement>()
val DESERIALIZATION_ERROR by error0<FirSourceElement, PsiElement>()
val ERROR_FROM_JAVA_RESOLUTION by error0<FirSourceElement, PsiElement>()
@@ -75,7 +75,7 @@ object FirErrors {
// Super
val SUPER_IS_NOT_AN_EXPRESSION 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>()
// Supertypes
@@ -139,12 +139,12 @@ object FirErrors {
val REDUNDANT_OPEN_IN_INTERFACE by warning0<FirSourceElement, KtModifierListOwner>(SourceElementPositioningStrategies.OPEN_MODIFIER)
// Applicability
val NONE_APPLICABLE by error1<FirSourceElement, PsiElement, Collection<AbstractFirBasedSymbol<*>>>()
val INAPPLICABLE_CANDIDATE by error1<FirSourceElement, PsiElement, AbstractFirBasedSymbol<*>>()
val NONE_APPLICABLE by error1<FirSourceElement, PsiElement, Collection<AbstractFirBasedSymbol<*>>>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
val INAPPLICABLE_CANDIDATE by error1<FirSourceElement, PsiElement, AbstractFirBasedSymbol<*>>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
val INAPPLICABLE_LATEINIT_MODIFIER by error1<FirSourceElement, KtModifierListOwner, String>(SourceElementPositioningStrategies.LATEINIT_MODIFIER)
// 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<*>>>()
// Types & type parameters
@@ -235,7 +235,7 @@ object FirErrors {
// Nullability
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_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() {
override fun mark(
node: LighterASTNode,
@@ -400,6 +426,14 @@ private fun FlyweightCapableTreeStructure<LighterASTNode>.nameIdentifier(node: L
private fun FlyweightCapableTreeStructure<LighterASTNode>.operationReference(node: LighterASTNode): LighterASTNode? =
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? =
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
)
val REFERENCE_BY_QUALIFIED = SourceElementPositioningStrategy(
LightTreePositioningStrategies.REFERENCE_BY_QUALIFIED,
PositioningStrategies.REFERENCE_BY_QUALIFIED
)
val WHEN_EXPRESSION = SourceElementPositioningStrategy(
LightTreePositioningStrategies.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)
}
}
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 {
var a by <!INAPPLICABLE_CANDIDATE!>CustomDelegate()<!>
val aval by <!INAPPLICABLE_CANDIDATE!>CustomDelegate()<!>
var a by <!INAPPLICABLE_CANDIDATE!>CustomDelegate<!>()
val aval by <!INAPPLICABLE_CANDIDATE!>CustomDelegate<!>()
var b by OkDelegate()
var c by CustomDelegate2()
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>) {
args.foo()()
<!INAPPLICABLE_CANDIDATE!>args.foo1()()<!>
<!INAPPLICABLE_CANDIDATE!><!UNRESOLVED_REFERENCE!>a<!>.foo1()()<!>
args.<!INAPPLICABLE_CANDIDATE!>foo1<!>()()
<!UNRESOLVED_REFERENCE!>a<!>.<!INAPPLICABLE_CANDIDATE!>foo1<!>()()
<!UNRESOLVED_REFERENCE!>a<!>.foo1()(<!UNRESOLVED_REFERENCE!>a<!>)
args.foo1()(1)
<!INAPPLICABLE_CANDIDATE!>args.foo1()("1")<!>
<!INAPPLICABLE_CANDIDATE!><!UNRESOLVED_REFERENCE!>a<!>.foo1()("1")<!>
args.<!INAPPLICABLE_CANDIDATE!>foo1<!>()("1")
<!UNRESOLVED_REFERENCE!>a<!>.<!INAPPLICABLE_CANDIDATE!>foo1<!>()("1")
<!UNRESOLVED_REFERENCE!>a<!>.foo1()(<!UNRESOLVED_REFERENCE!>a<!>)
foo2()({})
<!INAPPLICABLE_CANDIDATE!>foo2<!>(){}
(foo2()){}
<!INAPPLICABLE_CANDIDATE!>(foo2()){x -> }<!>
<!INAPPLICABLE_CANDIDATE!>foo2()({x -> })<!>
<!INAPPLICABLE_CANDIDATE!>(foo2())<!>{x -> }
<!INAPPLICABLE_CANDIDATE!>foo2<!>()({x -> })
val a = fooT1(1)()
checkSubtype<Int>(a)
@@ -50,25 +50,25 @@ fun main(args : Array<String>) {
checkSubtype<Int>(b)
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 main1() {
1.<!UNRESOLVED_REFERENCE!>(fun Int.() = 1)()<!>;
1.<!UNRESOLVED_REFERENCE!>(fun Int.() = 1)<!>();
{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}()
1.<!UNRESOLVED_REFERENCE!>((fun Int.() = 1))()<!>
1.<!UNRESOLVED_REFERENCE!>(f())()<!>
1.<!UNRESOLVED_REFERENCE!>if(true){f()}else{f()}()<!>
1.<!UNRESOLVED_REFERENCE!>if(true)(fun Int.() {})else{f()}()<!>
1.<!UNRESOLVED_REFERENCE!>((fun Int.() = 1))<!>()
1.<!UNRESOLVED_REFERENCE!>(f())<!>()
1.<!UNRESOLVED_REFERENCE!>if(true){f()}else{f()}<!>()
1.<!UNRESOLVED_REFERENCE!>if(true)(fun Int.() {})else{f()}<!>()
1.<!UNRESOLVED_REFERENCE!>"sdf"()<!>
1.<!UNRESOLVED_REFERENCE!>"sdf"<!>()
1."sdf"
1.{}
@@ -76,12 +76,12 @@ fun main1() {
}
fun test() {
<!INAPPLICABLE_CANDIDATE!>{x : Int -> 1}()<!>;
<!INAPPLICABLE_CANDIDATE!>(fun Int.() = 1)()<!>
"sd".<!UNRESOLVED_REFERENCE!>(fun Int.() = 1)()<!>
<!INAPPLICABLE_CANDIDATE!>{x : Int -> 1}<!>();
<!INAPPLICABLE_CANDIDATE!>(fun Int.() = 1)<!>()
"sd".<!UNRESOLVED_REFERENCE!>(fun Int.() = 1)<!>()
val i : Int? = null
i.<!UNRESOLVED_REFERENCE!>(fun Int.() = 1)()<!>;
<!INAPPLICABLE_CANDIDATE!>{}<Int>()<!>
1?.<!UNRESOLVED_REFERENCE!>(fun Int.() = 1)()<!>
1.<!UNRESOLVED_REFERENCE!>{}()<!>
i.<!UNRESOLVED_REFERENCE!>(fun Int.() = 1)<!>();
<!INAPPLICABLE_CANDIDATE!>{}<!><Int>()
1?.<!UNRESOLVED_REFERENCE!>(fun Int.() = 1)<!>()
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() {}
@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 {
compiler/testData/diagnostics/tests/callableReference/function/fakeOverrideType.fir.kt
Vendored
+1 -1
View File
@@ -13,5 +13,5 @@ class B : A() {
fun test() {
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 {
val client by <!UNRESOLVED_REFERENCE!>lazy { HttpClientImpl() }<!>
val client by <!UNRESOLVED_REFERENCE!>lazy<!> { HttpClientImpl() }
}
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
<!INAPPLICABLE_LATEINIT_MODIFIER!>lateinit<!> val <T> a4 = 0
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> {
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
<!INAPPLICABLE_LATEINIT_MODIFIER!>lateinit<!> val <T> a4 = 0
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> {
compiler/testData/diagnostics/tests/declarationChecks/namedFunAsLastExpressionInBlock.fir.kt
Vendored
+1 -1
View File
@@ -45,7 +45,7 @@ fun test() {
x4 checkType { _<Function1<Int, Unit>>() }
{ 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(){}<!>)
}
compiler/testData/diagnostics/tests/delegatedProperty/incompleteTypeInference.fir.kt
Vendored
+2 -2
View File
@@ -5,10 +5,10 @@ import kotlin.reflect.KProperty
class A
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> {
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
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()
compiler/testData/diagnostics/tests/delegatedProperty/inference/manyIncompleteCandidates.fir.kt
Vendored
+1 -1
View File
@@ -5,7 +5,7 @@ package test
import first.*
import second.*
val a12 by <!AMBIGUITY!>A()<!>
val a12 by <!AMBIGUITY!>A<!>()
// FILE: first.kt
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 }
}
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