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
compiler/fir/providers/src/org/jetbrains/kotlin/fir/resolve/providers/impl/FirExtensionSyntheticFunctionalInterfaceProvider.kt
+9 -8
View File
@@ -5,6 +5,9 @@
package org.jetbrains.kotlin.fir.resolve.providers.impl
import org.jetbrains.kotlin.builtins.functions.FunctionalTypeKind
import org.jetbrains.kotlin.builtins.functions.isBuiltin
import org.jetbrains.kotlin.builtins.functions.isSuspendType
import org.jetbrains.kotlin.descriptors.ClassKind
import org.jetbrains.kotlin.descriptors.EffectiveVisibility
import org.jetbrains.kotlin.descriptors.Modality
@@ -43,7 +46,7 @@ class FirExtensionSyntheticFunctionalInterfaceProvider(
moduleData: FirModuleData,
kotlinScopeProvider: FirKotlinScopeProvider
) : FirSyntheticFunctionalInterfaceProviderBase(session, moduleData, kotlinScopeProvider) {
override fun ConeFunctionalTypeKind.isAcceptable(): Boolean {
override fun FunctionalTypeKind.isAcceptable(): Boolean {
return !this.isBuiltin
}
}
@@ -56,7 +59,7 @@ class FirBuiltinSyntheticFunctionalInterfaceProvider(
moduleData: FirModuleData,
kotlinScopeProvider: FirKotlinScopeProvider
) : FirSyntheticFunctionalInterfaceProviderBase(session, moduleData, kotlinScopeProvider) {
override fun ConeFunctionalTypeKind.isAcceptable(): Boolean {
override fun FunctionalTypeKind.isAcceptable(): Boolean {
return this.isBuiltin
}
}
@@ -100,7 +103,7 @@ abstract class FirSyntheticFunctionalInterfaceProviderBase(
private val cache = moduleData.session.firCachesFactory.createCache(::createSyntheticFunctionalInterface)
protected abstract fun ConeFunctionalTypeKind.isAcceptable(): Boolean
protected abstract fun FunctionalTypeKind.isAcceptable(): Boolean
private fun createSyntheticFunctionalInterface(classId: ClassId): FirRegularClassSymbol? {
return with(classId) {
@@ -172,15 +175,13 @@ abstract class FirSyntheticFunctionalInterfaceProviderBase(
isInline = false
isTailRec = false
isExternal = false
isSuspend =
kind == ConeFunctionalTypeKind.SuspendFunction ||
kind == ConeFunctionalTypeKind.KSuspendFunction
isSuspend = kind.isSuspendType
}
val typeArguments = typeParameters.map {
ConeTypeParameterTypeImpl(it.symbol.toLookupTag(), false).toFirResolvedTypeRef()
}
fun createSuperType(kind: ConeFunctionalTypeKind): FirResolvedTypeRef {
fun createSuperType(kind: FunctionalTypeKind): FirResolvedTypeRef {
return kind.classId(arity).toLookupTag()
.constructClassType(typeArguments.map { it.type }.toTypedArray(), isNullable = false)
.toFirResolvedTypeRef()
@@ -241,5 +242,5 @@ abstract class FirSyntheticFunctionalInterfaceProviderBase(
}
}
private fun ConeFunctionalTypeKind.classId(arity: Int) = ClassId(packageFqName, numberedClassName(arity))
private fun FunctionalTypeKind.classId(arity: Int) = ClassId(packageFqName, numberedClassName(arity))
}
compiler/fir/providers/src/org/jetbrains/kotlin/fir/types/FirFunctionalTypeKindServiceImpl.kt
+25 -36
View File
@@ -5,50 +5,39 @@
package org.jetbrains.kotlin.fir.types
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.fir.FirSession
import org.jetbrains.kotlin.fir.extensions.FirFunctionalTypeKindExtension
import org.jetbrains.kotlin.fir.extensions.extensionService
import org.jetbrains.kotlin.fir.extensions.functionalTypeKindExtensions
import org.jetbrains.kotlin.name.FqName
class FirFunctionalTypeKindServiceImpl(session: FirSession) : FirFunctionalTypeKindService() {
private val knownKindsByPackageFqName = buildList {
add(ConeFunctionalTypeKind.Function)
add(ConeFunctionalTypeKind.SuspendFunction)
add(ConeFunctionalTypeKind.KFunction)
add(ConeFunctionalTypeKind.KSuspendFunction)
override val extractor: FunctionalTypeKindExtractor = run {
val kinds = buildList {
add(FunctionalTypeKind.Function)
add(FunctionalTypeKind.SuspendFunction)
add(FunctionalTypeKind.KFunction)
add(FunctionalTypeKind.KSuspendFunction)
val registrar = object : FirFunctionalTypeKindExtension.FunctionalTypeKindRegistrar {
override fun registerKind(nonReflectKind: ConeFunctionalTypeKind, reflectKind: ConeFunctionalTypeKind) {
require(nonReflectKind.reflectKind() == reflectKind)
require(reflectKind.nonReflectKind() == nonReflectKind)
add(nonReflectKind)
add(reflectKind)
val registrar = object : FirFunctionalTypeKindExtension.FunctionalTypeKindRegistrar {
override fun registerKind(nonReflectKind: FunctionalTypeKind, reflectKind: FunctionalTypeKind) {
require(nonReflectKind.reflectKind() == reflectKind)
require(reflectKind.nonReflectKind() == nonReflectKind)
add(nonReflectKind)
add(reflectKind)
}
}
for (extension in session.extensionService.functionalTypeKindExtensions) {
with(extension) { registrar.registerKinds() }
}
}.also { kinds ->
val allNames = kinds.map { "${it.packageFqName}.${it.classNamePrefix}" }
require(allNames.distinct() == allNames) {
"There are clashing functional type kinds: $allNames"
}
}
for (extension in session.extensionService.functionalTypeKindExtensions) {
with(extension) { registrar.registerKinds() }
}
}.also { kinds ->
val allNames = kinds.map { "${it.packageFqName}.${it.classNamePrefix}" }
require(allNames.distinct() == allNames) {
"There are clashing functional type kinds: $allNames"
}
}.groupBy { it.packageFqName }
override fun getKindByClassNamePrefix(packageFqName: FqName, className: String): ConeFunctionalTypeKind? {
val kinds = knownKindsByPackageFqName[packageFqName] ?: return null
for (kind in kinds) {
if (!className.startsWith(kind.classNamePrefix)) continue
if (!FunctionClassKind.hasArityAtTheEnd(kind.classNamePrefix, className)) continue
return kind
}
return null
}
override fun hasKindWithSpecificPackage(packageFqName: FqName): Boolean {
return packageFqName in knownKindsByPackageFqName
FunctionalTypeKindExtractor(kinds)
}
}
compiler/fir/providers/src/org/jetbrains/kotlin/fir/types/FunctionalTypeUtils.kt
+11 -10
View File
@@ -5,6 +5,7 @@
package org.jetbrains.kotlin.fir.types
import org.jetbrains.kotlin.builtins.functions.FunctionalTypeKind
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.declarations.FirClass
import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
@@ -27,12 +28,12 @@ import org.jetbrains.kotlin.utils.addToStdlib.runUnless
// ---------------------------------------------- is type is a functional type ----------------------------------------------
fun ConeKotlinType.functionalTypeKind(session: FirSession): ConeFunctionalTypeKind? {
fun ConeKotlinType.functionalTypeKind(session: FirSession): FunctionalTypeKind? {
if (this !is ConeClassLikeType) return null
return fullyExpandedType(session).lookupTag.functionalTypeKind(session)
}
private fun ConeClassLikeLookupTag.functionalTypeKind(session: FirSession): ConeFunctionalTypeKind? {
private fun ConeClassLikeLookupTag.functionalTypeKind(session: FirSession): FunctionalTypeKind? {
val classId = classId
return session.functionalTypeService.getKindByClassNamePrefix(classId.packageFqName, classId.shortClassName.asString())
}
@@ -40,7 +41,7 @@ private fun ConeClassLikeLookupTag.functionalTypeKind(session: FirSession): Cone
private inline fun ConeKotlinType.isFunctionalTypeWithPredicate(
session: FirSession,
errorOnNotFunctionalType: Boolean = false,
predicate: (ConeFunctionalTypeKind) -> Boolean
predicate: (FunctionalTypeKind) -> Boolean
): Boolean {
val kind = functionalTypeKind(session)
?: if (errorOnNotFunctionalType) error("$this is not a functional type") else return false
@@ -49,7 +50,7 @@ private inline fun ConeKotlinType.isFunctionalTypeWithPredicate(
// Function
fun ConeKotlinType.isSimpleFunctionType(session: FirSession): Boolean {
return isFunctionalTypeWithPredicate(session) { it == ConeFunctionalTypeKind.Function }
return isFunctionalTypeWithPredicate(session) { it == FunctionalTypeKind.Function }
}
// Function, SuspendFunction, [Custom]Function
@@ -60,7 +61,7 @@ fun ConeKotlinType.isNonReflectFunctionalType(session: FirSession): Boolean {
// SuspendFunction, KSuspendFunction
fun ConeKotlinType.isSuspendFunctionType(session: FirSession): Boolean {
return isFunctionalTypeWithPredicate(session) {
it == ConeFunctionalTypeKind.SuspendFunction || it == ConeFunctionalTypeKind.KSuspendFunction
it == FunctionalTypeKind.SuspendFunction || it == FunctionalTypeKind.KSuspendFunction
}
}
@@ -82,7 +83,7 @@ fun ConeClassLikeLookupTag.isSomeFunctionalType(session: FirSession): Boolean {
// Function, KFunction
private fun ConeKotlinType.isSimpleFunctionalType(session: FirSession, errorOnNotFunctionalType: Boolean): Boolean {
return isFunctionalTypeWithPredicate(session, errorOnNotFunctionalType) {
it == ConeFunctionalTypeKind.Function || it == ConeFunctionalTypeKind.KFunction
it == FunctionalTypeKind.Function || it == FunctionalTypeKind.KFunction
}
}
@@ -99,11 +100,11 @@ private fun ConeKotlinType.isNotSimpleFunctionalType(session: FirSession): Boole
*/
fun ConeKotlinType.customFunctionalTypeToSimpleFunctionalType(session: FirSession): ConeClassLikeType {
val kind = functionalTypeKind(session)
require(kind != null && kind != ConeFunctionalTypeKind.Function && kind != ConeFunctionalTypeKind.KFunction)
require(kind != null && kind != FunctionalTypeKind.Function && kind != FunctionalTypeKind.KFunction)
val newKind = if (kind.isReflectType) {
ConeFunctionalTypeKind.KFunction
FunctionalTypeKind.KFunction
} else {
ConeFunctionalTypeKind.Function
FunctionalTypeKind.Function
}
return createFunctionalTypeWithNewKind(newKind)
}
@@ -119,7 +120,7 @@ fun ConeKotlinType.reflectFunctionalTypeToNonReflectFunctionalType(session: FirS
return createFunctionalTypeWithNewKind(kind.nonReflectKind())
}
private fun ConeKotlinType.createFunctionalTypeWithNewKind(kind: ConeFunctionalTypeKind): ConeClassLikeType {
private fun ConeKotlinType.createFunctionalTypeWithNewKind(kind: FunctionalTypeKind): ConeClassLikeType {
val functionalTypeId = ClassId(kind.packageFqName, kind.numberedClassName(typeArguments.size - 1))
return functionalTypeId.toLookupTag().constructClassType(typeArguments, isNullable = false, attributes = attributes)
}