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

[TD] Update test data after previous commit

Browse Source
This commit is contained in:
Dmitriy Novozhilov
2020-12-15 12:58:53 +03:00
parent 49d9b85950
commit e1802fde29
306 changed files with 599 additions and 599 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!>foo<!>("") b.<!HIDDEN{LT}!><!HIDDEN{PSI}!>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!>foo<!>() <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>()<!>
<!INAPPLICABLE_CANDIDATE!>foo<!>(0, 0.0, false, "") <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>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!>bar<!>(1, true) <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>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!>baz<!>(0, "", false) <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>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!>bar<!>() a.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>bar<!>()<!>
a.<!INAPPLICABLE_CANDIDATE!>bar<!>("") a.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>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!>takeInt<!>(10000000000) <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeInt<!>(10000000000)<!>
takeLong(10000000000) takeLong(10000000000)
<!INAPPLICABLE_CANDIDATE!>takeByte<!>(1000) <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(1000)<!>
} }
fun test_3() { fun test_3() {
@@ -35,8 +35,8 @@ fun test_4() {
} }
fun test_5() { fun test_5() {
<!INAPPLICABLE_CANDIDATE!>takeString<!>(1) <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeString<!>(1)<!>
<!INAPPLICABLE_CANDIDATE!>takeString<!>(run { 1 }) <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>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!>takeA<!>(array) <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>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!>foo<!>(1) {} <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>(1) {}<!>
<!INAPPLICABLE_CANDIDATE!>foo<!>(f = {}) {} <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>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!>bar<!> {} <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>bar<!> {}<!>
<!INAPPLICABLE_CANDIDATE!>bar<!>({}) <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>bar<!>({})<!>
// OK // OK
baz(other = false, f = {}) baz(other = false, f = {})
baz({}, false) baz({}, false)
// Bad // Bad
<!INAPPLICABLE_CANDIDATE!>baz<!> {} <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>baz<!> {}<!>
<!INAPPLICABLE_CANDIDATE!>baz<!>() {} <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>baz<!>() {}<!>
<!INAPPLICABLE_CANDIDATE!>baz<!>(other = false) {} <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>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!>myRun<!> { <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>myRun<!> {
val x = 1 val x = 1
x * 2 x * 2
} }<!>
} }
fun test_2() { fun test_2() {
<!UNRESOLVED_REFERENCE!>myRun<!> { <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>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!>takeByte<!>(1 + 1) <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(1 + 1)<!>
<!INAPPLICABLE_CANDIDATE!>takeByte<!>(1 + 127) <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(1 + 127)<!>
<!INAPPLICABLE_CANDIDATE!>takeByte<!>(1 - 1) <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(1 - 1)<!>
<!INAPPLICABLE_CANDIDATE!>takeByte<!>(-100 - 100) <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(-100 - 100)<!>
<!INAPPLICABLE_CANDIDATE!>takeByte<!>(10 * 10) <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(10 * 10)<!>
<!INAPPLICABLE_CANDIDATE!>takeByte<!>(100 * 100) <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(100 * 100)<!>
<!UNRESOLVED_REFERENCE!>taleByte<!>(10 / 10) <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>taleByte<!>(10 / 10)<!>
<!INAPPLICABLE_CANDIDATE!>takeByte<!>(100 % 10) <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(100 % 10)<!>
<!INAPPLICABLE_CANDIDATE!>takeByte<!>(1000 % 10) <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(1000 % 10)<!>
<!INAPPLICABLE_CANDIDATE!>takeByte<!>(1000 and 100) <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(1000 and 100)<!>
<!INAPPLICABLE_CANDIDATE!>takeByte<!>(128 and 511) <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(128 and 511)<!>
<!INAPPLICABLE_CANDIDATE!>takeByte<!>(100 or 100) <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(100 or 100)<!>
<!INAPPLICABLE_CANDIDATE!>takeByte<!>(1000 or 0) <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(1000 or 0)<!>
<!INAPPLICABLE_CANDIDATE!>takeByte<!>(511 xor 511) <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(511 xor 511)<!>
<!INAPPLICABLE_CANDIDATE!>takeByte<!>(512 xor 511) <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(512 xor 511)<!>
} }
fun test_5() { fun test_5() {
takeByte(-1) takeByte(-1)
takeByte(+1) takeByte(+1)
<!INAPPLICABLE_CANDIDATE!>takeByte<!>(1.inv()) <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(1.inv())<!>
} }
fun test_6() { fun test_6() {
<!INAPPLICABLE_CANDIDATE!>takeByte<!>(run { 127 + 1 }) <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(run { 127 + 1 })<!>
<!INAPPLICABLE_CANDIDATE!>takeByte<!>(1 + run { 1 }) <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(1 + run { 1 })<!>
<!INAPPLICABLE_CANDIDATE!>takeByte<!>(run { 1 + 1 }) <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>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!>foo<!>() <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>()<!>
<!INAPPLICABLE_CANDIDATE!>foo<!>(0.0, false, 0, "") <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>(0.0, false, 0, "")<!>
foo(1, 2.0, third = true, "") foo(1, 2.0, third = true, "")
<!INAPPLICABLE_CANDIDATE!>foo<!>(second = 0.0, first = 0, fourth = "") <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>(second = 0.0, first = 0, fourth = "")<!>
<!INAPPLICABLE_CANDIDATE!>foo<!>(first = 0.0, second = 0, third = "", fourth = false) <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>(first = 0.0, second = 0, third = "", fourth = false)<!>
<!INAPPLICABLE_CANDIDATE!>foo<!>(first = 0, second = 0.0, third = false, fourth = "", first = 1) <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>(first = 0, second = 0.0, third = false, fourth = "", first = 1)<!>
<!INAPPLICABLE_CANDIDATE!>foo<!>(0, 0.0, false, foth = "") <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>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!>foo<!>("") <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>("")<!>
<!INAPPLICABLE_CANDIDATE!>foo<!>(1, 2) <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>(1, 2)<!>
bar(1, z = true, y = *arrayOf("my", "yours")) bar(1, z = true, y = *arrayOf("my", "yours"))
<!INAPPLICABLE_CANDIDATE!>bar<!>(0, z = false, y = "", y = "other") <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>bar<!>(0, z = false, y = "", y = "other")<!>
<!INAPPLICABLE_CANDIDATE!>bar<!>(0, "", true) <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>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!>A<!>() val a = <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>A<!>()<!>
val b = B() // should be OK val b = B() // should be OK
val c: B = <!UNRESOLVED_REFERENCE!>A<!>() val c: B = <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>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!>foo<!>("") <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>("")<!>
// Ambiguity // Ambiguity
<!AMBIGUITY!>bar<!>(c) <!AMBIGUITY{LT}!><!AMBIGUITY{PSI}!>bar<!>(c)<!>
// Unresolved reference // Unresolved reference
<!UNRESOLVED_REFERENCE!>baz<!>() <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>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!>bar<!>() { "" }.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>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!>inc<!>() // Bad y.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>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!>inc<!>() // Bad y.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>inc<!>()<!> // Bad
x as Int x as Int
materialize() materialize()
} }
), ),
run { run {
y as Int y as Int
x.<!UNRESOLVED_REFERENCE!>inc<!>() // Bad x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>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!>inc<!>() // Bad y.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>inc<!>()<!> // Bad
x as Int x as Int
} }
), ),
y as Int, y as Int,
myRun { myRun {
x.<!UNRESOLVED_REFERENCE!>inc<!>() // Bad x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>inc<!>()<!> // Bad
y.inc() // OK y.inc() // OK
1 1
} }
) )
<!INAPPLICABLE_CANDIDATE!>takeInt<!>(x) // Bad <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeInt<!>(x)<!> // Bad
takeInt(y) // OK takeInt(y) // OK
takeInt(a) // Bad takeInt(a) // Bad
} }
compiler/fir/analysis-tests/testData/resolve/cfg/jumps.kt
Vendored
+1 -1
View File
@@ -15,7 +15,7 @@ fun test_2(x: Int?) {
} else { } else {
x x
} }
y.<!INAPPLICABLE_CANDIDATE!>inc<!>() y.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>inc<!>()<!>
} }
fun test_3(x: Int?) { fun test_3(x: Int?) {
compiler/fir/analysis-tests/testData/resolve/delegatingConstructorCall.kt
Vendored
+5 -5
View File
@@ -10,18 +10,18 @@ open class A3(x: String, y: String = "") {
constructor(x: String, b: Boolean = true) : this(x, x) constructor(x: String, b: Boolean = true) : this(x, x)
} }
class B3_1 : <!AMBIGUITY!>A3<!>("") class B3_1 : <!AMBIGUITY{LT}!><!AMBIGUITY{PSI}!>A3<!>("")<!>
class B3_2 : A3("", "asas") class B3_2 : A3("", "asas")
class B3_3 : A3("", true) class B3_3 : A3("", true)
class B3_4 : <!NONE_APPLICABLE!>A3<!>("", Unit) class B3_4 : <!NONE_APPLICABLE{LT}!><!NONE_APPLICABLE{PSI}!>A3<!>("", Unit)<!>
open class A4(val x: Byte) open class A4(val x: Byte)
class B4 : <!INAPPLICABLE_CANDIDATE!>A4<!>( 1 + 1) class B4 : <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>A4<!>( 1 + 1)<!>
open class A5 { open class A5 {
constructor(x: Byte) constructor(x: Byte)
constructor(x: Short) constructor(x: Short)
} }
class B5_1 : <!NONE_APPLICABLE!>A5<!>(1 + 1) class B5_1 : <!NONE_APPLICABLE{LT}!><!NONE_APPLICABLE{PSI}!>A5<!>(1 + 1)<!>
class B5_2 : <!NONE_APPLICABLE!>A5<!>(100 * 2) class B5_2 : <!NONE_APPLICABLE{LT}!><!NONE_APPLICABLE{PSI}!>A5<!>(100 * 2)<!>
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!>f<!>() super.<!ABSTRACT_SUPER_CALL{LT}!><!ABSTRACT_SUPER_CALL{PSI}!>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!>f<!>() super.<!ABSTRACT_SUPER_CALL{LT}!><!ABSTRACT_SUPER_CALL{PSI}!>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!>bar<!>() // should be an error override fun bar(): String = super.<!ABSTRACT_SUPER_CALL{LT}!><!ABSTRACT_SUPER_CALL{PSI}!>bar<!>()<!> // should be an error
} }
compiler/fir/analysis-tests/testData/resolve/diagnostics/annotationClassMember.kt
Vendored
+1 -1
View File
@@ -1,5 +1,5 @@
annotation class A() { annotation class A() {
<!ANNOTATION_CLASS_MEMBER!><!PRIMARY_CONSTRUCTOR_DELEGATION_CALL_EXPECTED!>constructor(s: Nothing?)<!> {}<!> <!ANNOTATION_CLASS_MEMBER!><!PRIMARY_CONSTRUCTOR_DELEGATION_CALL_EXPECTED{PSI}!>constructor(s: Nothing?)<!><!PRIMARY_CONSTRUCTOR_DELEGATION_CALL_EXPECTED{LT}!><!> {}<!>
<!ANNOTATION_CLASS_MEMBER!>init {}<!> <!ANNOTATION_CLASS_MEMBER!>init {}<!>
<!ANNOTATION_CLASS_MEMBER!>fun foo() {}<!> <!ANNOTATION_CLASS_MEMBER!>fun foo() {}<!>
<!ANNOTATION_CLASS_MEMBER!>val bar: Nothing?<!> <!ANNOTATION_CLASS_MEMBER!>val bar: Nothing?<!>
compiler/fir/analysis-tests/testData/resolve/diagnostics/conflictingOverloads.kt
Vendored
+1 -1
View File
@@ -49,7 +49,7 @@ fun lol(a: Array<Boolean>) {}
<!CONFLICTING_OVERLOADS!>fun <T> mem(t: T) where T : String, T : () -> Boolean {}<!> <!CONFLICTING_OVERLOADS!>fun <T> mem(t: T) where T : String, T : () -> Boolean {}<!>
class M { class M {
companion <!REDECLARATION!>object<!> {} <!REDECLARATION{LT}!>companion <!REDECLARATION{PSI}!>object<!> {}<!>
<!REDECLARATION!>val Companion = object : Any {}<!> <!REDECLARATION!>val Companion = object : Any {}<!>
} }
compiler/fir/analysis-tests/testData/resolve/diagnostics/constructorInInterface.kt
Vendored
+3 -3
View File
@@ -1,7 +1,7 @@
interface <!CONSTRUCTOR_IN_INTERFACE!>A(val s: String)<!> <!CONSTRUCTOR_IN_INTERFACE{LT}!>interface <!CONSTRUCTOR_IN_INTERFACE{PSI}!>A(val s: String)<!><!>
interface <!CONSTRUCTOR_IN_INTERFACE!>B constructor(val s: String)<!> <!CONSTRUCTOR_IN_INTERFACE{LT}!>interface <!CONSTRUCTOR_IN_INTERFACE{PSI}!>B constructor(val s: String)<!><!>
interface C { interface C {
<!CONSTRUCTOR_IN_INTERFACE!>constructor(val s: String)<!> {} <!CONSTRUCTOR_IN_INTERFACE{LT}!><!CONSTRUCTOR_IN_INTERFACE{PSI}!>constructor(val s: String)<!> {}<!>
} }
compiler/fir/analysis-tests/testData/resolve/diagnostics/cyclicConstructorDelegationCall.kt
Vendored
+15 -15
View File
@@ -2,14 +2,14 @@ class B
class C class C
class A() { class A() {
constructor(a: Int) : <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL!>this<!>("test") {} constructor(a: Int) : <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL{LT}!><!CYCLIC_CONSTRUCTOR_DELEGATION_CALL{PSI}!>this<!>("test")<!> {}
constructor(a: String) : <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL!>this<!>(10) {} constructor(a: String) : <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL{LT}!><!CYCLIC_CONSTRUCTOR_DELEGATION_CALL{PSI}!>this<!>(10)<!> {}
constructor(a: Boolean) : <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL!>this<!>('\n') {} constructor(a: Boolean) : <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL{LT}!><!CYCLIC_CONSTRUCTOR_DELEGATION_CALL{PSI}!>this<!>('\n')<!> {}
constructor(a: Char) : <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL!>this<!>(0.0) {} constructor(a: Char) : <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL{LT}!><!CYCLIC_CONSTRUCTOR_DELEGATION_CALL{PSI}!>this<!>(0.0)<!> {}
constructor(a: Double) : <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL!>this<!>(false) {} constructor(a: Double) : <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL{LT}!><!CYCLIC_CONSTRUCTOR_DELEGATION_CALL{PSI}!>this<!>(false)<!> {}
constructor(b: B) : <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL!>this<!>(3.14159265) {} constructor(b: B) : <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL{LT}!><!CYCLIC_CONSTRUCTOR_DELEGATION_CALL{PSI}!>this<!>(3.14159265)<!> {}
constructor(c: C) : this() {} constructor(c: C) : this() {}
constructor(a: List<Int>) : this(C()) {} constructor(a: List<Int>) : this(C()) {}
@@ -17,7 +17,7 @@ class A() {
class D { class D {
constructor(i: Boolean) {} constructor(i: Boolean) {}
constructor(i: Int) : <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL!>this<!>(3) {} constructor(i: Int) : <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL{LT}!><!CYCLIC_CONSTRUCTOR_DELEGATION_CALL{PSI}!>this<!>(3)<!> {}
} }
class E<T> { class E<T> {
@@ -25,7 +25,7 @@ class E<T> {
// selection of the proper constructor // selection of the proper constructor
// but a type mismatch for the first // but a type mismatch for the first
// argument // argument
constructor(e: T, i: Int) : <!INAPPLICABLE_CANDIDATE!>this<!>(i, 10) {} constructor(e: T, i: Int) : <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>this<!>(i, 10)<!> {}
} }
class I<T> { class I<T> {
@@ -33,7 +33,7 @@ class I<T> {
// selection of the proper constructor // selection of the proper constructor
// but a type mismatch for the first // but a type mismatch for the first
// argument // argument
constructor(e: T, i: Int) : <!INAPPLICABLE_CANDIDATE!>this<!>(i, 10) constructor(e: T, i: Int) : <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>this<!>(i, 10)<!>
} }
class J<T> { class J<T> {
@@ -42,20 +42,20 @@ class J<T> {
} }
class F(s: String) { class F(s: String) {
<!PRIMARY_CONSTRUCTOR_DELEGATION_CALL_EXPECTED!>constructor(i: Boolean)<!> {} <!PRIMARY_CONSTRUCTOR_DELEGATION_CALL_EXPECTED{PSI}!>constructor(i: Boolean)<!><!PRIMARY_CONSTRUCTOR_DELEGATION_CALL_EXPECTED{LT}!><!> {}
constructor(i: Int) : <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL!>this<!>(3) {} constructor(i: Int) : <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL{LT}!><!CYCLIC_CONSTRUCTOR_DELEGATION_CALL{PSI}!>this<!>(3)<!> {}
} }
class G(x: Int) { class G(x: Int) {
<!PRIMARY_CONSTRUCTOR_DELEGATION_CALL_EXPECTED!>constructor()<!> {} <!PRIMARY_CONSTRUCTOR_DELEGATION_CALL_EXPECTED{PSI}!>constructor()<!><!PRIMARY_CONSTRUCTOR_DELEGATION_CALL_EXPECTED{LT}!><!> {}
} }
class H(x: Int) { class H(x: Int) {
<!PRIMARY_CONSTRUCTOR_DELEGATION_CALL_EXPECTED!>constructor()<!> <!PRIMARY_CONSTRUCTOR_DELEGATION_CALL_EXPECTED{PSI}!>constructor()<!><!PRIMARY_CONSTRUCTOR_DELEGATION_CALL_EXPECTED{LT}!><!>
} }
class K(x: Int) { class K(x: Int) {
constructor() : <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL!>this<!>() {} constructor() : <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL{LT}!><!CYCLIC_CONSTRUCTOR_DELEGATION_CALL{PSI}!>this<!>()<!> {}
} }
class M { class M {
@@ -63,5 +63,5 @@ class M {
} }
class U : M { class U : M {
<!INAPPLICABLE_CANDIDATE!>constructor()<!> <!INAPPLICABLE_CANDIDATE{PSI}!>constructor()<!><!INAPPLICABLE_CANDIDATE{LT}!><!>
} }
compiler/fir/analysis-tests/testData/resolve/diagnostics/delegationSuperCallInEnumConstructor.kt
Vendored
+1 -1
View File
@@ -1,6 +1,6 @@
enum class A { enum class A {
A(1), B(2), C("test"); A(1), B(2), C("test");
constructor(x: Int) : <!DELEGATION_SUPER_CALL_IN_ENUM_CONSTRUCTOR!>super<!>() constructor(x: Int) : <!DELEGATION_SUPER_CALL_IN_ENUM_CONSTRUCTOR{LT}!><!DELEGATION_SUPER_CALL_IN_ENUM_CONSTRUCTOR{PSI}!>super<!>()<!>
constructor(t: String) : this(10) constructor(t: String) : this(10)
} }
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, NONE_APPLICABLE{PSI}!>constructor()<!><!NONE_APPLICABLE{LT}!><!>
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, NONE_APPLICABLE{PSI}!>constructor()<!><!NONE_APPLICABLE{LT}!><!>
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)<!> <!NONE_APPLICABLE{PSI}, PRIMARY_CONSTRUCTOR_DELEGATION_CALL_EXPECTED{PSI}!>constructor(x: Int)<!><!NONE_APPLICABLE{LT}, PRIMARY_CONSTRUCTOR_DELEGATION_CALL_EXPECTED{LT}!><!>
constructor(z: String) : this() constructor(z: String) : this()
} }
compiler/fir/analysis-tests/testData/resolve/diagnostics/instanceAccessBeforeSuperCall.kt
Vendored
+3 -3
View File
@@ -1,5 +1,5 @@
class A { class A {
constructor(x: Int = <!UNRESOLVED_REFERENCE!>getSomeInt<!>(), other: A = <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>, header: String = <!UNRESOLVED_REFERENCE!>keker<!>) {} constructor(x: Int = <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>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"
} }
@@ -7,10 +7,10 @@ class A {
class B(other: B = <!NO_THIS!>this<!>) class B(other: B = <!NO_THIS!>this<!>)
class C() { class C() {
constructor(x: Int) : <!INAPPLICABLE_CANDIDATE!>this<!>({ constructor(x: Int) : <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>this<!>({
val a = 10 val a = 10
<!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!> <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>
}) {} })<!> {}
} }
class D { class D {
compiler/fir/analysis-tests/testData/resolve/diagnostics/localAnnotationClass.kt
Vendored
+2 -2
View File
@@ -2,7 +2,7 @@ fun foo() {
<!LOCAL_ANNOTATION_CLASS_ERROR!>annotation class Ann<!> <!LOCAL_ANNOTATION_CLASS_ERROR!>annotation class Ann<!>
@Ann class Local { @Ann class Local {
// There should also be NESTED_CLASS_NOT_ALLOWED report here. <!LOCAL_ANNOTATION_CLASS_ERROR{LT}!>// There should also be NESTED_CLASS_NOT_ALLOWED report here.
<!LOCAL_ANNOTATION_CLASS_ERROR!>annotation class Nested<!> <!LOCAL_ANNOTATION_CLASS_ERROR{PSI}!>annotation class Nested<!><!>
} }
} }
compiler/fir/analysis-tests/testData/resolve/diagnostics/localEntitytNotAllowed.kt
Vendored
+4 -4
View File
@@ -6,19 +6,19 @@ object A {
interface X interface X
val a = object : Any() { val a = object : Any() {
<!LOCAL_OBJECT_NOT_ALLOWED!>object D<!> { <!LOCAL_OBJECT_NOT_ALLOWED{LT}!><!LOCAL_OBJECT_NOT_ALLOWED{PSI}!>object D<!> {
<!LOCAL_OBJECT_NOT_ALLOWED!>object G<!> <!LOCAL_OBJECT_NOT_ALLOWED!>object G<!>
<!LOCAL_INTERFACE_NOT_ALLOWED!>interface Z<!> <!LOCAL_INTERFACE_NOT_ALLOWED!>interface Z<!>
} }<!>
<!LOCAL_INTERFACE_NOT_ALLOWED!>interface Y<!> <!LOCAL_INTERFACE_NOT_ALLOWED!>interface Y<!>
} }
fun b() { fun b() {
<!LOCAL_OBJECT_NOT_ALLOWED!>object E<!> { <!LOCAL_OBJECT_NOT_ALLOWED{LT}!><!LOCAL_OBJECT_NOT_ALLOWED{PSI}!>object E<!> {
<!LOCAL_OBJECT_NOT_ALLOWED!>object F<!> <!LOCAL_OBJECT_NOT_ALLOWED!>object F<!>
<!LOCAL_INTERFACE_NOT_ALLOWED!>interface M<!> <!LOCAL_INTERFACE_NOT_ALLOWED!>interface M<!>
} }<!>
<!LOCAL_INTERFACE_NOT_ALLOWED!>interface N<!> <!LOCAL_INTERFACE_NOT_ALLOWED!>interface N<!>
compiler/fir/analysis-tests/testData/resolve/diagnostics/manyCompanionObjects.kt
Vendored
+6 -6
View File
@@ -1,11 +1,11 @@
class A { class A {
companion <!REDECLARATION!>object<!> { <!REDECLARATION{LT}!>companion <!REDECLARATION{PSI}!>object<!> {
} }<!>
companion <!MANY_COMPANION_OBJECTS, REDECLARATION!>object<!> { <!MANY_COMPANION_OBJECTS{LT}, REDECLARATION{LT}!>companion <!MANY_COMPANION_OBJECTS{PSI}, REDECLARATION{PSI}!>object<!> {
} }<!>
} }
class B { class B {
@@ -13,7 +13,7 @@ class B {
} }
companion <!MANY_COMPANION_OBJECTS!>object B<!> { <!MANY_COMPANION_OBJECTS{LT}!>companion <!MANY_COMPANION_OBJECTS{PSI}!>object B<!> {
} }<!>
} }
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!>f<!>() <!NOT_A_SUPERTYPE!>super<String><!>.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>f<!>()<!>
super<A>.f() super<A>.f()
} }
} }
compiler/fir/analysis-tests/testData/resolve/diagnostics/propertyTypeMismatchOnOverride.kt
Vendored
+1 -1
View File
@@ -26,7 +26,7 @@ class G<E : Double>(val balue: E) : F<E>(balue) {
override var rest: E = balue override var rest: E = balue
} }
class H<E : String>(val balue: E) : <!INAPPLICABLE_CANDIDATE!>F<E><!>(balue) { class H<E : String>(val balue: E) : <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>F<E><!>(balue)<!> {
override var rest: E = balue // no report because of INAPPLICABLE_CANDIDATE override var rest: E = balue // no report because of INAPPLICABLE_CANDIDATE
} }
compiler/fir/analysis-tests/testData/resolve/diagnostics/returnTypeMismatchOnOverride.kt
Vendored
+1 -1
View File
@@ -27,7 +27,7 @@ class G<E : Double>(val balue: E) : F<E>(balue) {
override fun rest(): E = balue override fun rest(): E = balue
} }
class H<E : String>(val balue: E) : <!INAPPLICABLE_CANDIDATE!>F<E><!>(balue) { class H<E : String>(val balue: E) : <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>F<E><!>(balue)<!> {
override fun rest(): E = balue // no report because of INAPPLICABLE_CANDIDATE override fun rest(): E = balue // no report because of INAPPLICABLE_CANDIDATE
} }
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 = <!SEALED_CLASS_CONSTRUCTOR_CALL!>A<!>() val b = <!SEALED_CLASS_CONSTRUCTOR_CALL{LT}!><!SEALED_CLASS_CONSTRUCTOR_CALL{PSI}!>A<!>()<!>
compiler/fir/analysis-tests/testData/resolve/diagnostics/sealedSupertype.kt
Vendored
+2 -2
View File
@@ -28,9 +28,9 @@ sealed class P {
class K : P() class K : P()
<!REDECLARATION!>object B<!> { <!REDECLARATION{LT}!><!REDECLARATION{PSI}!>object B<!> {
class I : <!SEALED_SUPERTYPE!>P<!>() class I : <!SEALED_SUPERTYPE!>P<!>()
} }<!>
fun test() { fun test() {
class L : <!SEALED_SUPERTYPE_IN_LOCAL_CLASS!>P<!>() class L : <!SEALED_SUPERTYPE_IN_LOCAL_CLASS!>P<!>()
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!>invoke<!>() <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>invoke<!>()<!>
<!SUPER_IS_NOT_AN_EXPRESSION!>super<!> { <!SUPER_IS_NOT_AN_EXPRESSION!>super<!> {
println(<!ILLEGAL_CONST_EXPRESSION!>'weird'<!>) 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!>compareTo<!>("") <!SUPER_NOT_AVAILABLE!>super@f<!>.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>compareTo<!>("")<!>
<!SUPER_NOT_AVAILABLE!>super<!>.<!UNRESOLVED_REFERENCE!>compareTo<!>("") <!SUPER_NOT_AVAILABLE!>super<!>.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>compareTo<!>("")<!>
} }
fun foo() { fun foo() {
<!SUPER_NOT_AVAILABLE!>super<!> <!SUPER_NOT_AVAILABLE!>super<!>
<!SUPER_NOT_AVAILABLE!>super<!>.<!UNRESOLVED_REFERENCE!>foo<!>() <!SUPER_NOT_AVAILABLE!>super<!>.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
<!SUPER_NOT_AVAILABLE!>super<Nothing><!>.<!UNRESOLVED_REFERENCE!>foo<!>() <!SUPER_NOT_AVAILABLE!>super<Nothing><!>.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
} }
class A { class A {
fun act() { fun act() {
<!UNRESOLVED_REFERENCE!>println<!>("Test") <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>println<!>("Test")<!>
} }
fun String.fact() { fun String.fact() {
<!UNRESOLVED_REFERENCE!>println<!>("Fest") <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>println<!>("Fest")<!>
} }
} }
compiler/fir/analysis-tests/testData/resolve/diagnostics/typeArgumentsNotAllowed.kt
Vendored
+3 -3
View File
@@ -17,11 +17,11 @@ object Best {
} }
val a = <!TYPE_ARGUMENTS_NOT_ALLOWED!>rest<Int><!>.<!UNRESOLVED_REFERENCE!>MyClass<!><String> val a = <!TYPE_ARGUMENTS_NOT_ALLOWED!>rest<Int><!>.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>MyClass<!><String><!>
val b = Best.<!UNRESOLVED_REFERENCE!>MyClass<!><String> val b = Best.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>MyClass<!><String><!>
class B<E> class B<E>
class C<F<!SYNTAX!><<!><!SYNTAX!>Boolean<!><!SYNTAX!>><!><!SYNTAX!>><!> <!SYNTAX!>:<!> <!SYNTAX!>B<!><!SYNTAX!><<!><!SYNTAX!>F<!><!SYNTAX!><<!><!SYNTAX!>Boolean<!><!SYNTAX!>><!><!SYNTAX!>><!><!SYNTAX!>(<!><!SYNTAX!>)<!> 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}!>)<!>
fun <G> gest() {} fun <G> gest() {}
compiler/fir/analysis-tests/testData/resolve/diagnostics/typeParametersInObject.kt
Vendored
+7 -7
View File
@@ -1,15 +1,15 @@
<!TYPE_PARAMETERS_IN_OBJECT!>object A<!><T, K : T> { <!TYPE_PARAMETERS_IN_OBJECT{LT}!><!TYPE_PARAMETERS_IN_OBJECT{PSI}!>object A<!><T, K : T> {
<!TYPE_PARAMETERS_IN_OBJECT!>object B<!><L> <!TYPE_PARAMETERS_IN_OBJECT{LT}!><!TYPE_PARAMETERS_IN_OBJECT{PSI}!>object B<!><L><!>
} }<!>
class N { class N {
companion <!TYPE_PARAMETERS_IN_OBJECT!>object<!><T> { <!TYPE_PARAMETERS_IN_OBJECT{LT}!>companion <!TYPE_PARAMETERS_IN_OBJECT{PSI}!>object<!><T> {
} }<!>
} }
fun test() { fun test() {
<!LOCAL_OBJECT_NOT_ALLOWED, TYPE_PARAMETERS_IN_OBJECT!>object M<!><H> { <!LOCAL_OBJECT_NOT_ALLOWED{LT}, TYPE_PARAMETERS_IN_OBJECT{LT}!><!LOCAL_OBJECT_NOT_ALLOWED{PSI}, TYPE_PARAMETERS_IN_OBJECT{PSI}!>object M<!><H> {
} }<!>
} }
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!>NumberPhile<!>("Test") val np2 = <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>NumberPhile<!>("Test")<!>
compiler/fir/analysis-tests/testData/resolve/diagnostics/valOnAnnotationParameter.kt
Vendored
+1 -1
View File
@@ -1,4 +1,4 @@
annotation class A( annotation class A(
<!VAR_ANNOTATION_PARAMETER!>var<!> a: Int, <!VAR_ANNOTATION_PARAMETER{LT}!><!VAR_ANNOTATION_PARAMETER{PSI}!>var<!> a: Int<!>,
<!MISSING_VAL_ON_ANNOTATION_PARAMETER!>b: String<!> <!MISSING_VAL_ON_ANNOTATION_PARAMETER!>b: String<!>
) )
compiler/fir/analysis-tests/testData/resolve/exhaustiveness_enumJava.kt
Vendored
+3 -3
View File
@@ -10,13 +10,13 @@ fun test_1(e: JavaEnum) {
val a = when (e) { val a = when (e) {
JavaEnum.A -> 1 JavaEnum.A -> 1
JavaEnum.B -> 2 JavaEnum.B -> 2
}.<!UNRESOLVED_REFERENCE!>plus<!>(0) }.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>plus<!>(0)<!>
val b = when (e) { val b = when (e) {
JavaEnum.A -> 1 JavaEnum.A -> 1
JavaEnum.B -> 2 JavaEnum.B -> 2
is String -> 3 is String -> 3
}.<!UNRESOLVED_REFERENCE!>plus<!>(0) }.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>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!>plus<!>(0) }.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>plus<!>(0)<!>
val a = when (e) { val a = when (e) {
JavaEnum.A -> 1 JavaEnum.A -> 1
compiler/fir/analysis-tests/testData/resolve/exhaustiveness_sealedSubClass.kt
Vendored
+4 -4
View File
@@ -35,20 +35,20 @@ fun test_2(e: A) {
val a = when (e) { val a = when (e) {
is D -> 1 is D -> 1
is E -> 2 is E -> 2
}.<!UNRESOLVED_REFERENCE!>plus<!>(0) }.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>plus<!>(0)<!>
val b = when (e) { val b = when (e) {
is B -> 1 is B -> 1
is D -> 2 is D -> 2
is E -> 3 is E -> 3
}.<!UNRESOLVED_REFERENCE!>plus<!>(0) }.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>plus<!>(0)<!>
val c = when (e) { val c = when (e) {
is B -> 1 is B -> 1
is D -> 2 is D -> 2
}.<!UNRESOLVED_REFERENCE!>plus<!>(0) }.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>plus<!>(0)<!>
val d = when (e) { val d = when (e) {
is C -> 1 is C -> 1
}.<!UNRESOLVED_REFERENCE!>plus<!>(0) }.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>plus<!>(0)<!>
} }
compiler/fir/analysis-tests/testData/resolve/expresssions/CallBasedInExpressionGenerator.kt
Vendored
+8 -8
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!>getResolvedCallWithAssert<!>(codegen.<!UNRESOLVED_REFERENCE!>bindingContext<!>) private val resolvedCall = operatorReference.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>getResolvedCallWithAssert<!>(codegen.<!UNRESOLVED_REFERENCE!>bindingContext<!>)<!>
private val isInverted = operatorReference.<!UNRESOLVED_REFERENCE!>getReferencedNameElementType<!>() == <!UNRESOLVED_REFERENCE!>KtTokens<!>.<!UNRESOLVED_REFERENCE!>NOT_IN<!> private val isInverted = operatorReference.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>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!>Invert<!>(it) else it } gen(argument).let { if (isInverted) <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>Invert<!>(it)<!> else it }
private fun gen(argument: StackValue): BranchedValue = private fun gen(argument: StackValue): BranchedValue =
object : <!INAPPLICABLE_CANDIDATE!>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!>coerceTo<!>(type, kotlinType, v) <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>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!>visitJumpInsn<!>(if (jumpIfFalse) <!UNRESOLVED_REFERENCE!>Opcodes<!>.<!UNRESOLVED_REFERENCE!>IFEQ<!> else <!UNRESOLVED_REFERENCE!>Opcodes<!>.<!UNRESOLVED_REFERENCE!>IFNE<!>, jumpLabel) v.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>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!>invokeFunction<!>(resolvedCall.<!UNRESOLVED_REFERENCE!>call<!>, resolvedCall, <!UNRESOLVED_REFERENCE!>none<!>()) 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!>put<!>(result.<!UNRESOLVED_REFERENCE!>type<!>, result.<!UNRESOLVED_REFERENCE!>kotlinType<!>, v) result.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>put<!>(result.<!UNRESOLVED_REFERENCE!>type<!>, result.<!UNRESOLVED_REFERENCE!>kotlinType<!>, v)<!>
} }
} }
} }
compiler/fir/analysis-tests/testData/resolve/expresssions/access.kt
Vendored
+3 -3
View File
@@ -21,7 +21,7 @@ class Bar {
} }
// NB! abc() here is resolved to member Foo.abc(), and not to extension member of Bar // NB! abc() here is resolved to member Foo.abc(), and not to extension member of Bar
fun Foo.check() = abc() <!NONE_APPLICABLE!>+<!> bar() fun Foo.check() = <!NONE_APPLICABLE{LT}!>abc() <!NONE_APPLICABLE{PSI}!>+<!> bar()<!>
// NB! + here is resolved to member String.plus (not to extension member above) // NB! + here is resolved to member String.plus (not to extension member above)
fun Foo.check2() = "" + bar() fun Foo.check2() = "" + bar()
@@ -43,7 +43,7 @@ fun f() {
val d = "" val d = ""
val c = <!UNRESOLVED_REFERENCE!>c<!> val c = <!UNRESOLVED_REFERENCE!>c<!>
<!UNRESOLVED_REFERENCE!>abc<!>() <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>abc<!>()<!>
fun bcd() {} fun bcd() {}
@@ -57,7 +57,7 @@ fun f() {
dcb() dcb()
} }
<!UNRESOLVED_REFERENCE!>dcb<!>() <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>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!>bar<!>() val errBarViaBB = BB.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>bar<!>()<!>
val errBarViaAA = AA.<!UNRESOLVED_REFERENCE!>bar<!>() val errBarViaAA = AA.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>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!>useVararg<!>(1, 2, 3, 4, 5) <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>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!>foo<!>(bar) val b = <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>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!>foo<!><FooImpl>(fooBarImpl) val a = <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>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!>foobar<!>() buz.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foobar<!>()<!>
} }
} }
compiler/fir/analysis-tests/testData/resolve/expresssions/localObjects.kt
Vendored
+3 -3
View File
@@ -12,10 +12,10 @@ fun test() {
} }
b.foo() b.foo()
<!LOCAL_OBJECT_NOT_ALLOWED!>object B<!> { <!LOCAL_OBJECT_NOT_ALLOWED{LT}!><!LOCAL_OBJECT_NOT_ALLOWED{PSI}!>object B<!> {
fun foo() {} fun foo() {}
} }<!>
B.foo() B.foo()
} }
val bb = <!UNRESOLVED_REFERENCE!>B<!>.<!UNRESOLVED_REFERENCE!>foo<!>() val bb = <!UNRESOLVED_REFERENCE!>B<!>.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>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!>PrivateNested<!>() Outer.<!HIDDEN{LT}!><!HIDDEN{PSI}!>PrivateNested<!>()<!>
super.<!HIDDEN!>PrivateInner<!>() super.<!HIDDEN{LT}!><!HIDDEN{PSI}!>PrivateInner<!>()<!>
Outer.ProtectedNested() Outer.ProtectedNested()
super.ProtectedInner() super.ProtectedInner()
@@ -23,11 +23,11 @@ class Derived : Outer() {
} }
fun foo() { fun foo() {
Outer.<!HIDDEN!>PrivateNested<!>() Outer.<!HIDDEN{LT}!><!HIDDEN{PSI}!>PrivateNested<!>()<!>
Outer().<!HIDDEN!>PrivateInner<!>() Outer().<!HIDDEN{LT}!><!HIDDEN{PSI}!>PrivateInner<!>()<!>
Outer.<!HIDDEN!>ProtectedNested<!>() Outer.<!HIDDEN{LT}!><!HIDDEN{PSI}!>ProtectedNested<!>()<!>
Outer().<!HIDDEN!>ProtectedInner<!>() Outer().<!HIDDEN{LT}!><!HIDDEN{PSI}!>ProtectedInner<!>()<!>
Outer.PublicNested() Outer.PublicNested()
Outer().PublicInner() Outer().PublicInner()
compiler/fir/analysis-tests/testData/resolve/expresssions/operators/plusAssign.kt
Vendored
+1 -1
View File
@@ -7,7 +7,7 @@ class Foo {
fun test_1() { fun test_1() {
val f = Foo() val f = Foo()
f <!UNRESOLVED_REFERENCE!>+<!> f <!UNRESOLVED_REFERENCE{LT}!>f <!UNRESOLVED_REFERENCE{PSI}!>+<!> f<!>
} }
fun test_2() { fun test_2() {
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!>foo<!>() // hidden NotCompanion.<!HIDDEN{LT}!><!HIDDEN{PSI}!>foo<!>()<!> // hidden
} }
inner class Inner { inner class Inner {
fun foo() { fun foo() {
bar() bar()
fromCompanion() fromCompanion()
NotCompanion.<!HIDDEN!>foo<!>() // hidden NotCompanion.<!HIDDEN{LT}!><!HIDDEN{PSI}!>foo<!>()<!> // hidden
} }
} }
private class Nested { private class Nested {
fun foo() { fun foo() {
fromCompanion() fromCompanion()
NotCompanion.<!HIDDEN!>foo<!>() // hidden NotCompanion.<!HIDDEN{LT}!><!HIDDEN{PSI}!>foo<!>()<!> // hidden
} }
} }
@@ -54,7 +54,7 @@ fun withLocals() {
Local().baz() Local().baz()
Local().<!HIDDEN!>bar<!>() // hidden Local().<!HIDDEN{LT}!><!HIDDEN{PSI}!>bar<!>()<!> // hidden
} }
fun test() { fun test() {
@@ -62,14 +62,14 @@ fun test() {
Private().baz() Private().baz()
Private().Inner() Private().Inner()
Private().<!HIDDEN!>bar<!>() // hidden Private().<!HIDDEN{LT}!><!HIDDEN{PSI}!>bar<!>()<!> // hidden
Private.<!HIDDEN!>Nested<!>() // hidden Private.<!HIDDEN{LT}!><!HIDDEN{PSI}!>Nested<!>()<!> // hidden
Private.<!HIDDEN!>fromCompanion<!>() // hidden Private.<!HIDDEN{LT}!><!HIDDEN{PSI}!>fromCompanion<!>()<!> // hidden
} }
// FILE: second.kt // FILE: second.kt
fun secondTest() { fun secondTest() {
<!HIDDEN!>foo<!>() // hidden <!HIDDEN{LT}!><!HIDDEN{PSI}!>foo<!>()<!> // hidden
<!HIDDEN!>Private<!>() // hidden <!HIDDEN{LT}!><!HIDDEN{PSI}!>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!>bar<!>() // hidden Nested().<!HIDDEN{LT}!><!HIDDEN{PSI}!>bar<!>()<!> // hidden
fromCompanion() fromCompanion()
protectedFromCompanion() protectedFromCompanion()
@@ -48,8 +48,8 @@ fun test() {
Protected().baz() Protected().baz()
Protected().Inner() Protected().Inner()
Protected().<!HIDDEN!>bar<!>() // hidden Protected().<!HIDDEN{LT}!><!HIDDEN{PSI}!>bar<!>()<!> // hidden
Protected.<!HIDDEN!>Nested<!>() // hidden Protected.<!HIDDEN{LT}!><!HIDDEN{PSI}!>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!>err<!>() <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>err<!>()<!>
} }
} }
} }
@@ -17,5 +17,5 @@ fun test() {
c.bar() c.bar()
val err = C() val err = C()
err.<!UNRESOLVED_REFERENCE!>foo<!>() err.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>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!>println<!>("Hello!!!") <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>println<!>("Hello!!!")<!>
} }
}, },
VENERA(3.0, 4.0) { VENERA(3.0, 4.0) {
override fun sayHello() { override fun sayHello() {
<!UNRESOLVED_REFERENCE!>println<!>("Ola!!!") <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>println<!>("Ola!!!")<!>
} }
}, },
EARTH(5.0, 6.0) { EARTH(5.0, 6.0) {
override fun sayHello() { override fun sayHello() {
<!UNRESOLVED_REFERENCE!>println<!>("Privet!!!") <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>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!>bar<!>() // should be ambiguity (NB: really we should have overridden bar in C) super.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>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!>takeInt<!>(x) <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>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!>takeInt<!>(x) <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>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!>updateD<!>(d) // should fail val x = resolvedCall.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>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!>err<!>() this.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>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!>Inner<!>() val err = Owner.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>Inner<!>()<!>
err.<!UNRESOLVED_REFERENCE!>baz<!>() err.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>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!>accept<!>(Outer<Int>().Inner<Int>()) // illegal <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>accept<!>(Outer<Int>().Inner<Int>())<!> // illegal
<!INAPPLICABLE_CANDIDATE!>accept<!>(Outer<String>().Inner<String>()) // illegal <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>accept<!>(Outer<String>().Inner<String>())<!> // illegal
accept(Outer<String>().Inner<Int>()) // ok accept(Outer<String>().Inner<Int>()) // ok
<!INAPPLICABLE_CANDIDATE!>accept<!>(Boxed<Int>().substitute()) // illegal <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>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!>foo<!>() <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
this.<!UNRESOLVED_REFERENCE!>foo<!>() this.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>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!>take<!>(null) b.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>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!>_<!><Function1<Unit, KotlinClass?>>() } lambda.checkType { <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>_<!><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!>_<!><Function1<Unit, KotlinClass?>>() } lambda.checkType { <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>_<!><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!>_<!><Function1<Nothing, Boolean>>() } //(!!!) invalidType.checkType { <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>_<!><Function1<Nothing, Boolean>>()<!> } //(!!!)
Case1(javaClass).x.checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Function1<Nothing, Boolean>>() } //(!!!) Case1(javaClass).x.checkType { <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>_<!><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!>_<!><Function1<Nothing, Boolean>>() } //(!!!) invalidType.checkType { <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>_<!><Function1<Nothing, Boolean>>()<!> } //(!!!)
Case2(kotlinClass).x.checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Function1<Nothing, Boolean>>() } //(!!!) Case2(kotlinClass).x.checkType { <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>_<!><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!>C<!>() // shouldn't resolve val c = <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>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!>buz<!>() <!NONE_APPLICABLE{LT}!><!NONE_APPLICABLE{PSI}!>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!>f<!>(s, list) C().<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>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!>takeV<!>(value) <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>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!>getSetter<!>() // Should be error val res2 = descriptor.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>getSetter<!>()<!> // Should be error
val res3 = descriptor.isDelegated val res3 = descriptor.isDelegated
val res4 = descriptor.<!UNRESOLVED_REFERENCE!>isDelegated<!>() // Should be error val res4 = descriptor.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>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!>Another<!>() val another = <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>Another<!>()<!>
} }
compiler/fir/analysis-tests/testData/resolve/problems/objectDerivedFromInnerClass.kt
Vendored
+1 -1
View File
@@ -1,4 +1,4 @@
class Outer { inner class Inner } class Outer { inner class Inner }
fun test() { fun test() {
val x = object : <!UNRESOLVED_REFERENCE!>Outer.Inner<!>() { } val x = object : <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>Outer.Inner<!>()<!> { }
} }
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!>value<!>() // should be an error ann.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>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!>foo2<!>(MyFunction { x: Int -> <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>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!>foo<!>(MyRunnable { x -> <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>(MyRunnable { x ->
x > 1 x > 1
}) })<!>
<!INAPPLICABLE_CANDIDATE!>foo<!>(MyRunnable({ it > 1 })) <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>(MyRunnable({ it > 1 }))<!>
val x = { x: Int -> x > 1 } val x = { x: Int -> x > 1 }
<!INAPPLICABLE_CANDIDATE!>foo<!>(MyRunnable(x)) <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>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!>foo2<!> { x: Int -> JavaUsage.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>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!>foo2<!> { x -> x <!UNRESOLVED_REFERENCE!>><!> 1 } <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo2<!> { x -> x <!UNRESOLVED_REFERENCE!>><!> 1 }<!>
<!INAPPLICABLE_CANDIDATE!>foo2<!>(f) <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo2<!>(f)<!>
<!INAPPLICABLE_CANDIDATE!>foo3<!> { x -> x <!UNRESOLVED_REFERENCE!>><!> 1 } <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo3<!> { x -> x <!UNRESOLVED_REFERENCE!>><!> 1 }<!>
<!INAPPLICABLE_CANDIDATE!>foo3<!>(f) <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>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!>foo<!> { JavaUsage.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!> {
x -> x ->
x <!UNRESOLVED_REFERENCE!>><!> 1 x <!UNRESOLVED_REFERENCE!>><!> 1
} }<!>
JavaUsage.<!INAPPLICABLE_CANDIDATE!>foo<!>({ <!UNRESOLVED_REFERENCE!>it<!> <!UNRESOLVED_REFERENCE!>><!> 1 }) JavaUsage.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>({ <!UNRESOLVED_REFERENCE!>it<!> <!UNRESOLVED_REFERENCE!>><!> 1 })<!>
val x = { x: Int -> x > 1 } val x = { x: Int -> x > 1 }
JavaUsage.<!INAPPLICABLE_CANDIDATE!>foo<!>(x) JavaUsage.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>(x)<!>
} }
compiler/fir/analysis-tests/testData/resolve/sealedClass.kt
Vendored
+2 -2
View File
@@ -6,5 +6,5 @@ sealed class WithPrivateConstructor private constructor(val x: Int) {
private constructor() : this(42) private constructor() : this(42)
} }
object First : <!NONE_APPLICABLE!>WithPrivateConstructor<!>() // error object First : <!NONE_APPLICABLE{LT}!><!NONE_APPLICABLE{PSI}!>WithPrivateConstructor<!>()<!> // error
object Second : <!NONE_APPLICABLE!>WithPrivateConstructor<!>(0) // error object Second : <!NONE_APPLICABLE{LT}!><!NONE_APPLICABLE{PSI}!>WithPrivateConstructor<!>(0)<!> // error
compiler/fir/analysis-tests/testData/resolve/smartcasts/bangbang.kt
Vendored
+3 -3
View File
@@ -26,7 +26,7 @@ fun test_3(a: A?, b: Boolean) {
if (b && a!!.foo()) { if (b && a!!.foo()) {
a.foo() // OK a.foo() // OK
} }
a.<!INAPPLICABLE_CANDIDATE!>foo<!>() // Bad a.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>()<!> // Bad
} }
fun test_4(a: A?, b: Boolean) { fun test_4(a: A?, b: Boolean) {
@@ -38,9 +38,9 @@ fun test_4(a: A?, b: Boolean) {
fun test_5(a: A?, b: Boolean) { fun test_5(a: A?, b: Boolean) {
if (b || a!!.foo()) { if (b || a!!.foo()) {
a.<!INAPPLICABLE_CANDIDATE!>foo<!>() a.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>()<!>
} }
a.<!INAPPLICABLE_CANDIDATE!>foo<!>() a.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>()<!>
} }
fun <X : A?> test_6(x: X) { fun <X : A?> test_6(x: 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!>bar<!>() x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>bar<!>()<!>
x.<!UNRESOLVED_REFERENCE!>baz<!>() x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>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!>foo<!>() x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>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!>foo<!>() x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
} }
} }
fun test_9(x: Any) { fun test_9(x: Any) {
if (x is A || true) { if (x is A || true) {
x.<!UNRESOLVED_REFERENCE!>foo<!>() x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
} }
} }
fun test_10(x: Any) { fun test_10(x: Any) {
if (true || x is A) { if (true || x is A) {
x.<!UNRESOLVED_REFERENCE!>foo<!>() x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>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!>foo<!>() x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
} }
} }
compiler/fir/analysis-tests/testData/resolve/smartcasts/booleans/equalsToBoolean.kt
Vendored
+8 -8
View File
@@ -8,13 +8,13 @@ fun test_1(b: Boolean?) {
if ((b == true) == true) { if ((b == true) == true) {
b.not() // OK b.not() // OK
} else { } else {
b.<!INAPPLICABLE_CANDIDATE!>not<!>() // Bad b.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>not<!>()<!> // Bad
} }
} }
fun test_2(b: Boolean?) { fun test_2(b: Boolean?) {
if ((b == true) != true) { if ((b == true) != true) {
b.<!INAPPLICABLE_CANDIDATE!>not<!>() // Bad b.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>not<!>()<!> // Bad
} else { } else {
b.not() // OK b.not() // OK
} }
@@ -22,7 +22,7 @@ fun test_2(b: Boolean?) {
fun test_3(b: Boolean?) { fun test_3(b: Boolean?) {
if ((b == true) == false) { if ((b == true) == false) {
b.<!INAPPLICABLE_CANDIDATE!>not<!>() // Bad b.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>not<!>()<!> // Bad
} else { } else {
b.not() // OK b.not() // OK
} }
@@ -32,13 +32,13 @@ fun test_4(b: Boolean?) {
if ((b == true) != false) { if ((b == true) != false) {
b.not() // OK b.not() // OK
} else { } else {
b.<!INAPPLICABLE_CANDIDATE!>not<!>() // Bad b.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>not<!>()<!> // Bad
} }
} }
fun test_5(b: Boolean?) { fun test_5(b: Boolean?) {
if ((b != true) == true) { if ((b != true) == true) {
b.<!INAPPLICABLE_CANDIDATE!>not<!>() // Bad b.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>not<!>()<!> // Bad
} else { } else {
b.not() // OK b.not() // OK
} }
@@ -48,7 +48,7 @@ fun test_6(b: Boolean?) {
if ((b != true) != true) { if ((b != true) != true) {
b.not() // OK b.not() // OK
} else { } else {
b.<!INAPPLICABLE_CANDIDATE!>not<!>() // Bad b.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>not<!>()<!> // Bad
} }
} }
@@ -56,13 +56,13 @@ fun test_7(b: Boolean?) {
if ((b != true) == false) { if ((b != true) == false) {
b.not() // OK b.not() // OK
} else { } else {
b.<!INAPPLICABLE_CANDIDATE!>not<!>() // Bad b.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>not<!>()<!> // Bad
} }
} }
fun test_8(b: Boolean?) { fun test_8(b: Boolean?) {
if ((b != true) != false) { if ((b != true) != false) {
b.<!INAPPLICABLE_CANDIDATE!>not<!>() // Bad b.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>not<!>()<!> // Bad
} else { } else {
b.not() // OK b.not() // OK
} }
compiler/fir/analysis-tests/testData/resolve/smartcasts/booleans/jumpFromRhsOfOperator.kt
Vendored
+6 -6
View File
@@ -34,24 +34,24 @@ fun test_4(a: A?) {
fun test_5(a: A?) { fun test_5(a: A?) {
a == null || throw Exception() a == null || throw Exception()
a.<!INAPPLICABLE_CANDIDATE!>foo<!>() a.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>()<!>
} }
fun teat_6(a: A?) { fun teat_6(a: A?) {
a != null && throw Exception() a != null && throw Exception()
a.<!INAPPLICABLE_CANDIDATE!>foo<!>() a.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>()<!>
} }
fun test_7(a: A?) { fun test_7(a: A?) {
if (a == null || throw Exception()) { if (a == null || throw Exception()) {
a.<!INAPPLICABLE_CANDIDATE!>foo<!>() a.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>()<!>
} }
a.<!INAPPLICABLE_CANDIDATE!>foo<!>() a.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>()<!>
} }
fun test_8(a: A?) { fun test_8(a: A?) {
if (a != null && throw Exception()) { if (a != null && throw Exception()) {
a.<!INAPPLICABLE_CANDIDATE!>foo<!>() a.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>()<!>
} }
a.<!INAPPLICABLE_CANDIDATE!>foo<!>() a.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>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!>foo<!>() z.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>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!>inc<!>() x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>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!>not<!>() x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>not<!>()<!>
if (b && x as Boolean == true) { if (b && x as Boolean == true) {
x.not() x.not()
} }
x.<!UNRESOLVED_REFERENCE!>not<!>() x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>not<!>()<!>
if (b || x as Boolean) { if (b || x as Boolean) {
x.<!UNRESOLVED_REFERENCE!>not<!>() x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>not<!>()<!>
} }
x.<!UNRESOLVED_REFERENCE!>not<!>() x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>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!>not<!>() b.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>not<!>()<!>
} }
b.<!UNRESOLVED_REFERENCE!>not<!>() b.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>not<!>()<!>
if (b as? Boolean == null) { if (b as? Boolean == null) {
b.<!UNRESOLVED_REFERENCE!>not<!>() b.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>not<!>()<!>
} else { } else {
b.not() b.not()
} }
b.<!UNRESOLVED_REFERENCE!>not<!>() b.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>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!>bar<!>() x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>bar<!>()<!>
x.<!UNRESOLVED_REFERENCE!>baz<!>() x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>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!>foo<!>() x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
x.<!UNRESOLVED_REFERENCE!>bar<!>() x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>bar<!>()<!>
x.<!UNRESOLVED_REFERENCE!>baz<!>() x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>baz<!>()<!>
} }
fun <T> runHigherOrder(f: () -> T): T = f() fun <T> runHigherOrder(f: () -> T): T = f()
compiler/fir/analysis-tests/testData/resolve/smartcasts/equalsAndIdentity.kt
Vendored
+4 -4
View File
@@ -16,12 +16,12 @@ fun test_1(x: A, y: A?) {
fun test_2(x: A?, y: A?) { fun test_2(x: A?, y: A?) {
if (x == y) { if (x == y) {
x.<!INAPPLICABLE_CANDIDATE!>foo<!>() x.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>()<!>
y.<!INAPPLICABLE_CANDIDATE!>foo<!>() y.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>()<!>
} }
if (x === y) { if (x === y) {
x.<!INAPPLICABLE_CANDIDATE!>foo<!>() x.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>()<!>
y.<!INAPPLICABLE_CANDIDATE!>foo<!>() y.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>()<!>
} }
} }
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!>foo<!>() // No smartcast x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!> // No smartcast
} }
fun test_5(x: Any, b: Boolean) { fun test_5(x: Any, b: Boolean) {
compiler/fir/analysis-tests/testData/resolve/smartcasts/nullability.kt
Vendored
+18 -18
View File
@@ -39,18 +39,18 @@ fun test_1(x: A?) {
if (x != null) { if (x != null) {
x.foo() x.foo()
} else { } else {
x.<!INAPPLICABLE_CANDIDATE!>foo<!>() x.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>()<!>
} }
x.<!INAPPLICABLE_CANDIDATE!>foo<!>() x.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>()<!>
} }
fun test_2(x: A?) { fun test_2(x: A?) {
if (x == null) { if (x == null) {
x.<!INAPPLICABLE_CANDIDATE!>foo<!>() x.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>()<!>
} else { } else {
x.foo() x.foo()
} }
x.<!INAPPLICABLE_CANDIDATE!>foo<!>() x.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>()<!>
} }
fun test_3(x: A?) { fun test_3(x: A?) {
@@ -83,8 +83,8 @@ fun test_6(q: Q?) {
fun test_7(q: Q?) { fun test_7(q: Q?) {
if (q?.fdata()?.fs()?.inc() != null) { if (q?.fdata()?.fs()?.inc() != null) {
q.fdata() // good q.fdata() // good
q.fdata().<!INAPPLICABLE_CANDIDATE!>fs<!>() // bad q.fdata().<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>fs<!>()<!> // bad
q.fdata().<!INAPPLICABLE_CANDIDATE!>fs<!>().inc() // bad q.fdata().<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>fs<!>()<!>.inc() // bad
} }
} }
@@ -98,44 +98,44 @@ fun test_9(a: Int, b: Int?) {
if (a == b) { if (a == b) {
b.inc() b.inc()
} }
b.<!INAPPLICABLE_CANDIDATE!>inc<!>() b.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>inc<!>()<!>
if (a === b) { if (a === b) {
b.inc() b.inc()
} }
b.<!INAPPLICABLE_CANDIDATE!>inc<!>() b.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>inc<!>()<!>
if (b == a) { if (b == a) {
b.inc() b.inc()
} }
b.<!INAPPLICABLE_CANDIDATE!>inc<!>() b.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>inc<!>()<!>
if (b === a) { if (b === a) {
b.inc() b.inc()
} }
b.<!INAPPLICABLE_CANDIDATE!>inc<!>() b.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>inc<!>()<!>
} }
fun test_10(a: Int?, b: Int?) { fun test_10(a: Int?, b: Int?) {
if (a == b) { if (a == b) {
b.<!INAPPLICABLE_CANDIDATE!>inc<!>() b.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>inc<!>()<!>
} }
b.<!INAPPLICABLE_CANDIDATE!>inc<!>() b.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>inc<!>()<!>
if (a === b) { if (a === b) {
b.<!INAPPLICABLE_CANDIDATE!>inc<!>() b.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>inc<!>()<!>
} }
b.<!INAPPLICABLE_CANDIDATE!>inc<!>() b.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>inc<!>()<!>
if (b == a) { if (b == a) {
b.<!INAPPLICABLE_CANDIDATE!>inc<!>() b.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>inc<!>()<!>
} }
b.<!INAPPLICABLE_CANDIDATE!>inc<!>() b.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>inc<!>()<!>
if (b === a) { if (b === a) {
b.<!INAPPLICABLE_CANDIDATE!>inc<!>() b.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>inc<!>()<!>
} }
b.<!INAPPLICABLE_CANDIDATE!>inc<!>() b.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>inc<!>()<!>
} }
fun test_11(q: QImpl?, q2: QImpl) { fun test_11(q: QImpl?, q2: QImpl) {
compiler/fir/analysis-tests/testData/resolve/smartcasts/orInWhenBranch.kt
Vendored
+4 -4
View File
@@ -4,24 +4,24 @@ fun String.foo() {}
fun test_1(a: Any?) { fun test_1(a: Any?) {
when (a) { when (a) {
is String, is Any -> a.<!INAPPLICABLE_CANDIDATE!>foo<!>() // Should be Bad is String, is Any -> a.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>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!>foo<!>() // Should be Bad a.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>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!>foo<!>() // Should be Bad is String, b -> a.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>()<!> // Should be Bad
} }
} }
fun test_4(a: Any?, b: Boolean) { fun test_4(a: Any?, b: Boolean) {
if (a is String || b) { if (a is String || b) {
a.<!INAPPLICABLE_CANDIDATE!>foo<!>() // Should be Bad a.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>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!>foo<!>() this.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
<!UNRESOLVED_REFERENCE!>foo<!>() <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
} }
this.<!UNRESOLVED_REFERENCE!>foo<!>() this.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
<!UNRESOLVED_REFERENCE!>foo<!>() <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
} }
fun Any?.test_2() { fun Any?.test_2() {
if (this !is A) { if (this !is A) {
this.<!UNRESOLVED_REFERENCE!>foo<!>() this.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
<!UNRESOLVED_REFERENCE!>foo<!>() <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
} else { } else {
this.foo() this.foo()
foo() foo()
} }
this.<!UNRESOLVED_REFERENCE!>foo<!>() this.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
<!UNRESOLVED_REFERENCE!>foo<!>() <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>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!>foo<!>() this.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
<!UNRESOLVED_REFERENCE!>foo<!>() <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
this.<!UNRESOLVED_REFERENCE!>bar<!>() this.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>bar<!>()<!>
<!UNRESOLVED_REFERENCE!>bar<!>() <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>bar<!>()<!>
} else if (this !is B) { } else if (this !is B) {
this.<!UNRESOLVED_REFERENCE!>bar<!>() this.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>bar<!>()<!>
<!UNRESOLVED_REFERENCE!>bar<!>() <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>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!>foo<!>() this.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
<!UNRESOLVED_REFERENCE!>foo<!>() <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
this.<!UNRESOLVED_REFERENCE!>bar<!>() this.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>bar<!>()<!>
<!UNRESOLVED_REFERENCE!>bar<!>() <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>bar<!>()<!>
} }
fun Any.test_5(): Int = when { fun Any.test_5(): Int = when {
compiler/fir/analysis-tests/testData/resolve/smartcasts/safeCalls/safeCalls.kt
Vendored
+3 -3
View File
@@ -22,17 +22,17 @@ 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!>bool<!>() x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>bool<!>()<!>
} }
fun test_4(x: A?) { fun test_4(x: A?) {
x?.id()?.bool() x?.id()?.bool()
x.<!INAPPLICABLE_CANDIDATE!>id<!>() x.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>id<!>()<!>
} }
fun Any?.boo(b: Boolean) {} fun Any?.boo(b: Boolean) {}
fun test_5(x: A?) { fun test_5(x: A?) {
x?.let { return }?.boo(x.bool()) x?.let { return }?.boo(x.bool())
x.<!INAPPLICABLE_CANDIDATE!>id<!>() x.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>id<!>()<!>
} }
compiler/fir/analysis-tests/testData/resolve/smartcasts/variables/delayedAssignment.kt
Vendored
+1 -1
View File
@@ -11,5 +11,5 @@ fun test(b: Boolean) {
} else { } else {
a = null a = null
} }
a.<!INAPPLICABLE_CANDIDATE!>foo<!>() a.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>()<!>
} }
compiler/fir/analysis-tests/testData/resolve/typeAliasWithTypeArguments.kt
Vendored
+7 -7
View File
@@ -10,10 +10,10 @@ interface C {
fun baz() fun baz()
} }
interface <!CONSTRUCTOR_IN_INTERFACE!>Inv<K, T>()<!> { <!CONSTRUCTOR_IN_INTERFACE{LT}!>interface <!CONSTRUCTOR_IN_INTERFACE{PSI}!>Inv<K, T>()<!> {
fun k(): K fun k(): K
fun t(): T fun t(): T
} }<!>
typealias Inv0 = Inv<A, B> typealias Inv0 = Inv<A, B>
typealias Inv1<X> = Inv<A, X> typealias Inv1<X> = Inv<A, X>
@@ -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!>bar<!>() inv.t().<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>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!>take<!>(a) in3.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>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!>value<!>().<!UNRESOLVED_REFERENCE!>foo<!>() out2.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>value<!>()<!>.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>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!>foo<!>() inv2.value().<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
inv3.value().foo() inv3.value().foo()
inv1.take(a) inv1.take(a)
inv2.take(a) inv2.take(a)
inv3.<!INAPPLICABLE_CANDIDATE!>take<!>(a) inv3.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>take<!>(a)<!>
} }
compiler/fir/analysis-tests/testData/resolve/typeParameterVsNested.kt
Vendored
+1 -1
View File
@@ -13,7 +13,7 @@ abstract class My<T : Some> {
abstract val z: test.My.T abstract val z: test.My.T
class Some : <!OTHER_ERROR, UNRESOLVED_REFERENCE!>T<!>() class Some : <!UNRESOLVED_REFERENCE{LT}!><!OTHER_ERROR, UNRESOLVED_REFERENCE{PSI}!>T<!>()<!>
} }
abstract class Your<T : Some> : <!OTHER_ERROR!>T<!> abstract class Your<T : Some> : <!OTHER_ERROR!>T<!>
compiler/fir/analysis-tests/testData/resolve/visibility/exposedFunctionReturnType.kt
Vendored
+1 -1
View File
@@ -5,7 +5,7 @@ class A {
} }
abstract class B { abstract class B {
fun <!EXPOSED_FUNCTION_RETURN_TYPE!>foo<!>(str: String): A.InnerA <!EXPOSED_FUNCTION_RETURN_TYPE{LT}!>fun <!EXPOSED_FUNCTION_RETURN_TYPE{PSI}!>foo<!>(str: String): A.InnerA<!>
} }
private enum class Some { private enum class Some {
compiler/fir/analysis-tests/testData/resolve/visibility/exposedPropertyType.kt
Vendored
+2 -2
View File
@@ -17,7 +17,7 @@ class Property {
var var1: String var var1: String
var var2: String var var2: String
var var3: Int var var3: Int
var <!EXPOSED_PROPERTY_TYPE!>var4<!>: A.AInnerPrivate <!EXPOSED_PROPERTY_TYPE{LT}!>var <!EXPOSED_PROPERTY_TYPE{PSI}!>var4<!>: A.AInnerPrivate<!>
var var5: A.AInnerPublic var var5: A.AInnerPublic
var <!EXPOSED_PROPERTY_TYPE!>var6<!>: A.AInnerProtectedEnum <!EXPOSED_PROPERTY_TYPE{LT}!>var <!EXPOSED_PROPERTY_TYPE{PSI}!>var6<!>: A.AInnerProtectedEnum<!>
} }
compiler/fir/analysis-tests/testData/resolve/visibility/exposedSupertype.kt
Vendored
+2 -2
View File
@@ -38,7 +38,7 @@ interface E {
} }
class Test2 : A.APublicI, <!UNRESOLVED_REFERENCE!>B.BInner<!>() { class Test2 : A.APublicI, <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>B.BInner<!>()<!> {
} }
@@ -50,7 +50,7 @@ class Test4 : E, A.AProtectedI {
} }
class Test5 : C.CPublicI, <!UNRESOLVED_REFERENCE!>B.BInner<!>() { class Test5 : C.CPublicI, <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>B.BInner<!>()<!> {
} }
compiler/fir/analysis-tests/testData/resolve/visibility/exposedTypeAlias.kt
Vendored
+2 -2
View File
@@ -2,7 +2,7 @@ class A {
private inner class Inner private inner class Inner
} }
class B { class B {
typealias <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>AInner<!> = A.Inner <!EXPOSED_TYPEALIAS_EXPANDED_TYPE{LT}!>typealias <!EXPOSED_TYPEALIAS_EXPANDED_TYPE{PSI}!>AInner<!> = A.Inner<!>
inner class Inner inner class Inner
} }
@@ -10,7 +10,7 @@ class C {
typealias BInner = B.Inner typealias BInner = B.Inner
} }
typealias <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>AInner0<!> = A.Inner <!EXPOSED_TYPEALIAS_EXPANDED_TYPE{LT}!>typealias <!EXPOSED_TYPEALIAS_EXPANDED_TYPE{PSI}!>AInner0<!> = A.Inner<!>
typealias BInner0 = B.Inner typealias BInner0 = B.Inner
private typealias MyString = String private typealias MyString = String
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!>Comp<!>() <!HIDDEN{LT}!><!HIDDEN{PSI}!>Comp<!>()<!>
} }
} }
object B { object B {
private val x = <!HIDDEN!>B<!>() private val x = <!HIDDEN{LT}!><!HIDDEN{PSI}!>B<!>()<!>
} }
class D { class D {
@@ -26,6 +26,6 @@ enum class E {
}; };
fun foo() { fun foo() {
<!UNRESOLVED_REFERENCE!>X<!>() <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>X<!>()<!>
} }
} }
compiler/fir/analysis-tests/testData/resolve/visibility/visibilityWithOverrides.kt
Vendored
+1 -1
View File
@@ -19,5 +19,5 @@ abstract class A {
// FILE: main.kt // FILE: main.kt
fun test(b: B): String { fun test(b: B): String {
return b <!HIDDEN!>foo<!> "hello" // should be an error return <!HIDDEN{LT}!>b <!HIDDEN{PSI}!>foo<!> "hello"<!> // should be an error
} }