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/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()
}
}