Move FunctionClassKind utils to :core.descriptors.common

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

@@ -5,7 +5,6 @@
 
 package org.jetbrains.kotlin.fir
 
-import org.jetbrains.kotlin.builtins.functions.BuiltInFictitiousFunctionClassFactory
 import org.jetbrains.kotlin.builtins.functions.FunctionClassKind
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
 import org.jetbrains.kotlin.fir.contracts.FirContractDescription
@@ -875,7 +874,7 @@ class FirRenderer(builder: StringBuilder, private val mode: RenderMode = RenderM
     private val FirResolvedTypeRef.functionTypeKind: FunctionClassKind?
         get() {
             val classId = (type as? ConeClassLikeType)?.lookupTag?.classId ?: return null
-            return BuiltInFictitiousFunctionClassFactory.getFunctionalClassKind(
+            return FunctionClassKind.getFunctionalClassKind(
                 classId.shortClassName.asString(), classId.packageFqName
             )
         }

core/descriptors.common/src/org/jetbrains/kotlin/builtins/functions/FunctionClassKind.kt

@@ -20,5 +20,34 @@ enum class FunctionClassKind(val packageFqName: FqName, val classNamePrefix: Str
     companion object {
         fun byClassNamePrefix(packageFqName: FqName, className: String): FunctionClassKind? =
             values().firstOrNull { it.packageFqName == packageFqName && className.startsWith(it.classNamePrefix) }
+
+        data class KindWithArity(val kind: FunctionClassKind, val arity: Int)
+
+        fun parseClassName(className: String, packageFqName: FqName): KindWithArity? {
+            val kind = byClassNamePrefix(packageFqName, className) ?: return null
+
+            val prefix = kind.classNamePrefix
+
+            val arity = toInt(className.substring(prefix.length)) ?: return null
+
+            // TODO: validate arity, should be <= 255
+            return KindWithArity(kind, arity)
+        }
+
+        @JvmStatic
+        fun getFunctionalClassKind(className: String, packageFqName: FqName) =
+            parseClassName(className, packageFqName)?.kind
+
+        private fun toInt(s: String): Int? {
+            if (s.isEmpty()) return null
+
+            var result = 0
+            for (c in s) {
+                val d = c - '0'
+                if (d !in 0..9) return null
+                result = result * 10 + d
+            }
+            return result
+        }
     }
 }

core/descriptors/src/org/jetbrains/kotlin/builtins/functionTypes.kt

@@ -125,7 +125,7 @@ fun DeclarationDescriptor.getFunctionalClassKind(): FunctionClassKind? {
 private fun FqNameUnsafe.getFunctionalClassKind(): FunctionClassKind? {
     if (!isSafe || isRoot) return null
 
-    return BuiltInFictitiousFunctionClassFactory.getFunctionalClassKind(shortName().asString(), toSafe().parent())
+    return FunctionClassKind.getFunctionalClassKind(shortName().asString(), toSafe().parent())
 }
 
 

core/descriptors/src/org/jetbrains/kotlin/builtins/functions/BuiltInFictitiousFunctionClassFactory.kt

@@ -33,43 +33,11 @@ class BuiltInFictitiousFunctionClassFactory(
         private val storageManager: StorageManager,
         private val module: ModuleDescriptor
 ) : ClassDescriptorFactory {
-
-    private data class KindWithArity(val kind: FunctionClassKind, val arity: Int)
-
-    companion object {
-        private fun parseClassName(className: String, packageFqName: FqName): KindWithArity? {
-            val kind = FunctionClassKind.byClassNamePrefix(packageFqName, className) ?: return null
-
-            val prefix = kind.classNamePrefix
-
-            val arity = toInt(className.substring(prefix.length)) ?: return null
-
-            // TODO: validate arity, should be <= 255
-            return KindWithArity(kind, arity)
-        }
-
-        @JvmStatic
-        fun getFunctionalClassKind(className: String, packageFqName: FqName) =
-                parseClassName(className, packageFqName)?.kind
-
-        private fun toInt(s: String): Int? {
-            if (s.isEmpty()) return null
-
-            var result = 0
-            for (c in s) {
-                val d = c - '0'
-                if (d !in 0..9) return null
-                result = result * 10 + d
-            }
-            return result
-        }
-    }
-
     override fun shouldCreateClass(packageFqName: FqName, name: Name): Boolean {
         val string = name.asString()
         return (string.startsWith("Function") || string.startsWith("KFunction") ||
                 string.startsWith("SuspendFunction") || string.startsWith("KSuspendFunction")) // an optimization
-               && parseClassName(string, packageFqName) != null
+               && FunctionClassKind.parseClassName(string, packageFqName) != null
     }
 
     override fun createClass(classId: ClassId): ClassDescriptor? {
@@ -79,7 +47,7 @@ class BuiltInFictitiousFunctionClassFactory(
         if ("Function" !in className) return null // An optimization
 
         val packageFqName = classId.packageFqName
-        val (kind, arity) = parseClassName(className, packageFqName) ?: return null
+        val (kind, arity) = FunctionClassKind.parseClassName(className, packageFqName) ?: return null
 
 
         val builtInsFragments = module.getPackage(packageFqName).fragments.filterIsInstance<BuiltInsPackageFragment>()