azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[FE] Completely replace FunctionClassKind with FunctionalTypeKind

Browse Source 
FunctionalTypeKind can be used in FE 1.0 too, so there is no need to
  keep both classes. Also, removal of FunctionClassKind simplifies work
  with FunctionalTypeKind in common code, like Analysis Api
This commit is contained in:
Dmitriy Novozhilov
2023-01-20 14:54:33 +02:00
committed by Space Team
parent 87a9103cc6
commit 67aa80562d
38 changed files with 242 additions and 262 deletions
Download Patch File Download Diff File Expand all files Collapse all files
core/compiler.common.jvm/src/org/jetbrains/kotlin/builtins/jvm/JavaToKotlinClassMap.kt
+6 -6
View File
@@ -9,19 +9,19 @@ import org.jetbrains.kotlin.builtins.CompanionObjectMapping
import org.jetbrains.kotlin.builtins.StandardNames
import org.jetbrains.kotlin.builtins.StandardNames.FqNames
import org.jetbrains.kotlin.builtins.functions.BuiltInFunctionArity
import org.jetbrains.kotlin.builtins.functions.FunctionClassKind
import org.jetbrains.kotlin.builtins.functions.FunctionalTypeKind
import org.jetbrains.kotlin.name.*
import org.jetbrains.kotlin.resolve.jvm.JvmPrimitiveType
object JavaToKotlinClassMap {
private val NUMBERED_FUNCTION_PREFIX: String =
FunctionClassKind.Function.packageFqName.toString() + "." + FunctionClassKind.Function.classNamePrefix
FunctionalTypeKind.Function.packageFqName.toString() + "." + FunctionalTypeKind.Function.classNamePrefix
private val NUMBERED_K_FUNCTION_PREFIX: String =
FunctionClassKind.KFunction.packageFqName.toString() + "." + FunctionClassKind.KFunction.classNamePrefix
FunctionalTypeKind.KFunction.packageFqName.toString() + "." + FunctionalTypeKind.KFunction.classNamePrefix
private val NUMBERED_SUSPEND_FUNCTION_PREFIX: String =
FunctionClassKind.SuspendFunction.packageFqName.toString() + "." + FunctionClassKind.SuspendFunction.classNamePrefix
FunctionalTypeKind.SuspendFunction.packageFqName.toString() + "." + FunctionalTypeKind.SuspendFunction.classNamePrefix
private val NUMBERED_K_SUSPEND_FUNCTION_PREFIX: String =
FunctionClassKind.KSuspendFunction.packageFqName.toString() + "." + FunctionClassKind.KSuspendFunction.classNamePrefix
FunctionalTypeKind.KSuspendFunction.packageFqName.toString() + "." + FunctionalTypeKind.KSuspendFunction.classNamePrefix
private val FUNCTION_N_CLASS_ID: ClassId = ClassId.topLevel(FqName("kotlin.jvm.functions.FunctionN"))
val FUNCTION_N_FQ_NAME: FqName = FUNCTION_N_CLASS_ID.asSingleFqName()
@@ -97,7 +97,7 @@ object JavaToKotlinClassMap {
addKotlinToJava(FqName(NUMBERED_K_FUNCTION_PREFIX + i), K_FUNCTION_CLASS_ID)
}
for (i in 0 until BuiltInFunctionArity.BIG_ARITY - 1) {
val kSuspendFunction = FunctionClassKind.KSuspendFunction
val kSuspendFunction = FunctionalTypeKind.KSuspendFunction
val kSuspendFun = kSuspendFunction.packageFqName.toString() + "." + kSuspendFunction.classNamePrefix
addKotlinToJava(FqName(kSuspendFun + i), K_FUNCTION_CLASS_ID)
}
core/compiler.common/src/org/jetbrains/kotlin/builtins/StandardNames.kt
+4 -4
View File
@@ -6,7 +6,7 @@
package org.jetbrains.kotlin.builtins
import org.jetbrains.kotlin.builtins.StandardNames.FqNames.reflect
import org.jetbrains.kotlin.builtins.functions.FunctionClassKind
import org.jetbrains.kotlin.builtins.functions.FunctionalTypeKind
import org.jetbrains.kotlin.name.ClassId
import org.jetbrains.kotlin.name.FqName
import org.jetbrains.kotlin.name.FqNameUnsafe
@@ -252,7 +252,7 @@ object StandardNames {
@JvmStatic
fun getKFunctionFqName(parameterCount: Int): FqNameUnsafe {
return reflect(FunctionClassKind.KFunction.classNamePrefix + parameterCount)
return reflect(FunctionalTypeKind.KFunction.classNamePrefix + parameterCount)
}
@JvmStatic
@@ -263,7 +263,7 @@ object StandardNames {
@JvmStatic
fun getSuspendFunctionName(parameterCount: Int): String {
return FunctionClassKind.SuspendFunction.classNamePrefix + parameterCount
return FunctionalTypeKind.SuspendFunction.classNamePrefix + parameterCount
}
@JvmStatic
@@ -273,7 +273,7 @@ object StandardNames {
@JvmStatic
fun getKSuspendFunctionName(parameterCount: Int): FqNameUnsafe {
return reflect(FunctionClassKind.KSuspendFunction.classNamePrefix + parameterCount)
return reflect(FunctionalTypeKind.KSuspendFunction.classNamePrefix + parameterCount)
}
@JvmStatic
core/compiler.common/src/org/jetbrains/kotlin/builtins/functions/FunctionClassKind.kt
-62
View File
@@ -1,62 +0,0 @@
/*
* 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.StandardNames
import org.jetbrains.kotlin.name.FqName
import org.jetbrains.kotlin.name.Name
enum class FunctionClassKind(
val packageFqName: FqName,
val classNamePrefix: String,
val isSuspendType: Boolean,
val isReflectType: Boolean
) {
Function(StandardNames.BUILT_INS_PACKAGE_FQ_NAME, "Function", isSuspendType = false, isReflectType = false),
SuspendFunction(StandardNames.COROUTINES_PACKAGE_FQ_NAME, "SuspendFunction", isSuspendType = true, isReflectType = false),
KFunction(StandardNames.KOTLIN_REFLECT_FQ_NAME, "KFunction", isSuspendType = false, isReflectType = true),
KSuspendFunction(StandardNames.KOTLIN_REFLECT_FQ_NAME, "KSuspendFunction", isSuspendType = true, isReflectType = true);
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) }
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
fun hasArityAtTheEnd(prefix: String, className: String): Boolean {
return toInt(className.substring(prefix.length)) != null
}
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/compiler.common/src/org/jetbrains/kotlin/builtins/functions/FunctionalTypeKind.kt
+145
View File
@@ -0,0 +1,145 @@
/*
* Copyright 2010-2023 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.StandardNames
import org.jetbrains.kotlin.name.ClassId
import org.jetbrains.kotlin.name.FqName
import org.jetbrains.kotlin.name.Name
/**
* [FunctionalTypeKind] describes a family of various similar functional types (like kotlin.FunctionN)
* All types in the same family have corresponding shape of classId: [packageFqName].[classNamePrefix]N,
* where `N` is an arity of function
*
* Functional type kind may be either reflect type or non-reflect type
* Each non-reflect kind should have corresponding reflect kind and vice-versa (like `kotlin.FunctionN` and `kotlin.reflection.KFunctionN`)
*
* Classes for such functional types are synthetic and generated by compiler itself
* [annotationOnInvokeClassId] is a classId of annotation, which will be added to `invoke` function of generated
* functional interface. This argument is mandatory for non-standard functional kinds
*
* Assume we have `some.CustomFunctionN` and `some.KCustomFunctionN` families with [annotationOnInvokeClassId] = /some.Anno
* Classes for those kinds will look like this:
*
* interface CustomFunctionN<P1, P2, ..., PN, R> : kotlin.Function<R> {
* @some.Anno
* operator fun invoke(p1: P1, p2: P2, ..., pN: PN): R
* }
*
* interface KCustomFunctionN<P1, P2, ..., PN, R> : kotlin.reflect.KFunction<R>, some.CustomFunctionN<P1, P2, ..., PN, R> {
* @some.Anno
* override operator fun invoke(p1: P1, p2: P2, ..., pN: PN): R
* }
*
* Note that if you provide some new functional type kind it's your responsibility to handle all references to it in backend
* with [IrGenerationExtension] implementation
*/
abstract class FunctionalTypeKind internal constructor(
val packageFqName: FqName,
val classNamePrefix: String,
val isReflectType: Boolean,
val annotationOnInvokeClassId: ClassId?
) {
/*
* This constructor is needed to enforce not nullable [annotationOnInvokeClassId] for
* functional kinds provided by compiler plugins
*/
constructor(
packageFqName: FqName,
classNamePrefix: String,
annotationOnInvokeClassId: ClassId,
isReflectType: Boolean
) : this(packageFqName, classNamePrefix, isReflectType, annotationOnInvokeClassId)
/*
* Specifies how corresponding type will be rendered
* E.g. if `prefixForTypeRender = @Some` and type is `some.CustomFunction2<Int, String, Double>`,
* then type will be rendered as `@Some (Int, String) -> Double`
*/
open val prefixForTypeRender: String?
get() = null
/**
* @return corresponding non-reflect kind for reflect kind
* @return [this] if [isReflectType] is false
*
* Should be overridden for reflect kinds
*/
open fun nonReflectKind(): FunctionalTypeKind {
return if (isReflectType) error("Should be overridden explicitly") else this
}
/**
* @return corresponding reflect kind for non-reflect kind
* @return [this] if [isReflectType] is true
*
* Should be overridden for non reflect kinds
*/
open fun reflectKind(): FunctionalTypeKind {
return if (isReflectType) this else error("Should be overridden explicitly")
}
fun numberedClassName(arity: Int): Name = Name.identifier("$classNamePrefix$arity")
override fun toString(): String {
return "$packageFqName.${classNamePrefix}N"
}
// ------------------------------------------- Builtin functional kinds -------------------------------------------
object Function : FunctionalTypeKind(
StandardNames.BUILT_INS_PACKAGE_FQ_NAME,
"Function",
isReflectType = false,
annotationOnInvokeClassId = null
) {
override fun reflectKind(): FunctionalTypeKind = KFunction
}
object SuspendFunction : FunctionalTypeKind(
StandardNames.COROUTINES_PACKAGE_FQ_NAME,
"SuspendFunction",
isReflectType = false,
annotationOnInvokeClassId = null
) {
override val prefixForTypeRender: String
get() = "suspend"
override fun reflectKind(): FunctionalTypeKind = KSuspendFunction
}
object KFunction : FunctionalTypeKind(
StandardNames.KOTLIN_REFLECT_FQ_NAME,
"KFunction",
isReflectType = true,
annotationOnInvokeClassId = null
) {
override fun nonReflectKind(): FunctionalTypeKind = Function
}
object KSuspendFunction : FunctionalTypeKind(
StandardNames.KOTLIN_REFLECT_FQ_NAME,
"KSuspendFunction",
isReflectType = true,
annotationOnInvokeClassId = null
) {
override fun nonReflectKind(): FunctionalTypeKind = SuspendFunction
}
}
val FunctionalTypeKind.isBuiltin: Boolean
get() = when (this) {
FunctionalTypeKind.Function,
FunctionalTypeKind.SuspendFunction,
FunctionalTypeKind.KFunction,
FunctionalTypeKind.KSuspendFunction -> true
else -> false
}
val FunctionalTypeKind.isSuspendType: Boolean
get() = this == FunctionalTypeKind.SuspendFunction || this == FunctionalTypeKind.KSuspendFunction
core/compiler.common/src/org/jetbrains/kotlin/builtins/functions/FunctionalTypeKindExtractor.kt
+65
View File
@@ -0,0 +1,65 @@
/*
* Copyright 2010-2023 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.name.FqName
@RequiresOptIn
annotation class AllowedToUsedOnlyInK1
class FunctionalTypeKindExtractor(kinds: List<FunctionalTypeKind>) {
companion object {
/**
* This instance should be used only in:
* - FE 1.0, since it does not support custom functional kinds from plugins
* - places in FIR where session is not accessible by design (like in renderer of FIR elements)
*/
@JvmStatic
@AllowedToUsedOnlyInK1
val Default = FunctionalTypeKindExtractor(
listOf(
FunctionalTypeKind.Function,
FunctionalTypeKind.SuspendFunction,
FunctionalTypeKind.KFunction,
FunctionalTypeKind.KSuspendFunction,
)
)
}
private val knownKindsByPackageFqName = kinds.groupBy { it.packageFqName }
fun getFunctionalClassKind(packageFqName: FqName, className: String): FunctionalTypeKind? {
return getFunctionalClassKindWithArity(packageFqName, className)?.kind
}
fun getFunctionalClassKindWithArity(packageFqName: FqName, className: String): KindWithArity? {
val kinds = knownKindsByPackageFqName[packageFqName] ?: return null
for (kind in kinds) {
if (!className.startsWith(kind.classNamePrefix)) continue
val arity = toInt(className.substring(kind.classNamePrefix.length)) ?: continue
return KindWithArity(kind, arity)
}
return null
}
fun hasKindWithSpecificPackage(packageFqName: FqName): Boolean {
return packageFqName in knownKindsByPackageFqName
}
data class KindWithArity(val kind: FunctionalTypeKind, val arity: Int)
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/KotlinBuiltIns.java
+3 -3
View File
@@ -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.FunctionClassKind;
import org.jetbrains.kotlin.builtins.functions.FunctionalTypeKind;
import org.jetbrains.kotlin.descriptors.*;
import org.jetbrains.kotlin.descriptors.annotations.Annotations;
import org.jetbrains.kotlin.descriptors.deserialization.AdditionalClassPartsProvider;
@@ -33,8 +33,8 @@ import org.jetbrains.kotlin.types.checker.KotlinTypeChecker;
import java.util.*;
import static org.jetbrains.kotlin.builtins.StandardNames.*;
import static org.jetbrains.kotlin.builtins.PrimitiveType.*;
import static org.jetbrains.kotlin.builtins.StandardNames.*;
import static org.jetbrains.kotlin.resolve.DescriptorUtils.getFqName;
public abstract class KotlinBuiltIns {
@@ -315,7 +315,7 @@ public abstract class KotlinBuiltIns {
@NotNull
public ClassDescriptor getKSuspendFunction(int parameterCount) {
Name name = Name.identifier(FunctionClassKind.KSuspendFunction.getClassNamePrefix() + parameterCount);
Name name = Name.identifier(FunctionalTypeKind.KSuspendFunction.INSTANCE.getClassNamePrefix() + parameterCount);
return getBuiltInClassByFqName(COROUTINES_PACKAGE_FQ_NAME.child(name));
}
core/descriptors/src/org/jetbrains/kotlin/builtins/functionTypes.kt
+16 -14
View File
@@ -6,7 +6,9 @@
package org.jetbrains.kotlin.builtins
import org.jetbrains.kotlin.builtins.StandardNames.BUILT_INS_PACKAGE_NAME
import org.jetbrains.kotlin.builtins.functions.FunctionClassKind
import org.jetbrains.kotlin.builtins.functions.FunctionalTypeKind
import org.jetbrains.kotlin.builtins.functions.FunctionalTypeKindExtractor
import org.jetbrains.kotlin.builtins.functions.AllowedToUsedOnlyInK1
import org.jetbrains.kotlin.descriptors.ClassDescriptor
import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
import org.jetbrains.kotlin.descriptors.annotations.Annotations
@@ -24,7 +26,6 @@ import org.jetbrains.kotlin.types.typeUtil.replaceAnnotations
import org.jetbrains.kotlin.types.typeUtil.supertypes
import org.jetbrains.kotlin.utils.DFS
import org.jetbrains.kotlin.utils.addIfNotNull
import java.util.*
private fun KotlinType.isTypeOrSubtypeOf(predicate: (KotlinType) -> Boolean): Boolean =
predicate(this) ||
@@ -59,16 +60,16 @@ fun KotlinType.isFunctionTypeOrSubtype(predicate: (KotlinType) -> Boolean): Bool
isTypeOrSubtypeOf { it.isFunctionType && predicate(it) }
val KotlinType.isFunctionType: Boolean
get() = constructor.declarationDescriptor?.getFunctionalClassKind() == FunctionClassKind.Function
get() = constructor.declarationDescriptor?.getFunctionalClassKind() == FunctionalTypeKind.Function
val KotlinType.isKFunctionType: Boolean
get() = constructor.declarationDescriptor?.getFunctionalClassKind() == FunctionClassKind.KFunction
get() = constructor.declarationDescriptor?.getFunctionalClassKind() == FunctionalTypeKind.KFunction
val KotlinType.isSuspendFunctionType: Boolean
get() = constructor.declarationDescriptor?.getFunctionalClassKind() == FunctionClassKind.SuspendFunction
get() = constructor.declarationDescriptor?.getFunctionalClassKind() == FunctionalTypeKind.SuspendFunction
val KotlinType.isKSuspendFunctionType: Boolean
get() = constructor.declarationDescriptor?.getFunctionalClassKind() == FunctionClassKind.KSuspendFunction
get() = constructor.declarationDescriptor?.getFunctionalClassKind() == FunctionalTypeKind.KSuspendFunction
val KotlinType.isFunctionOrSuspendFunctionType: Boolean
get() = isFunctionType || isSuspendFunctionType
@@ -82,16 +83,16 @@ val KotlinType.isBuiltinFunctionalType: Boolean
val DeclarationDescriptor.isBuiltinFunctionalClassDescriptor: Boolean
get() {
val functionalClassKind = getFunctionalClassKind()
return functionalClassKind == FunctionClassKind.Function ||
functionalClassKind == FunctionClassKind.SuspendFunction
return functionalClassKind == FunctionalTypeKind.Function ||
functionalClassKind == FunctionalTypeKind.SuspendFunction
}
fun isBuiltinFunctionClass(classId: ClassId): Boolean {
if (!classId.startsWith(StandardNames.BUILT_INS_PACKAGE_NAME)) return false
val kind = classId.asSingleFqName().toUnsafe().getFunctionalClassKind()
return kind == FunctionClassKind.Function ||
kind == FunctionClassKind.SuspendFunction
return kind == FunctionalTypeKind.Function ||
kind == FunctionalTypeKind.SuspendFunction
}
val KotlinType.isNonExtensionFunctionType: Boolean
@@ -112,20 +113,21 @@ private val KotlinType.isTypeAnnotatedWithExtensionFunctionType: Boolean
*/
fun isNumberedFunctionClassFqName(fqName: FqNameUnsafe): Boolean {
return fqName.startsWith(BUILT_INS_PACKAGE_NAME) &&
fqName.getFunctionalClassKind() == FunctionClassKind.Function
fqName.getFunctionalClassKind() == FunctionalTypeKind.Function
}
fun DeclarationDescriptor.getFunctionalClassKind(): FunctionClassKind? {
fun DeclarationDescriptor.getFunctionalClassKind(): FunctionalTypeKind? {
if (this !is ClassDescriptor) return null
if (!KotlinBuiltIns.isUnderKotlinPackage(this)) return null
return fqNameUnsafe.getFunctionalClassKind()
}
private fun FqNameUnsafe.getFunctionalClassKind(): FunctionClassKind? {
@OptIn(AllowedToUsedOnlyInK1::class)
private fun FqNameUnsafe.getFunctionalClassKind(): FunctionalTypeKind? {
if (!isSafe || isRoot) return null
return FunctionClassKind.getFunctionalClassKind(shortName().asString(), toSafe().parent())
return FunctionalTypeKindExtractor.Default.getFunctionalClassKind(toSafe().parent(), shortName().asString())
}
fun KotlinType.contextFunctionTypeParamsCount(): Int {
core/descriptors/src/org/jetbrains/kotlin/builtins/functions/BuiltInFictitiousFunctionClassFactory.kt
+4 -2
View File
@@ -33,13 +33,15 @@ class BuiltInFictitiousFunctionClassFactory(
private val storageManager: StorageManager,
private val module: ModuleDescriptor
) : ClassDescriptorFactory {
@OptIn(AllowedToUsedOnlyInK1::class)
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
&& FunctionClassKind.parseClassName(string, packageFqName) != null
&& FunctionalTypeKindExtractor.Default.getFunctionalClassKindWithArity(packageFqName, string) != null
}
@OptIn(AllowedToUsedOnlyInK1::class)
override fun createClass(classId: ClassId): ClassDescriptor? {
if (classId.isLocal || classId.isNestedClass) return null
@@ -47,7 +49,7 @@ class BuiltInFictitiousFunctionClassFactory(
if ("Function" !in className) return null // An optimization
val packageFqName = classId.packageFqName
val (kind, arity) = FunctionClassKind.parseClassName(className, packageFqName) ?: return null
val (kind, arity) = FunctionalTypeKindExtractor.Default.getFunctionalClassKindWithArity(packageFqName, className) ?: return null
val builtInsFragments = module.getPackage(packageFqName).fragments.filterIsInstance<BuiltInsPackageFragment>()
core/descriptors/src/org/jetbrains/kotlin/builtins/functions/FunctionClassDescriptor.kt
+9 -7
View File
@@ -18,6 +18,7 @@ import org.jetbrains.kotlin.resolve.scopes.MemberScope
import org.jetbrains.kotlin.storage.StorageManager
import org.jetbrains.kotlin.types.*
import org.jetbrains.kotlin.types.checker.KotlinTypeRefiner
import org.jetbrains.kotlin.utils.addToStdlib.shouldNotBeCalled
/**
* A [ClassDescriptor] representing the fictitious class for a function type, such as kotlin.Function1 or kotlin.reflect.KFunction2.
@@ -30,7 +31,7 @@ import org.jetbrains.kotlin.types.checker.KotlinTypeRefiner
class FunctionClassDescriptor(
private val storageManager: StorageManager,
private val containingDeclaration: PackageFragmentDescriptor,
val functionKind: FunctionClassKind,
val functionKind: FunctionalTypeKind,
val arity: Int
) : AbstractClassDescriptor(storageManager, functionKind.numberedClassName(arity)) {
@@ -95,14 +96,15 @@ 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) {
FunctionClassKind.Function -> // Function$N <: Function
FunctionalTypeKind.Function -> // Function$N <: Function
listOf(functionClassId)
FunctionClassKind.KFunction -> // KFunction$N <: KFunction
listOf(kFunctionClassId, ClassId(BUILT_INS_PACKAGE_FQ_NAME, FunctionClassKind.Function.numberedClassName(arity)))
FunctionClassKind.SuspendFunction -> // SuspendFunction$N<...> <: Function
FunctionalTypeKind.KFunction -> // KFunction$N <: KFunction
listOf(kFunctionClassId, ClassId(BUILT_INS_PACKAGE_FQ_NAME, FunctionalTypeKind.Function.numberedClassName(arity)))
FunctionalTypeKind.SuspendFunction -> // SuspendFunction$N<...> <: Function
listOf(functionClassId)
FunctionClassKind.KSuspendFunction -> // KSuspendFunction$N<...> <: KFunction
listOf(kFunctionClassId, ClassId(COROUTINES_PACKAGE_FQ_NAME, FunctionClassKind.SuspendFunction.numberedClassName(arity)))
FunctionalTypeKind.KSuspendFunction -> // KSuspendFunction$N<...> <: KFunction
listOf(kFunctionClassId, ClassId(COROUTINES_PACKAGE_FQ_NAME, FunctionalTypeKind.SuspendFunction.numberedClassName(arity)))
else -> shouldNotBeCalled()
}
val moduleDescriptor = containingDeclaration.containingDeclaration
core/descriptors/src/org/jetbrains/kotlin/builtins/functions/FunctionClassScope.kt
+2 -2
View File
@@ -26,8 +26,8 @@ class FunctionClassScope(
) : GivenFunctionsMemberScope(storageManager, containingClass) {
override fun computeDeclaredFunctions(): List<FunctionDescriptor> =
when ((containingClass as FunctionClassDescriptor).functionKind) {
FunctionClassKind.Function -> listOf(FunctionInvokeDescriptor.create(containingClass, isSuspend = false))
FunctionClassKind.SuspendFunction -> listOf(FunctionInvokeDescriptor.create(containingClass, isSuspend = true))
FunctionalTypeKind.Function -> listOf(FunctionInvokeDescriptor.create(containingClass, isSuspend = false))
FunctionalTypeKind.SuspendFunction -> listOf(FunctionInvokeDescriptor.create(containingClass, isSuspend = true))
else -> emptyList()
}
}