FIR: Support function type resolve #KT-24092 Fixed

compiler/fir/cones/src/org/jetbrains/kotlin/fir/types/ConeTypes.kt

@@ -61,4 +61,11 @@ abstract class ConeAbbreviatedType : ConeClassLikeType() {
 
 abstract class ConeTypeParameterType : ConeSymbolBasedType() {
     abstract override val symbol: ConeTypeParameterSymbol
-}
+}
+
+
+abstract class ConeFunctionType : ConeKotlinType() {
+    abstract val receiverType: ConeKotlinType?
+    abstract val parameterTypes: List<ConeKotlinType>
+    abstract val returnType: ConeKotlinType
+}

compiler/fir/cones/src/org/jetbrains/kotlin/fir/types/impl/ConeFunctionTypeImpl.kt

@@ -0,0 +1,15 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.fir.types.impl
+
+import org.jetbrains.kotlin.fir.types.ConeFunctionType
+import org.jetbrains.kotlin.fir.types.ConeKotlinType
+
+class ConeFunctionTypeImpl(
+    override val receiverType: ConeKotlinType?,
+    override val parameterTypes: List<ConeKotlinType>,
+    override val returnType: ConeKotlinType
+) : ConeFunctionType()

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/impl/FirTypeResolverImpl.kt

@@ -105,7 +105,14 @@ class FirTypeResolverImpl : FirTypeResolver {
             is FirErrorType -> {
                 ConeKotlinErrorType(type.reason)
             }
-            is FirFunctionType, is FirDynamicType, is FirImplicitType, is FirDelegatedType -> {
+            is FirFunctionType -> {
+                ConeFunctionTypeImpl(
+                    (type.receiverType as FirResolvedType?)?.type,
+                    type.valueParameters.map { it.returnType.coneTypeUnsafe<ConeKotlinType>() },
+                    type.returnType.coneTypeUnsafe()
+                )
+            }
+            is FirDynamicType, is FirImplicitType, is FirDelegatedType -> {
                 ConeKotlinErrorType("Not supported: ${type::class.simpleName}")
             }
             else -> error("!")

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirTypeResolveTransformer.kt

@@ -8,6 +8,7 @@ package org.jetbrains.kotlin.fir.resolve.transformers
 import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.declarations.*
+import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.render
 import org.jetbrains.kotlin.fir.resolve.FirProvider
 import org.jetbrains.kotlin.fir.resolve.FirTypeResolver
@@ -16,6 +17,7 @@ import org.jetbrains.kotlin.fir.scopes.impl.*
 import org.jetbrains.kotlin.fir.symbols.*
 import org.jetbrains.kotlin.fir.transformSingle
 import org.jetbrains.kotlin.fir.types.*
+import org.jetbrains.kotlin.fir.types.impl.FirResolvedFunctionTypeImpl
 import org.jetbrains.kotlin.fir.types.impl.FirResolvedTypeImpl
 import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
@@ -114,7 +116,18 @@ open class FirTypeResolveTransformer : FirTransformer<Nothing?>() {
     }
 
     override fun transformFunctionType(functionType: FirFunctionType, data: Nothing?): CompositeTransformResult<FirType> {
-        return (functionType.transformChildren(this, data) as FirType).compose()
+        val typeResolver = FirTypeResolver.getInstance(functionType.session)
+        functionType.transformChildren(this, data)
+        return FirResolvedFunctionTypeImpl(
+            functionType.psi,
+            functionType.session,
+            functionType.isNullable,
+            functionType.annotations as MutableList<FirAnnotationCall>,
+            functionType.receiverType,
+            functionType.valueParameters as MutableList<FirValueParameter>,
+            functionType.returnType,
+            typeResolver.resolveType(functionType, scope, FirPosition.OTHER)
+        ).compose()
     }
 
     private fun transformType(type: FirType, resolvedType: ConeKotlinType): CompositeTransformResult<FirType> {

compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirRenderer.kt

@@ -441,6 +441,18 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() {
             is ConeTypeParameterType -> {
                 symbol.asString()
             }
+            is ConeFunctionType -> {
+                buildString {
+                    receiverType?.let {
+                        append(it.asString())
+                        append(".")
+                    }
+                    append("(")
+                    parameterTypes.joinTo(this) { it.asString() }
+                    append(") -> ")
+                    append(returnType.asString())
+                }
+            }
         }
     }
 

compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirResolvedType.kt

@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.fir.types
 
+import org.jetbrains.kotlin.fir.VisitedSupertype
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
 interface FirResolvedType : FirTypeWithNullability {
@@ -14,5 +15,10 @@ interface FirResolvedType : FirTypeWithNullability {
         visitor.visitResolvedType(this, data)
 }
 
+interface FirResolvedFunctionType : @VisitedSupertype FirResolvedType, FirFunctionType {
+    override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
+        visitor.visitResolvedFunctionType(this, data)
+}
+
 inline fun <reified T : ConeKotlinType> FirType.coneTypeUnsafe() = (this as FirResolvedType).type as T
 inline fun <reified T : ConeKotlinType> FirType.coneTypeSafe() = (this as? FirResolvedType)?.type as? T

compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirResolvedFunctionTypeImpl.kt

@@ -0,0 +1,38 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.fir.types.impl
+
+import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.fir.FirElement
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.declarations.FirValueParameter
+import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
+import org.jetbrains.kotlin.fir.transformInplace
+import org.jetbrains.kotlin.fir.transformSingle
+import org.jetbrains.kotlin.fir.types.ConeKotlinType
+import org.jetbrains.kotlin.fir.types.FirResolvedFunctionType
+import org.jetbrains.kotlin.fir.types.FirType
+import org.jetbrains.kotlin.fir.visitors.FirTransformer
+
+class FirResolvedFunctionTypeImpl(
+    override val psi: PsiElement?,
+    override val session: FirSession,
+    override val isNullable: Boolean,
+    override val annotations: MutableList<FirAnnotationCall>,
+    override var receiverType: FirType?,
+    override val valueParameters: MutableList<FirValueParameter>,
+    override var returnType: FirType,
+    override val type: ConeKotlinType
+) : FirResolvedFunctionType {
+
+    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
+        receiverType = receiverType?.transformSingle(transformer, data)
+        returnType = returnType.transformSingle(transformer, data)
+        valueParameters.transformInplace(transformer, data)
+
+        return this
+    }
+}

compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirTransformerGenerated.kt

@@ -166,6 +166,10 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
         return transformTypeWithNullability(resolvedType, data)
     }
 
+    open fun transformResolvedFunctionType(resolvedFunctionType: FirResolvedFunctionType, data: D): CompositeTransformResult<FirType> {
+        return transformResolvedType(resolvedFunctionType, data)
+    }
+
     open fun transformUserType(userType: FirUserType, data: D): CompositeTransformResult<FirType> {
         return transformTypeWithNullability(userType, data)
     }
@@ -226,6 +230,10 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
         return transformPackageFragment(packageFragment, data)
     }
 
