From 20a2ad822305a9a51af322098cc53c34d2696322 Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Sun, 16 Aug 2020 23:15:15 +0300 Subject: [PATCH] Move FunctionClassDescriptor.Kind to :core:descriptors.common module --- .../kotlin/codegen/state/KotlinTypeMapper.kt | 5 +-- .../kotlin/fir/types/TypeRenderer.kt | 12 +++---- .../fir/serialization/FirElementSerializer.kt | 6 ++-- .../generators/CallAndReferenceGenerator.kt | 6 ++-- .../deserialization/FirTypeDeserializer.kt | 6 ++-- .../kotlin/fir/resolve/ResolveUtils.kt | 6 ++-- .../fir/resolve/inference/InferenceUtils.kt | 18 +++++----- .../impl/FirBuiltinSymbolProvider.kt | 34 +++++++++---------- .../org/jetbrains/kotlin/fir/FirRenderer.kt | 4 +-- .../ir/descriptors/IrFunctionFactory.kt | 9 ++--- .../serialization/IrModuleDeserializer.kt | 9 ++--- .../builtins/functions/FunctionClassKind.kt | 24 +++++++++++++ .../builtins/jvm/JavaToKotlinClassMap.kt | 12 +++---- .../kotlin/builtins/KotlinBuiltIns.java | 8 ++--- .../kotlin/builtins/functionTypes.kt | 24 ++++++------- .../BuiltInFictitiousFunctionClassFactory.kt | 5 ++- .../functions/FunctionClassDescriptor.kt | 29 ++++------------ .../builtins/functions/FunctionClassScope.kt | 4 +-- .../expression/ExpressionVisitor.java | 6 ++-- 19 files changed, 120 insertions(+), 107 deletions(-) create mode 100644 core/descriptors.common/src/org/jetbrains/kotlin/builtins/functions/FunctionClassKind.kt diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/KotlinTypeMapper.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/KotlinTypeMapper.kt index 9716de3f3ce..f16231383d4 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/KotlinTypeMapper.kt +++ b/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 == FunctionClassDescriptor.Kind.KSuspendFunction + classDescriptor.functionKind == FunctionClassKind.KFunction || + classDescriptor.functionKind == FunctionClassKind.KSuspendFunction ) { // kotlin.reflect.KFunction{n} is mapped to kotlin.reflect.KFunction (for all n), and // kotlin.Function{n} is mapped to kotlin.jvm.functions.FunctionN (for n > 22). diff --git a/compiler/fir/cones/src/org/jetbrains/kotlin/fir/types/TypeRenderer.kt b/compiler/fir/cones/src/org/jetbrains/kotlin/fir/types/TypeRenderer.kt index 25b65c17a66..77f7cc44a6b 100644 --- a/compiler/fir/cones/src/org/jetbrains/kotlin/fir/types/TypeRenderer.kt +++ b/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 -} \ No newline at end of file + return this != null && this != FunctionClassKind.KSuspendFunction && this != FunctionClassKind.KFunction +} diff --git a/compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/FirElementSerializer.kt b/compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/FirElementSerializer.kt index be8618f1fb8..55b362cbd93 100644 --- a/compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/FirElementSerializer.kt +++ b/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 - else FunctionClassDescriptor.Kind.Function + if (relativeClassName.startsWith("K")) FunctionClassKind.KFunction + else FunctionClassKind.Function val runtimeClassId = ClassId(kind.packageFqName, Name.identifier(relativeClassName.replaceFirst("Suspend", ""))) val continuationClassId = CONTINUATION_INTERFACE_CLASS_ID return ConeClassLikeLookupTagImpl(runtimeClassId).constructClassType( diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/CallAndReferenceGenerator.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/CallAndReferenceGenerator.kt index 89fb1370a8e..826f9d30455 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/CallAndReferenceGenerator.kt +++ b/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 - else FunctionClassDescriptor.Kind.Function + if (isSuspendFunctionType(session)) FunctionClassKind.SuspendFunction + 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 diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/deserialization/FirTypeDeserializer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/deserialization/FirTypeDeserializer.kt index cc7ef4c83bc..dd8f52136cd 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/deserialization/FirTypeDeserializer.kt +++ b/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, diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ResolveUtils.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ResolveUtils.kt index 1badc654ab5..0ff2a122fd0 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ResolveUtils.kt +++ b/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)) diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/InferenceUtils.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/InferenceUtils.kt index 19e46f09931..2f8a0a879ac 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/InferenceUtils.kt +++ b/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 - return kind == FunctionClassDescriptor.Kind.Function || - kind == FunctionClassDescriptor.Kind.KFunction || - kind == FunctionClassDescriptor.Kind.SuspendFunction || - kind == FunctionClassDescriptor.Kind.KSuspendFunction + val kind = FunctionClassKind.byClassNamePrefix(classId.packageFqName, classId.relativeClassName.asString()) ?: return false + return kind == FunctionClassKind.Function || + kind == FunctionClassKind.KFunction || + kind == FunctionClassKind.SuspendFunction || + 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 - return kind == FunctionClassDescriptor.Kind.SuspendFunction || - kind == FunctionClassDescriptor.Kind.KSuspendFunction + val kind = FunctionClassKind.byClassNamePrefix(classId.packageFqName, classId.relativeClassName.asString()) ?: return false + return kind == FunctionClassKind.SuspendFunction || + kind == FunctionClassKind.KSuspendFunction } fun ConeKotlinType.receiverType(expectedTypeRef: FirTypeRef?, session: FirSession): ConeKotlinType? { diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/providers/impl/FirBuiltinSymbolProvider.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/providers/impl/FirBuiltinSymbolProvider.kt index db1b3d4b866..0b94edcc7a1 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/providers/impl/FirBuiltinSymbolProvider.kt +++ b/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() @@ -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 == FunctionClassDescriptor.Kind.KSuspendFunction + kind == FunctionClassKind.SuspendFunction || + kind == FunctionClassKind.KSuspendFunction } val typeArguments = typeParameters.map { buildResolvedTypeRef { type = ConeTypeParameterTypeImpl(it.symbol.toLookupTag(), false) } } - val superKind: FunctionClassDescriptor.Kind? = when (kind) { - FunctionClassDescriptor.Kind.KFunction -> FunctionClassDescriptor.Kind.Function - FunctionClassDescriptor.Kind.KSuspendFunction -> FunctionClassDescriptor.Kind.SuspendFunction + val superKind: FunctionClassKind? = when (kind) { + FunctionClassKind.KFunction -> FunctionClassKind.Function + 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>, packageFqName: FqName, name: Name) { diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirRenderer.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirRenderer.kt index e08eabe3b52..0c7bdd0b6cb 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirRenderer.kt +++ b/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( diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/descriptors/IrFunctionFactory.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/descriptors/IrFunctionFactory.kt index e5d9e19eb4e..37cc6c0d5e8 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/descriptors/IrFunctionFactory.kt +++ b/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) } } diff --git a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/IrModuleDeserializer.kt b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/IrModuleDeserializer.kt index 59ad88b1155..d1b4b24e174 100644 --- a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/IrModuleDeserializer.kt +++ b/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) } } } diff --git a/core/descriptors.common/src/org/jetbrains/kotlin/builtins/functions/FunctionClassKind.kt b/core/descriptors.common/src/org/jetbrains/kotlin/builtins/functions/FunctionClassKind.kt new file mode 100644 index 00000000000..db69e222b28 --- /dev/null +++ b/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) } + } +} diff --git a/core/descriptors.jvm/src/org/jetbrains/kotlin/builtins/jvm/JavaToKotlinClassMap.kt b/core/descriptors.jvm/src/org/jetbrains/kotlin/builtins/jvm/JavaToKotlinClassMap.kt index f17a80cdacc..96d7f0087c9 100644 --- a/core/descriptors.jvm/src/org/jetbrains/kotlin/builtins/jvm/JavaToKotlinClassMap.kt +++ b/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) } diff --git a/core/descriptors/src/org/jetbrains/kotlin/builtins/KotlinBuiltIns.java b/core/descriptors/src/org/jetbrains/kotlin/builtins/KotlinBuiltIns.java index fd2f002d306..244bb8f0706 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/builtins/KotlinBuiltIns.java +++ b/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)); } diff --git a/core/descriptors/src/org/jetbrains/kotlin/builtins/functionTypes.kt b/core/descriptors/src/org/jetbrains/kotlin/builtins/functionTypes.kt index 65cd74ccd25..367ec52600a 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/builtins/functionTypes.kt +++ b/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 || - functionalClassKind == FunctionClassDescriptor.Kind.SuspendFunction + return functionalClassKind == FunctionClassKind.Function || + 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 || - kind == FunctionClassDescriptor.Kind.SuspendFunction + return kind == FunctionClassKind.Function || + 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()) diff --git a/core/descriptors/src/org/jetbrains/kotlin/builtins/functions/BuiltInFictitiousFunctionClassFactory.kt b/core/descriptors/src/org/jetbrains/kotlin/builtins/functions/BuiltInFictitiousFunctionClassFactory.kt index 3bc5a25bd3e..6b8f59fcc3f 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/builtins/functions/BuiltInFictitiousFunctionClassFactory.kt +++ b/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 diff --git a/core/descriptors/src/org/jetbrains/kotlin/builtins/functions/FunctionClassDescriptor.kt b/core/descriptors/src/org/jetbrains/kotlin/builtins/functions/FunctionClassDescriptor.kt index 37f0c8e2d63..e683b5f416e 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/builtins/functions/FunctionClassDescriptor.kt +++ b/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 { // 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 - listOf(kFunctionClassId, ClassId(BUILT_INS_PACKAGE_FQ_NAME, Kind.Function.numberedClassName(arity))) - Kind.SuspendFunction -> // SuspendFunction$N<...> <: Function + FunctionClassKind.KFunction -> // KFunction$N <: KFunction + listOf(kFunctionClassId, ClassId(BUILT_INS_PACKAGE_FQ_NAME, FunctionClassKind.Function.numberedClassName(arity))) + FunctionClassKind.SuspendFunction -> // SuspendFunction$N<...> <: Function listOf(functionClassId) - Kind.KSuspendFunction -> // KSuspendFunction$N<...> <: KFunction - listOf(kFunctionClassId, ClassId(COROUTINES_PACKAGE_FQ_NAME_RELEASE, Kind.SuspendFunction.numberedClassName(arity))) + FunctionClassKind.KSuspendFunction -> // KSuspendFunction$N<...> <: KFunction + listOf(kFunctionClassId, ClassId(COROUTINES_PACKAGE_FQ_NAME_RELEASE, FunctionClassKind.SuspendFunction.numberedClassName(arity))) } val moduleDescriptor = containingDeclaration.containingDeclaration diff --git a/core/descriptors/src/org/jetbrains/kotlin/builtins/functions/FunctionClassScope.kt b/core/descriptors/src/org/jetbrains/kotlin/builtins/functions/FunctionClassScope.kt index 670fc899377..1ad16f9f453 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/builtins/functions/FunctionClassScope.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/builtins/functions/FunctionClassScope.kt @@ -26,8 +26,8 @@ class FunctionClassScope( ) : GivenFunctionsMemberScope(storageManager, containingClass) { override fun computeDeclaredFunctions(): List = when ((containingClass as FunctionClassDescriptor).functionKind) { - FunctionClassDescriptor.Kind.Function -> listOf(FunctionInvokeDescriptor.create(containingClass, isSuspend = false)) - FunctionClassDescriptor.Kind.SuspendFunction -> listOf(FunctionInvokeDescriptor.create(containingClass, isSuspend = true)) + FunctionClassKind.Function -> listOf(FunctionInvokeDescriptor.create(containingClass, isSuspend = false)) + FunctionClassKind.SuspendFunction -> listOf(FunctionInvokeDescriptor.create(containingClass, isSuspend = true)) else -> emptyList() } } diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/ExpressionVisitor.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/ExpressionVisitor.java index 0b88dbe5463..7b8b6c0b180 100644 --- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/ExpressionVisitor.java +++ b/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 { 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(