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

[FIR] Consistently use _function_ instead of _functional_ in names of classes and functions

Browse Source
This commit is contained in:
Dmitriy Novozhilov
2023-01-26 13:35:07 +02:00
committed by Space Team
parent f268ab8858
commit 89c42e20c9
102 changed files with 573 additions and 574 deletions
Download Patch File Download Diff File Expand all files Collapse all files
core/descriptors/src/org/jetbrains/kotlin/builtins/KotlinBuiltIns.java
+2 -2
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.FunctionalTypeKind;
import org.jetbrains.kotlin.builtins.functions.FunctionTypeKind;
import org.jetbrains.kotlin.descriptors.*;
import org.jetbrains.kotlin.descriptors.annotations.Annotations;
import org.jetbrains.kotlin.descriptors.deserialization.AdditionalClassPartsProvider;
@@ -315,7 +315,7 @@ public abstract class KotlinBuiltIns {
@NotNull
public ClassDescriptor getKSuspendFunction(int parameterCount) {
Name name = Name.identifier(FunctionalTypeKind.KSuspendFunction.INSTANCE.getClassNamePrefix() + parameterCount);
Name name = Name.identifier(FunctionTypeKind.KSuspendFunction.INSTANCE.getClassNamePrefix() + parameterCount);
return getBuiltInClassByFqName(COROUTINES_PACKAGE_FQ_NAME.child(name));
}
core/descriptors/src/org/jetbrains/kotlin/builtins/functionTypes.kt
+19 -19
View File
@@ -6,8 +6,8 @@
package org.jetbrains.kotlin.builtins
import org.jetbrains.kotlin.builtins.StandardNames.BUILT_INS_PACKAGE_NAME
import org.jetbrains.kotlin.builtins.functions.FunctionalTypeKind
import org.jetbrains.kotlin.builtins.functions.FunctionalTypeKindExtractor
import org.jetbrains.kotlin.builtins.functions.FunctionTypeKind
import org.jetbrains.kotlin.builtins.functions.FunctionTypeKindExtractor
import org.jetbrains.kotlin.builtins.functions.AllowedToUsedOnlyInK1
import org.jetbrains.kotlin.descriptors.ClassDescriptor
import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
@@ -59,20 +59,20 @@ val KotlinType.isBuiltinFunctionalTypeOrSubtype: Boolean
fun KotlinType.isFunctionTypeOrSubtype(predicate: (KotlinType) -> Boolean): Boolean =
isTypeOrSubtypeOf { it.isFunctionType && predicate(it) }
val KotlinType.functionalTypeKind: FunctionalTypeKind?
get() = constructor.declarationDescriptor?.getFunctionalClassKind()
val KotlinType.functionTypeKind: FunctionTypeKind?
get() = constructor.declarationDescriptor?.getFunctionTypeKind()
val KotlinType.isFunctionType: Boolean
get() = functionalTypeKind == FunctionalTypeKind.Function
get() = functionTypeKind == FunctionTypeKind.Function
val KotlinType.isKFunctionType: Boolean
get() = functionalTypeKind == FunctionalTypeKind.KFunction
get() = functionTypeKind == FunctionTypeKind.KFunction
val KotlinType.isSuspendFunctionType: Boolean
get() = functionalTypeKind == FunctionalTypeKind.SuspendFunction
get() = functionTypeKind == FunctionTypeKind.SuspendFunction
val KotlinType.isKSuspendFunctionType: Boolean
get() = functionalTypeKind == FunctionalTypeKind.KSuspendFunction
get() = functionTypeKind == FunctionTypeKind.KSuspendFunction
val KotlinType.isFunctionOrSuspendFunctionType: Boolean
get() = isFunctionType || isSuspendFunctionType
@@ -85,17 +85,17 @@ val KotlinType.isBuiltinFunctionalType: Boolean
val DeclarationDescriptor.isBuiltinFunctionalClassDescriptor: Boolean
get() {
val functionalClassKind = getFunctionalClassKind()
return functionalClassKind == FunctionalTypeKind.Function ||
functionalClassKind == FunctionalTypeKind.SuspendFunction
val functionalClassKind = getFunctionTypeKind()
return functionalClassKind == FunctionTypeKind.Function ||
functionalClassKind == FunctionTypeKind.SuspendFunction
}
fun isBuiltinFunctionClass(classId: ClassId): Boolean {
if (!classId.startsWith(StandardNames.BUILT_INS_PACKAGE_NAME)) return false
val kind = classId.asSingleFqName().toUnsafe().getFunctionalClassKind()
return kind == FunctionalTypeKind.Function ||
kind == FunctionalTypeKind.SuspendFunction
val kind = classId.asSingleFqName().toUnsafe().getFunctionTypeKind()
return kind == FunctionTypeKind.Function ||
kind == FunctionTypeKind.SuspendFunction
}
val KotlinType.isNonExtensionFunctionType: Boolean
@@ -116,21 +116,21 @@ private val KotlinType.isTypeAnnotatedWithExtensionFunctionType: Boolean
*/
fun isNumberedFunctionClassFqName(fqName: FqNameUnsafe): Boolean {
return fqName.startsWith(BUILT_INS_PACKAGE_NAME) &&
fqName.getFunctionalClassKind() == FunctionalTypeKind.Function
fqName.getFunctionTypeKind() == FunctionTypeKind.Function
}
fun DeclarationDescriptor.getFunctionalClassKind(): FunctionalTypeKind? {
fun DeclarationDescriptor.getFunctionTypeKind(): FunctionTypeKind? {
if (this !is ClassDescriptor) return null
if (!KotlinBuiltIns.isUnderKotlinPackage(this)) return null
return fqNameUnsafe.getFunctionalClassKind()
return fqNameUnsafe.getFunctionTypeKind()
}
@OptIn(AllowedToUsedOnlyInK1::class)
private fun FqNameUnsafe.getFunctionalClassKind(): FunctionalTypeKind? {
private fun FqNameUnsafe.getFunctionTypeKind(): FunctionTypeKind? {
if (!isSafe || isRoot) return null
return FunctionalTypeKindExtractor.Default.getFunctionalClassKind(toSafe().parent(), shortName().asString())
return FunctionTypeKindExtractor.Default.getFunctionalClassKind(toSafe().parent(), shortName().asString())
}
fun KotlinType.contextFunctionTypeParamsCount(): Int {
core/descriptors/src/org/jetbrains/kotlin/builtins/functions/BuiltInFictitiousFunctionClassFactory.kt
+2 -2
View File
@@ -38,7 +38,7 @@ class BuiltInFictitiousFunctionClassFactory(
val string = name.asString()
return (string.startsWith("Function") || string.startsWith("KFunction") ||
string.startsWith("SuspendFunction") || string.startsWith("KSuspendFunction")) // an optimization
&& FunctionalTypeKindExtractor.Default.getFunctionalClassKindWithArity(packageFqName, string) != null
&& FunctionTypeKindExtractor.Default.getFunctionalClassKindWithArity(packageFqName, string) != null
}
@OptIn(AllowedToUsedOnlyInK1::class)
@@ -49,7 +49,7 @@ class BuiltInFictitiousFunctionClassFactory(
if ("Function" !in className) return null // An optimization
val packageFqName = classId.packageFqName
val (kind, arity) = FunctionalTypeKindExtractor.Default.getFunctionalClassKindWithArity(packageFqName, className) ?: return null
val (kind, arity) = FunctionTypeKindExtractor.Default.getFunctionalClassKindWithArity(packageFqName, className) ?: return null
val builtInsFragments = module.getPackage(packageFqName).fragments.filterIsInstance<BuiltInsPackageFragment>()
core/descriptors/src/org/jetbrains/kotlin/builtins/functions/FunctionClassDescriptor.kt
+10 -10
View File
@@ -29,10 +29,10 @@ import org.jetbrains.kotlin.utils.addToStdlib.shouldNotBeCalled
* This allows to use both 'invoke' and reflection API on function references obtained by '::'.
*/
class FunctionClassDescriptor(
private val storageManager: StorageManager,
private val containingDeclaration: PackageFragmentDescriptor,
val functionKind: FunctionalTypeKind,
val arity: Int
private val storageManager: StorageManager,
private val containingDeclaration: PackageFragmentDescriptor,
val functionKind: FunctionTypeKind,
val arity: Int
) : AbstractClassDescriptor(storageManager, functionKind.numberedClassName(arity)) {
private val typeConstructor = FunctionTypeConstructor()
@@ -96,14 +96,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) {
FunctionalTypeKind.Function -> // Function$N <: Function
FunctionTypeKind.Function -> // Function$N <: Function
listOf(functionClassId)
FunctionalTypeKind.KFunction -> // KFunction$N <: KFunction
listOf(kFunctionClassId, ClassId(BUILT_INS_PACKAGE_FQ_NAME, FunctionalTypeKind.Function.numberedClassName(arity)))
FunctionalTypeKind.SuspendFunction -> // SuspendFunction$N<...> <: Function
FunctionTypeKind.KFunction -> // KFunction$N <: KFunction
listOf(kFunctionClassId, ClassId(BUILT_INS_PACKAGE_FQ_NAME, FunctionTypeKind.Function.numberedClassName(arity)))
FunctionTypeKind.SuspendFunction -> // SuspendFunction$N<...> <: Function
listOf(functionClassId)
FunctionalTypeKind.KSuspendFunction -> // KSuspendFunction$N<...> <: KFunction
listOf(kFunctionClassId, ClassId(COROUTINES_PACKAGE_FQ_NAME, FunctionalTypeKind.SuspendFunction.numberedClassName(arity)))
FunctionTypeKind.KSuspendFunction -> // KSuspendFunction$N<...> <: KFunction
listOf(kFunctionClassId, ClassId(COROUTINES_PACKAGE_FQ_NAME, FunctionTypeKind.SuspendFunction.numberedClassName(arity)))
else -> shouldNotBeCalled()
}
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) {
FunctionalTypeKind.Function -> listOf(FunctionInvokeDescriptor.create(containingClass, isSuspend = false))
FunctionalTypeKind.SuspendFunction -> listOf(FunctionInvokeDescriptor.create(containingClass, isSuspend = true))
FunctionTypeKind.Function -> listOf(FunctionInvokeDescriptor.create(containingClass, isSuspend = false))
FunctionTypeKind.SuspendFunction -> listOf(FunctionInvokeDescriptor.create(containingClass, isSuspend = true))
else -> emptyList()
}
}
core/descriptors/src/org/jetbrains/kotlin/types/checker/ClassicTypeSystemContext.kt
+10 -10
View File
@@ -7,7 +7,7 @@ package org.jetbrains.kotlin.types.checker
import org.jetbrains.kotlin.builtins.*
import org.jetbrains.kotlin.builtins.StandardNames.FqNames
import org.jetbrains.kotlin.builtins.functions.FunctionalTypeKind
import org.jetbrains.kotlin.builtins.functions.FunctionTypeKind
import org.jetbrains.kotlin.descriptors.*
import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor
import org.jetbrains.kotlin.descriptors.annotations.Annotations
@@ -411,7 +411,7 @@ interface ClassicTypeSystemContext : TypeSystemInferenceExtensionContext, TypeSy
return KotlinBuiltIns.isUnit(this)
}
override fun KotlinTypeMarker.isBuiltinFunctionalTypeOrSubtype(): Boolean {
override fun KotlinTypeMarker.isBuiltinFunctionTypeOrSubtype(): Boolean {
require(this is UnwrappedType, this::errorMessage)
return isBuiltinFunctionalTypeOrSubtype
}
@@ -855,34 +855,34 @@ interface ClassicTypeSystemContext : TypeSystemInferenceExtensionContext, TypeSy
return this.isBuiltinExtensionFunctionalType
}
override fun KotlinTypeMarker.extractArgumentsForFunctionalTypeOrSubtype(): List<KotlinTypeMarker> {
override fun KotlinTypeMarker.extractArgumentsForFunctionTypeOrSubtype(): List<KotlinTypeMarker> {
require(this is KotlinType, this::errorMessage)
return this.getPureArgumentsForFunctionalTypeOrSubtype()
}
override fun KotlinTypeMarker.getFunctionalTypeFromSupertypes(): KotlinTypeMarker {
override fun KotlinTypeMarker.getFunctionTypeFromSupertypes(): KotlinTypeMarker {
require(this is KotlinType)
return this.extractFunctionalTypeFromSupertypes()
}
override fun KotlinTypeMarker.functionalTypeKind(): FunctionalTypeKind? {
override fun KotlinTypeMarker.functionTypeKind(): FunctionTypeKind? {
require(this is KotlinType)
return this.functionalTypeKind
return this.functionTypeKind
}
override fun getNonReflectFunctionTypeConstructor(parametersNumber: Int, kind: FunctionalTypeKind): TypeConstructorMarker {
override fun getNonReflectFunctionTypeConstructor(parametersNumber: Int, kind: FunctionTypeKind): TypeConstructorMarker {
return getFunctionDescriptor(
builtIns,
parametersNumber,
isSuspendFunction = kind.nonReflectKind() == FunctionalTypeKind.SuspendFunction
isSuspendFunction = kind.nonReflectKind() == FunctionTypeKind.SuspendFunction
).typeConstructor
}
override fun getReflectFunctionTypeConstructor(parametersNumber: Int, kind: FunctionalTypeKind): TypeConstructorMarker {
override fun getReflectFunctionTypeConstructor(parametersNumber: Int, kind: FunctionTypeKind): TypeConstructorMarker {
return getKFunctionDescriptor(
builtIns,
parametersNumber,
isSuspendFunction = kind.reflectKind() == FunctionalTypeKind.KSuspendFunction
isSuspendFunction = kind.reflectKind() == FunctionTypeKind.KSuspendFunction
).typeConstructor
}