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

FIR checker: fix REFERENCE_BY_QUALIFIED positioning strategy to consider callable reference

Browse Source
This commit is contained in:
Jinseong Jeon
2021-03-24 23:26:15 -07:00
committed by Mikhail Glukhikh
parent 8d8ed4cc18
commit bfc7eb7bab
116 changed files with 272 additions and 455 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/testData/diagnostics/tests/callableReference/bound/expressionWithNullableType.fir.kt
Vendored
+5 -5
View File
@@ -6,10 +6,10 @@ public interface J {
// FILE: test.kt
fun f1(x: Int?): Any = <!UNRESOLVED_REFERENCE!>x::hashCode<!>
fun <T> f2(t: T): Any = <!UNRESOLVED_REFERENCE!>t::hashCode<!>
fun <S : String?> f3(s: S): Any = <!UNRESOLVED_REFERENCE!>s::hashCode<!>
fun <U : Any> f4(u: U?): Any = <!UNRESOLVED_REFERENCE!>u::hashCode<!>
fun f5(c: List<*>): Any = <!UNRESOLVED_REFERENCE!>c[0]::hashCode<!>
fun f1(x: Int?): Any = x::<!UNRESOLVED_REFERENCE!>hashCode<!>
fun <T> f2(t: T): Any = t::<!UNRESOLVED_REFERENCE!>hashCode<!>
fun <S : String?> f3(s: S): Any = s::<!UNRESOLVED_REFERENCE!>hashCode<!>
fun <U : Any> f4(u: U?): Any = u::<!UNRESOLVED_REFERENCE!>hashCode<!>
fun f5(c: List<*>): Any = c[0]::<!UNRESOLVED_REFERENCE!>hashCode<!>
fun f6(j: J): Any = j.platformString()::hashCode
compiler/testData/diagnostics/tests/callableReference/bound/functionCallWithoutArguments.fir.kt
Vendored
+1 -1
View File
@@ -1 +1 @@
fun test() = <!UNRESOLVED_REFERENCE!>("").<!UNRESOLVED_REFERENCE!>hashCode<!>::hashCode<!>
fun test() = ("").<!UNRESOLVED_REFERENCE!>hashCode<!>::<!UNRESOLVED_REFERENCE!>hashCode<!>
compiler/testData/diagnostics/tests/callableReference/bound/innerNested.fir.kt
Vendored
-9
View File
@@ -1,9 +0,0 @@
class Outer {
class Nested
inner class Inner
}
fun test() {
Outer()::Inner
<!UNRESOLVED_REFERENCE!>Outer()::Nested<!>
}
compiler/testData/diagnostics/tests/callableReference/bound/innerNested.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
class Outer {
class Nested
inner class Inner
compiler/testData/diagnostics/tests/callableReference/bound/kt12843.fir.kt
Vendored
+2 -2
View File
@@ -1,6 +1,6 @@
class Foo {
fun bar() {}
fun f() = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>Unresolved<!>()::bar<!>
fun f() = <!UNRESOLVED_REFERENCE!>Unresolved<!>()::<!UNRESOLVED_REFERENCE!>bar<!>
}
val f: () -> Unit = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>Unresolved<!>()::foo<!>
val f: () -> Unit = <!UNRESOLVED_REFERENCE!>Unresolved<!>()::<!UNRESOLVED_REFERENCE!>foo<!>
compiler/testData/diagnostics/tests/callableReference/bound/referenceToStaticMethodOnInstance.fir.kt
Vendored
-14
View File
@@ -1,14 +0,0 @@
// FILE: A.java
public class A {
public static void test() {}
}
// FILE: test.kt
enum class E { EN }
fun test() {
<!UNRESOLVED_REFERENCE!>A()::test<!>
<!UNRESOLVED_REFERENCE!>E.EN::valueOf<!>
}
compiler/testData/diagnostics/tests/callableReference/bound/referenceToStaticMethodOnInstance.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
// FILE: A.java
public class A {
compiler/testData/diagnostics/tests/callableReference/bound/reservedExpressionSyntax.fir.kt
Vendored
+3 -3
View File
@@ -18,9 +18,9 @@ class Test {
val <T> List<T>.b: Int? get() = size
fun <T> List<T>.testCallable1(): () -> Unit = a<T>::foo
fun <T> List<T>.testCallable2(): () -> Unit = <!UNRESOLVED_REFERENCE!>b?::foo<!>
fun <T> List<T>.testCallable3(): () -> Unit = <!UNRESOLVED_REFERENCE!>b<T, Any>::foo<!>
fun <T> List<T>.testCallable4(): () -> Unit = <!UNRESOLVED_REFERENCE!>b<T>?::foo<!>
fun <T> List<T>.testCallable2(): () -> Unit = b?::<!UNRESOLVED_REFERENCE!>foo<!>
fun <T> List<T>.testCallable3(): () -> Unit = b<T, Any>::<!UNRESOLVED_REFERENCE!>foo<!>
fun <T> List<T>.testCallable4(): () -> Unit = b<T>?::<!UNRESOLVED_REFERENCE!>foo<!>
fun <T> List<T>.testClassLiteral1() = a<T>::class
fun <T> List<T>.testClassLiteral2() = <!EXPRESSION_OF_NULLABLE_TYPE_IN_CLASS_LITERAL_LHS!>b<!>?::class
compiler/testData/diagnostics/tests/callableReference/bound/reservedExpressionSyntax2.fir.kt
Vendored
+1 -1
View File
@@ -4,4 +4,4 @@ package test
fun nullableFun(): Int? = null
fun Int.foo() {}
val test1 = <!UNRESOLVED_REFERENCE!>nullableFun()?::foo<!>
val test1 = nullableFun()?::<!UNRESOLVED_REFERENCE!>foo<!>
compiler/testData/diagnostics/tests/callableReference/constraintFromLHSWithCorrectDirection.fir.kt
Vendored
+1 -1
View File
@@ -19,6 +19,6 @@ fun <K, V> B<K>.star(p: KProperty1<*, V>): B<V> = TODO()
fun <R : A> B<R>.test(){
foo(A::bla)
bar(A::bla)
<!INAPPLICABLE_CANDIDATE!>baz<!>(<!UNRESOLVED_REFERENCE!>A::bla<!>)
<!INAPPLICABLE_CANDIDATE!>baz<!>(A::<!UNRESOLVED_REFERENCE!>bla<!>)
star(A::bla)
}
compiler/testData/diagnostics/tests/callableReference/constraintFromLHSWithCorrectDirectionError.fir.kt
Vendored
+1 -1
View File
@@ -15,5 +15,5 @@ fun <K, V> B<K>.foo(p: KProperty1<K, V>) {}
class C : A
fun <R : A> B<R>.test(){
<!INAPPLICABLE_CANDIDATE!>foo<!>(<!UNRESOLVED_REFERENCE!>C::bla<!>)
<!INAPPLICABLE_CANDIDATE!>foo<!>(C::<!UNRESOLVED_REFERENCE!>bla<!>)
}
compiler/testData/diagnostics/tests/callableReference/expectedTypeAsSubtypeOfFunctionType.fir.kt
Vendored
+1 -1
View File
@@ -8,6 +8,6 @@ fun <T> takeIt(x: T, f: SubFunction) {}
fun cr() {}
fun test() {
<!INAPPLICABLE_CANDIDATE!>takeIt<!>(42, <!UNRESOLVED_REFERENCE!>::cr<!>)
<!INAPPLICABLE_CANDIDATE!>takeIt<!>(42, ::<!UNRESOLVED_REFERENCE!>cr<!>)
<!INAPPLICABLE_CANDIDATE!>takeIt<!>(42, { })
}
compiler/testData/diagnostics/tests/callableReference/function/abstractClassConstructors.fir.kt
Vendored
+3 -3
View File
@@ -5,8 +5,8 @@ annotation class C
enum class D
fun main() {
<!UNRESOLVED_REFERENCE!>::A<!>
::<!UNRESOLVED_REFERENCE!>A<!>
::B
<!CALLABLE_REFERENCE_TO_ANNOTATION_CONSTRUCTOR!>::C<!> // KT-3465
<!UNRESOLVED_REFERENCE!>::D<!>
::<!CALLABLE_REFERENCE_TO_ANNOTATION_CONSTRUCTOR!>C<!> // KT-3465
::<!UNRESOLVED_REFERENCE!>D<!>
}
compiler/testData/diagnostics/tests/callableReference/function/ambiguityTopLevelVsTopLevel.fir.kt
Vendored
+2 -2
View File
@@ -3,7 +3,7 @@ fun foo(x: Int, y: Any) = x
fun foo(x: Any, y: Int) = y
fun main() {
<!UNRESOLVED_REFERENCE!>::foo<!>
::<!UNRESOLVED_REFERENCE!>foo<!>
val fooRef: (Int, Any) -> Unit = <!UNRESOLVED_REFERENCE!>::foo<!>
val fooRef: (Int, Any) -> Unit = ::<!UNRESOLVED_REFERENCE!>foo<!>
}
compiler/testData/diagnostics/tests/callableReference/function/annotationClassConstructor.fir.kt
Vendored
-5
View File
@@ -1,5 +0,0 @@
annotation class Ann(val prop: String)
val annCtorRef = <!CALLABLE_REFERENCE_TO_ANNOTATION_CONSTRUCTOR!>::Ann<!>
val annClassRef = Ann::class
val annPropRef = Ann::prop
compiler/testData/diagnostics/tests/callableReference/function/annotationClassConstructor.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
annotation class Ann(val prop: String)
val annCtorRef = ::<!CALLABLE_REFERENCE_TO_ANNOTATION_CONSTRUCTOR!>Ann<!>
compiler/testData/diagnostics/tests/callableReference/function/classMemberVsConstructorLikeFunction.fir.kt
Vendored
-16
View File
@@ -1,16 +0,0 @@
// FILE: Foo.kt
package test
class Foo {
fun bar() {}
}
// FILE: test.kt
import test.Foo
fun Foo(): String = ""
val f = Foo::bar
val g = <!UNRESOLVED_REFERENCE!>Foo::length<!>
compiler/testData/diagnostics/tests/callableReference/function/classMemberVsConstructorLikeFunction.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
// FILE: Foo.kt
package test
compiler/testData/diagnostics/tests/callableReference/function/constructorOfNestedClassInObject.fir.kt
Vendored
+2 -2
View File
@@ -16,6 +16,6 @@ fun test() {
Outer.Companion::Wrapper
(Outer.Companion)::Wrapper
<!UNRESOLVED_REFERENCE!>Outer::Wrapper<!>
<!UNRESOLVED_REFERENCE!>(Outer)::Wrapper<!>
Outer::<!UNRESOLVED_REFERENCE!>Wrapper<!>
(Outer)::<!UNRESOLVED_REFERENCE!>Wrapper<!>
}
compiler/testData/diagnostics/tests/callableReference/function/differentPackageExtension.fir.kt
Vendored
-31
View File
@@ -1,31 +0,0 @@
// !CHECK_TYPE
// !DIAGNOSTICS: -UNUSED_EXPRESSION
// FILE: a.kt
package first
import checkSubtype
class A
fun A.foo() {}
fun A.bar() {}
fun A.baz() {}
// FILE: b.kt
package other
import kotlin.reflect.KFunction1
import first.A
import first.foo
import checkSubtype
fun main() {
val x = first.A::foo
<!UNRESOLVED_REFERENCE!>first.A::bar<!>
<!UNRESOLVED_REFERENCE!>A::baz<!>
checkSubtype<KFunction1<A, Unit>>(x)
}
compiler/testData/diagnostics/tests/callableReference/function/differentPackageExtension.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
// !CHECK_TYPE
// !DIAGNOSTICS: -UNUSED_EXPRESSION
// FILE: a.kt
compiler/testData/diagnostics/tests/callableReference/function/extensionInClassDisallowed.fir.kt
Vendored
-20
View File
@@ -1,20 +0,0 @@
// !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_EXPRESSION
class A {
fun Int.extInt() = 42
fun A.extA(x: String) = x
fun main() {
<!EXTENSION_IN_CLASS_REFERENCE_NOT_ALLOWED!>Int::extInt<!>
<!EXTENSION_IN_CLASS_REFERENCE_NOT_ALLOWED!>A::extA<!>
eat(<!EXTENSION_IN_CLASS_REFERENCE_NOT_ALLOWED!>Int::extInt<!>)
eat(<!EXTENSION_IN_CLASS_REFERENCE_NOT_ALLOWED!>A::extA<!>)
}
}
fun eat(value: Any) {}
fun main() {
<!UNRESOLVED_REFERENCE!>A::extInt<!>
<!UNRESOLVED_REFERENCE!>A::extA<!>
}
compiler/testData/diagnostics/tests/callableReference/function/extensionInClassDisallowed.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
// !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_EXPRESSION
class A {
fun Int.extInt() = 42
compiler/testData/diagnostics/tests/callableReference/function/innerConstructorFromClass.fir.kt
Vendored
+2 -2
View File
@@ -26,9 +26,9 @@ class A {
class B {
fun main() {
<!UNRESOLVED_REFERENCE!>::Inner<!>
::<!UNRESOLVED_REFERENCE!>Inner<!>
val y = A::Inner
checkSubtype<KFunction1<A, A.Inner>>(y)
}
}
}
compiler/testData/diagnostics/tests/callableReference/function/innerConstructorFromExtension.fir.kt
Vendored
-23
View File
@@ -1,23 +0,0 @@
// !CHECK_TYPE
// !DIAGNOSTICS: -UNUSED_EXPRESSION
// !LANGUAGE: +CallableReferencesToClassMembersWithEmptyLHS
import kotlin.reflect.KFunction1
class A {
inner class Inner
}
fun A.main() {
::Inner
val y = A::Inner
checkSubtype<KFunction1<A, A.Inner>>(y)
}
fun Int.main() {
<!UNRESOLVED_REFERENCE!>::Inner<!>
val y = A::Inner
checkSubtype<KFunction1<A, A.Inner>>(y)
}
compiler/testData/diagnostics/tests/callableReference/function/innerConstructorFromExtension.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
// !CHECK_TYPE
// !DIAGNOSTICS: -UNUSED_EXPRESSION
// !LANGUAGE: +CallableReferencesToClassMembersWithEmptyLHS
compiler/testData/diagnostics/tests/callableReference/function/innerConstructorFromTopLevel.fir.kt
Vendored
-14
View File
@@ -1,14 +0,0 @@
// !CHECK_TYPE
// !DIAGNOSTICS: -UNUSED_EXPRESSION
import kotlin.reflect.KFunction1
class A {
inner class Inner
}
fun main() {
<!UNRESOLVED_REFERENCE!>::Inner<!>
val y = A::Inner
checkSubtype<KFunction1<A, A.Inner>>(y)
}
compiler/testData/diagnostics/tests/callableReference/function/innerConstructorFromTopLevel.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
// !CHECK_TYPE
// !DIAGNOSTICS: -UNUSED_EXPRESSION
import kotlin.reflect.KFunction1
compiler/testData/diagnostics/tests/callableReference/function/nestedConstructorFromClass.fir.kt
Vendored
-33
View File
@@ -1,33 +0,0 @@
// !CHECK_TYPE
// !DIAGNOSTICS: -UNUSED_EXPRESSION
import kotlin.reflect.KFunction0
class A {
class Nested
fun main() {
val x = ::Nested
val y = A::Nested
checkSubtype<KFunction0<Nested>>(x)
checkSubtype<KFunction0<Nested>>(y)
}
companion object {
fun main() {
::Nested
val y = A::Nested
checkSubtype<KFunction0<A.Nested>>(y)
}
}
}
class B {
fun main() {
<!UNRESOLVED_REFERENCE!>::Nested<!>
val y = A::Nested
checkSubtype<KFunction0<A.Nested>>(y)
}
}
compiler/testData/diagnostics/tests/callableReference/function/nestedConstructorFromClass.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
// !CHECK_TYPE
// !DIAGNOSTICS: -UNUSED_EXPRESSION
import kotlin.reflect.KFunction0
compiler/testData/diagnostics/tests/callableReference/function/nestedConstructorFromExtension.fir.kt
Vendored
-21
View File
@@ -1,21 +0,0 @@
// !CHECK_TYPE
// !DIAGNOSTICS: -UNUSED_EXPRESSION
import kotlin.reflect.KFunction0
class A {
class Nested
}
fun A.main() {
<!UNRESOLVED_REFERENCE!>::Nested<!>
val y = A::Nested
checkSubtype<KFunction0<A.Nested>>(y)
}
fun Int.main() {
<!UNRESOLVED_REFERENCE!>::Nested<!>
val y = A::Nested
checkSubtype<KFunction0<A.Nested>>(y)
}
compiler/testData/diagnostics/tests/callableReference/function/nestedConstructorFromExtension.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
// !CHECK_TYPE
// !DIAGNOSTICS: -UNUSED_EXPRESSION
import kotlin.reflect.KFunction0
compiler/testData/diagnostics/tests/callableReference/function/noAmbiguityMemberVsTopLevel.fir.kt
Vendored
+2 -2
View File
@@ -25,7 +25,7 @@ class A {
expectFunction0Unit(::foo)
expectFunction0String(::foo)
<!INAPPLICABLE_CANDIDATE!>expectFunction1Unit<!>(<!UNRESOLVED_REFERENCE!>::foo<!>)
<!INAPPLICABLE_CANDIDATE!>expectFunction1String<!>(<!UNRESOLVED_REFERENCE!>::foo<!>)
<!INAPPLICABLE_CANDIDATE!>expectFunction1Unit<!>(::<!UNRESOLVED_REFERENCE!>foo<!>)
<!INAPPLICABLE_CANDIDATE!>expectFunction1String<!>(::<!UNRESOLVED_REFERENCE!>foo<!>)
}
}
compiler/testData/diagnostics/tests/callableReference/function/unresolved.fir.kt
Vendored
+8 -8
View File
@@ -4,21 +4,21 @@
class A
fun test1() {
val foo = <!UNRESOLVED_REFERENCE!>::foo<!>
val foo = ::<!UNRESOLVED_REFERENCE!>foo<!>
<!UNRESOLVED_REFERENCE!>::bar<!>
::<!UNRESOLVED_REFERENCE!>bar<!>
<!UNRESOLVED_REFERENCE!>A::bar<!>
A::<!UNRESOLVED_REFERENCE!>bar<!>
<!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>B<!>::bar<!>
<!UNRESOLVED_REFERENCE!>B<!>::<!UNRESOLVED_REFERENCE!>bar<!>
}
fun test2() {
fun foo(x: Any) {}
fun foo() {}
<!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>Unresolved<!>::foo<!>
<!INAPPLICABLE_CANDIDATE!>foo<!>(<!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>Unresolved<!>::foo<!>)
<!INAPPLICABLE_CANDIDATE!>foo<!>(<!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>Unresolved<!>::unresolved<!>)
<!UNRESOLVED_REFERENCE!>::unresolved<!>
<!UNRESOLVED_REFERENCE!>Unresolved<!>::<!UNRESOLVED_REFERENCE!>foo<!>
<!INAPPLICABLE_CANDIDATE!>foo<!>(<!UNRESOLVED_REFERENCE!>Unresolved<!>::<!UNRESOLVED_REFERENCE!>foo<!>)
<!INAPPLICABLE_CANDIDATE!>foo<!>(<!UNRESOLVED_REFERENCE!>Unresolved<!>::<!UNRESOLVED_REFERENCE!>unresolved<!>)
::<!UNRESOLVED_REFERENCE!>unresolved<!>
}
compiler/testData/diagnostics/tests/callableReference/generic/dependOnArgumentType.fir.kt
Vendored
+2 -2
View File
@@ -16,14 +16,14 @@ fun <T> bar(s: T) {}
fun <T> complex(t: T, f: (T) -> Unit) {}
fun test1() {
<!INAPPLICABLE_CANDIDATE!>foo<!>(1, <!UNRESOLVED_REFERENCE!>A::invokeLater<!>) // KT-24507 SAM conversion accidentally applied to callable reference and incorrectly handled via BE
<!INAPPLICABLE_CANDIDATE!>foo<!>(1, A::<!UNRESOLVED_REFERENCE!>invokeLater<!>) // KT-24507 SAM conversion accidentally applied to callable reference and incorrectly handled via BE
foo(1, ::bar)
complex(1, ::bar)
}
fun <R> test2(x: R) {
<!INAPPLICABLE_CANDIDATE!>foo<!>(x, <!UNRESOLVED_REFERENCE!>A::invokeLater<!>) // KT-24507 SAM conversion accidentally applied to callable reference and incorrectly handled via BE
<!INAPPLICABLE_CANDIDATE!>foo<!>(x, A::<!UNRESOLVED_REFERENCE!>invokeLater<!>) // KT-24507 SAM conversion accidentally applied to callable reference and incorrectly handled via BE
foo(x, ::bar)
complex(x, ::bar)
compiler/testData/diagnostics/tests/callableReference/generic/explicitTypeArguments.fir.kt
Vendored
+1 -1
View File
@@ -14,7 +14,7 @@ fun <T> Wrapper<T>.baz(transform: (T) -> Unit): T = TODO()
fun test() {
takeFun<String>(::foo)
<!INAPPLICABLE_CANDIDATE!>takeFun<!><String>(<!UNRESOLVED_REFERENCE!>::fooInt<!>)
<!INAPPLICABLE_CANDIDATE!>takeFun<!><String>(::<!UNRESOLVED_REFERENCE!>fooInt<!>)
callFun<String, Wrapper<String>>(::createWrapper)
callFun<Int, Wrapper<Number>>(::createWrapper)
compiler/testData/diagnostics/tests/callableReference/generic/genericExtensionFunction.fir.kt
Vendored
+2 -2
View File
@@ -23,8 +23,8 @@ fun test1() {
fun <T> test2() {
bar<Wrapper, Int, String>(Wrapper::fooReturnString).checkType { _<Tripple<Wrapper, Int, String>>() }
bar<Wrapper, T, String>(Wrapper::fooReturnString).checkType { _<Tripple<Wrapper, T, String>>() }
<!INAPPLICABLE_CANDIDATE!>bar<!><Wrapper, T, T>(<!UNRESOLVED_REFERENCE!>Wrapper::fooReturnString<!>)
<!INAPPLICABLE_CANDIDATE!>bar<!><Wrapper, Int, Int>(<!UNRESOLVED_REFERENCE!>Wrapper::fooReturnString<!>)
<!INAPPLICABLE_CANDIDATE!>bar<!><Wrapper, T, T>(Wrapper::<!UNRESOLVED_REFERENCE!>fooReturnString<!>)
<!INAPPLICABLE_CANDIDATE!>bar<!><Wrapper, Int, Int>(Wrapper::<!UNRESOLVED_REFERENCE!>fooReturnString<!>)
bar<Wrapper, Int, T>(Wrapper::fooTakeInt).checkType { _<Tripple<Wrapper, Int, T>>() }
bar<Wrapper, Int, String>(Wrapper::fooTakeInt).checkType { _<Tripple<Wrapper, Int, String>>() }
compiler/testData/diagnostics/tests/callableReference/generic/kt11075.fir.kt
Vendored
+1 -1
View File
@@ -6,5 +6,5 @@ object TestCallableReferences {
fun test0(): (String) -> String = TestCallableReferences::foo
fun <T> test1(): (List<T>) -> List<T> = <!UNRESOLVED_REFERENCE!>TestCallableReferences::foo<!>
fun <T> test1(): (List<T>) -> List<T> = TestCallableReferences::<!UNRESOLVED_REFERENCE!>foo<!>
}
compiler/testData/diagnostics/tests/callableReference/generic/nestedCallWithOverload.fir.kt
Vendored
+1 -1
View File
@@ -11,7 +11,7 @@ fun test() {
val x2: (Int) -> Unit = baz(id(::foo), ::foo)
val x3: (Int) -> Unit = baz(id(::foo), id(id(::foo)))
val x4: (String) -> Unit = baz(id(::foo), id(id(::foo)))
val x5: (Double) -> Unit = baz(id(<!UNRESOLVED_REFERENCE!>::foo<!>), id(id(<!UNRESOLVED_REFERENCE!>::foo<!>)))
val x5: (Double) -> Unit = baz(id(::<!UNRESOLVED_REFERENCE!>foo<!>), id(id(::<!UNRESOLVED_REFERENCE!>foo<!>)))
id<(Int) -> Unit>(id(id(::foo)))
compiler/testData/diagnostics/tests/callableReference/generic/resolutionGenericCallableWithNullableTypes.fir.kt
Vendored
+3 -3
View File
@@ -17,7 +17,7 @@ fun test1() {
baz<String>(::foo).checkType { _<String?>() }
baz<Boolean>(::foo).checkType { _<Boolean?>() }
val b1: Int = baz(<!UNRESOLVED_REFERENCE!>::foo<!>)
val b2: String = baz(<!UNRESOLVED_REFERENCE!>::foo<!>)
val b3: Boolean = baz(<!UNRESOLVED_REFERENCE!>::foo<!>)
val b1: Int = baz(::<!UNRESOLVED_REFERENCE!>foo<!>)
val b2: String = baz(::<!UNRESOLVED_REFERENCE!>foo<!>)
val b3: Boolean = baz(::<!UNRESOLVED_REFERENCE!>foo<!>)
}
compiler/testData/diagnostics/tests/callableReference/generic/resolutionWithGenericCallable.fir.kt
Vendored
+4 -4
View File
@@ -5,9 +5,9 @@ fun test() {
val a1: Array<Double.(Double) -> Double> = arrayOf(Double::plus, Double::minus)
val a2: Array<Double.(Int) -> Double> = arrayOf(Double::plus, Double::minus)
val a3: Array<Int.(Int) -> Double> = arrayOf(<!UNRESOLVED_REFERENCE!>Double::plus<!>, <!UNRESOLVED_REFERENCE!>Double::minus<!>)
val a4: Array<Int.(Double) -> Double> = arrayOf(Int::plus, <!UNRESOLVED_REFERENCE!>Double::minus<!>)
val a5: Array<Double.(Double) -> Double> = arrayOf(Double::plus, <!UNRESOLVED_REFERENCE!>Int::minus<!>)
val a3: Array<Int.(Int) -> Double> = arrayOf(Double::<!UNRESOLVED_REFERENCE!>plus<!>, Double::<!UNRESOLVED_REFERENCE!>minus<!>)
val a4: Array<Int.(Double) -> Double> = arrayOf(Int::plus, Double::<!UNRESOLVED_REFERENCE!>minus<!>)
val a5: Array<Double.(Double) -> Double> = arrayOf(Double::plus, Int::<!UNRESOLVED_REFERENCE!>minus<!>)
}
fun foo(x: Int) {}
@@ -18,5 +18,5 @@ fun <T> bar(x: T, f: (T) -> Unit) {}
fun test2() {
bar(1, ::foo)
bar("", ::foo)
<!INAPPLICABLE_CANDIDATE!>bar<!>(1.0, <!UNRESOLVED_REFERENCE!>::foo<!>)
<!INAPPLICABLE_CANDIDATE!>bar<!>(1.0, ::<!UNRESOLVED_REFERENCE!>foo<!>)
}
compiler/testData/diagnostics/tests/callableReference/genericCallWithReferenceAgainstVararg.fir.kt
Vendored
+1 -1
View File
@@ -5,7 +5,7 @@ fun foo(vararg ints: Int) {}
fun test(i: IntArray) {
myLet(i, ::foo)
myLet(::foo)
<!INAPPLICABLE_CANDIDATE!>myLet<!><Int>(<!UNRESOLVED_REFERENCE!>::foo<!>)
<!INAPPLICABLE_CANDIDATE!>myLet<!><Int>(::<!UNRESOLVED_REFERENCE!>foo<!>)
myLet<IntArray>(::foo)
myLetExplicit1(::foo)
myLetExplicit2(::foo)
compiler/testData/diagnostics/tests/callableReference/kt7430_wrongClassOnLHS.fir.kt
Vendored
-12
View File
@@ -1,12 +0,0 @@
// !DIAGNOSTICS: -UNUSED_EXPRESSION
class Unrelated()
class Test(val name: String = "") {
init {
<!UNRESOLVED_REFERENCE!>Unrelated::name<!>
<!UNRESOLVED_REFERENCE!>Unrelated::foo<!>
}
fun foo() {}
}
compiler/testData/diagnostics/tests/callableReference/kt7430_wrongClassOnLHS.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
// !DIAGNOSTICS: -UNUSED_EXPRESSION
class Unrelated()
compiler/testData/diagnostics/tests/callableReference/memberExtensionsImportedFromObjectsUnsupported.fir.kt
Vendored
+7 -7
View File
@@ -14,13 +14,13 @@ class A {
}
fun test() {
<!EXTENSION_IN_CLASS_REFERENCE_NOT_ALLOWED!>String::ext<!>
<!UNRESOLVED_REFERENCE!>Obj::ext<!>
String::<!EXTENSION_IN_CLASS_REFERENCE_NOT_ALLOWED!>ext<!>
Obj::<!UNRESOLVED_REFERENCE!>ext<!>
<!EXTENSION_IN_CLASS_REFERENCE_NOT_ALLOWED!>String::ext2<!>
<!UNRESOLVED_REFERENCE!>A.Companion::ext2<!>
<!UNRESOLVED_REFERENCE!>A::ext2<!>
String::<!EXTENSION_IN_CLASS_REFERENCE_NOT_ALLOWED!>ext2<!>
A.Companion::<!UNRESOLVED_REFERENCE!>ext2<!>
A::<!UNRESOLVED_REFERENCE!>ext2<!>
<!UNRESOLVED_REFERENCE!>A::foo<!>
<!UNRESOLVED_REFERENCE!>A::bar<!>
A::<!UNRESOLVED_REFERENCE!>foo<!>
A::<!UNRESOLVED_REFERENCE!>bar<!>
}
compiler/testData/diagnostics/tests/callableReference/property/javaInstanceField.fir.kt
Vendored
+2 -2
View File
@@ -21,6 +21,6 @@ fun test() {
val pubMutRef: KMutableProperty1<JavaClass, Long> = JavaClass::publicMutable
val protFinRef: KProperty1<JavaClass, Double> = JavaClass::protectedFinal
val protMutRef: KMutableProperty1<JavaClass, Char> = JavaClass::protectedMutable
val privFinRef: KProperty1<JavaClass, String?> = <!UNRESOLVED_REFERENCE!>JavaClass::privateFinal<!>
val privMutRef: KMutableProperty1<JavaClass, Any?> = <!UNRESOLVED_REFERENCE!>JavaClass::privateMutable<!>
val privFinRef: KProperty1<JavaClass, String?> = JavaClass::<!UNRESOLVED_REFERENCE!>privateFinal<!>
val privMutRef: KMutableProperty1<JavaClass, Any?> = JavaClass::<!UNRESOLVED_REFERENCE!>privateMutable<!>
}
compiler/testData/diagnostics/tests/callableReference/property/javaStaticFieldViaImport.fir.kt
Vendored
+2 -2
View File
@@ -23,6 +23,6 @@ fun test() {
val pubMutRef: KMutableProperty0<Any?> = ::publicMutable
val protFinRef: KProperty<Double> = ::protectedFinal
val protMutRef: KMutableProperty<Char> = ::protectedMutable
val privFinRef: KProperty<JavaClass?> = <!UNRESOLVED_REFERENCE!>::privateFinal<!>
val privMutRef: KMutableProperty<Throwable?> = <!UNRESOLVED_REFERENCE!>::privateMutable<!>
val privFinRef: KProperty<JavaClass?> = ::<!UNRESOLVED_REFERENCE!>privateFinal<!>
val privMutRef: KMutableProperty<Throwable?> = ::<!UNRESOLVED_REFERENCE!>privateMutable<!>
}
compiler/testData/diagnostics/tests/callableReference/property/kt7945_unrelatedClass.fir.kt
Vendored
+1 -1
View File
@@ -7,5 +7,5 @@ class TestClass(var prop: Int)
open class OtherClass
fun OtherClass.test(prop: KProperty1<TestClass, Int>): Unit = throw Exception()
class OtherClass2: OtherClass() {
val result = <!INAPPLICABLE_CANDIDATE!>test<!>(<!UNRESOLVED_REFERENCE!>TestClass::result<!>)
val result = <!INAPPLICABLE_CANDIDATE!>test<!>(TestClass::<!UNRESOLVED_REFERENCE!>result<!>)
}
compiler/testData/diagnostics/tests/callableReference/referenceToCompanionObjectMemberViaClassNameCompatibility.fir.kt
Vendored
+1 -1
View File
@@ -22,7 +22,7 @@ fun B.foo(): Double = 0.0
fun call(a: Any) {}
fun testA(a: A) {
call(<!UNRESOLVED_REFERENCE!>A::foo<!>)
call(A::<!UNRESOLVED_REFERENCE!>foo<!>)
call(A.Companion::foo)
}
compiler/testData/diagnostics/tests/callableReference/resolve/ambiguityWhenNoApplicableCallableReferenceCandidate.fir.kt
Vendored
+2 -2
View File
@@ -7,5 +7,5 @@ fun foo(y: String) {}
fun <T> bar(f: (T) -> Unit) {}
fun test() {
bar(<!UNRESOLVED_REFERENCE!>::foo<!>)
}
bar(::<!UNRESOLVED_REFERENCE!>foo<!>)
}
compiler/testData/diagnostics/tests/callableReference/resolve/ambiguityWithBoundExtensionReceiver.fir.kt
Vendored
+1 -1
View File
@@ -10,6 +10,6 @@ fun A.foo() = ""
class A {
fun main() {
bar(<!UNRESOLVED_REFERENCE!>::foo<!>) checkType { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
bar(::<!UNRESOLVED_REFERENCE!>foo<!>) checkType { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
}
}
compiler/testData/diagnostics/tests/callableReference/resolve/ambiguousWithVararg.fir.kt
Vendored
+3 -3
View File
@@ -3,14 +3,14 @@
fun fun1() {}
fun fun1(x: Int) {}
val ref1 = <!UNRESOLVED_REFERENCE!>::fun1<!>
val ref1 = ::<!UNRESOLVED_REFERENCE!>fun1<!>
fun fun2(vararg x: Int) {}
fun fun2(x: Int) {}
val ref2 = <!UNRESOLVED_REFERENCE!>::fun2<!>
val ref2 = ::<!UNRESOLVED_REFERENCE!>fun2<!>
fun fun3(x0: Int, vararg xs: Int) {}
fun fun3(x0: String, vararg xs: String) {}
val ref3 = <!UNRESOLVED_REFERENCE!>::fun3<!>
val ref3 = ::<!UNRESOLVED_REFERENCE!>fun3<!>
compiler/testData/diagnostics/tests/callableReference/resolve/byGenericArgType.fir.kt
Vendored
+1 -1
View File
@@ -8,4 +8,4 @@ fun foo(s: String) {}
val x1 = ofType<() -> Unit>(::foo)
val x2 = ofType<(String) -> Unit>(::foo)
val x3 = <!INAPPLICABLE_CANDIDATE!>ofType<!><(Int) -> Unit>(<!UNRESOLVED_REFERENCE!>::foo<!>)
val x3 = <!INAPPLICABLE_CANDIDATE!>ofType<!><(Int) -> Unit>(::<!UNRESOLVED_REFERENCE!>foo<!>)
compiler/testData/diagnostics/tests/callableReference/resolve/byValType.fir.kt
Vendored
+2 -2
View File
@@ -3,7 +3,7 @@
fun foo() {}
fun foo(s: String) {}
val x1 = <!UNRESOLVED_REFERENCE!>::foo<!>
val x1 = ::<!UNRESOLVED_REFERENCE!>foo<!>
val x2: () -> Unit = ::foo
val x3: (String) -> Unit = ::foo
val x4: (Int) -> Unit = <!UNRESOLVED_REFERENCE!>::foo<!>
val x4: (Int) -> Unit = ::<!UNRESOLVED_REFERENCE!>foo<!>
compiler/testData/diagnostics/tests/callableReference/resolve/chooseCallableReferenceDependingOnInferredReceiver.fir.kt
Vendored
+2 -2
View File
@@ -31,9 +31,9 @@ fun test() {
val t3 = bar(::baz)
t3
bar(<!UNRESOLVED_REFERENCE!>::foo<!>)
bar(::<!UNRESOLVED_REFERENCE!>foo<!>)
}
}
}
inline fun <T, R> myWith(receiver: T, block: T.() -> R): R = TODO()
inline fun <T, R> myWith(receiver: T, block: T.() -> R): R = TODO()
compiler/testData/diagnostics/tests/callableReference/resolve/eagerAndPostponedCallableReferences.fir.kt
Vendored
+2 -2
View File
@@ -31,5 +31,5 @@ fun test() {
val a6 = foo(::singleA, ::singleB)
a6
foo(<!UNRESOLVED_REFERENCE!>::multiple<!>, <!UNRESOLVED_REFERENCE!>::multiple<!>)
}
foo(::<!UNRESOLVED_REFERENCE!>multiple<!>, ::<!UNRESOLVED_REFERENCE!>multiple<!>)
}
compiler/testData/diagnostics/tests/callableReference/resolve/kt35887_simple.fir.kt
Vendored
+1 -1
View File
@@ -6,4 +6,4 @@ import kotlin.reflect.KProperty0
object A
fun <TProperty> property0(property: KProperty0<TProperty>) = A
val <K> K.key get() : A = <!INAPPLICABLE_CANDIDATE!>property0<!>(<!UNRESOLVED_REFERENCE!>Map.Entry<K, *>::key<!>) // should be forbidden
val <K> K.key get() : A = <!INAPPLICABLE_CANDIDATE!>property0<!>(Map.Entry<K, *>::<!UNRESOLVED_REFERENCE!>key<!>) // should be forbidden
compiler/testData/diagnostics/tests/callableReference/resolve/moreSpecificAmbiguousExtensions.fir.kt
Vendored
+4 -4
View File
@@ -9,13 +9,13 @@ fun IB.extFun(x: IA) {}
fun test() {
val extFun1 = IA::extFun
val extFun2 = <!UNRESOLVED_REFERENCE!>IB::extFun<!>
val extFun2 = IB::<!UNRESOLVED_REFERENCE!>extFun<!>
}
fun testWithExpectedType() {
val extFun_AB_A: IA.(IB) -> Unit = IA::extFun
val extFun_AA_B: IA.(IA) -> Unit = <!UNRESOLVED_REFERENCE!>IB::extFun<!>
val extFun_AA_B: IA.(IA) -> Unit = IB::<!UNRESOLVED_REFERENCE!>extFun<!>
val extFun_BB_A: IB.(IB) -> Unit = IA::extFun
val extFun_BA_B: IB.(IA) -> Unit = IB::extFun
val extFun_BB_B: IB.(IB) -> Unit = <!UNRESOLVED_REFERENCE!>IB::extFun<!>
}
val extFun_BB_B: IB.(IB) -> Unit = IB::<!UNRESOLVED_REFERENCE!>extFun<!>
}
compiler/testData/diagnostics/tests/callableReference/resolve/overloads.fir.kt
Vendored
+2 -2
View File
@@ -24,7 +24,7 @@ fun test() {
B::bar checkType { _<KFunction1<B, Unit>>() }
<!UNRESOLVED_REFERENCE!>B::bas<!>
B::<!UNRESOLVED_REFERENCE!>bas<!>
<!UNRESOLVED_REFERENCE!>::fas<!>
::<!UNRESOLVED_REFERENCE!>fas<!>
}
compiler/testData/diagnostics/tests/callableReference/resolve/resolveCallableReferencesAfterAllSimpleArguments.fir.kt
Vendored
+2 -2
View File
@@ -11,6 +11,6 @@ fun <T> baz(e: T, f: (T) -> Unit) {}
fun test(a: A, b: B) {
// Note that diagnostic is always on callable references as they are resolved after simple arguments
<!INAPPLICABLE_CANDIDATE!>baz<!>(a, <!UNRESOLVED_REFERENCE!>::fooB<!>)
<!INAPPLICABLE_CANDIDATE!>bar<!>(<!UNRESOLVED_REFERENCE!>::fooB<!>, a)
<!INAPPLICABLE_CANDIDATE!>baz<!>(a, ::<!UNRESOLVED_REFERENCE!>fooB<!>)
<!INAPPLICABLE_CANDIDATE!>bar<!>(::<!UNRESOLVED_REFERENCE!>fooB<!>, a)
}
compiler/testData/diagnostics/tests/callableReference/resolve/withAs.fir.kt
Vendored
+2 -2
View File
@@ -6,5 +6,5 @@ fun foo(s: String) {}
fun bar(f: () -> Unit) = 1
fun bar(f: (String) -> Unit) = 2
val x1 = <!UNRESOLVED_REFERENCE!>::foo<!> as () -> Unit
val x2 = bar(<!UNRESOLVED_REFERENCE!>::foo<!> as (String) -> Unit)
val x1 = ::<!UNRESOLVED_REFERENCE!>foo<!> as () -> Unit
val x2 = bar(::<!UNRESOLVED_REFERENCE!>foo<!> as (String) -> Unit)
compiler/testData/diagnostics/tests/callableReference/resolve/withExtFun.fir.kt
Vendored
+2 -2
View File
@@ -14,14 +14,14 @@ class A {
fun A.foo(): String = "A"
val x0 = <!UNRESOLVED_REFERENCE!>A::foo<!>
val x0 = A::<!UNRESOLVED_REFERENCE!>foo<!>
val x1 = ofType<(A) -> Unit>(A::foo)
val x2 = ofType<KProperty1<A, Int>>(A::foo)
val x3: KProperty1<A, Int> = A::foo
val x4: (A) -> String = A::foo
val y0 = <!UNRESOLVED_REFERENCE!>A::bar<!>
val y0 = A::<!UNRESOLVED_REFERENCE!>bar<!>
val y1 = ofType<(A) -> Unit>(A::bar)
val y2 = ofType<KProperty1<A, Int>>(A::bar)
val y3: KProperty1<A, Int> = A::bar
compiler/testData/diagnostics/tests/callableReference/resolve/withGenericFun.fir.kt
Vendored
+1 -1
View File
@@ -9,4 +9,4 @@ fun foo(s: String) {}
val x1 = apply(1, ::foo)
val x2 = apply("hello", ::foo)
val x3 = <!INAPPLICABLE_CANDIDATE!>apply<!>(true, <!UNRESOLVED_REFERENCE!>::foo<!>)
val x3 = <!INAPPLICABLE_CANDIDATE!>apply<!>(true, ::<!UNRESOLVED_REFERENCE!>foo<!>)
compiler/testData/diagnostics/tests/callableReference/resolve/withPlaceholderTypes.fir.kt
Vendored
+2 -2
View File
@@ -22,7 +22,7 @@ val x1 = fn1(1, ::foo, ::foo)
val x2 = fn1(1, ::foo, ::bar)
val x3 = fn2(::bar, ::foo)
val x4 = <!AMBIGUITY!>fn2<!>(<!UNRESOLVED_REFERENCE!>::foo<!>, ::bar)
val x5 = <!AMBIGUITY!>fn2<!>(<!UNRESOLVED_REFERENCE!>::foo<!>, <!UNRESOLVED_REFERENCE!>::foo<!>)
val x4 = <!AMBIGUITY!>fn2<!>(::<!UNRESOLVED_REFERENCE!>foo<!>, ::bar)
val x5 = <!AMBIGUITY!>fn2<!>(::<!UNRESOLVED_REFERENCE!>foo<!>, ::<!UNRESOLVED_REFERENCE!>foo<!>)
val x6 = fn3(1, ::qux)
compiler/testData/diagnostics/tests/callableReference/withQuestionMarks.fir.kt
Vendored
+16 -16
View File
@@ -4,24 +4,24 @@
fun foo() {}
fun main() {
val x1 = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>logger<!>::info<!>?::print<!>
val x2 = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>logger<!>?::info<!>?::print<!>
val x3 = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>logger<!>?::info<!>::print<!>
val x4 = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>logger<!>?::info<!>?::print<!>?::print<!>?::print<!>?::print<!>?::print<!>?::print<!>?::print<!>?::print<!>?::print<!>?::print<!>
val x5 = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>logger<!>::info<!>?::print<!>?::print<!>?::print<!>?::print<!>?::print<!>?::print<!>?::print<!>?::print<!>?::print<!>?::print<!>
val x6 = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>logger<!>!!::info<!>?::print<!>?::print<!>
val x7 = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>logger<!>::info!!::print<!>?::print<!>
val x8 = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>logger<!>?::info!!::print<!>?::print<!>
val x9 = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>logger<!>!!::info<!>?::print<!>?::print<!>
val x10 = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>logger<!>::info<!>?::print!!::print<!>
val x11 = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>logger<!>!!::info!!::print!!::print<!>
val x12 = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>logger<!>?::info!!::print!!::print<!>
val x13 = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>42?::unresolved<!>?::print<!>
val x1 = <!UNRESOLVED_REFERENCE!>logger<!>::<!UNRESOLVED_REFERENCE!>info<!>?::<!UNRESOLVED_REFERENCE!>print<!>
val x2 = <!UNRESOLVED_REFERENCE!>logger<!>?::<!UNRESOLVED_REFERENCE!>info<!>?::<!UNRESOLVED_REFERENCE!>print<!>
val x3 = <!UNRESOLVED_REFERENCE!>logger<!>?::<!UNRESOLVED_REFERENCE!>info<!>::<!UNRESOLVED_REFERENCE!>print<!>
val x4 = <!UNRESOLVED_REFERENCE!>logger<!>?::<!UNRESOLVED_REFERENCE!>info<!>?::<!UNRESOLVED_REFERENCE!>print<!>?::<!UNRESOLVED_REFERENCE!>print<!>?::<!UNRESOLVED_REFERENCE!>print<!>?::<!UNRESOLVED_REFERENCE!>print<!>?::<!UNRESOLVED_REFERENCE!>print<!>?::<!UNRESOLVED_REFERENCE!>print<!>?::<!UNRESOLVED_REFERENCE!>print<!>?::<!UNRESOLVED_REFERENCE!>print<!>?::<!UNRESOLVED_REFERENCE!>print<!>?::<!UNRESOLVED_REFERENCE!>print<!>
val x5 = <!UNRESOLVED_REFERENCE!>logger<!>::<!UNRESOLVED_REFERENCE!>info<!>?::<!UNRESOLVED_REFERENCE!>print<!>?::<!UNRESOLVED_REFERENCE!>print<!>?::<!UNRESOLVED_REFERENCE!>print<!>?::<!UNRESOLVED_REFERENCE!>print<!>?::<!UNRESOLVED_REFERENCE!>print<!>?::<!UNRESOLVED_REFERENCE!>print<!>?::<!UNRESOLVED_REFERENCE!>print<!>?::<!UNRESOLVED_REFERENCE!>print<!>?::<!UNRESOLVED_REFERENCE!>print<!>?::<!UNRESOLVED_REFERENCE!>print<!>
val x6 = <!UNRESOLVED_REFERENCE!>logger<!>!!::<!UNRESOLVED_REFERENCE!>info<!>?::<!UNRESOLVED_REFERENCE!>print<!>?::<!UNRESOLVED_REFERENCE!>print<!>
val x7 = <!UNRESOLVED_REFERENCE!>logger<!>::info!!::<!UNRESOLVED_REFERENCE!>print<!>?::<!UNRESOLVED_REFERENCE!>print<!>
val x8 = <!UNRESOLVED_REFERENCE!>logger<!>?::info!!::<!UNRESOLVED_REFERENCE!>print<!>?::<!UNRESOLVED_REFERENCE!>print<!>
val x9 = <!UNRESOLVED_REFERENCE!>logger<!>!!::<!UNRESOLVED_REFERENCE!>info<!>?::<!UNRESOLVED_REFERENCE!>print<!>?::<!UNRESOLVED_REFERENCE!>print<!>
val x10 = <!UNRESOLVED_REFERENCE!>logger<!>::<!UNRESOLVED_REFERENCE!>info<!>?::print!!::<!UNRESOLVED_REFERENCE!>print<!>
val x11 = <!UNRESOLVED_REFERENCE!>logger<!>!!::info!!::print!!::<!UNRESOLVED_REFERENCE!>print<!>
val x12 = <!UNRESOLVED_REFERENCE!>logger<!>?::info!!::print!!::<!UNRESOLVED_REFERENCE!>print<!>
val x13 = 42?::<!UNRESOLVED_REFERENCE!>unresolved<!>?::<!UNRESOLVED_REFERENCE!>print<!>
val x14 = <!UNRESOLVED_REFERENCE!>logger<!><!SYNTAX!>?!!::info?::print?::print<!>
val x15 = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>logger<!>::info<!><!SYNTAX!>?!!::print?::print<!>
val x16 = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>logger<!>!!?::info<!>?::print<!>?::print<!>
val x17 = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>logger<!>::info!!?::print<!>?::print<!>
val x15 = <!UNRESOLVED_REFERENCE!>logger<!>::<!UNRESOLVED_REFERENCE!>info<!><!SYNTAX!>?!!::print?::print<!>
val x16 = <!UNRESOLVED_REFERENCE!>logger<!>!!?::<!UNRESOLVED_REFERENCE!>info<!>?::<!UNRESOLVED_REFERENCE!>print<!>?::<!UNRESOLVED_REFERENCE!>print<!>
val x17 = <!UNRESOLVED_REFERENCE!>logger<!>::info!!?::<!UNRESOLVED_REFERENCE!>print<!>?::<!UNRESOLVED_REFERENCE!>print<!>
// It must be OK
val x18 = String?::hashCode ?: ::foo