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/fir/analysis-tests/testData/resolve/expresssions/errCallable.kt
Vendored
+2 -2
View File
@@ -4,10 +4,10 @@ class Your {
class My {
fun foo() {
val x = <!UNRESOLVED_REFERENCE!>::Nested<!> // Should be error
val x = ::<!UNRESOLVED_REFERENCE!>Nested<!> // Should be error
}
}
fun Your.foo() {
val x = <!UNRESOLVED_REFERENCE!>::Nested<!> // Still should be error
val x = ::<!UNRESOLVED_REFERENCE!>Nested<!> // Still should be error
}
compiler/fir/analysis-tests/testData/resolve/references/referenceToExtension.kt
Vendored
+4 -4
View File
@@ -17,8 +17,8 @@ class GenericTest {
}
fun test_2() {
val extensionValRef = <!UNRESOLVED_REFERENCE!>B<*>::extensionVal<!>
val extensionFunRef = <!UNRESOLVED_REFERENCE!>B<*>::extensionFun<!>
val extensionValRef = B<*>::<!UNRESOLVED_REFERENCE!>extensionVal<!>
val extensionFunRef = B<*>::<!UNRESOLVED_REFERENCE!>extensionFun<!>
}
}
@@ -36,8 +36,8 @@ class NoGenericTest {
fun B.extensionFun(): A = A()
fun test_1() {
val extensionValRef = <!EXTENSION_IN_CLASS_REFERENCE_NOT_ALLOWED!>B::extensionVal<!>
val extensionFunRef = <!EXTENSION_IN_CLASS_REFERENCE_NOT_ALLOWED!>B::extensionFun<!>
val extensionValRef = B::<!EXTENSION_IN_CLASS_REFERENCE_NOT_ALLOWED!>extensionVal<!>
val extensionFunRef = B::<!EXTENSION_IN_CLASS_REFERENCE_NOT_ALLOWED!>extensionFun<!>
}
fun test_2() {
compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/beyoundCalls.kt
Vendored
+1 -1
View File
@@ -6,7 +6,7 @@ fun <T, R> foobaz(x: T): R = TODO()
fun foo() {
val x: (String) -> Int = ::bar
val y = <!UNRESOLVED_REFERENCE!>::bar<!>
val y = ::<!UNRESOLVED_REFERENCE!>bar<!>
val z = ::baz
val w: (String) -> Int = ::foobaz
compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/companions.kt
Vendored
+2 -2
View File
@@ -34,13 +34,13 @@ fun main() {
<!AMBIGUITY!>foo3<!>(KotlinClass::baz)
// Type mismatch
<!INAPPLICABLE_CANDIDATE!>foo1<!>(<!UNRESOLVED_REFERENCE!>KotlinClass::bar<!>)
<!INAPPLICABLE_CANDIDATE!>foo1<!>(KotlinClass::<!UNRESOLVED_REFERENCE!>bar<!>)
foo2(KotlinClass::bar)
foo3(KotlinClass::bar)
foo1(KotlinClass2::bar)
// Type mismatch
<!INAPPLICABLE_CANDIDATE!>foo2<!>(<!UNRESOLVED_REFERENCE!>KotlinClass2::bar<!>)
<!INAPPLICABLE_CANDIDATE!>foo2<!>(KotlinClass2::<!UNRESOLVED_REFERENCE!>bar<!>)
foo3(KotlinClass2::bar)
}
compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/fromBasicDiagnosticTests/ambiguityWhenNoApplicableCallableReferenceCandidate.kt
Vendored
+1 -1
View File
@@ -4,5 +4,5 @@ fun foo(y: String) {}
fun <T> bar(f: (T) -> Unit) {}
fun test() {
bar(<!UNRESOLVED_REFERENCE!>::foo<!>)
bar(::<!UNRESOLVED_REFERENCE!>foo<!>)
}
compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/fromBasicDiagnosticTests/chooseCallableReferenceDependingOnInferredReceiver.kt
Vendored
+1 -1
View File
@@ -25,7 +25,7 @@ fun test() {
val t3 = bar(::baz)
bar(<!UNRESOLVED_REFERENCE!>::foo<!>)
bar(::<!UNRESOLVED_REFERENCE!>foo<!>)
}
}
}
compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/fromBasicDiagnosticTests/eagerAndPostponedCallableReferences.kt
Vendored
+1 -1
View File
@@ -22,5 +22,5 @@ fun test() {
val a6 = foo(::singleA, ::singleB)
foo(<!UNRESOLVED_REFERENCE!>::multiple<!>, <!UNRESOLVED_REFERENCE!>::multiple<!>)
foo(::<!UNRESOLVED_REFERENCE!>multiple<!>, ::<!UNRESOLVED_REFERENCE!>multiple<!>)
}
compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/fromBasicDiagnosticTests/moreSpecificAmbiguousExtensions.kt
Vendored
+3 -3
View File
@@ -6,14 +6,14 @@ 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() {
// NB: should be resolved to kotlin/FunctionX, not kotlin/reflect/FunctionX
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/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/fromBasicDiagnosticTests/resolveCallableReferencesAfterAllSimpleArguments.kt
Vendored
+2 -2
View File
@@ -7,6 +7,6 @@ fun <T> bar(f: (T) -> Unit, e: T) {}
fun <T> baz(e: T, f: (T) -> Unit) {}
fun test(a: A, b: B) {
<!INAPPLICABLE_CANDIDATE!>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/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/implicitTypes.kt
Vendored
+1 -1
View File
@@ -3,5 +3,5 @@ fun <T, R> use(x: (T) -> R): (T) -> R = x
fun foo() = use(::bar)
fun bar(x: String) = 1
fun loop1() = <!INAPPLICABLE_CANDIDATE!>use<!>(<!UNRESOLVED_REFERENCE!>::loop2<!>)
fun loop1() = <!INAPPLICABLE_CANDIDATE!>use<!>(::<!UNRESOLVED_REFERENCE!>loop2<!>)
fun loop2() = loop1()
compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/manyInnermanyOuterCandidatesAmbiguity.kt
Vendored
+1 -1
View File
@@ -6,5 +6,5 @@ fun bar(): Int = 1
fun bar(x: String): Int = 1
fun main() {
<!AMBIGUITY!>foo<!>(<!UNRESOLVED_REFERENCE!>::bar<!>)
<!AMBIGUITY!>foo<!>(::<!UNRESOLVED_REFERENCE!>bar<!>)
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/LightTreePositioningStrategies.kt
+8 -5
View File
@@ -378,7 +378,10 @@ object LightTreePositioningStrategies {
if (node.tokenType == KtNodeTypes.CALL_EXPRESSION || node.tokenType == KtNodeTypes.CONSTRUCTOR_DELEGATION_CALL) {
return markElement(tree.referenceExpression(node) ?: node, startOffset, endOffset, tree, node)
}
if (node.tokenType != KtNodeTypes.DOT_QUALIFIED_EXPRESSION && node.tokenType != KtNodeTypes.SAFE_ACCESS_EXPRESSION) {
if (node.tokenType != KtNodeTypes.DOT_QUALIFIED_EXPRESSION &&
node.tokenType != KtNodeTypes.SAFE_ACCESS_EXPRESSION &&
node.tokenType != KtNodeTypes.CALLABLE_REFERENCE_EXPRESSION
) {
return super.mark(node, startOffset, endOffset, tree)
}
val selector = tree.selector(node)
@@ -533,14 +536,14 @@ fun FlyweightCapableTreeStructure<LighterASTNode>.selector(node: LighterASTNode)
val childrenRef = Ref<Array<LighterASTNode?>>()
getChildren(node, childrenRef)
val children = childrenRef.get() ?: return null
var dotFound = false
var dotOrDoubleColonFound = false
for (child in children) {
if (child == null) continue
if (child.tokenType == KtTokens.DOT) {
dotFound = true
if (child.tokenType == KtTokens.DOT || child.tokenType == KtTokens.COLONCOLON) {
dotOrDoubleColonFound = true
continue
}
if (dotFound && (child.tokenType == KtNodeTypes.CALL_EXPRESSION || child.tokenType == KtNodeTypes.REFERENCE_EXPRESSION)) {
if (dotOrDoubleColonFound && (child.tokenType == KtNodeTypes.CALL_EXPRESSION || child.tokenType == KtNodeTypes.REFERENCE_EXPRESSION)) {
return child
}
}
compiler/frontend/src/org/jetbrains/kotlin/diagnostics/PositioningStrategies.kt
+1
View File
@@ -753,6 +753,7 @@ object PositioningStrategies {
is KtReferenceExpression -> return mark(selectorExpression)
}
}
is KtCallableReferenceExpression -> return mark(element.callableReference)
is KtCallExpression -> return mark(element.calleeExpression ?: element)
is KtConstructorDelegationCall -> return mark(element.calleeExpression ?: element)
is KtSuperTypeCallEntry -> return mark(element.calleeExpression)
compiler/testData/diagnostics/tests/annotations/annotationRenderingInTypes.fir.kt
Vendored
+1 -1
View File
@@ -4,7 +4,7 @@
fun f1(x: String) {}
fun f2(f: () -> Unit) {}
fun test1() = <!INAPPLICABLE_CANDIDATE!>f2<!>(<!UNRESOLVED_REFERENCE!>::f1<!>)
fun test1() = <!INAPPLICABLE_CANDIDATE!>f2<!>(::<!UNRESOLVED_REFERENCE!>f1<!>)
@Target(AnnotationTarget.TYPE_PARAMETER, AnnotationTarget.TYPE)
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
compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/provideDelegateOnFunctionalTypeWithThis.fir.kt
Vendored
+2 -2
View File
@@ -13,10 +13,10 @@ fun wrong(arg: Wrong) {}
class Wrong
class Right {
val prop: () -> Unit by <!UNRESOLVED_REFERENCE!>::wrong<!>
val prop: () -> Unit by ::<!UNRESOLVED_REFERENCE!>wrong<!>
}
fun box(): String {
Right().prop()
return "OK"
}
}
compiler/testData/diagnostics/tests/incompleteCode/illegalSelectorCallableReference.fir.kt
Vendored
+2 -2
View File
@@ -1,8 +1,8 @@
// !DIAGNOSTICS: -UNUSED_EXPRESSION
fun test() {
<!UNRESOLVED_REFERENCE!>"a"."b"::foo<!>
"a"."b"::<!UNRESOLVED_REFERENCE!>foo<!>
"a"."b"::class
<!UNRESOLVED_REFERENCE!>"a"."b"."c"::foo<!>
"a"."b"."c"::<!UNRESOLVED_REFERENCE!>foo<!>
"a"."b"."c"::class
}
compiler/testData/diagnostics/tests/inference/capturedTypes/approximateContravariantCapturedTypes.fir.kt
Vendored
+2 -2
View File
@@ -24,7 +24,7 @@ fun <T> Foo2<T>.setX(y: T): T {
fun Float.bar() {}
fun test1() {
val fooSetRef = <!DEBUG_INFO_EXPRESSION_TYPE("Type is unknown"), UNRESOLVED_REFERENCE!>Foo<*>::setX<!>
val fooSetRef = <!DEBUG_INFO_EXPRESSION_TYPE("Type is unknown")!>Foo<*>::<!UNRESOLVED_REFERENCE!>setX<!><!>
val foo = Foo<Float>(1f)
fooSetRef.<!UNRESOLVED_REFERENCE!>invoke<!>(foo, 1)
@@ -42,7 +42,7 @@ fun test2() {
}
fun test3() {
val fooSetRef = <!DEBUG_INFO_EXPRESSION_TYPE("Type is unknown"), UNRESOLVED_REFERENCE!>Foo2<*>::setX<!>
val fooSetRef = <!DEBUG_INFO_EXPRESSION_TYPE("Type is unknown")!>Foo2<*>::<!UNRESOLVED_REFERENCE!>setX<!><!>
val foo = Foo2<Int>(1)
fooSetRef.<!UNRESOLVED_REFERENCE!>invoke<!>(foo, "")
compiler/testData/diagnostics/tests/inference/kt39220.fir.kt
Vendored
+22 -22
View File
@@ -27,22 +27,22 @@ interface Foo {
// CR on property with to receivers are forbidden
fun <T: Foo> test() {
// with LHS and property
<!INAPPLICABLE_CANDIDATE!>bar8<!><T>(<!UNRESOLVED_REFERENCE!>Foo::x1<!>)
<!INAPPLICABLE_CANDIDATE!>bar8<!><Foo>(<!UNRESOLVED_REFERENCE!>Foo::x1<!>)
<!INAPPLICABLE_CANDIDATE!>bar8<!>(<!UNRESOLVED_REFERENCE!>Foo::x1<!>)
<!INAPPLICABLE_CANDIDATE!>bar8<!><T>(Foo::<!UNRESOLVED_REFERENCE!>x1<!>)
<!INAPPLICABLE_CANDIDATE!>bar8<!><Foo>(Foo::<!UNRESOLVED_REFERENCE!>x1<!>)
<!INAPPLICABLE_CANDIDATE!>bar8<!>(Foo::<!UNRESOLVED_REFERENCE!>x1<!>)
// with LHS and mutable property
<!INAPPLICABLE_CANDIDATE!>bar8<!><T>(<!UNRESOLVED_REFERENCE!>Foo::x2<!>)
<!INAPPLICABLE_CANDIDATE!>bar8<!><Foo>(<!UNRESOLVED_REFERENCE!>Foo::x2<!>)
<!INAPPLICABLE_CANDIDATE!>bar8<!>(<!UNRESOLVED_REFERENCE!>Foo::x2<!>)
<!INAPPLICABLE_CANDIDATE!>bar8<!><T>(Foo::<!UNRESOLVED_REFERENCE!>x2<!>)
<!INAPPLICABLE_CANDIDATE!>bar8<!><Foo>(Foo::<!UNRESOLVED_REFERENCE!>x2<!>)
<!INAPPLICABLE_CANDIDATE!>bar8<!>(Foo::<!UNRESOLVED_REFERENCE!>x2<!>)
// with LHS and propery + mutable property (mixed)
<!INAPPLICABLE_CANDIDATE!>bar8<!><T>(<!UNRESOLVED_REFERENCE!>Foo::x3<!>)
<!INAPPLICABLE_CANDIDATE!>bar8<!><Foo>(<!UNRESOLVED_REFERENCE!>Foo::x3<!>)
<!INAPPLICABLE_CANDIDATE!>bar8<!>(<!UNRESOLVED_REFERENCE!>Foo::x3<!>)
<!INAPPLICABLE_CANDIDATE!>bar9<!><T>(<!UNRESOLVED_REFERENCE!>Foo::x3<!>)
<!INAPPLICABLE_CANDIDATE!>bar9<!><Foo>(<!UNRESOLVED_REFERENCE!>Foo::x3<!>)
<!INAPPLICABLE_CANDIDATE!>bar9<!>(<!UNRESOLVED_REFERENCE!>Foo::x3<!>)
<!INAPPLICABLE_CANDIDATE!>bar8<!><T>(Foo::<!UNRESOLVED_REFERENCE!>x3<!>)
<!INAPPLICABLE_CANDIDATE!>bar8<!><Foo>(Foo::<!UNRESOLVED_REFERENCE!>x3<!>)
<!INAPPLICABLE_CANDIDATE!>bar8<!>(Foo::<!UNRESOLVED_REFERENCE!>x3<!>)
<!INAPPLICABLE_CANDIDATE!>bar9<!><T>(Foo::<!UNRESOLVED_REFERENCE!>x3<!>)
<!INAPPLICABLE_CANDIDATE!>bar9<!><Foo>(Foo::<!UNRESOLVED_REFERENCE!>x3<!>)
<!INAPPLICABLE_CANDIDATE!>bar9<!>(Foo::<!UNRESOLVED_REFERENCE!>x3<!>)
}
}
@@ -84,14 +84,14 @@ fun <T : Foo, R: Number, D: Int> main() {
bar1(::resolve) // OK
// with LHS and conflicting projection
bar2<T>(<!UNRESOLVED_REFERENCE!>Foo::resolve<!>)
bar2<Foo>(<!UNRESOLVED_REFERENCE!>Foo::resolve<!>)
bar2(<!UNRESOLVED_REFERENCE!>Foo::resolve<!>)
bar2<T>(Foo::<!UNRESOLVED_REFERENCE!>resolve<!>)
bar2<Foo>(Foo::<!UNRESOLVED_REFERENCE!>resolve<!>)
bar2(Foo::<!UNRESOLVED_REFERENCE!>resolve<!>)
// with LHS and Any? expected type
bar3<T>(<!UNRESOLVED_REFERENCE!>Foo::resolve<!>)
bar3<Foo>(<!UNRESOLVED_REFERENCE!>Foo::resolve<!>)
bar3(<!UNRESOLVED_REFERENCE!>Foo::resolve<!>)
bar3<T>(Foo::<!UNRESOLVED_REFERENCE!>resolve<!>)
bar3<Foo>(Foo::<!UNRESOLVED_REFERENCE!>resolve<!>)
bar3(Foo::<!UNRESOLVED_REFERENCE!>resolve<!>)
// with LHS and `Function` expected type
bar4<T>(Foo::resolve) // ERROR before the fix in NI
@@ -114,14 +114,14 @@ fun <T : Foo, R: Number, D: Int> main() {
bar7(Foo::resolve) // OK
// with LHS and sentension function expected type
<!INAPPLICABLE_CANDIDATE!>bar10<!><D>(<!UNRESOLVED_REFERENCE!>Int::x1<!>) // ERROR before the fix in NI
<!INAPPLICABLE_CANDIDATE!>bar10<!><D>(Int::<!UNRESOLVED_REFERENCE!>x1<!>) // ERROR before the fix in NI
bar10<Int>(Int::x1) // OK
bar10(Int::x1) // OK
fun Int.ext() {
// with LHS and sentension function expected type
<!INAPPLICABLE_CANDIDATE!>bar10<!><D>(<!UNRESOLVED_REFERENCE!>::x1<!>) // ERROR before the fix in NI
<!INAPPLICABLE_CANDIDATE!>bar10<!><Int>(<!UNRESOLVED_REFERENCE!>::x1<!>) // OK
<!INAPPLICABLE_CANDIDATE!>bar10<!>(<!UNRESOLVED_REFERENCE!>::x1<!>) // OK
<!INAPPLICABLE_CANDIDATE!>bar10<!><D>(::<!UNRESOLVED_REFERENCE!>x1<!>) // ERROR before the fix in NI
<!INAPPLICABLE_CANDIDATE!>bar10<!><Int>(::<!UNRESOLVED_REFERENCE!>x1<!>) // OK
<!INAPPLICABLE_CANDIDATE!>bar10<!>(::<!UNRESOLVED_REFERENCE!>x1<!>) // OK
}
}
compiler/testData/diagnostics/tests/inference/regressions/kt32862_both.fir.kt
Vendored
+1 -1
View File
@@ -12,5 +12,5 @@ fun <V, T : V?> G<T>.foo(vararg values: V2<V?>) = build()
fun forReference(ref: Any?) {}
fun test() {
forReference(<!UNRESOLVED_REFERENCE!>G<Int?>::foo<!>)
forReference(G<Int?>::<!UNRESOLVED_REFERENCE!>foo<!>)
}
compiler/testData/diagnostics/tests/inference/regressions/kt32862_none.fir.kt
Vendored
+1 -1
View File
@@ -7,5 +7,5 @@ fun foo(i: Long) {}
fun bar(f: (Boolean) -> Unit) {}
fun test() {
<!INAPPLICABLE_CANDIDATE!>bar<!>(<!UNRESOLVED_REFERENCE!>::foo<!>)
<!INAPPLICABLE_CANDIDATE!>bar<!>(::<!UNRESOLVED_REFERENCE!>foo<!>)
}
compiler/testData/diagnostics/tests/inference/regressions/kt34282.fir.kt
Vendored
+1 -1
View File
@@ -6,5 +6,5 @@ fun foo(x: Float) = 10f
fun foo(x: String) = ""
fun main() {
<!INAPPLICABLE_CANDIDATE!>bar<!>(<!UNRESOLVED_REFERENCE!>::foo<!>) // no report about unresolved callable reference for `foo`
<!INAPPLICABLE_CANDIDATE!>bar<!>(::<!UNRESOLVED_REFERENCE!>foo<!>) // no report about unresolved callable reference for `foo`
}
compiler/testData/diagnostics/tests/inference/reportAboutUnresolvedReferenceAsUnresolved.fir.kt
Vendored
+2 -2
View File
@@ -3,5 +3,5 @@ fun <T, U> T.map(f: (T) -> U) = f(this)
fun consume(s: String) {}
fun test() {
consume(1.<!INAPPLICABLE_CANDIDATE!>map<!>(<!UNRESOLVED_REFERENCE!>::foo<!>))
}
consume(1.<!INAPPLICABLE_CANDIDATE!>map<!>(::<!UNRESOLVED_REFERENCE!>foo<!>))
}
compiler/testData/diagnostics/tests/inference/reportingImprovements/kt42620.fir.kt
Vendored
+2 -2
View File
@@ -3,13 +3,13 @@
class Foo
fun main1() = when {
else -> <!UNRESOLVED_REFERENCE!>Foo::plus<!>
else -> Foo::<!UNRESOLVED_REFERENCE!>plus<!>
}
fun main2() = if (true) Foo::minus else Foo::times
fun main3() = if (true) { Foo::minus } else { Foo::times }
fun main4() = try { Foo::minus } finally { <!UNRESOLVED_REFERENCE!>Foo::times<!> }
fun main4() = try { Foo::minus } finally { Foo::<!UNRESOLVED_REFERENCE!>times<!> }
fun main5() = Foo::minus ?: Foo::times
compiler/testData/diagnostics/tests/inference/specialCallsWithCallableReferences.fir.kt
Vendored
+12 -12
View File
@@ -129,7 +129,7 @@ fun poll36(flag: Boolean) {
}
fun poll4() {
val inv = try { ::bar } finally { <!UNRESOLVED_REFERENCE!>::foo<!> }
val inv = try { ::bar } finally { ::<!UNRESOLVED_REFERENCE!>foo<!> }
<!INAPPLICABLE_CANDIDATE!>inv<!>()
}
@@ -139,7 +139,7 @@ fun poll41() {
}
fun poll42() {
val inv = try { ::bar3 } finally { <!UNRESOLVED_REFERENCE!>::foo3<!> }
val inv = try { ::bar3 } finally { ::<!UNRESOLVED_REFERENCE!>foo3<!> }
<!INAPPLICABLE_CANDIDATE!>inv<!>()
}
@@ -149,7 +149,7 @@ fun poll43() {
}
fun poll44() {
val inv = try { ::bar5 } finally { <!UNRESOLVED_REFERENCE!>::foo5<!> }
val inv = try { ::bar5 } finally { ::<!UNRESOLVED_REFERENCE!>foo5<!> }
<!INAPPLICABLE_CANDIDATE!>inv<!>()
}
@@ -164,7 +164,7 @@ fun poll46() {
}
fun poll5() {
val inv = try { ::bar } catch (e: Exception) { ::foo } finally { <!UNRESOLVED_REFERENCE!>::foo<!> }
val inv = try { ::bar } catch (e: Exception) { ::foo } finally { ::<!UNRESOLVED_REFERENCE!>foo<!> }
<!INAPPLICABLE_CANDIDATE!>inv<!>()
}
@@ -174,7 +174,7 @@ fun poll51() {
}
fun poll52() {
val inv = try { ::bar3 } catch (e: Exception) { ::foo3 } finally { <!UNRESOLVED_REFERENCE!>::foo3<!> }
val inv = try { ::bar3 } catch (e: Exception) { ::foo3 } finally { ::<!UNRESOLVED_REFERENCE!>foo3<!> }
<!INAPPLICABLE_CANDIDATE!>inv<!>()
}
@@ -184,7 +184,7 @@ fun poll53() {
}
fun poll54() {
val inv = try { ::bar5 } catch (e: Exception) { ::foo5 } finally { <!UNRESOLVED_REFERENCE!>::foo5<!> }
val inv = try { ::bar5 } catch (e: Exception) { ::foo5 } finally { ::<!UNRESOLVED_REFERENCE!>foo5<!> }
<!INAPPLICABLE_CANDIDATE!>inv<!>()
}
@@ -199,7 +199,7 @@ fun poll56() {
}
fun poll6() {
val inv = <!UNRESOLVED_REFERENCE!>::bar<!>
val inv = ::<!UNRESOLVED_REFERENCE!>bar<!>
inv
}
@@ -209,7 +209,7 @@ fun poll61() {
}
fun poll62() {
val inv = <!UNRESOLVED_REFERENCE!>::bar3<!>
val inv = ::<!UNRESOLVED_REFERENCE!>bar3<!>
inv
}
@@ -219,7 +219,7 @@ fun poll63() {
}
fun poll64() {
val inv = <!UNRESOLVED_REFERENCE!>::bar5<!>
val inv = ::<!UNRESOLVED_REFERENCE!>bar5<!>
inv
}
@@ -269,7 +269,7 @@ fun poll76() {
}
fun poll8() {
val inv = <!UNRESOLVED_REFERENCE!>::bar<!> <!NONE_APPLICABLE!>in<!> <!NONE_APPLICABLE!>setOf<!>(<!UNRESOLVED_REFERENCE!>::foo<!>)
val inv = ::<!UNRESOLVED_REFERENCE!>bar<!> <!NONE_APPLICABLE!>in<!> <!NONE_APPLICABLE!>setOf<!>(::<!UNRESOLVED_REFERENCE!>foo<!>)
<!INAPPLICABLE_CANDIDATE!>inv<!>()
}
@@ -279,7 +279,7 @@ fun poll81() {
}
fun poll82() {
val inv = <!UNRESOLVED_REFERENCE!>::bar3<!> <!NONE_APPLICABLE!>in<!> <!NONE_APPLICABLE!>setOf<!>(<!UNRESOLVED_REFERENCE!>::foo3<!>)
val inv = ::<!UNRESOLVED_REFERENCE!>bar3<!> <!NONE_APPLICABLE!>in<!> <!NONE_APPLICABLE!>setOf<!>(::<!UNRESOLVED_REFERENCE!>foo3<!>)
<!INAPPLICABLE_CANDIDATE!>inv<!>()
}
@@ -289,7 +289,7 @@ fun poll83() {
}
fun poll84() {
val inv = <!UNRESOLVED_REFERENCE!>::bar5<!> <!NONE_APPLICABLE!>in<!> <!NONE_APPLICABLE!>setOf<!>(<!UNRESOLVED_REFERENCE!>::foo5<!>)
val inv = ::<!UNRESOLVED_REFERENCE!>bar5<!> <!NONE_APPLICABLE!>in<!> <!NONE_APPLICABLE!>setOf<!>(::<!UNRESOLVED_REFERENCE!>foo5<!>)
inv
}
compiler/testData/diagnostics/tests/j+k/properties/fieldPropertyOverloads.fir.kt
Vendored
+2 -2
View File
@@ -22,6 +22,6 @@ fun main(c: CollectionWithSize) {
CompressionType.ZIP.<!AMBIGUITY!>name<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Double>() }
c.<!AMBIGUITY!>size<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
<!UNRESOLVED_REFERENCE!>CompressionType.ZIP::name<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><kotlin.reflect.KProperty0<Double>>() }
<!UNRESOLVED_REFERENCE!>c::size<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><kotlin.reflect.KProperty0<String>>() }
CompressionType.ZIP::<!UNRESOLVED_REFERENCE!>name<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><kotlin.reflect.KProperty0<Double>>() }
c::<!UNRESOLVED_REFERENCE!>size<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><kotlin.reflect.KProperty0<String>>() }
}
compiler/testData/diagnostics/tests/j+k/properties/fieldPropertyOverloadsDisabled.fir.kt
Vendored
+2 -2
View File
@@ -23,6 +23,6 @@ fun main(c: CollectionWithSize) {
CompressionType.ZIP.<!AMBIGUITY!>name<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Double>() }
c.<!AMBIGUITY!>size<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
<!UNRESOLVED_REFERENCE!>CompressionType.ZIP::name<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><kotlin.reflect.KProperty0<Double>>() }
<!UNRESOLVED_REFERENCE!>c::size<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><kotlin.reflect.KProperty0<String>>() }
CompressionType.ZIP::<!UNRESOLVED_REFERENCE!>name<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><kotlin.reflect.KProperty0<Double>>() }
c::<!UNRESOLVED_REFERENCE!>size<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><kotlin.reflect.KProperty0<String>>() }
}
compiler/testData/diagnostics/tests/j+k/properties/fieldPropertyOverloadsNI.fir.kt
Vendored
+2 -2
View File
@@ -22,6 +22,6 @@ fun main(c: CollectionWithSize) {
CompressionType.ZIP.<!AMBIGUITY!>name<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Double>() }
c.<!AMBIGUITY!>size<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
<!UNRESOLVED_REFERENCE!>CompressionType.ZIP::name<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><kotlin.reflect.KProperty0<Double>>() }
<!UNRESOLVED_REFERENCE!>c::size<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><kotlin.reflect.KProperty0<String>>() }
CompressionType.ZIP::<!UNRESOLVED_REFERENCE!>name<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><kotlin.reflect.KProperty0<Double>>() }
c::<!UNRESOLVED_REFERENCE!>size<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><kotlin.reflect.KProperty0<String>>() }
}
compiler/testData/diagnostics/tests/j+k/sam/referenceToSamFunctionAgainstExpectedType.fir.kt
Vendored
+1 -1
View File
@@ -18,7 +18,7 @@ public class Inv<T> {
fun test(inv: Inv<String>) {
val m: ((String) -> String) -> Inv<String> = inv::map
<!INAPPLICABLE_CANDIDATE!>take<!>(<!UNRESOLVED_REFERENCE!>inv::map<!>)
<!INAPPLICABLE_CANDIDATE!>take<!>(inv::<!UNRESOLVED_REFERENCE!>map<!>)
}
fun take(f: ((String) -> String) -> Inv<String>) {}
compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesNew.fir.kt
Vendored
+14 -14
View File
@@ -115,28 +115,28 @@ class C : O.B() {
val n = FromCompanionC::foo
// INVISIBLE: direct superclasses themselves.
val a = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>A<!>::foo<!>
val b = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>A<!>::foo<!>
val a = <!UNRESOLVED_REFERENCE!>A<!>::<!UNRESOLVED_REFERENCE!>foo<!>
val b = <!UNRESOLVED_REFERENCE!>A<!>::<!UNRESOLVED_REFERENCE!>foo<!>
// DEPRECATED: Classifiers from companions of direct superclasses
val e = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>FromCompanionA<!>::foo<!>
val f = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>FromCompanionB<!>::foo<!>
val e = <!UNRESOLVED_REFERENCE!>FromCompanionA<!>::<!UNRESOLVED_REFERENCE!>foo<!>
val f = <!UNRESOLVED_REFERENCE!>FromCompanionB<!>::<!UNRESOLVED_REFERENCE!>foo<!>
// INVISIBLE: "cousin" supertypes themselves
val g = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>Alpha<!>::foo<!>
val h = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>Beta<!>::foo<!>
val i = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>Gamma<!>::foo<!>
val g = <!UNRESOLVED_REFERENCE!>Alpha<!>::<!UNRESOLVED_REFERENCE!>foo<!>
val h = <!UNRESOLVED_REFERENCE!>Beta<!>::<!UNRESOLVED_REFERENCE!>foo<!>
val i = <!UNRESOLVED_REFERENCE!>Gamma<!>::<!UNRESOLVED_REFERENCE!>foo<!>
// DEPRECATED: classifiers from "cousin" superclasses
val k = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>FromAlpha<!>::foo<!>
val l = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>FromBeta<!>::foo<!>
val m = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>FromGamma<!>::foo<!>
val k = <!UNRESOLVED_REFERENCE!>FromAlpha<!>::<!UNRESOLVED_REFERENCE!>foo<!>
val l = <!UNRESOLVED_REFERENCE!>FromBeta<!>::<!UNRESOLVED_REFERENCE!>foo<!>
val m = <!UNRESOLVED_REFERENCE!>FromGamma<!>::<!UNRESOLVED_REFERENCE!>foo<!>
// INVISIBLE: We don't see classifiers from companions of "cousin" superclasses
val o = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>FromCompanionAlpha<!>::foo<!>
val p = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>FromCompanionBeta<!>::foo<!>
val q = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>FromCompanionGamma<!>::foo<!>
val o = <!UNRESOLVED_REFERENCE!>FromCompanionAlpha<!>::<!UNRESOLVED_REFERENCE!>foo<!>
val p = <!UNRESOLVED_REFERENCE!>FromCompanionBeta<!>::<!UNRESOLVED_REFERENCE!>foo<!>
val q = <!UNRESOLVED_REFERENCE!>FromCompanionGamma<!>::<!UNRESOLVED_REFERENCE!>foo<!>
// DEPRECATED: Classifiers from supertypes of our own companion
val r = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>FromDelta<!>::foo<!>
val r = <!UNRESOLVED_REFERENCE!>FromDelta<!>::<!UNRESOLVED_REFERENCE!>foo<!>
}
compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesOld.fir.kt
Vendored
+14 -14
View File
@@ -115,28 +115,28 @@ class C : O.B() {
val n = FromCompanionC::foo
// INVISIBLE: direct superclasses themselves.
val a = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>A<!>::foo<!>
val b = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>A<!>::foo<!>
val a = <!UNRESOLVED_REFERENCE!>A<!>::<!UNRESOLVED_REFERENCE!>foo<!>
val b = <!UNRESOLVED_REFERENCE!>A<!>::<!UNRESOLVED_REFERENCE!>foo<!>
// DEPRECATED: Classifiers from companions of direct superclasses
val e = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>FromCompanionA<!>::foo<!>
val f = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>FromCompanionB<!>::foo<!>
val e = <!UNRESOLVED_REFERENCE!>FromCompanionA<!>::<!UNRESOLVED_REFERENCE!>foo<!>
val f = <!UNRESOLVED_REFERENCE!>FromCompanionB<!>::<!UNRESOLVED_REFERENCE!>foo<!>
// INVISIBLE: "cousin" supertypes themselves
val g = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>Alpha<!>::foo<!>
val h = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>Beta<!>::foo<!>
val i = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>Gamma<!>::foo<!>
val g = <!UNRESOLVED_REFERENCE!>Alpha<!>::<!UNRESOLVED_REFERENCE!>foo<!>
val h = <!UNRESOLVED_REFERENCE!>Beta<!>::<!UNRESOLVED_REFERENCE!>foo<!>
val i = <!UNRESOLVED_REFERENCE!>Gamma<!>::<!UNRESOLVED_REFERENCE!>foo<!>
// DEPRECATED: classifiers from "cousin" superclasses
val k = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>FromAlpha<!>::foo<!>
val l = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>FromBeta<!>::foo<!>
val m = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>FromGamma<!>::foo<!>
val k = <!UNRESOLVED_REFERENCE!>FromAlpha<!>::<!UNRESOLVED_REFERENCE!>foo<!>
val l = <!UNRESOLVED_REFERENCE!>FromBeta<!>::<!UNRESOLVED_REFERENCE!>foo<!>
val m = <!UNRESOLVED_REFERENCE!>FromGamma<!>::<!UNRESOLVED_REFERENCE!>foo<!>
// INVISIBLE: We don't see classifiers from companions of "cousin" superclasses
val o = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>FromCompanionAlpha<!>::foo<!>
val p = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>FromCompanionBeta<!>::foo<!>
val q = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>FromCompanionGamma<!>::foo<!>
val o = <!UNRESOLVED_REFERENCE!>FromCompanionAlpha<!>::<!UNRESOLVED_REFERENCE!>foo<!>
val p = <!UNRESOLVED_REFERENCE!>FromCompanionBeta<!>::<!UNRESOLVED_REFERENCE!>foo<!>
val q = <!UNRESOLVED_REFERENCE!>FromCompanionGamma<!>::<!UNRESOLVED_REFERENCE!>foo<!>
// DEPRECATED: Classifiers from supertypes of our own companion
val r = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>FromDelta<!>::foo<!>
val r = <!UNRESOLVED_REFERENCE!>FromDelta<!>::<!UNRESOLVED_REFERENCE!>foo<!>
}
compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesOldComplexCases.fir.kt
Vendored
+4 -4
View File
@@ -12,7 +12,7 @@ object A {
}
class Derived : Base() {
val a = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>FromBaseCompanion<!>::foo<!>
val a = <!UNRESOLVED_REFERENCE!>FromBaseCompanion<!>::<!UNRESOLVED_REFERENCE!>foo<!>
}
}
@@ -30,7 +30,7 @@ object B {
}
class Derived : Base() {
val a = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>FromBaseCompanion<!>::foo<!>
val a = <!UNRESOLVED_REFERENCE!>FromBaseCompanion<!>::<!UNRESOLVED_REFERENCE!>foo<!>
}
}
@@ -48,7 +48,7 @@ object C {
}
class Derived : Base() {
val a = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>FromBaseCompanion<!>::foo<!>
val a = <!UNRESOLVED_REFERENCE!>FromBaseCompanion<!>::<!UNRESOLVED_REFERENCE!>foo<!>
}
}
@@ -64,6 +64,6 @@ object D {
}
class Derived : Base() {
val a = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>FromBaseCompanion<!>::foo<!>
val a = <!UNRESOLVED_REFERENCE!>FromBaseCompanion<!>::<!UNRESOLVED_REFERENCE!>foo<!>
}
}
compiler/testData/diagnostics/tests/qualifiedExpression/calleeExpressionAsCallExpression.fir.kt
Vendored
+1 -1
View File
@@ -1,2 +1,2 @@
// !WITH_NEW_INFERENCE
val unwrapped = <!UNRESOLVED_REFERENCE!>some<!><!UNRESOLVED_REFERENCE!><<!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE!>sdf<!>()()<out Any>::unwrap<!>
val unwrapped = <!UNRESOLVED_REFERENCE!>some<!><!UNRESOLVED_REFERENCE!><<!><!UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE!>sdf<!>()()<out Any>::<!UNRESOLVED_REFERENCE!>unwrap<!>
compiler/testData/diagnostics/tests/qualifiedExpression/nullCalleeExpression.fir.kt
Vendored
+1 -1
View File
@@ -1,4 +1,4 @@
// !WITH_NEW_INFERENCE
// NI_EXPECTED_FILE
val unwrapped = some.<!SYNTAX!><<!><!UNRESOLVED_REFERENCE!>cabc<!><!UNRESOLVED_REFERENCE!><!SYNTAX!>$Wrapper<!><<!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>out Any<!>>::unwrap<!>
val unwrapped = some.<!SYNTAX!><<!><!UNRESOLVED_REFERENCE!>cabc<!><!SYNTAX!>$Wrapper<!><<!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>out Any<!>>::<!UNRESOLVED_REFERENCE!>unwrap<!>
compiler/testData/diagnostics/tests/regressions/kt13685.fir.kt
Vendored
+1 -1
View File
@@ -3,5 +3,5 @@
fun foo() {
val text: List<Any> = null!!
text.<!UNRESOLVED_REFERENCE!>map<!> <!UNRESOLVED_REFERENCE!>Any<!><!UNRESOLVED_REFERENCE!><!SYNTAX!>?<!>::toString<!>
text.<!UNRESOLVED_REFERENCE!>map<!> <!UNRESOLVED_REFERENCE!>Any<!><!SYNTAX!>?<!>::<!UNRESOLVED_REFERENCE!>toString<!>
}
compiler/testData/diagnostics/tests/regressions/kt31975.fir.kt
Vendored
+1 -1
View File
@@ -11,7 +11,7 @@ interface TypeConstructor
class Refiner {
val memoizedFunctionLambda = createMemoizedFunction { it.foo() } // error type infered, no diagnostic, BAD, backend fails
val memoizedFunctionReference = createMemoizedFunction(<!EXTENSION_IN_CLASS_REFERENCE_NOT_ALLOWED!>TypeConstructor::foo<!>) // EXTENSION_IN_CLASS_REFERENCE_IS_NOT_ALLOWED, fine
val memoizedFunctionReference = createMemoizedFunction(TypeConstructor::<!EXTENSION_IN_CLASS_REFERENCE_NOT_ALLOWED!>foo<!>) // EXTENSION_IN_CLASS_REFERENCE_IS_NOT_ALLOWED, fine
val memoizedFunctionTypes = createMemoizedFunction<TypeConstructor, Boolean> { it.foo() } // works fine
private fun TypeConstructor.foo(): Boolean = true

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