+    final override fun visitResolvedType(resolvedType: FirResolvedType, data: D): CompositeTransformResult<FirElement> {
+        return transformResolvedType(resolvedType, data)
+    }
+
     final override fun visitStatement(statement: FirStatement, data: D): CompositeTransformResult<FirElement> {
         return transformStatement(statement, data)
     }
@@ -318,6 +326,10 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
         return transformFile(file, data)
     }
 
+    final override fun visitResolvedFunctionType(resolvedFunctionType: FirResolvedFunctionType, data: D): CompositeTransformResult<FirElement> {
+        return transformResolvedFunctionType(resolvedFunctionType, data)
+    }
+
     final override fun visitDelegatedType(delegatedType: FirDelegatedType, data: D): CompositeTransformResult<FirElement> {
         return transformDelegatedType(delegatedType, data)
     }
@@ -346,10 +358,6 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
         return transformFunctionType(functionType, data)
     }
 
-    final override fun visitResolvedType(resolvedType: FirResolvedType, data: D): CompositeTransformResult<FirElement> {
-        return transformResolvedType(resolvedType, data)
-    }
-
     final override fun visitUserType(userType: FirUserType, data: D): CompositeTransformResult<FirElement> {
         return transformUserType(userType, data)
     }

compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirVisitorGenerated.kt

@@ -166,6 +166,10 @@ abstract class FirVisitor<out R, in D> {
         return visitTypeWithNullability(resolvedType, data)
     }
 
+    open fun visitResolvedFunctionType(resolvedFunctionType: FirResolvedFunctionType, data: D): R {
+        return visitResolvedType(resolvedFunctionType, data)
+    }
+
     open fun visitUserType(userType: FirUserType, data: D): R {
         return visitTypeWithNullability(userType, data)
     }

compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirVisitorVoidGenerated.kt

@@ -166,6 +166,10 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
         visitTypeWithNullability(resolvedType, null)
     }
 
+    open fun visitResolvedFunctionType(resolvedFunctionType: FirResolvedFunctionType) {
+        visitResolvedType(resolvedFunctionType, null)
+    }
+
     open fun visitUserType(userType: FirUserType) {
         visitTypeWithNullability(userType, null)
     }
@@ -226,6 +230,10 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
         visitPackageFragment(packageFragment)
     }
 
+    final override fun visitResolvedType(resolvedType: FirResolvedType, data: Nothing?) {
+        visitResolvedType(resolvedType)
+    }
+
     final override fun visitStatement(statement: FirStatement, data: Nothing?) {
         visitStatement(statement)
     }
@@ -318,6 +326,10 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
         visitFile(file)
     }
 
+    final override fun visitResolvedFunctionType(resolvedFunctionType: FirResolvedFunctionType, data: Nothing?) {
+        visitResolvedFunctionType(resolvedFunctionType)
+    }
+
     final override fun visitDelegatedType(delegatedType: FirDelegatedType, data: Nothing?) {
         visitDelegatedType(delegatedType)
     }
@@ -346,10 +358,6 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
         visitFunctionType(functionType)
     }
 
-    final override fun visitResolvedType(resolvedType: FirResolvedType, data: Nothing?) {
-        visitResolvedType(resolvedType)
-    }
-
     final override fun visitUserType(userType: FirUserType, data: Nothing?) {
         visitUserType(userType)
     }