Move FunctionClassDescriptor.Kind to :core:descriptors.common module

compiler/backend/src/org/jetbrains/kotlin/codegen/state/KotlinTypeMapper.kt

@@ -10,6 +10,7 @@ import org.jetbrains.kotlin.builtins.BuiltInsPackageFragment
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.builtins.KotlinBuiltInsNames.RESULT_FQ_NAME
 import org.jetbrains.kotlin.builtins.functions.FunctionClassDescriptor
+import org.jetbrains.kotlin.builtins.functions.FunctionClassKind
 import org.jetbrains.kotlin.builtins.jvm.JavaToKotlinClassMap
 import org.jetbrains.kotlin.codegen.*
 import org.jetbrains.kotlin.codegen.AsmUtil.isStaticMethod
@@ -328,8 +329,8 @@ class KotlinTypeMapper @JvmOverloads constructor(
 
         if (classDescriptor is FunctionClassDescriptor) {
             if (classDescriptor.hasBigArity ||
-                classDescriptor.functionKind == FunctionClassDescriptor.Kind.KFunction ||
+                classDescriptor.functionKind == FunctionClassKind.KFunction ||
-                classDescriptor.functionKind == FunctionClassDescriptor.Kind.KSuspendFunction
+                classDescriptor.functionKind == FunctionClassKind.KSuspendFunction
             ) {
                 // kotlin.reflect.KFunction{n}<P1, ..., Pn, R> is mapped to kotlin.reflect.KFunction<R> (for all n), and
                 // kotlin.Function{n}<P1, ..., Pn, R> is mapped to kotlin.jvm.functions.FunctionN<R> (for n > 22).

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

@@ -5,7 +5,7 @@
 
 package org.jetbrains.kotlin.fir.types
 
-import org.jetbrains.kotlin.builtins.functions.FunctionClassDescriptor
+import org.jetbrains.kotlin.builtins.functions.FunctionClassKind
 import kotlin.contracts.ExperimentalContracts
 import kotlin.contracts.contract
 
@@ -59,10 +59,10 @@ private fun ConeTypeProjection.render(): String {
     }
 }
 
-fun ConeKotlinType.renderFunctionType(kind: FunctionClassDescriptor.Kind?, isExtension: Boolean): String {
+fun ConeKotlinType.renderFunctionType(kind: FunctionClassKind?, isExtension: Boolean): String {
     if (!kind.withPrettyRender()) return render()
     return buildString {
-        if (kind == FunctionClassDescriptor.Kind.SuspendFunction) {
+        if (kind == FunctionClassKind.SuspendFunction) {
             append("suspend ")
         }
         val (receiver, otherTypeArguments) = if (isExtension && typeArguments.first() != ConeStarProjection) {
@@ -83,9 +83,9 @@ fun ConeKotlinType.renderFunctionType(kind: FunctionClassDescriptor.Kind?, isExt
 }
 
 @OptIn(ExperimentalContracts::class)
-fun FunctionClassDescriptor.Kind?.withPrettyRender(): Boolean {
+fun FunctionClassKind?.withPrettyRender(): Boolean {
     contract {
         returns(true) implies (this@withPrettyRender != null)
     }
-    return this != null && this != FunctionClassDescriptor.Kind.KSuspendFunction && this != FunctionClassDescriptor.Kind.KFunction
+    return this != null && this != FunctionClassKind.KSuspendFunction && this != FunctionClassKind.KFunction
-}
+}

compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/FirElementSerializer.kt

@@ -5,7 +5,7 @@
 
 package org.jetbrains.kotlin.fir.serialization
 
-import org.jetbrains.kotlin.builtins.functions.FunctionClassDescriptor
+import org.jetbrains.kotlin.builtins.functions.FunctionClassKind
 import org.jetbrains.kotlin.config.LanguageFeature
 import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.descriptors.Modality
@@ -611,8 +611,8 @@ class FirElementSerializer private constructor(
         val suspendClassId = type.classId!!
         val relativeClassName = suspendClassId.relativeClassName.asString()
         val kind =
-            if (relativeClassName.startsWith("K")) FunctionClassDescriptor.Kind.KFunction
+            if (relativeClassName.startsWith("K")) FunctionClassKind.KFunction
-            else FunctionClassDescriptor.Kind.Function
+            else FunctionClassKind.Function
         val runtimeClassId = ClassId(kind.packageFqName, Name.identifier(relativeClassName.replaceFirst("Suspend", "")))
         val continuationClassId = CONTINUATION_INTERFACE_CLASS_ID
         return ConeClassLikeLookupTagImpl(runtimeClassId).constructClassType(

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/CallAndReferenceGenerator.kt

@@ -5,7 +5,7 @@
 
 package org.jetbrains.kotlin.fir.backend.generators
 
-import org.jetbrains.kotlin.builtins.functions.FunctionClassDescriptor
+import org.jetbrains.kotlin.builtins.functions.FunctionClassKind
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.fir.backend.*
 import org.jetbrains.kotlin.fir.declarations.*
@@ -128,8 +128,8 @@ class CallAndReferenceGenerator(
 
     private fun ConeKotlinType.kFunctionTypeToFunctionType(): IrSimpleType {
         val kind =
-            if (isSuspendFunctionType(session)) FunctionClassDescriptor.Kind.SuspendFunction
+            if (isSuspendFunctionType(session)) FunctionClassKind.SuspendFunction
-            else FunctionClassDescriptor.Kind.Function
+            else FunctionClassKind.Function
         val functionalTypeId = ClassId(kind.packageFqName, kind.numberedClassName(typeArguments.size - 1))
         val coneType = ConeClassLikeTypeImpl(ConeClassLikeLookupTagImpl(functionalTypeId), typeArguments, isNullable = false)
         return coneType.toIrType() as IrSimpleType

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/deserialization/FirTypeDeserializer.kt

@@ -5,7 +5,7 @@
 
 package org.jetbrains.kotlin.fir.deserialization
 
-import org.jetbrains.kotlin.builtins.functions.FunctionClassDescriptor
+import org.jetbrains.kotlin.builtins.functions.FunctionClassKind
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirDeclarationOrigin
 import org.jetbrains.kotlin.fir.declarations.FirTypeParameterRefsOwner
@@ -169,7 +169,7 @@ class FirTypeDeserializer(
 
         val valueParameters = arguments.dropLast(2)
 
-        val kind = FunctionClassDescriptor.Kind.SuspendFunction
+        val kind = FunctionClassKind.SuspendFunction
         return ConeClassLikeTypeImpl(
             ConeClassLikeLookupTagImpl(ClassId(kind.packageFqName, kind.numberedClassName(valueParameters.size))),
             (valueParameters + suspendReturnType).toTypedArray(),
@@ -191,7 +191,7 @@ class FirTypeDeserializer(
                 1 -> {
                     val arity = arguments.size - 1
                     if (arity >= 0) {
-                        val kind = FunctionClassDescriptor.Kind.SuspendFunction
+                        val kind = FunctionClassKind.SuspendFunction
                         ConeClassLikeTypeImpl(
                             ConeClassLikeLookupTagImpl(ClassId(kind.packageFqName, kind.numberedClassName(arity))),
                             arguments,

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ResolveUtils.kt

@@ -6,7 +6,7 @@
 package org.jetbrains.kotlin.fir.resolve
 
 import org.jetbrains.kotlin.builtins.KotlinBuiltInsNames
-import org.jetbrains.kotlin.builtins.functions.FunctionClassDescriptor
+import org.jetbrains.kotlin.builtins.functions.FunctionClassKind
 import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.fir.*
 import org.jetbrains.kotlin.fir.declarations.*
@@ -210,9 +210,9 @@ fun createFunctionalType(
     val receiverAndParameterTypes = listOfNotNull(receiverType) + parameters + listOf(rawReturnType)
 
     val kind = if (isSuspend) {
-        if (isKFunctionType) FunctionClassDescriptor.Kind.KSuspendFunction else FunctionClassDescriptor.Kind.SuspendFunction
+        if (isKFunctionType) FunctionClassKind.KSuspendFunction else FunctionClassKind.SuspendFunction
     } else {
-        if (isKFunctionType) FunctionClassDescriptor.Kind.KFunction else FunctionClassDescriptor.Kind.Function
+        if (isKFunctionType) FunctionClassKind.KFunction else FunctionClassKind.Function
     }
 
     val functionalTypeId = ClassId(kind.packageFqName, kind.numberedClassName(receiverAndParameterTypes.size - 1))

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/InferenceUtils.kt

@@ -5,7 +5,7 @@
 
 package org.jetbrains.kotlin.fir.resolve.inference
 
-import org.jetbrains.kotlin.builtins.functions.FunctionClassDescriptor
+import org.jetbrains.kotlin.builtins.functions.FunctionClassKind
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirAnonymousFunction
 import org.jetbrains.kotlin.fir.resolve.BodyResolveComponents
@@ -22,11 +22,11 @@ fun ConeKotlinType.isBuiltinFunctionalType(session: FirSession): Boolean {
     }
     if (this !is ConeClassLikeType) return false
     val classId = fullyExpandedType(session).lookupTag.classId
-    val kind = FunctionClassDescriptor.Kind.byClassNamePrefix(classId.packageFqName, classId.relativeClassName.asString()) ?: return false
+    val kind = FunctionClassKind.byClassNamePrefix(classId.packageFqName, classId.relativeClassName.asString()) ?: return false
-    return kind == FunctionClassDescriptor.Kind.Function ||
+    return kind == FunctionClassKind.Function ||
-            kind == FunctionClassDescriptor.Kind.KFunction ||
+            kind == FunctionClassKind.KFunction ||
-            kind == FunctionClassDescriptor.Kind.SuspendFunction ||
+            kind == FunctionClassKind.SuspendFunction ||
-            kind == FunctionClassDescriptor.Kind.KSuspendFunction
+            kind == FunctionClassKind.KSuspendFunction
 }
 
 @OptIn(ExperimentalContracts::class)
@@ -36,9 +36,9 @@ fun ConeKotlinType.isSuspendFunctionType(session: FirSession): Boolean {
     }
     if (this !is ConeClassLikeType) return false
     val classId = this.fullyExpandedType(session).lookupTag.classId
-    val kind = FunctionClassDescriptor.Kind.byClassNamePrefix(classId.packageFqName, classId.relativeClassName.asString()) ?: return false
+    val kind = FunctionClassKind.byClassNamePrefix(classId.packageFqName, classId.relativeClassName.asString()) ?: return false
-    return kind == FunctionClassDescriptor.Kind.SuspendFunction ||
+    return kind == FunctionClassKind.SuspendFunction ||
-            kind == FunctionClassDescriptor.Kind.KSuspendFunction
+            kind == FunctionClassKind.KSuspendFunction
 }
 
 fun ConeKotlinType.receiverType(expectedTypeRef: FirTypeRef?, session: FirSession): ConeKotlinType? {

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/providers/impl/FirBuiltinSymbolProvider.kt

@@ -6,7 +6,7 @@
 package org.jetbrains.kotlin.fir.resolve.providers.impl
 
 import org.jetbrains.kotlin.builtins.KotlinBuiltInsNames
-import org.jetbrains.kotlin.builtins.functions.FunctionClassDescriptor
+import org.jetbrains.kotlin.builtins.functions.FunctionClassKind
 import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.SourceElement
@@ -48,7 +48,7 @@ import java.io.InputStream
 
 class FirBuiltinSymbolProvider(session: FirSession, val kotlinScopeProvider: KotlinScopeProvider) : FirSymbolProvider(session) {
 
-    private data class SyntheticFunctionalInterfaceSymbolKey(val kind: FunctionClassDescriptor.Kind, val arity: Int)
+    private data class SyntheticFunctionalInterfaceSymbolKey(val kind: FunctionClassKind, val arity: Int)
 
     private val allPackageFragments = loadBuiltIns().groupBy { it.fqName }
     private val syntheticFunctionalInterfaceSymbols = mutableMapOf<SyntheticFunctionalInterfaceSymbolKey, FirRegularClassSymbol>()
@@ -79,7 +79,7 @@ class FirBuiltinSymbolProvider(session: FirSession, val kotlinScopeProvider: Kot
     private fun trySyntheticFunctionalInterface(classId: ClassId): FirRegularClassSymbol? {
         return with(classId) {
             val className = relativeClassName.asString()
-            val kind = FunctionClassDescriptor.Kind.byClassNamePrefix(packageFqName, className) ?: return@with null
+            val kind = FunctionClassKind.byClassNamePrefix(packageFqName, className) ?: return@with null
             val prefix = kind.classNamePrefix
             val arity = className.substring(prefix.length).toIntOrNull() ?: return null
             syntheticFunctionalInterfaceSymbols.getOrPut(SyntheticFunctionalInterfaceSymbolKey(kind, arity)) {
@@ -141,22 +141,22 @@ class FirBuiltinSymbolProvider(session: FirSession, val kotlinScopeProvider: Kot
                             isTailRec = false
                             isExternal = false
                             isSuspend =
-                                kind == FunctionClassDescriptor.Kind.SuspendFunction ||
+                                kind == FunctionClassKind.SuspendFunction ||
-                                        kind == FunctionClassDescriptor.Kind.KSuspendFunction
+                                        kind == FunctionClassKind.KSuspendFunction
                         }
                         val typeArguments = typeParameters.map {
                             buildResolvedTypeRef {
                                 type = ConeTypeParameterTypeImpl(it.symbol.toLookupTag(), false)
                             }
                         }
-                        val superKind: FunctionClassDescriptor.Kind? = when (kind) {
+                        val superKind: FunctionClassKind? = when (kind) {
-                            FunctionClassDescriptor.Kind.KFunction -> FunctionClassDescriptor.Kind.Function
+                            FunctionClassKind.KFunction -> FunctionClassKind.Function
-                            FunctionClassDescriptor.Kind.KSuspendFunction -> FunctionClassDescriptor.Kind.SuspendFunction
+                            FunctionClassKind.KSuspendFunction -> FunctionClassKind.SuspendFunction
                             else -> null
                         }
 
                         fun createSuperType(
-                            kind: FunctionClassDescriptor.Kind,
+                            kind: FunctionClassKind,
                         ): FirResolvedTypeRef {
                             return buildResolvedTypeRef {
                                 type = ConeClassLikeLookupTagImpl(kind.classId(arity))
@@ -165,34 +165,34 @@ class FirBuiltinSymbolProvider(session: FirSession, val kotlinScopeProvider: Kot
                         }
 
                         superTypeRefs += when (kind) {
-                            FunctionClassDescriptor.Kind.Function -> listOf(
+                            FunctionClassKind.Function -> listOf(
                                 buildResolvedTypeRef {
                                     type = ConeClassLikeLookupTagImpl(StandardClassIds.Function)
                                         .constructClassType(arrayOf(typeArguments.last().type), isNullable = false)
                                 }
                             )
 
-                            FunctionClassDescriptor.Kind.SuspendFunction -> listOf(
+                            FunctionClassKind.SuspendFunction -> listOf(
                                 buildResolvedTypeRef {
                                     type = ConeClassLikeLookupTagImpl(StandardClassIds.Function)
                                         .constructClassType(arrayOf(typeArguments.last().type), isNullable = false)
                                 }
                             )
 
-                            FunctionClassDescriptor.Kind.KFunction -> listOf(
+                            FunctionClassKind.KFunction -> listOf(
                                 buildResolvedTypeRef {
                                     type = ConeClassLikeLookupTagImpl(StandardClassIds.KFunction)
                                         .constructClassType(arrayOf(typeArguments.last().type), isNullable = false)
                                 },
-                                createSuperType(FunctionClassDescriptor.Kind.Function)
+                                createSuperType(FunctionClassKind.Function)
                             )
 
-                            FunctionClassDescriptor.Kind.KSuspendFunction -> listOf(
+                            FunctionClassKind.KSuspendFunction -> listOf(
                                 buildResolvedTypeRef {
                                     type = ConeClassLikeLookupTagImpl(StandardClassIds.KFunction)
                                         .constructClassType(arrayOf(typeArguments.last().type), isNullable = false)
                                 },
-                                createSuperType(FunctionClassDescriptor.Kind.SuspendFunction)
+                                createSuperType(FunctionClassKind.SuspendFunction)
                             )
                         }
                         addDeclaration(
@@ -232,14 +232,14 @@ class FirBuiltinSymbolProvider(session: FirSession, val kotlinScopeProvider: Kot
     }
 
     // Find the symbol for "invoke" in the function class
-    private fun FunctionClassDescriptor.Kind.getInvoke(arity: Int): FirNamedFunctionSymbol? {
+    private fun FunctionClassKind.getInvoke(arity: Int): FirNamedFunctionSymbol? {
         val functionClass = getClassLikeSymbolByFqName(classId(arity)) ?: return null
         val invoke =
             functionClass.fir.declarations.find { it is FirSimpleFunction && it.name == OperatorNameConventions.INVOKE } ?: return null
         return (invoke as FirSimpleFunction).symbol as? FirNamedFunctionSymbol
     }
 
-    private fun FunctionClassDescriptor.Kind.classId(arity: Int) = ClassId(packageFqName, numberedClassName(arity))
+    private fun FunctionClassKind.classId(arity: Int) = ClassId(packageFqName, numberedClassName(arity))
 
     @FirSymbolProviderInternals
     override fun getTopLevelCallableSymbolsTo(destination: MutableList<FirCallableSymbol<*>>, packageFqName: FqName, name: Name) {

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

@@ -6,7 +6,7 @@
 package org.jetbrains.kotlin.fir
 
 import org.jetbrains.kotlin.builtins.functions.BuiltInFictitiousFunctionClassFactory
-import org.jetbrains.kotlin.builtins.functions.FunctionClassDescriptor
+import org.jetbrains.kotlin.builtins.functions.FunctionClassKind
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
 import org.jetbrains.kotlin.fir.contracts.FirContractDescription
 import org.jetbrains.kotlin.fir.contracts.FirRawContractDescription
@@ -872,7 +872,7 @@ class FirRenderer(builder: StringBuilder, private val mode: RenderMode = RenderM
         print("|")
     }
 
-    private val FirResolvedTypeRef.functionTypeKind: FunctionClassDescriptor.Kind?
+    private val FirResolvedTypeRef.functionTypeKind: FunctionClassKind?
         get() {
             val classId = (type as? ConeClassLikeType)?.lookupTag?.classId ?: return null
             return BuiltInFictitiousFunctionClassFactory.getFunctionalClassKind(

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/descriptors/IrFunctionFactory.kt

@@ -7,6 +7,7 @@ package org.jetbrains.kotlin.ir.descriptors
 
 import org.jetbrains.kotlin.builtins.KotlinBuiltInsNames.KOTLIN_REFLECT_FQ_NAME
 import org.jetbrains.kotlin.builtins.functions.FunctionClassDescriptor
+import org.jetbrains.kotlin.builtins.functions.FunctionClassKind
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation
 import org.jetbrains.kotlin.ir.ObsoleteDescriptorBasedAPI
@@ -281,13 +282,13 @@ class IrFunctionFactory(private val irBuiltIns: IrBuiltIns, private val symbolTa
         return symbolTable.declareClass(this) {
             val factory = FunctionDescriptorFactory.RealDescriptorFactory(this, symbolTable)
             when (functionKind) {
-                FunctionClassDescriptor.Kind.Function ->
+                FunctionClassKind.Function ->
                     createFunctionClass(it, false, false, arity, irBuiltIns.functionClass, kotlinPackageFragment, factory)
-                FunctionClassDescriptor.Kind.SuspendFunction ->
+                FunctionClassKind.SuspendFunction ->
                     createFunctionClass(it, false, true, arity, irBuiltIns.functionClass, kotlinCoroutinesPackageFragment, factory)
-                FunctionClassDescriptor.Kind.KFunction ->
+                FunctionClassKind.KFunction ->
                     createFunctionClass(it, true, false, arity, irBuiltIns.kFunctionClass, kotlinReflectPackageFragment, factory)
-                FunctionClassDescriptor.Kind.KSuspendFunction ->
+                FunctionClassKind.KSuspendFunction ->
                     createFunctionClass(it, true, true, arity, irBuiltIns.kFunctionClass, kotlinReflectPackageFragment, factory)
             }
         }

compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/IrModuleDeserializer.kt

@@ -7,6 +7,7 @@ package org.jetbrains.kotlin.backend.common.serialization
 
 import org.jetbrains.kotlin.backend.common.serialization.encodings.BinarySymbolData
 import org.jetbrains.kotlin.builtins.functions.FunctionClassDescriptor
+import org.jetbrains.kotlin.builtins.functions.FunctionClassKind
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.ir.declarations.IrDeclarationWithName
 import org.jetbrains.kotlin.ir.declarations.IrModuleFragment
@@ -119,16 +120,16 @@ class IrModuleDeserializerWithBuiltIns(
         val topLevelSignature = IdSignature.PublicSignature(publicSig.packageFqName, className, null, publicSig.mask)
 
         val functionClass = when (functionDescriptor.functionKind) {
-            FunctionClassDescriptor.Kind.KSuspendFunction -> functionFactory.kSuspendFunctionN(functionDescriptor.arity) { callback ->
+            FunctionClassKind.KSuspendFunction -> functionFactory.kSuspendFunctionN(functionDescriptor.arity) { callback ->
                 declareClassFromLinker(functionDescriptor, topLevelSignature) { callback(it) }
             }
-            FunctionClassDescriptor.Kind.KFunction -> functionFactory.kFunctionN(functionDescriptor.arity) { callback ->
+            FunctionClassKind.KFunction -> functionFactory.kFunctionN(functionDescriptor.arity) { callback ->
                 declareClassFromLinker(functionDescriptor, topLevelSignature) { callback(it) }
             }
-            FunctionClassDescriptor.Kind.SuspendFunction -> functionFactory.suspendFunctionN(functionDescriptor.arity) { callback ->
+            FunctionClassKind.SuspendFunction -> functionFactory.suspendFunctionN(functionDescriptor.arity) { callback ->
                 declareClassFromLinker(functionDescriptor, topLevelSignature) { callback(it) }
             }
-            FunctionClassDescriptor.Kind.Function -> functionFactory.functionN(functionDescriptor.arity) { callback ->
+            FunctionClassKind.Function -> functionFactory.functionN(functionDescriptor.arity) { callback ->
                 declareClassFromLinker(functionDescriptor, topLevelSignature) { callback(it) }
             }
         }

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

@@ -0,0 +1,24 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * 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.builtins.functions
+
+import org.jetbrains.kotlin.builtins.KotlinBuiltInsNames
+import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.name.Name
+
+enum class FunctionClassKind(val packageFqName: FqName, val classNamePrefix: String) {
+    Function(KotlinBuiltInsNames.BUILT_INS_PACKAGE_FQ_NAME, "Function"),
+    SuspendFunction(KotlinBuiltInsNames.COROUTINES_PACKAGE_FQ_NAME_RELEASE, "SuspendFunction"),
+    KFunction(KotlinBuiltInsNames.KOTLIN_REFLECT_FQ_NAME, "KFunction"),
+    KSuspendFunction(KotlinBuiltInsNames.KOTLIN_REFLECT_FQ_NAME, "KSuspendFunction");
+
+    fun numberedClassName(arity: Int) = Name.identifier("$classNamePrefix$arity")
+
+    companion object {
+        fun byClassNamePrefix(packageFqName: FqName, className: String): FunctionClassKind? =
+            values().firstOrNull { it.packageFqName == packageFqName && className.startsWith(it.classNamePrefix) }
+    }
+}

core/descriptors.jvm/src/org/jetbrains/kotlin/builtins/jvm/JavaToKotlinClassMap.kt

@@ -9,7 +9,7 @@ import org.jetbrains.kotlin.builtins.CompanionObjectMapping
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.builtins.KotlinBuiltInsNames.FqNames
 import org.jetbrains.kotlin.builtins.PlatformToKotlinClassMap
-import org.jetbrains.kotlin.builtins.functions.FunctionClassDescriptor
+import org.jetbrains.kotlin.builtins.functions.FunctionClassKind
 import org.jetbrains.kotlin.builtins.functions.FunctionInvokeDescriptor
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.name.*
@@ -23,13 +23,13 @@ import java.util.*
 
 object JavaToKotlinClassMap : PlatformToKotlinClassMap {
     private val NUMBERED_FUNCTION_PREFIX =
-        FunctionClassDescriptor.Kind.Function.packageFqName.toString() + "." + FunctionClassDescriptor.Kind.Function.classNamePrefix
+        FunctionClassKind.Function.packageFqName.toString() + "." + FunctionClassKind.Function.classNamePrefix
     private val NUMBERED_K_FUNCTION_PREFIX =
-        FunctionClassDescriptor.Kind.KFunction.packageFqName.toString() + "." + FunctionClassDescriptor.Kind.KFunction.classNamePrefix
+        FunctionClassKind.KFunction.packageFqName.toString() + "." + FunctionClassKind.KFunction.classNamePrefix
     private val NUMBERED_SUSPEND_FUNCTION_PREFIX =
-        FunctionClassDescriptor.Kind.SuspendFunction.packageFqName.toString() + "." + FunctionClassDescriptor.Kind.SuspendFunction.classNamePrefix
+        FunctionClassKind.SuspendFunction.packageFqName.toString() + "." + FunctionClassKind.SuspendFunction.classNamePrefix
     private val NUMBERED_K_SUSPEND_FUNCTION_PREFIX =
-        FunctionClassDescriptor.Kind.KSuspendFunction.packageFqName.toString() + "." + FunctionClassDescriptor.Kind.KSuspendFunction.classNamePrefix
+        FunctionClassKind.KSuspendFunction.packageFqName.toString() + "." + FunctionClassKind.KSuspendFunction.classNamePrefix
 
     private val FUNCTION_N_CLASS_ID = ClassId.topLevel(FqName("kotlin.jvm.functions.FunctionN"))
     val FUNCTION_N_FQ_NAME = FUNCTION_N_CLASS_ID.asSingleFqName()
@@ -102,7 +102,7 @@ object JavaToKotlinClassMap : PlatformToKotlinClassMap {
             addKotlinToJava(FqName(NUMBERED_K_FUNCTION_PREFIX + i), K_FUNCTION_CLASS_ID)
         }
         for (i in 0 until FunctionInvokeDescriptor.BIG_ARITY - 1) {
-            val kSuspendFunction = FunctionClassDescriptor.Kind.KSuspendFunction
+            val kSuspendFunction = FunctionClassKind.KSuspendFunction
             val kSuspendFun = kSuspendFunction.packageFqName.toString() + "." + kSuspendFunction.classNamePrefix
             addKotlinToJava(FqName(kSuspendFun + i), K_FUNCTION_CLASS_ID)
         }

core/descriptors/src/org/jetbrains/kotlin/builtins/KotlinBuiltIns.java

@@ -10,7 +10,7 @@ import kotlin.jvm.functions.Function1;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.builtins.functions.BuiltInFictitiousFunctionClassFactory;
-import org.jetbrains.kotlin.builtins.functions.FunctionClassDescriptor;
+import org.jetbrains.kotlin.builtins.functions.FunctionClassKind;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.descriptors.annotations.Annotations;
 import org.jetbrains.kotlin.descriptors.deserialization.AdditionalClassPartsProvider;
@@ -295,7 +295,7 @@ public abstract class KotlinBuiltIns {
 
     @NotNull
     private static FqNameUnsafe getKFunctionFqName(int parameterCount) {
-        return FqNames.reflect(FunctionClassDescriptor.Kind.KFunction.getClassNamePrefix() + parameterCount);
+        return FqNames.reflect(FunctionClassKind.KFunction.getClassNamePrefix() + parameterCount);
     }
 
     @NotNull
@@ -310,7 +310,7 @@ public abstract class KotlinBuiltIns {
 
     @NotNull
     public static String getSuspendFunctionName(int parameterCount) {
-        return FunctionClassDescriptor.Kind.SuspendFunction.getClassNamePrefix() + parameterCount;
+        return FunctionClassKind.SuspendFunction.getClassNamePrefix() + parameterCount;
     }
 
     @NotNull
@@ -330,7 +330,7 @@ public abstract class KotlinBuiltIns {
 
     @NotNull
     public ClassDescriptor getKSuspendFunction(int parameterCount) {
-        Name name = Name.identifier(FunctionClassDescriptor.Kind.KSuspendFunction.getClassNamePrefix() + parameterCount);
+        Name name = Name.identifier(FunctionClassKind.KSuspendFunction.getClassNamePrefix() + parameterCount);
         return getBuiltInClassByFqName(COROUTINES_PACKAGE_FQ_NAME_RELEASE.child(name));
     }
 

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

@@ -7,7 +7,7 @@ package org.jetbrains.kotlin.builtins
 
 import org.jetbrains.kotlin.builtins.KotlinBuiltInsNames.BUILT_INS_PACKAGE_NAME
 import org.jetbrains.kotlin.builtins.functions.BuiltInFictitiousFunctionClassFactory
-import org.jetbrains.kotlin.builtins.functions.FunctionClassDescriptor
+import org.jetbrains.kotlin.builtins.functions.FunctionClassKind
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.annotations.Annotations
@@ -59,16 +59,16 @@ fun KotlinType.isFunctionTypeOrSubtype(predicate: (KotlinType) -> Boolean): Bool
     isTypeOrSubtypeOf { it.isFunctionType && predicate(it) }
 
 val KotlinType.isFunctionType: Boolean
-    get() = constructor.declarationDescriptor?.getFunctionalClassKind() == FunctionClassDescriptor.Kind.Function
+    get() = constructor.declarationDescriptor?.getFunctionalClassKind() == FunctionClassKind.Function
 
 val KotlinType.isKFunctionType: Boolean
-    get() = constructor.declarationDescriptor?.getFunctionalClassKind() == FunctionClassDescriptor.Kind.KFunction
+    get() = constructor.declarationDescriptor?.getFunctionalClassKind() == FunctionClassKind.KFunction
 
 val KotlinType.isSuspendFunctionType: Boolean
-    get() = constructor.declarationDescriptor?.getFunctionalClassKind() == FunctionClassDescriptor.Kind.SuspendFunction
+    get() = constructor.declarationDescriptor?.getFunctionalClassKind() == FunctionClassKind.SuspendFunction
 
 val KotlinType.isKSuspendFunctionType: Boolean
-    get() = constructor.declarationDescriptor?.getFunctionalClassKind() == FunctionClassDescriptor.Kind.KSuspendFunction
+    get() = constructor.declarationDescriptor?.getFunctionalClassKind() == FunctionClassKind.KSuspendFunction
 
 val KotlinType.isFunctionOrSuspendFunctionType: Boolean
     get() = isFunctionType || isSuspendFunctionType
@@ -82,16 +82,16 @@ val KotlinType.isBuiltinFunctionalType: Boolean
 val DeclarationDescriptor.isBuiltinFunctionalClassDescriptor: Boolean
     get() {
         val functionalClassKind = getFunctionalClassKind()
-        return functionalClassKind == FunctionClassDescriptor.Kind.Function ||
+        return functionalClassKind == FunctionClassKind.Function ||
-                functionalClassKind == FunctionClassDescriptor.Kind.SuspendFunction
+                functionalClassKind == FunctionClassKind.SuspendFunction
     }
 
 fun isBuiltinFunctionClass(classId: ClassId): Boolean {
     if (!classId.startsWith(KotlinBuiltInsNames.BUILT_INS_PACKAGE_NAME)) return false
 
     val kind = classId.asSingleFqName().toUnsafe().getFunctionalClassKind()
-    return kind == FunctionClassDescriptor.Kind.Function ||
+    return kind == FunctionClassKind.Function ||
-           kind == FunctionClassDescriptor.Kind.SuspendFunction
+           kind == FunctionClassKind.SuspendFunction
 }
 
 val KotlinType.isNonExtensionFunctionType: Boolean
@@ -112,17 +112,17 @@ private val KotlinType.isTypeAnnotatedWithExtensionFunctionType: Boolean
  */
 fun isNumberedFunctionClassFqName(fqName: FqNameUnsafe): Boolean {
     return fqName.startsWith(BUILT_INS_PACKAGE_NAME) &&
-           fqName.getFunctionalClassKind() == FunctionClassDescriptor.Kind.Function
+           fqName.getFunctionalClassKind() == FunctionClassKind.Function
 }
 
-fun DeclarationDescriptor.getFunctionalClassKind(): FunctionClassDescriptor.Kind? {
+fun DeclarationDescriptor.getFunctionalClassKind(): FunctionClassKind? {
     if (this !is ClassDescriptor) return null
     if (!KotlinBuiltIns.isUnderKotlinPackage(this)) return null
 
     return fqNameUnsafe.getFunctionalClassKind()
 }
 
-private fun FqNameUnsafe.getFunctionalClassKind(): FunctionClassDescriptor.Kind? {
+private fun FqNameUnsafe.getFunctionalClassKind(): FunctionClassKind? {
     if (!isSafe || isRoot) return null
 
     return BuiltInFictitiousFunctionClassFactory.getFunctionalClassKind(shortName().asString(), toSafe().parent())

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

@@ -18,7 +18,6 @@ package org.jetbrains.kotlin.builtins.functions
 
 import org.jetbrains.kotlin.builtins.BuiltInsPackageFragment
 import org.jetbrains.kotlin.builtins.FunctionInterfacePackageFragment
-import org.jetbrains.kotlin.builtins.functions.FunctionClassDescriptor.Kind
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.descriptors.deserialization.ClassDescriptorFactory
@@ -35,11 +34,11 @@ class BuiltInFictitiousFunctionClassFactory(
         private val module: ModuleDescriptor
 ) : ClassDescriptorFactory {
 
-    private data class KindWithArity(val kind: Kind, val arity: Int)
+    private data class KindWithArity(val kind: FunctionClassKind, val arity: Int)
 
     companion object {
         private fun parseClassName(className: String, packageFqName: FqName): KindWithArity? {
-            val kind = FunctionClassDescriptor.Kind.byClassNamePrefix(packageFqName, className) ?: return null
+            val kind = FunctionClassKind.byClassNamePrefix(packageFqName, className) ?: return null
 
             val prefix = kind.classNamePrefix
 

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

@@ -13,7 +13,6 @@ import org.jetbrains.kotlin.descriptors.annotations.Annotations
 import org.jetbrains.kotlin.descriptors.impl.AbstractClassDescriptor
 import org.jetbrains.kotlin.descriptors.impl.TypeParameterDescriptorImpl
 import org.jetbrains.kotlin.name.ClassId
-import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.resolve.scopes.MemberScope
 import org.jetbrains.kotlin.storage.StorageManager
@@ -32,24 +31,10 @@ import java.util.*
 class FunctionClassDescriptor(
         private val storageManager: StorageManager,
         private val containingDeclaration: PackageFragmentDescriptor,
-        val functionKind: Kind,
+        val functionKind: FunctionClassKind,
         val arity: Int
 ) : AbstractClassDescriptor(storageManager, functionKind.numberedClassName(arity)) {
 
-    enum class Kind(val packageFqName: FqName, val classNamePrefix: String) {
-        Function(BUILT_INS_PACKAGE_FQ_NAME, "Function"),
-        SuspendFunction(COROUTINES_PACKAGE_FQ_NAME_RELEASE, "SuspendFunction"),
-        KFunction(KOTLIN_REFLECT_FQ_NAME, "KFunction"),
-        KSuspendFunction(KOTLIN_REFLECT_FQ_NAME, "KSuspendFunction");
-
-        fun numberedClassName(arity: Int) = Name.identifier("$classNamePrefix$arity")
-
-        companion object {
-            fun byClassNamePrefix(packageFqName: FqName, className: String) =
-                    Kind.values().firstOrNull { it.packageFqName == packageFqName && className.startsWith(it.classNamePrefix) }
-        }
-    }
-
     private val typeConstructor = FunctionTypeConstructor()
     private val memberScope = FunctionClassScope(storageManager, this)
 
@@ -109,14 +94,14 @@ class FunctionClassDescriptor(
         override fun computeSupertypes(): Collection<KotlinType> {
             // For K{Suspend}Function{n}, add corresponding numbered {Suspend}Function{n} class, e.g. {Suspend}Function2 for K{Suspend}Function2
             val supertypes = when (functionKind) {
-                Kind.Function -> // Function$N <: Function
+                FunctionClassKind.Function -> // Function$N <: Function
                     listOf(functionClassId)
-                Kind.KFunction -> // KFunction$N <: KFunction
+                FunctionClassKind.KFunction -> // KFunction$N <: KFunction
-                    listOf(kFunctionClassId, ClassId(BUILT_INS_PACKAGE_FQ_NAME, Kind.Function.numberedClassName(arity)))
+                    listOf(kFunctionClassId, ClassId(BUILT_INS_PACKAGE_FQ_NAME, FunctionClassKind.Function.numberedClassName(arity)))
-                Kind.SuspendFunction -> // SuspendFunction$N<...> <: Function
+                FunctionClassKind.SuspendFunction -> // SuspendFunction$N<...> <: Function
                     listOf(functionClassId)
-                Kind.KSuspendFunction -> // KSuspendFunction$N<...> <: KFunction
+                FunctionClassKind.KSuspendFunction -> // KSuspendFunction$N<...> <: KFunction
-                    listOf(kFunctionClassId, ClassId(COROUTINES_PACKAGE_FQ_NAME_RELEASE, Kind.SuspendFunction.numberedClassName(arity)))
+                    listOf(kFunctionClassId, ClassId(COROUTINES_PACKAGE_FQ_NAME_RELEASE, FunctionClassKind.SuspendFunction.numberedClassName(arity)))
             }
 
             val moduleDescriptor = containingDeclaration.containingDeclaration

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

@@ -26,8 +26,8 @@ class FunctionClassScope(
 ) : GivenFunctionsMemberScope(storageManager, containingClass) {
     override fun computeDeclaredFunctions(): List<FunctionDescriptor> =
             when ((containingClass as FunctionClassDescriptor).functionKind) {
-                FunctionClassDescriptor.Kind.Function -> listOf(FunctionInvokeDescriptor.create(containingClass, isSuspend = false))
+                FunctionClassKind.Function -> listOf(FunctionInvokeDescriptor.create(containingClass, isSuspend = false))
-                FunctionClassDescriptor.Kind.SuspendFunction -> listOf(FunctionInvokeDescriptor.create(containingClass, isSuspend = true))
+                FunctionClassKind.SuspendFunction -> listOf(FunctionInvokeDescriptor.create(containingClass, isSuspend = true))
                 else -> emptyList()
             }
 }

js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/ExpressionVisitor.java

@@ -23,6 +23,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
 import org.jetbrains.kotlin.builtins.functions.FunctionClassDescriptor;
+import org.jetbrains.kotlin.builtins.functions.FunctionClassKind;
 import org.jetbrains.kotlin.config.LanguageVersion;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor;
@@ -67,7 +68,8 @@ import java.util.Arrays;
 import java.util.List;
 
 import static org.jetbrains.kotlin.descriptors.FindClassInModuleKt.findClassAcrossModuleDependencies;
-import static org.jetbrains.kotlin.js.translate.context.Namer.*;
+import static org.jetbrains.kotlin.js.translate.context.Namer.GET_KCLASS_FROM_EXPRESSION;
+import static org.jetbrains.kotlin.js.translate.context.Namer.getCapturedVarAccessor;
 import static org.jetbrains.kotlin.js.translate.general.Translation.translateAsExpression;
 import static org.jetbrains.kotlin.js.translate.utils.BindingUtils.*;
 import static org.jetbrains.kotlin.js.translate.utils.ErrorReportingUtils.message;
@@ -331,7 +333,7 @@ public final class ExpressionVisitor extends TranslatorVisitor<JsNode> {
             default: {
                 if (descriptor instanceof FunctionClassDescriptor) {
                     FunctionClassDescriptor functionClassDescriptor = (FunctionClassDescriptor) descriptor;
-                    if (functionClassDescriptor.getFunctionKind() == FunctionClassDescriptor.Kind.Function) {
+                    if (functionClassDescriptor.getFunctionKind() == FunctionClassKind.Function) {
                         ClassDescriptor primitivesObject = findPrimitiveClassesObject(context);
                         assert primitivesObject != null;
                         FunctionDescriptor function = DescriptorUtils.getFunctionByName(