diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10TypeInfoProvider.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10TypeInfoProvider.kt index 17db196fa26..e717b3ddd21 100644 --- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10TypeInfoProvider.kt +++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10TypeInfoProvider.kt @@ -12,8 +12,8 @@ import org.jetbrains.kotlin.analysis.api.descriptors.types.base.KtFe10Type import org.jetbrains.kotlin.analysis.api.lifetime.KtLifetimeToken import org.jetbrains.kotlin.analysis.api.types.KtType import org.jetbrains.kotlin.builtins.KotlinBuiltIns -import org.jetbrains.kotlin.builtins.functions.FunctionalTypeKind -import org.jetbrains.kotlin.builtins.getFunctionalClassKind +import org.jetbrains.kotlin.builtins.functions.FunctionTypeKind +import org.jetbrains.kotlin.builtins.getFunctionTypeKind import org.jetbrains.kotlin.load.java.sam.JavaSingleAbstractMethodUtils import org.jetbrains.kotlin.name.SpecialNames import org.jetbrains.kotlin.types.DefinitelyNotNullType @@ -31,9 +31,9 @@ internal class KtFe10TypeInfoProvider( return JavaSingleAbstractMethodUtils.isSamType(type.fe10Type) } - override fun getFunctionClassKind(type: KtType): FunctionalTypeKind? { + override fun getFunctionClassKind(type: KtType): FunctionTypeKind? { require(type is KtFe10Type) - return type.fe10Type.constructor.declarationDescriptor?.getFunctionalClassKind() + return type.fe10Type.constructor.declarationDescriptor?.getFunctionTypeKind() } override fun canBeNull(type: KtType): Boolean { diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/KtFe10FunctionalType.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/KtFe10FunctionalType.kt index c8307969f30..93bd3333176 100644 --- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/KtFe10FunctionalType.kt +++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/KtFe10FunctionalType.kt @@ -26,8 +26,7 @@ import org.jetbrains.kotlin.analysis.api.types.KtType import org.jetbrains.kotlin.analysis.api.types.KtTypeNullability import org.jetbrains.kotlin.builtins.* import org.jetbrains.kotlin.builtins.functions.FunctionClassDescriptor -import org.jetbrains.kotlin.builtins.functions.FunctionalTypeKind -import org.jetbrains.kotlin.builtins.functions.isSuspendType +import org.jetbrains.kotlin.builtins.functions.isSuspendOrKSuspendFunction import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.types.SimpleType @@ -53,7 +52,7 @@ internal class KtFe10FunctionalType( } override val isSuspend: Boolean - get() = withValidityAssertion { descriptor.functionKind.isSuspendType } + get() = withValidityAssertion { descriptor.functionKind.isSuspendOrKSuspendFunction } override val isReflectType: Boolean get() = withValidityAssertion { descriptor.functionKind.isReflectType } diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/utils/KtFe10TypeSystemCommonBackendContextForTypeMapping.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/utils/KtFe10TypeSystemCommonBackendContextForTypeMapping.kt index 3ec640697fa..4f7c0c74e29 100644 --- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/utils/KtFe10TypeSystemCommonBackendContextForTypeMapping.kt +++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/utils/KtFe10TypeSystemCommonBackendContextForTypeMapping.kt @@ -8,7 +8,7 @@ package org.jetbrains.kotlin.analysis.api.descriptors.utils import org.jetbrains.kotlin.builtins.FAKE_CONTINUATION_CLASS_DESCRIPTOR import org.jetbrains.kotlin.builtins.KotlinBuiltIns import org.jetbrains.kotlin.builtins.functions.FunctionClassDescriptor -import org.jetbrains.kotlin.builtins.functions.isSuspendType +import org.jetbrains.kotlin.builtins.functions.isSuspendOrKSuspendFunction import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.incremental.components.NoLookupLocation import org.jetbrains.kotlin.name.StandardClassIds @@ -61,7 +61,7 @@ internal class KtFe10TypeSystemCommonBackendContextForTypeMapping( override fun SimpleTypeMarker.isSuspendFunction(): Boolean { require(this is SimpleType) val declaration = constructor.declarationDescriptor - return declaration is FunctionClassDescriptor && declaration.functionKind.isSuspendType + return declaration is FunctionClassDescriptor && declaration.functionKind.isSuspendOrKSuspendFunction } override fun SimpleTypeMarker.isKClass(): Boolean { diff --git a/analysis/analysis-api-fir/analysis-api-fir-generator/src/org/jetbrains/kotlin/analysis/api/fir/generator/HLDiagnosticConverter.kt b/analysis/analysis-api-fir/analysis-api-fir-generator/src/org/jetbrains/kotlin/analysis/api/fir/generator/HLDiagnosticConverter.kt index d4f1120c460..1112bed8ff1 100644 --- a/analysis/analysis-api-fir/analysis-api-fir-generator/src/org/jetbrains/kotlin/analysis/api/fir/generator/HLDiagnosticConverter.kt +++ b/analysis/analysis-api-fir/analysis-api-fir-generator/src/org/jetbrains/kotlin/analysis/api/fir/generator/HLDiagnosticConverter.kt @@ -9,7 +9,7 @@ import com.intellij.psi.PsiElement import org.jetbrains.kotlin.KtSourceElement import org.jetbrains.kotlin.analysis.api.symbols.* import org.jetbrains.kotlin.analysis.api.types.KtType -import org.jetbrains.kotlin.builtins.functions.FunctionalTypeKind +import org.jetbrains.kotlin.builtins.functions.FunctionTypeKind import org.jetbrains.kotlin.config.ApiVersion import org.jetbrains.kotlin.config.LanguageFeature import org.jetbrains.kotlin.config.LanguageVersionSettings @@ -366,7 +366,7 @@ internal object FirToKtConversionCreator { ApiVersion::class, CallableId::class, ClassKind::class, - FunctionalTypeKind::class, + FunctionTypeKind::class, ) private val KType.kClass: KClass<*> diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/KtSymbolByFirBuilder.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/KtSymbolByFirBuilder.kt index 3c2464b9f7d..df34bff715b 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/KtSymbolByFirBuilder.kt +++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/KtSymbolByFirBuilder.kt @@ -487,7 +487,7 @@ internal class KtSymbolByFirBuilder constructor( } private fun hasFunctionalClassId(coneType: ConeClassLikeTypeImpl): Boolean { - return coneType.isSomeFunctionalType(analysisSession.firResolveSession.useSiteFirSession) + return coneType.isSomeFunctionType(analysisSession.firResolveSession.useSiteFirSession) } fun buildKtType(coneType: FirTypeRef): KtType { diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirExpressionTypeProvider.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirExpressionTypeProvider.kt index 98fe53d902e..81b45c80513 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirExpressionTypeProvider.kt +++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirExpressionTypeProvider.kt @@ -22,7 +22,7 @@ import org.jetbrains.kotlin.fir.expressions.* import org.jetbrains.kotlin.fir.references.FirNamedReference import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference import org.jetbrains.kotlin.fir.references.FirSuperReference -import org.jetbrains.kotlin.fir.resolve.constructFunctionalType +import org.jetbrains.kotlin.fir.resolve.constructFunctionType import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.lexer.KtTokens @@ -113,7 +113,7 @@ internal class KtFirExpressionTypeProvider( declaration.toFirAnonymousFunction() else declaration.getOrBuildFirOfType(firResolveSession) - return firFunction.constructFunctionalType(firFunction.specialFunctionalTypeKind(firResolveSession.useSiteFirSession)).asKtType() + return firFunction.constructFunctionType(firFunction.specialFunctionTypeKind(firResolveSession.useSiteFirSession)).asKtType() } @OptIn(ExperimentalContracts::class) diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirTypeInfoProvider.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirTypeInfoProvider.kt index 6a9ddebf2f0..49558f0d314 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirTypeInfoProvider.kt +++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirTypeInfoProvider.kt @@ -11,7 +11,7 @@ import org.jetbrains.kotlin.analysis.api.fir.types.KtFirType import org.jetbrains.kotlin.analysis.api.fir.types.PublicTypeApproximator import org.jetbrains.kotlin.analysis.api.lifetime.KtLifetimeToken import org.jetbrains.kotlin.analysis.api.types.KtType -import org.jetbrains.kotlin.builtins.functions.FunctionalTypeKind +import org.jetbrains.kotlin.builtins.functions.FunctionTypeKind import org.jetbrains.kotlin.fir.resolve.FirSamResolver import org.jetbrains.kotlin.fir.resolve.fullyExpandedType import org.jetbrains.kotlin.fir.types.* @@ -31,9 +31,10 @@ internal class KtFirTypeInfoProvider( return samResolver.isSamType(coneType) } - override fun getFunctionClassKind(type: KtType): FunctionalTypeKind? { - return (type as KtFirType).coneType.functionalTypeKind(analysisSession.useSiteSession) + override fun getFunctionClassKind(type: KtType): FunctionTypeKind? { + return (type as KtFirType).coneType.functionTypeKind(analysisSession.useSiteSession) } + override fun canBeNull(type: KtType): Boolean = (type as KtFirType).coneType.canBeNull override fun isDenotable(type: KtType): Boolean { diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDataClassConverters.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDataClassConverters.kt index e5a396c7585..5c46ebc92f8 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDataClassConverters.kt +++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDataClassConverters.kt @@ -1814,10 +1814,10 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert token, ) } - add(FirErrors.AMBIGUOUS_FUNCTIONAL_TYPE_KIND) { firDiagnostic -> - AmbiguousFunctionalTypeKindImpl( - firDiagnostic.a.map { functionalTypeKind -> - functionalTypeKind + add(FirErrors.AMBIGUOUS_FUNCTION_TYPE_KIND) { firDiagnostic -> + AmbiguousFunctionTypeKindImpl( + firDiagnostic.a.map { functionTypeKind -> + functionTypeKind }, firDiagnostic as KtPsiDiagnostic, token, diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDiagnostics.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDiagnostics.kt index 980c387e52c..3e580f1f97c 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDiagnostics.kt +++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDiagnostics.kt @@ -16,7 +16,7 @@ import org.jetbrains.kotlin.analysis.api.symbols.KtTypeParameterSymbol import org.jetbrains.kotlin.analysis.api.symbols.KtVariableLikeSymbol import org.jetbrains.kotlin.analysis.api.symbols.KtVariableSymbol import org.jetbrains.kotlin.analysis.api.types.KtType -import org.jetbrains.kotlin.builtins.functions.FunctionalTypeKind +import org.jetbrains.kotlin.builtins.functions.FunctionTypeKind import org.jetbrains.kotlin.config.ApiVersion import org.jetbrains.kotlin.config.LanguageFeature import org.jetbrains.kotlin.config.LanguageVersionSettings @@ -1293,9 +1293,9 @@ sealed class KtFirDiagnostic : KtDiagnosticWithPsi { abstract val candidates: List } - abstract class AmbiguousFunctionalTypeKind : KtFirDiagnostic() { - override val diagnosticClass get() = AmbiguousFunctionalTypeKind::class - abstract val kinds: List + abstract class AmbiguousFunctionTypeKind : KtFirDiagnostic() { + override val diagnosticClass get() = AmbiguousFunctionTypeKind::class + abstract val kinds: List } abstract class NoContextReceiver : KtFirDiagnostic() { diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDiagnosticsImpl.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDiagnosticsImpl.kt index ed2b4432fb1..8f1a8878cd1 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDiagnosticsImpl.kt +++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDiagnosticsImpl.kt @@ -16,7 +16,7 @@ import org.jetbrains.kotlin.analysis.api.symbols.KtTypeParameterSymbol import org.jetbrains.kotlin.analysis.api.symbols.KtVariableLikeSymbol import org.jetbrains.kotlin.analysis.api.symbols.KtVariableSymbol import org.jetbrains.kotlin.analysis.api.types.KtType -import org.jetbrains.kotlin.builtins.functions.FunctionalTypeKind +import org.jetbrains.kotlin.builtins.functions.FunctionTypeKind import org.jetbrains.kotlin.config.ApiVersion import org.jetbrains.kotlin.config.LanguageFeature import org.jetbrains.kotlin.config.LanguageVersionSettings @@ -1553,11 +1553,11 @@ internal class NextAmbiguityImpl( override val token: KtLifetimeToken, ) : KtFirDiagnostic.NextAmbiguity(), KtAbstractFirDiagnostic -internal class AmbiguousFunctionalTypeKindImpl( - override val kinds: List, +internal class AmbiguousFunctionTypeKindImpl( + override val kinds: List, override val firDiagnostic: KtPsiDiagnostic, override val token: KtLifetimeToken, -) : KtFirDiagnostic.AmbiguousFunctionalTypeKind(), KtAbstractFirDiagnostic +) : KtFirDiagnostic.AmbiguousFunctionTypeKind(), KtAbstractFirDiagnostic internal class NoContextReceiverImpl( override val contextReceiverRepresentation: KtType, diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/types/KtFirFunctionalType.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/types/KtFirFunctionalType.kt index d968adcf639..e1b78bfa7ac 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/types/KtFirFunctionalType.kt +++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/types/KtFirFunctionalType.kt @@ -23,6 +23,7 @@ import org.jetbrains.kotlin.analysis.api.types.KtFunctionalType import org.jetbrains.kotlin.analysis.api.types.KtType import org.jetbrains.kotlin.analysis.api.types.KtTypeNullability import org.jetbrains.kotlin.analysis.low.level.api.fir.util.errorWithFirSpecificEntries +import org.jetbrains.kotlin.builtins.functions.FunctionTypeKind import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.fir.types.impl.ConeClassLikeTypeImpl import org.jetbrains.kotlin.name.ClassId @@ -49,10 +50,10 @@ internal class KtFirFunctionalType( override val nullability: KtTypeNullability get() = withValidityAssertion { coneType.nullability.asKtNullability() } - override val isSuspend: Boolean get() = withValidityAssertion { coneType.isSuspendFunctionType(builder.rootSession) } + override val isSuspend: Boolean get() = withValidityAssertion { coneType.isSuspendOrKSuspendFunctionType(builder.rootSession) } override val isReflectType: Boolean - get() = withValidityAssertion { coneType.functionalTypeKind(builder.rootSession)?.isReflectType == true } + get() = withValidityAssertion { coneType.functionTypeKind(builder.rootSession)?.isReflectType == true } override val arity: Int get() = withValidityAssertion { diff --git a/analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/cases/components/typeInfoProvider/AbstractFunctionClassKindTest.kt b/analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/cases/components/typeInfoProvider/AbstractFunctionClassKindTest.kt index b21b32725c6..85009028431 100644 --- a/analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/cases/components/typeInfoProvider/AbstractFunctionClassKindTest.kt +++ b/analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/cases/components/typeInfoProvider/AbstractFunctionClassKindTest.kt @@ -23,7 +23,7 @@ abstract class AbstractFunctionClassKindTest : AbstractAnalysisApiSingleFileTes val (type, functionClassKind) = executeOnPooledThreadInReadAction { analyseForTest(expressionAtCaret) { val functionType = expressionAtCaret.getExpectedType() - functionType?.render(position = Variance.INVARIANT) to functionType?.functionalTypeKind + functionType?.render(position = Variance.INVARIANT) to functionType?.functionTypeKind } } val actual = buildString { diff --git a/analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/components/KtTypeInfoProvider.kt b/analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/components/KtTypeInfoProvider.kt index 1e08a3fbc29..e3d4d4cddbb 100644 --- a/analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/components/KtTypeInfoProvider.kt +++ b/analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/components/KtTypeInfoProvider.kt @@ -13,12 +13,12 @@ import org.jetbrains.kotlin.analysis.api.types.KtNonErrorClassType import org.jetbrains.kotlin.analysis.api.types.KtType import org.jetbrains.kotlin.analysis.api.types.KtTypeNullability import org.jetbrains.kotlin.builtins.StandardNames -import org.jetbrains.kotlin.builtins.functions.FunctionalTypeKind +import org.jetbrains.kotlin.builtins.functions.FunctionTypeKind import org.jetbrains.kotlin.name.ClassId public abstract class KtTypeInfoProvider : KtAnalysisSessionComponent() { public abstract fun isFunctionalInterfaceType(type: KtType): Boolean - public abstract fun getFunctionClassKind(type: KtType): FunctionalTypeKind? + public abstract fun getFunctionClassKind(type: KtType): FunctionTypeKind? public abstract fun canBeNull(type: KtType): Boolean public abstract fun isDenotable(type: KtType): Boolean public abstract fun isArrayOrPrimitiveArray(type: KtType): Boolean @@ -41,22 +41,22 @@ public interface KtTypeInfoProviderMixIn : KtAnalysisSessionMixIn { get() = withValidityAssertion { analysisSession.typeInfoProvider.isFunctionalInterfaceType(this) } /** - * Returns [FunctionalTypeKind] of the given [KtType] + * Returns [FunctionTypeKind] of the given [KtType] */ - public val KtType.functionalTypeKind: FunctionalTypeKind? + public val KtType.functionTypeKind: FunctionTypeKind? get() = withValidityAssertion { analysisSession.typeInfoProvider.getFunctionClassKind(this) } public val KtType.isFunctionType: Boolean - get() = withValidityAssertion { functionalTypeKind == FunctionalTypeKind.Function } + get() = withValidityAssertion { functionTypeKind == FunctionTypeKind.Function } public val KtType.isKFunctionType: Boolean - get() = withValidityAssertion { functionalTypeKind == FunctionalTypeKind.KFunction } + get() = withValidityAssertion { functionTypeKind == FunctionTypeKind.KFunction } public val KtType.isSuspendFunctionType: Boolean - get() = withValidityAssertion { functionalTypeKind == FunctionalTypeKind.SuspendFunction } + get() = withValidityAssertion { functionTypeKind == FunctionTypeKind.SuspendFunction } public val KtType.isKSuspendFunctionType: Boolean - get() = withValidityAssertion { functionalTypeKind == FunctionalTypeKind.KSuspendFunction } + get() = withValidityAssertion { functionTypeKind == FunctionTypeKind.KSuspendFunction } /** * Returns true if a public value of this type can potentially be null. This means this type is not a subtype of [Any]. However, it does not diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/project/structure/LLFirBuiltinsSessionFactory.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/project/structure/LLFirBuiltinsSessionFactory.kt index 7aa0b867913..8c3c2126726 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/project/structure/LLFirBuiltinsSessionFactory.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/project/structure/LLFirBuiltinsSessionFactory.kt @@ -19,7 +19,7 @@ import org.jetbrains.kotlin.fir.backend.jvm.FirJvmTypeMapper import org.jetbrains.kotlin.fir.resolve.providers.FirProvider import org.jetbrains.kotlin.fir.resolve.providers.FirSymbolProvider import org.jetbrains.kotlin.fir.resolve.providers.impl.FirCloneableSymbolProvider -import org.jetbrains.kotlin.fir.resolve.providers.impl.FirExtensionSyntheticFunctionalInterfaceProvider +import org.jetbrains.kotlin.fir.resolve.providers.impl.FirExtensionSyntheticFunctionInterfaceProvider import org.jetbrains.kotlin.fir.resolve.scopes.wrapScopeWithJvmMapped import org.jetbrains.kotlin.fir.resolve.transformers.FirDummyCompilerLazyDeclarationResolver import org.jetbrains.kotlin.fir.scopes.FirKotlinScopeProvider @@ -64,7 +64,7 @@ class LLFirBuiltinsSessionFactory( register(FirKotlinScopeProvider::class, kotlinScopeProvider) val symbolProvider = createCompositeSymbolProvider(this) { add(LLFirBuiltinSymbolProvider(this@session, moduleData, kotlinScopeProvider)) - add(FirExtensionSyntheticFunctionalInterfaceProvider(this@session, moduleData, kotlinScopeProvider)) + add(FirExtensionSyntheticFunctionInterfaceProvider(this@session, moduleData, kotlinScopeProvider)) add(FirCloneableSymbolProvider(this@session, moduleData, kotlinScopeProvider)) } diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/sessions/LLFirSessionFactory.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/sessions/LLFirSessionFactory.kt index e869e4e7ed9..375a42ef791 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/sessions/LLFirSessionFactory.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/sessions/LLFirSessionFactory.kt @@ -31,7 +31,7 @@ import org.jetbrains.kotlin.fir.backend.jvm.FirJvmTypeMapper import org.jetbrains.kotlin.fir.extensions.* import org.jetbrains.kotlin.fir.java.JavaSymbolProvider import org.jetbrains.kotlin.fir.resolve.providers.* -import org.jetbrains.kotlin.fir.resolve.providers.impl.FirExtensionSyntheticFunctionalInterfaceProvider +import org.jetbrains.kotlin.fir.resolve.providers.impl.FirExtensionSyntheticFunctionInterfaceProvider import org.jetbrains.kotlin.fir.resolve.scopes.wrapScopeWithJvmMapped import org.jetbrains.kotlin.fir.scopes.FirKotlinScopeProvider import org.jetbrains.kotlin.fir.session.* @@ -149,7 +149,7 @@ internal object LLFirSessionFactory { } val javaSymbolProvider = createJavaSymbolProvider(this, moduleData, project, contentScope) - val syntheticFunctionalInterfaceProvider = FirExtensionSyntheticFunctionalInterfaceProvider(this, moduleData, scopeProvider) + val syntheticFunctionalInterfaceProvider = FirExtensionSyntheticFunctionInterfaceProvider(this, moduleData, scopeProvider) register( FirSymbolProvider::class, LLFirModuleWithDependenciesSymbolProvider( 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 ccc8df2a5b7..75e039fee19 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/KotlinTypeMapper.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/KotlinTypeMapper.kt @@ -9,7 +9,7 @@ import com.intellij.openapi.util.text.StringUtil import org.jetbrains.kotlin.builtins.BuiltInsPackageFragment import org.jetbrains.kotlin.builtins.KotlinBuiltIns import org.jetbrains.kotlin.builtins.functions.FunctionClassDescriptor -import org.jetbrains.kotlin.builtins.functions.FunctionalTypeKind +import org.jetbrains.kotlin.builtins.functions.FunctionTypeKind import org.jetbrains.kotlin.builtins.jvm.JavaToKotlinClassMap import org.jetbrains.kotlin.codegen.* import org.jetbrains.kotlin.codegen.DescriptorAsmUtil.isStaticMethod @@ -342,8 +342,8 @@ class KotlinTypeMapper @JvmOverloads constructor( if (classDescriptor is FunctionClassDescriptor) { if (classDescriptor.hasBigArity || - classDescriptor.functionKind == FunctionalTypeKind.KFunction || - classDescriptor.functionKind == FunctionalTypeKind.KSuspendFunction + classDescriptor.functionKind == FunctionTypeKind.KFunction || + classDescriptor.functionKind == FunctionTypeKind.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/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/diagnostics/FirDiagnosticsList.kt b/compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/diagnostics/FirDiagnosticsList.kt index 6cbf6c422ea..63d85df2915 100644 --- a/compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/diagnostics/FirDiagnosticsList.kt +++ b/compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/diagnostics/FirDiagnosticsList.kt @@ -8,7 +8,7 @@ package org.jetbrains.kotlin.fir.checkers.generator.diagnostics import com.intellij.psi.PsiElement import com.intellij.psi.impl.source.tree.LeafPsiElement import org.jetbrains.kotlin.KtSourceElement -import org.jetbrains.kotlin.builtins.functions.FunctionalTypeKind +import org.jetbrains.kotlin.builtins.functions.FunctionTypeKind import org.jetbrains.kotlin.config.ApiVersion import org.jetbrains.kotlin.config.LanguageFeature import org.jetbrains.kotlin.config.LanguageVersionSettings @@ -568,8 +568,8 @@ object DIAGNOSTICS_LIST : DiagnosticList("FirErrors") { val NEXT_AMBIGUITY by error(PositioningStrategy.REFERENCE_BY_QUALIFIED) { parameter>>("candidates") } - val AMBIGUOUS_FUNCTIONAL_TYPE_KIND by error { - parameter>("kinds") + val AMBIGUOUS_FUNCTION_TYPE_KIND by error { + parameter>("kinds") } } diff --git a/compiler/fir/checkers/checkers.js/src/org/jetbrains/kotlin/fir/analysis/js/checkers/declaration/FirJsInheritanceClassChecker.kt b/compiler/fir/checkers/checkers.js/src/org/jetbrains/kotlin/fir/analysis/js/checkers/declaration/FirJsInheritanceClassChecker.kt index 3966194a6e6..97703a980ae 100644 --- a/compiler/fir/checkers/checkers.js/src/org/jetbrains/kotlin/fir/analysis/js/checkers/declaration/FirJsInheritanceClassChecker.kt +++ b/compiler/fir/checkers/checkers.js/src/org/jetbrains/kotlin/fir/analysis/js/checkers/declaration/FirJsInheritanceClassChecker.kt @@ -22,7 +22,7 @@ import org.jetbrains.kotlin.fir.scopes.collectAllFunctions import org.jetbrains.kotlin.fir.symbols.impl.FirIntersectionOverrideFunctionSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol import org.jetbrains.kotlin.fir.types.ConeClassLikeType -import org.jetbrains.kotlin.fir.types.isSuspendFunctionType +import org.jetbrains.kotlin.fir.types.isSuspendOrKSuspendFunctionType import org.jetbrains.kotlin.fir.types.typeContext object FirJsInheritanceClassChecker : FirClassChecker() { @@ -49,11 +49,11 @@ object FirJsInheritanceClassChecker : FirClassChecker() { } private fun ConeClassLikeType.isBuiltinFunctionalTypeOrSubtype(session: FirSession): Boolean { - return with(session.typeContext) { isBuiltinFunctionalTypeOrSubtype() } + return with(session.typeContext) { isBuiltinFunctionTypeOrSubtype() } } private fun ConeClassLikeType.isSuspendFunctionTypeOrSubtype(session: FirSession): Boolean { - return with(session.typeContext) { isTypeOrSubtypeOf { it.isSuspendFunctionType(session) } } + return with(session.typeContext) { isTypeOrSubtypeOf { it.isSuspendOrKSuspendFunctionType(session) } } } private fun FirClass.findFakeMethodOverridingExternalWithOptionalParams(context: CheckerContext): FirNamedFunctionSymbol? { diff --git a/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirSynchronizedAnnotationChecker.kt b/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirSynchronizedAnnotationChecker.kt index b303bb257d5..79c42e70874 100644 --- a/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirSynchronizedAnnotationChecker.kt +++ b/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirSynchronizedAnnotationChecker.kt @@ -20,7 +20,7 @@ import org.jetbrains.kotlin.fir.declarations.utils.isAbstract import org.jetbrains.kotlin.fir.declarations.utils.isInline import org.jetbrains.kotlin.fir.declarations.utils.isSuspend import org.jetbrains.kotlin.fir.types.coneType -import org.jetbrains.kotlin.fir.types.isSuspendFunctionType +import org.jetbrains.kotlin.fir.types.isSuspendOrKSuspendFunctionType import org.jetbrains.kotlin.name.JvmNames.SYNCHRONIZED_ANNOTATION_CLASS_ID object FirSynchronizedAnnotationChecker : FirFunctionChecker() { @@ -33,7 +33,7 @@ object FirSynchronizedAnnotationChecker : FirFunctionChecker() { return } if (declaration.isSuspend || - (declaration as? FirAnonymousFunction)?.typeRef?.coneType?.isSuspendFunctionType(session) == true + (declaration as? FirAnonymousFunction)?.typeRef?.coneType?.isSuspendOrKSuspendFunctionType(session) == true ) { reporter.reportOn(annotation.source, FirJvmErrors.SYNCHRONIZED_ON_SUSPEND, context) return diff --git a/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrors.kt b/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrors.kt index 54b626cac6e..8b3cddbbddd 100644 --- a/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrors.kt +++ b/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrors.kt @@ -8,7 +8,7 @@ package org.jetbrains.kotlin.fir.analysis.diagnostics import com.intellij.psi.PsiElement import com.intellij.psi.impl.source.tree.LeafPsiElement import org.jetbrains.kotlin.KtSourceElement -import org.jetbrains.kotlin.builtins.functions.FunctionalTypeKind +import org.jetbrains.kotlin.builtins.functions.FunctionTypeKind import org.jetbrains.kotlin.config.ApiVersion import org.jetbrains.kotlin.config.LanguageFeature import org.jetbrains.kotlin.config.LanguageFeature.ForbidExposingTypesInPrimaryConstructorProperties @@ -370,7 +370,7 @@ object FirErrors { val ITERATOR_AMBIGUITY by error1>>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED) val HAS_NEXT_FUNCTION_AMBIGUITY by error1>>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED) val NEXT_AMBIGUITY by error1>>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED) - val AMBIGUOUS_FUNCTIONAL_TYPE_KIND by error1>() + val AMBIGUOUS_FUNCTION_TYPE_KIND by error1>() // Context receivers resolution val NO_CONTEXT_RECEIVER by error1(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED) diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/cfa/FirCallsEffectAnalyzer.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/cfa/FirCallsEffectAnalyzer.kt index dd18d44e15b..4fd7e9704be 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/cfa/FirCallsEffectAnalyzer.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/cfa/FirCallsEffectAnalyzer.kt @@ -52,13 +52,13 @@ object FirCallsEffectAnalyzer : FirControlFlowChecker() { val functionalTypeEffects = mutableMapOf, ConeCallsEffectDeclaration>() function.valueParameters.forEachIndexed { index, parameter -> - if (parameter.returnTypeRef.isFunctionalTypeRef(session)) { + if (parameter.returnTypeRef.isFunctionTypeRef(session)) { val effectDeclaration = function.contractDescription.getParameterCallsEffectDeclaration(index) if (effectDeclaration != null) functionalTypeEffects[parameter.symbol] = effectDeclaration } } - if (function.receiverParameter?.typeRef.isFunctionalTypeRef(session)) { + if (function.receiverParameter?.typeRef.isFunctionTypeRef(session)) { val effectDeclaration = function.contractDescription.getParameterCallsEffectDeclaration(-1) if (effectDeclaration != null) functionalTypeEffects[function.symbol] = effectDeclaration } @@ -277,8 +277,8 @@ object FirCallsEffectAnalyzer : FirControlFlowChecker() { } } - private fun FirTypeRef?.isFunctionalTypeRef(session: FirSession): Boolean { - return this?.coneType?.isSomeFunctionalType(session) == true + private fun FirTypeRef?.isFunctionTypeRef(session: FirSession): Boolean { + return this?.coneType?.isSomeFunctionType(session) == true } private fun FirContractDescription?.getParameterCallsEffectDeclaration(index: Int): ConeCallsEffectDeclaration? { diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirCastDiagnosticsHelpers.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirCastDiagnosticsHelpers.kt index 86ecb655998..001ca732637 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirCastDiagnosticsHelpers.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirCastDiagnosticsHelpers.kt @@ -303,10 +303,10 @@ private fun isUpcast(context: CheckerContext, candidateType: ConeKotlinType, tar if (!AbstractTypeChecker.isSubtypeOf(context.session.typeContext, candidateType, targetType, stubTypesEqualToAnything = false)) return false - // E.g., foo(p1: (X) -> Y), where p1 has a functional type whose receiver type is X and return type is Y. - // For bar(p2: X.() -> Y), p2 has the same functional type (with same receiver and return types). + // E.g., foo(p1: (X) -> Y), where p1 has a function type whose receiver type is X and return type is Y. + // For bar(p2: X.() -> Y), p2 has the same function type (with same receiver and return types). // The only difference is the existence of type annotation, @ExtensionFunctionType, // which indicates that the annotated type represents an extension function. // If one casts p1 to p2 (or vice versa), it is _not_ up cast, i.e., not redundant, yet meaningful. return candidateType.isExtensionFunctionType == targetType.isExtensionFunctionType -} \ No newline at end of file +} diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirConstChecks.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirConstChecks.kt index 9cb62bfc661..de9d32483bf 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirConstChecks.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirConstChecks.kt @@ -144,7 +144,7 @@ internal fun checkConstantArguments( } expression is FirQualifiedAccessExpression -> { val expressionType = expression.typeRef.coneType - if (expressionType.isReflectFunctionalType(session) || expressionType.isKProperty(session) || expressionType.isKMutableProperty(session)) { + if (expressionType.isReflectFunctionType(session) || expressionType.isKProperty(session) || expressionType.isKMutableProperty(session)) { return checkConstantArguments(expression.dispatchReceiver, session) } diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirInlineDeclarationChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirInlineDeclarationChecker.kt index a04f2287c95..f937d42d5c2 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirInlineDeclarationChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirInlineDeclarationChecker.kt @@ -7,7 +7,7 @@ package org.jetbrains.kotlin.fir.analysis.checkers.declaration import org.jetbrains.kotlin.KtSourceElement import org.jetbrains.kotlin.builtins.StandardNames.BACKING_FIELD -import org.jetbrains.kotlin.builtins.functions.isSuspendType +import org.jetbrains.kotlin.builtins.functions.isSuspendOrKSuspendFunction import org.jetbrains.kotlin.config.LanguageFeature import org.jetbrains.kotlin.descriptors.EffectiveVisibility import org.jetbrains.kotlin.descriptors.Visibilities @@ -62,7 +62,7 @@ abstract class FirInlineDeclarationChecker : FirFunctionChecker() { val inalienableParameters = function.valueParameters.filter { if (it.isNoinline) return@filter false val type = it.returnTypeRef.coneType - !type.isMarkedNullable && type.isNonReflectFunctionalType(context.session) + !type.isMarkedNullable && type.isNonReflectFunctionType(context.session) }.map { it.symbol } val visitor = inlineVisitor( @@ -234,7 +234,7 @@ abstract class FirInlineDeclarationChecker : FirFunctionChecker() { // TODO: receivers are currently not inline (KT-5837) // if (targetSymbol.isInline) return true return targetSymbol.name == OperatorNameConventions.INVOKE && - targetSymbol.dispatchReceiverType?.isSomeFunctionalType(session) == true + targetSymbol.dispatchReceiverType?.isSomeFunctionType(session) == true } private fun checkQualifiedAccess( @@ -405,22 +405,22 @@ abstract class FirInlineDeclarationChecker : FirFunctionChecker() { ) { for (param in function.valueParameters) { val coneType = param.returnTypeRef.coneType - val functionalKind = coneType.functionalTypeKind(context.session) - val isFunctionalType = functionalKind != null - val isSuspendFunctionalType = functionalKind?.isSuspendType == true + val functionKind = coneType.functionTypeKind(context.session) + val isFunctionalType = functionKind != null + val isSuspendFunctionType = functionKind?.isSuspendOrKSuspendFunction == true val defaultValue = param.defaultValue - if (!(isFunctionalType || isSuspendFunctionalType) && (param.isNoinline || param.isCrossinline)) { + if (!(isFunctionalType || isSuspendFunctionType) && (param.isNoinline || param.isCrossinline)) { reporter.reportOn(param.source, FirErrors.ILLEGAL_INLINE_PARAMETER_MODIFIER, context) } if (param.isNoinline) continue - if (function.isSuspend && defaultValue != null && isSuspendFunctionalType) { + if (function.isSuspend && defaultValue != null && isSuspendFunctionType) { checkSuspendFunctionalParameterWithDefaultValue(param, context, reporter) } - if (isSuspendFunctionalType && !param.isCrossinline) { + if (isSuspendFunctionType && !param.isCrossinline) { if (function.isSuspend) { val modifier = param.returnTypeRef.getModifier(KtTokens.SUSPEND_KEYWORD) if (modifier != null) { @@ -490,7 +490,7 @@ abstract class FirInlineDeclarationChecker : FirFunctionChecker() { function.valueParameters.any { param -> val type = param.returnTypeRef.coneType !param.isNoinline && !type.isNullable - && (type.isSimpleFunctionType(session) || type.isSuspendFunctionType(session)) + && (type.isBasicFunctionType(session) || type.isSuspendOrKSuspendFunctionType(session)) } if (hasInlinableParameters) return if (function.isInlineOnly(session)) return diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirSuspendCallChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirSuspendCallChecker.kt index 7d1fe5754e8..87d53bb7178 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirSuspendCallChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirSuspendCallChecker.kt @@ -130,7 +130,7 @@ object FirSuspendCallChecker : FirQualifiedAccessExpressionChecker() { private fun findEnclosingSuspendFunction(context: CheckerContext): FirFunction? { return context.containingDeclarations.lastOrNull { when (it) { - is FirAnonymousFunction -> it.typeRef.coneType.isSuspendFunctionType(context.session) + is FirAnonymousFunction -> it.typeRef.coneType.isSuspendOrKSuspendFunctionType(context.session) is FirSimpleFunction -> it.isSuspend else -> false } @@ -218,7 +218,7 @@ object FirSuspendCallChecker : FirQualifiedAccessExpressionChecker() { calledDeclarationSymbol: FirCallableSymbol<*> ): Triple { if (this is FirImplicitInvokeCall && - dispatchReceiver != FirNoReceiverExpression && dispatchReceiver.typeRef.coneType.isSuspendFunctionType(session) + dispatchReceiver != FirNoReceiverExpression && dispatchReceiver.typeRef.coneType.isSuspendOrKSuspendFunctionType(session) ) { val variableForInvoke = dispatchReceiver val variableForInvokeType = variableForInvoke.typeRef.coneType diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/extended/UnusedChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/extended/UnusedChecker.kt index 6a8cbd8856f..4ad7825b29d 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/extended/UnusedChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/extended/UnusedChecker.kt @@ -28,7 +28,7 @@ import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase import org.jetbrains.kotlin.fir.types.coneType -import org.jetbrains.kotlin.fir.types.isSimpleFunctionType +import org.jetbrains.kotlin.fir.types.isBasicFunctionType object UnusedChecker : AbstractFirPropertyInitializationChecker() { override fun analyze(data: PropertyInitializationInfoData, reporter: DiagnosticReporter, context: CheckerContext) { @@ -278,7 +278,7 @@ object UnusedChecker : AbstractFirPropertyInitializationChecker() { val reference = node.fir.calleeReference.resolved ?: return dataForNode val functionSymbol = reference.resolvedSymbol as? FirFunctionSymbol<*> ?: return dataForNode val symbol = if (functionSymbol.callableId.callableName.identifier == "invoke") { - localProperties.find { it.name == reference.name && it.resolvedReturnTypeRef.coneType.isSimpleFunctionType(session) } + localProperties.find { it.name == reference.name && it.resolvedReturnTypeRef.coneType.isBasicFunctionType(session) } } else null symbol ?: return dataForNode diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/type/FirTypeAnnotationChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/type/FirTypeAnnotationChecker.kt index 484e63bb169..21195a1df0f 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/type/FirTypeAnnotationChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/type/FirTypeAnnotationChecker.kt @@ -15,7 +15,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors import org.jetbrains.kotlin.fir.declarations.toAnnotationClassId import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef import org.jetbrains.kotlin.fir.types.FirTypeRef -import org.jetbrains.kotlin.fir.types.isSomeFunctionalType +import org.jetbrains.kotlin.fir.types.isSomeFunctionType import org.jetbrains.kotlin.name.StandardClassIds object FirTypeAnnotationChecker : FirTypeRefChecker() { @@ -33,7 +33,7 @@ object FirTypeAnnotationChecker : FirTypeRefChecker() { } } if (annotation.toAnnotationClassId(context.session) == StandardClassIds.Annotations.ExtensionFunctionType) { - if (!typeRef.type.isSomeFunctionalType(context.session)) { + if (!typeRef.type.isSomeFunctionType(context.session)) { if (context.languageVersionSettings.supportsFeature(LanguageFeature.ForbidExtensionFunctionTypeOnNonFunctionTypes)) { reporter.reportOn(annotation.source, FirErrors.WRONG_EXTENSION_FUNCTION_TYPE, context) } else { diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirDiagnosticRenderers.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirDiagnosticRenderers.kt index ef660bd6c9b..248c08b86eb 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirDiagnosticRenderers.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirDiagnosticRenderers.kt @@ -5,7 +5,7 @@ package org.jetbrains.kotlin.fir.analysis.diagnostics -import org.jetbrains.kotlin.builtins.functions.FunctionalTypeKind +import org.jetbrains.kotlin.builtins.functions.FunctionTypeKind import org.jetbrains.kotlin.descriptors.ClassKind import org.jetbrains.kotlin.diagnostics.KtDiagnosticRenderers import org.jetbrains.kotlin.diagnostics.WhenMissingCase @@ -143,7 +143,7 @@ object FirDiagnosticRenderers { } } - val FUNCTIONAL_TYPE_KIND = Renderer { kind: FunctionalTypeKind -> + val FUNCTIONAL_TYPE_KIND = Renderer { kind: FunctionTypeKind -> kind.prefixForTypeRender ?: kind.classNamePrefix } diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrorsDefaultMessages.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrorsDefaultMessages.kt index 4ae9efd13fb..bd9a14fe1e3 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrorsDefaultMessages.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrorsDefaultMessages.kt @@ -61,7 +61,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.AMBIGUOUS_ALTERED import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.AMBIGUOUS_ANONYMOUS_TYPE_INFERRED import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.AMBIGUOUS_CALL_WITH_IMPLICIT_CONTEXT_RECEIVER import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.AMBIGUOUS_EXPECTS -import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.AMBIGUOUS_FUNCTIONAL_TYPE_KIND +import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.AMBIGUOUS_FUNCTION_TYPE_KIND import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.AMBIGUOUS_SUPER import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ANNOTATION_ARGUMENT_KCLASS_LITERAL_OF_TYPE_PARAMETER_ERROR import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ANNOTATION_ARGUMENT_MUST_BE_CONST @@ -1078,7 +1078,7 @@ object FirErrorsDefaultMessages : BaseDiagnosticRendererFactory() { map.put(NEXT_MISSING, "Method ''next()'' cannot be called on ''iterator()''") map.put(NEXT_AMBIGUITY, "Method ''next()'' is ambiguous for this expression: {0}", SYMBOLS) - map.put(AMBIGUOUS_FUNCTIONAL_TYPE_KIND, "Multiple functional type conversions are not allowed for single type. Detected type conversions: {0}", FUNCTIONAL_TYPE_KINDS) + map.put(AMBIGUOUS_FUNCTION_TYPE_KIND, "Multiple functional type conversions are not allowed for single type. Detected type conversions: {0}", FUNCTIONAL_TYPE_KINDS) map.put(NEXT_NONE_APPLICABLE, "None of the ''next()'' functions is applicable for ''iterator()'' of type ''{0}''", SYMBOLS) map.put(NO_CONTEXT_RECEIVER, "No required context receiver found: {0}", RENDER_TYPE) diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/coneDiagnosticToFirDiagnostic.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/coneDiagnosticToFirDiagnostic.kt index 894ba4ee9df..ca3d50383e5 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/coneDiagnosticToFirDiagnostic.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/coneDiagnosticToFirDiagnostic.kt @@ -132,7 +132,7 @@ private fun ConeDiagnostic.toKtDiagnostic( is ConeAmbiguouslyResolvedAnnotationFromPlugin -> { FirErrors.PLUGIN_ANNOTATION_AMBIGUITY.createOn(source, typeFromCompilerPhase, typeFromTypesPhase) } - is ConeAmbiguousFunctionalTypeKinds -> FirErrors.AMBIGUOUS_FUNCTIONAL_TYPE_KIND.createOn(source, kinds) + is ConeAmbiguousFunctionTypeKinds -> FirErrors.AMBIGUOUS_FUNCTION_TYPE_KIND.createOn(source, kinds) else -> throw IllegalArgumentException("Unsupported diagnostic type: ${this.javaClass}") } diff --git a/compiler/fir/cones/src/org/jetbrains/kotlin/fir/renderer/ConeTypeRenderer.kt b/compiler/fir/cones/src/org/jetbrains/kotlin/fir/renderer/ConeTypeRenderer.kt index 98cb0863c41..bf02788e87f 100644 --- a/compiler/fir/cones/src/org/jetbrains/kotlin/fir/renderer/ConeTypeRenderer.kt +++ b/compiler/fir/cones/src/org/jetbrains/kotlin/fir/renderer/ConeTypeRenderer.kt @@ -5,7 +5,7 @@ package org.jetbrains.kotlin.fir.renderer -import org.jetbrains.kotlin.builtins.functions.FunctionalTypeKind +import org.jetbrains.kotlin.builtins.functions.FunctionTypeKind import org.jetbrains.kotlin.fir.types.* open class ConeTypeRenderer { @@ -15,10 +15,10 @@ open class ConeTypeRenderer { open fun renderAsPossibleFunctionType( type: ConeKotlinType, - functionalClassKindExtractor: (ConeKotlinType) -> FunctionalTypeKind?, + functionClassKindExtractor: (ConeKotlinType) -> FunctionTypeKind?, renderType: ConeTypeProjection.() -> Unit = { render() } ) { - val kind = functionalClassKindExtractor(type) + val kind = functionClassKindExtractor(type) if (kind?.isReflectType != false) { type.renderType() return diff --git a/compiler/fir/cones/src/org/jetbrains/kotlin/fir/renderer/ConeTypeRendererForDebugging.kt b/compiler/fir/cones/src/org/jetbrains/kotlin/fir/renderer/ConeTypeRendererForDebugging.kt index 01eb23bf7f8..acea8520389 100644 --- a/compiler/fir/cones/src/org/jetbrains/kotlin/fir/renderer/ConeTypeRendererForDebugging.kt +++ b/compiler/fir/cones/src/org/jetbrains/kotlin/fir/renderer/ConeTypeRendererForDebugging.kt @@ -5,7 +5,7 @@ package org.jetbrains.kotlin.fir.renderer -import org.jetbrains.kotlin.builtins.functions.FunctionalTypeKind +import org.jetbrains.kotlin.builtins.functions.FunctionTypeKind import org.jetbrains.kotlin.fir.types.ConeKotlinType import org.jetbrains.kotlin.fir.types.ConeTypeProjection @@ -19,11 +19,11 @@ class ConeTypeRendererForDebugging() : ConeTypeRenderer() { override fun renderAsPossibleFunctionType( type: ConeKotlinType, - functionalClassKindExtractor: (ConeKotlinType) -> FunctionalTypeKind?, + functionClassKindExtractor: (ConeKotlinType) -> FunctionTypeKind?, renderType: ConeTypeProjection.() -> Unit ) { builder.append("R|") - super.renderAsPossibleFunctionType(type, functionalClassKindExtractor, renderType) + super.renderAsPossibleFunctionType(type, functionClassKindExtractor, renderType) builder.append("|") } } diff --git a/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/extensions/FirExtensionRegistrar.kt b/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/extensions/FirExtensionRegistrar.kt index bbd3dbebdd3..4b4d24fe9b1 100644 --- a/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/extensions/FirExtensionRegistrar.kt +++ b/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/extensions/FirExtensionRegistrar.kt @@ -32,7 +32,7 @@ abstract class FirExtensionRegistrar : FirExtensionRegistrarAdapter() { FirSamConversionTransformerExtension::class, FirAssignExpressionAltererExtension::class, FirScriptConfiguratorExtension::class, - FirFunctionalTypeKindExtension::class, + FirFunctionTypeKindExtension::class, ) } @@ -91,9 +91,9 @@ abstract class FirExtensionRegistrar : FirExtensionRegistrarAdapter() { registerExtension(FirScriptConfiguratorExtension::class, this) } - @JvmName("plusFunctionalTypeKindExtension") - operator fun (FirFunctionalTypeKindExtension.Factory).unaryPlus() { - registerExtension(FirFunctionalTypeKindExtension::class, this) + @JvmName("plusFunctionTypeKindExtension") + operator fun (FirFunctionTypeKindExtension.Factory).unaryPlus() { + registerExtension(FirFunctionTypeKindExtension::class, this) } // ------------------ reference methods ------------------ @@ -148,9 +148,9 @@ abstract class FirExtensionRegistrar : FirExtensionRegistrarAdapter() { FirScriptConfiguratorExtension.Factory { this.invoke(it) }.unaryPlus() } - @JvmName("plusFunctionalTypeKindExtension") - operator fun ((FirSession) -> FirFunctionalTypeKindExtension).unaryPlus() { - FirFunctionalTypeKindExtension.Factory { this.invoke(it) }.unaryPlus() + @JvmName("plusFunctionTypeKindExtension") + operator fun ((FirSession) -> FirFunctionTypeKindExtension).unaryPlus() { + FirFunctionTypeKindExtension.Factory { this.invoke(it) }.unaryPlus() } // ------------------ utilities ------------------ diff --git a/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/ComponentsContainers.kt b/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/ComponentsContainers.kt index 2395285a2dc..78de5649d6c 100644 --- a/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/ComponentsContainers.kt +++ b/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/ComponentsContainers.kt @@ -46,8 +46,8 @@ import org.jetbrains.kotlin.fir.scopes.impl.FirIntersectionOverrideStorage import org.jetbrains.kotlin.fir.scopes.impl.FirSubstitutionOverrideStorage import org.jetbrains.kotlin.fir.symbols.FirLazyDeclarationResolver import org.jetbrains.kotlin.fir.types.FirCorrespondingSupertypesCache -import org.jetbrains.kotlin.fir.types.FirFunctionalTypeKindService -import org.jetbrains.kotlin.fir.types.FirFunctionalTypeKindServiceImpl +import org.jetbrains.kotlin.fir.types.FirFunctionTypeKindService +import org.jetbrains.kotlin.fir.types.FirFunctionTypeKindServiceImpl import org.jetbrains.kotlin.fir.types.TypeComponents import org.jetbrains.kotlin.incremental.components.EnumWhenTracker import org.jetbrains.kotlin.incremental.components.LookupTracker @@ -77,7 +77,7 @@ fun FirSession.registerCommonComponents(languageVersionSettings: LanguageVersion @OptIn(SessionConfiguration::class) fun FirSession.registerCommonComponentsAfterExtensionsAreConfigured() { - register(FirFunctionalTypeKindService::class, FirFunctionalTypeKindServiceImpl(this)) + register(FirFunctionTypeKindService::class, FirFunctionTypeKindServiceImpl(this)) } @OptIn(SessionConfiguration::class) diff --git a/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/FirAbstractSessionFactory.kt b/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/FirAbstractSessionFactory.kt index 9f6909a503d..3059987da3a 100644 --- a/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/FirAbstractSessionFactory.kt +++ b/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/FirAbstractSessionFactory.kt @@ -77,7 +77,7 @@ abstract class FirAbstractSessionFactory { createProviders: ( FirSession, FirKotlinScopeProvider, FirSymbolProvider, FirSwitchableExtensionDeclarationsSymbolProvider?, - FirExtensionSyntheticFunctionalInterfaceProvider, + FirExtensionSyntheticFunctionInterfaceProvider, dependencies: List, ) -> List ): FirSession { @@ -109,14 +109,14 @@ abstract class FirAbstractSessionFactory { val dependencyProviders = computeDependencyProviderList(moduleData) val generatedSymbolsProvider = FirSwitchableExtensionDeclarationsSymbolProvider.create(this) - val syntheticFunctionalInterfaceProvider = FirExtensionSyntheticFunctionalInterfaceProvider(this, moduleData, kotlinScopeProvider) + val syntheticFunctionInterfaceProvider = FirExtensionSyntheticFunctionInterfaceProvider(this, moduleData, kotlinScopeProvider) val providers = createProviders( this, kotlinScopeProvider, firProvider.symbolProvider, generatedSymbolsProvider, - syntheticFunctionalInterfaceProvider, + syntheticFunctionInterfaceProvider, dependencyProviders, ) diff --git a/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/FirJsSessionFactory.kt b/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/FirJsSessionFactory.kt index d0100e521d3..c27333a1091 100644 --- a/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/FirJsSessionFactory.kt +++ b/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/FirJsSessionFactory.kt @@ -44,11 +44,11 @@ object FirJsSessionFactory : FirAbstractSessionFactory() { }, registerExtraCheckers = { it.registerJsCheckers() }, createKotlinScopeProvider = { FirKotlinScopeProvider { _, declaredMemberScope, _, _ -> declaredMemberScope } }, - createProviders = { _, _, symbolProvider, generatedSymbolsProvider, syntheticFunctionalInterfaceProvider, dependencies -> + createProviders = { _, _, symbolProvider, generatedSymbolsProvider, syntheticFunctionInterfaceProvider, dependencies -> listOfNotNull( symbolProvider, generatedSymbolsProvider, - syntheticFunctionalInterfaceProvider, + syntheticFunctionInterfaceProvider, *dependencies.toTypedArray(), ) } @@ -79,7 +79,7 @@ object FirJsSessionFactory : FirAbstractSessionFactory() { // TODO: consider using "poisoning" provider for builtins to ensure that proper ones are taken from dependencies // NOTE: it requires precise filtering for true nuiltins, like Function* FirBuiltinSymbolProvider(session, builtinsModuleData, kotlinScopeProvider), - FirExtensionSyntheticFunctionalInterfaceProvider(session, builtinsModuleData, kotlinScopeProvider), + FirExtensionSyntheticFunctionInterfaceProvider(session, builtinsModuleData, kotlinScopeProvider), ) } ) diff --git a/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/FirJvmSessionFactory.kt b/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/FirJvmSessionFactory.kt index 0daf3bd442b..532ce78fb81 100644 --- a/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/FirJvmSessionFactory.kt +++ b/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/FirJvmSessionFactory.kt @@ -58,7 +58,7 @@ object FirJvmSessionFactory : FirAbstractSessionFactory() { projectEnvironment.getFirJavaFacade(session, moduleDataProvider.allModuleData.last(), scope) ), FirBuiltinSymbolProvider(session, builtinsModuleData, kotlinScopeProvider), - FirExtensionSyntheticFunctionalInterfaceProvider(session, builtinsModuleData, kotlinScopeProvider), + FirExtensionSyntheticFunctionInterfaceProvider(session, builtinsModuleData, kotlinScopeProvider), FirCloneableSymbolProvider(session, builtinsModuleData, kotlinScopeProvider), OptionalAnnotationClassesProvider( session, @@ -101,7 +101,7 @@ object FirJvmSessionFactory : FirAbstractSessionFactory() { }, registerExtraCheckers = { it.registerJvmCheckers() }, createKotlinScopeProvider = { FirKotlinScopeProvider(::wrapScopeWithJvmMapped) }, - createProviders = { session, kotlinScopeProvider, symbolProvider, generatedSymbolsProvider, syntheticFunctionalInterfaceProvider, dependencies -> + createProviders = { session, kotlinScopeProvider, symbolProvider, generatedSymbolsProvider, syntheticFunctionInterfaceProvider, dependencies -> var symbolProviderForBinariesFromIncrementalCompilation: JvmClassFileBasedSymbolProvider? = null var optionalAnnotationClassesProviderForBinariesFromIncrementalCompilation: OptionalAnnotationClassesProvider? = null incrementalCompilationContext?.let { @@ -138,7 +138,7 @@ object FirJvmSessionFactory : FirAbstractSessionFactory() { symbolProviderForBinariesFromIncrementalCompilation, generatedSymbolsProvider, javaSymbolProvider, - syntheticFunctionalInterfaceProvider, + syntheticFunctionInterfaceProvider, *dependencies.toTypedArray(), optionalAnnotationClassesProviderForBinariesFromIncrementalCompilation, ) diff --git a/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/FirNativeSessionFactory.kt b/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/FirNativeSessionFactory.kt index 424a7108494..702f45a0c47 100644 --- a/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/FirNativeSessionFactory.kt +++ b/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/FirNativeSessionFactory.kt @@ -15,7 +15,7 @@ import org.jetbrains.kotlin.fir.java.FirProjectSessionProvider import org.jetbrains.kotlin.fir.resolve.calls.ConeCallConflictResolverFactory import org.jetbrains.kotlin.fir.resolve.providers.impl.FirBuiltinSymbolProvider import org.jetbrains.kotlin.fir.resolve.providers.impl.FirCloneableSymbolProvider -import org.jetbrains.kotlin.fir.resolve.providers.impl.FirExtensionSyntheticFunctionalInterfaceProvider +import org.jetbrains.kotlin.fir.resolve.providers.impl.FirExtensionSyntheticFunctionInterfaceProvider import org.jetbrains.kotlin.fir.scopes.FirKotlinScopeProvider import org.jetbrains.kotlin.fir.scopes.FirPlatformClassMapper import org.jetbrains.kotlin.library.metadata.resolver.KotlinResolvedLibrary @@ -41,7 +41,7 @@ object FirNativeSessionFactory : FirAbstractSessionFactory() { listOf( KlibBasedSymbolProvider(session, moduleDataProvider, kotlinScopeProvider, resolvedLibraries), FirBuiltinSymbolProvider(session, builtinsModuleData, kotlinScopeProvider), - FirExtensionSyntheticFunctionalInterfaceProvider(session, builtinsModuleData, kotlinScopeProvider), + FirExtensionSyntheticFunctionInterfaceProvider(session, builtinsModuleData, kotlinScopeProvider), FirCloneableSymbolProvider(session, builtinsModuleData, kotlinScopeProvider), ) }) @@ -69,11 +69,11 @@ object FirNativeSessionFactory : FirAbstractSessionFactory() { }, registerExtraCheckers = { it.registerNativeCheckers() }, createKotlinScopeProvider = { FirKotlinScopeProvider { _, declaredMemberScope, _, _ -> declaredMemberScope } }, - createProviders = { _, _, symbolProvider, generatedSymbolsProvider, syntheticFunctionalInterfaceProvider, dependencies -> + createProviders = { _, _, symbolProvider, generatedSymbolsProvider, syntheticFunctionInterfaceProvider, dependencies -> listOfNotNull( symbolProvider, generatedSymbolsProvider, - syntheticFunctionalInterfaceProvider, + syntheticFunctionInterfaceProvider, *dependencies.toTypedArray(), ) } diff --git a/compiler/fir/fir-deserialization/src/org/jetbrains/kotlin/fir/deserialization/FirTypeDeserializer.kt b/compiler/fir/fir-deserialization/src/org/jetbrains/kotlin/fir/deserialization/FirTypeDeserializer.kt index 364749aa542..0ad3fab3628 100644 --- a/compiler/fir/fir-deserialization/src/org/jetbrains/kotlin/fir/deserialization/FirTypeDeserializer.kt +++ b/compiler/fir/fir-deserialization/src/org/jetbrains/kotlin/fir/deserialization/FirTypeDeserializer.kt @@ -5,7 +5,7 @@ package org.jetbrains.kotlin.fir.deserialization -import org.jetbrains.kotlin.builtins.functions.FunctionalTypeKind +import org.jetbrains.kotlin.builtins.functions.FunctionTypeKind import org.jetbrains.kotlin.fir.FirModuleData import org.jetbrains.kotlin.fir.computeTypeAttributes import org.jetbrains.kotlin.fir.declarations.FirDeclarationOrigin @@ -202,7 +202,7 @@ class FirTypeDeserializer( val suspendReturnType = continuationType.typeArguments.single() as ConeKotlinTypeProjection val valueParameters = arguments.dropLast(2) - val kind = FunctionalTypeKind.SuspendFunction + val kind = FunctionTypeKind.SuspendFunction return ConeClassLikeTypeImpl( ClassId(kind.packageFqName, kind.numberedClassName(valueParameters.size)).toLookupTag(), (valueParameters + suspendReturnType).toTypedArray(), @@ -222,7 +222,7 @@ class FirTypeDeserializer( 1 -> { val arity = arguments.size - 1 if (arity >= 0) { - val kind = FunctionalTypeKind.SuspendFunction + val kind = FunctionTypeKind.SuspendFunction ConeClassLikeTypeImpl( ClassId(kind.packageFqName, kind.numberedClassName(arity)).toLookupTag(), arguments, diff --git a/compiler/fir/fir-deserialization/src/org/jetbrains/kotlin/fir/resolve/providers/impl/FirBuiltinSymbolProvider.kt b/compiler/fir/fir-deserialization/src/org/jetbrains/kotlin/fir/resolve/providers/impl/FirBuiltinSymbolProvider.kt index 279cd47a70a..0733ad51a4a 100644 --- a/compiler/fir/fir-deserialization/src/org/jetbrains/kotlin/fir/resolve/providers/impl/FirBuiltinSymbolProvider.kt +++ b/compiler/fir/fir-deserialization/src/org/jetbrains/kotlin/fir/resolve/providers/impl/FirBuiltinSymbolProvider.kt @@ -40,7 +40,7 @@ open class FirBuiltinSymbolProvider( val moduleData: FirModuleData, val kotlinScopeProvider: FirKotlinScopeProvider ) : FirSymbolProvider(session) { - private val syntheticFunctionalInterfaceProvider = FirBuiltinSyntheticFunctionalInterfaceProvider( + private val syntheticFunctionInterfaceProvider = FirBuiltinSyntheticFunctionInterfaceProvider( session, moduleData, kotlinScopeProvider @@ -68,7 +68,7 @@ open class FirBuiltinSymbolProvider( override fun getClassLikeSymbolByClassId(classId: ClassId): FirRegularClassSymbol? { return allPackageFragments[classId.packageFqName]?.firstNotNullOfOrNull { it.getClassLikeSymbolByClassId(classId) - } ?: syntheticFunctionalInterfaceProvider.getClassLikeSymbolByClassId(classId) + } ?: syntheticFunctionInterfaceProvider.getClassLikeSymbolByClassId(classId) } override fun computePackageSetWithTopLevelCallables(): Set = 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 0359397010d..a61b78b60cd 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 @@ -6,7 +6,7 @@ package org.jetbrains.kotlin.fir.serialization import org.jetbrains.kotlin.builtins.StandardNames -import org.jetbrains.kotlin.builtins.functions.FunctionalTypeKind +import org.jetbrains.kotlin.builtins.functions.FunctionTypeKind import org.jetbrains.kotlin.config.LanguageFeature import org.jetbrains.kotlin.config.LanguageVersionSettings import org.jetbrains.kotlin.descriptors.ClassKind @@ -682,7 +682,7 @@ class FirElementSerializer private constructor( return lowerBound } is ConeClassLikeType -> { - if (type.functionalTypeKind(session) == FunctionalTypeKind.SuspendFunction) { + if (type.functionTypeKind(session) == FunctionTypeKind.SuspendFunction) { val runtimeFunctionType = type.suspendFunctionTypeToFunctionTypeWithContinuation( session, StandardClassIds.Continuation ) diff --git a/compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/serializationUtil.kt b/compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/serializationUtil.kt index bb251d3de66..6d6c44d8a77 100644 --- a/compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/serializationUtil.kt +++ b/compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/serializationUtil.kt @@ -5,7 +5,7 @@ package org.jetbrains.kotlin.fir.serialization -import org.jetbrains.kotlin.builtins.functions.FunctionalTypeKind +import org.jetbrains.kotlin.builtins.functions.FunctionTypeKind import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.diagnostics.ConeIntermediateDiagnostic import org.jetbrains.kotlin.fir.languageVersionSettings @@ -25,16 +25,16 @@ class TypeApproximatorForMetadataSerializer(session: FirSession) : } fun ConeKotlinType.suspendFunctionTypeToFunctionTypeWithContinuation(session: FirSession, continuationClassId: ClassId): ConeClassLikeType { - require(this.isSuspendFunctionType(session)) + require(this.isSuspendOrKSuspendFunctionType(session)) val kind = - if (isReflectFunctionalType(session)) FunctionalTypeKind.KFunction - else FunctionalTypeKind.Function + if (isReflectFunctionType(session)) FunctionTypeKind.KFunction + else FunctionTypeKind.Function val fullyExpandedType = type.fullyExpandedType(session) val typeArguments = fullyExpandedType.typeArguments - val functionalTypeId = ClassId(kind.packageFqName, kind.numberedClassName(typeArguments.size)) + val functionTypeId = ClassId(kind.packageFqName, kind.numberedClassName(typeArguments.size)) val lastTypeArgument = typeArguments.last() return ConeClassLikeTypeImpl( - functionalTypeId.toLookupTag(), + functionTypeId.toLookupTag(), typeArguments = (typeArguments.dropLast(1) + continuationClassId.toLookupTag().constructClassType( arrayOf(lastTypeArgument), isNullable = false diff --git a/compiler/fir/fir2ir/jvm-backend/src/org/jetbrains/kotlin/fir/backend/jvm/FirJvmSerializerExtension.kt b/compiler/fir/fir2ir/jvm-backend/src/org/jetbrains/kotlin/fir/backend/jvm/FirJvmSerializerExtension.kt index 6281e25ab94..3653fa90f12 100644 --- a/compiler/fir/fir2ir/jvm-backend/src/org/jetbrains/kotlin/fir/backend/jvm/FirJvmSerializerExtension.kt +++ b/compiler/fir/fir2ir/jvm-backend/src/org/jetbrains/kotlin/fir/backend/jvm/FirJvmSerializerExtension.kt @@ -233,8 +233,8 @@ class FirJvmSerializerExtension( private fun FirFunction.needsInlineParameterNullCheckRequirement(): Boolean = this is FirSimpleFunction && isInline && !isSuspend && !isParamAssertionsDisabled && !Visibilities.isPrivate(visibility) && - (valueParameters.any { it.returnTypeRef.coneType.isSomeFunctionalType(session) } || - receiverParameter?.typeRef?.coneType?.isSomeFunctionalType(session) == true) + (valueParameters.any { it.returnTypeRef.coneType.isSomeFunctionType(session) } || + receiverParameter?.typeRef?.coneType?.isSomeFunctionType(session) == true) override fun serializeProperty( property: FirProperty, diff --git a/compiler/fir/fir2ir/jvm-backend/src/org/jetbrains/kotlin/fir/backend/jvm/FirJvmTypeMapper.kt b/compiler/fir/fir2ir/jvm-backend/src/org/jetbrains/kotlin/fir/backend/jvm/FirJvmTypeMapper.kt index 25f6d5ea440..8b14393acff 100644 --- a/compiler/fir/fir2ir/jvm-backend/src/org/jetbrains/kotlin/fir/backend/jvm/FirJvmTypeMapper.kt +++ b/compiler/fir/fir2ir/jvm-backend/src/org/jetbrains/kotlin/fir/backend/jvm/FirJvmTypeMapper.kt @@ -172,8 +172,8 @@ class FirJvmTypeMapper(val session: FirSession) : FirSessionComponent { val parameters = classifier?.typeParameters.orEmpty().map { it.symbol } val arguments = type.arguments - if ((defaultType.isSimpleFunctionType(session) && arguments.size > BuiltInFunctionArity.BIG_ARITY) - || defaultType.isReflectFunctionalType(session) + if ((defaultType.isBasicFunctionType(session) && arguments.size > BuiltInFunctionArity.BIG_ARITY) + || defaultType.isReflectFunctionType(session) ) { writeGenericArguments(sw, listOf(arguments.last()), listOf(parameters.last()), mode) return @@ -264,7 +264,7 @@ class ConeTypeSystemCommonBackendContextForTypeMapping( override fun SimpleTypeMarker.isSuspendFunction(): Boolean { require(this is ConeSimpleKotlinType) - return isSuspendFunctionType(session) + return isSuspendOrKSuspendFunctionType(session) } override fun SimpleTypeMarker.isKClass(): Boolean { diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrDeclarationStorage.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrDeclarationStorage.kt index a6204a63bfe..83229d3ce02 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrDeclarationStorage.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrDeclarationStorage.kt @@ -538,7 +538,7 @@ class Fir2IrDeclarationStorage( ?: if (isLambda) SpecialNames.ANONYMOUS else Name.special("") val visibility = simpleFunction?.visibility ?: Visibilities.Local val isSuspend = - if (isLambda) ((function as FirAnonymousFunction).typeRef as? FirResolvedTypeRef)?.type?.isSuspendFunctionType(session) == true + if (isLambda) ((function as FirAnonymousFunction).typeRef as? FirResolvedTypeRef)?.type?.isSuspendOrKSuspendFunctionType(session) == true else simpleFunction?.isSuspend == true val created = function.convertWithOffsets { startOffset, endOffset -> val result = declareIrSimpleFunction(signature, simpleFunction?.containerSource) { symbol -> diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/AdapterGenerator.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/AdapterGenerator.kt index f5c025a2720..5dd631d988a 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/AdapterGenerator.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/AdapterGenerator.kt @@ -134,7 +134,7 @@ internal class AdapterGenerator( } internal fun ConeKotlinType.kFunctionTypeToFunctionType(): IrSimpleType = - reflectFunctionalTypeToNonReflectFunctionalType(session).toIrType() as IrSimpleType + reflectFunctionTypeToNonReflectFunctionType(session).toIrType() as IrSimpleType internal fun generateAdaptedCallableReference( callableReferenceAccess: FirCallableReferenceAccess, @@ -479,7 +479,7 @@ internal class AdapterGenerator( } // If the expected type is a built-in functional type, we don't need SAM conversion. val expectedType = argument.getExpectedType(parameter) - if (expectedType is ConeTypeParameterType || expectedType.isSomeFunctionalType(session)) { + if (expectedType is ConeTypeParameterType || expectedType.isSomeFunctionType(session)) { return false } // On the other hand, the actual type should be either a functional type or a subtype of a class that has a contributed `invoke`. @@ -514,10 +514,10 @@ internal class AdapterGenerator( return this } // Expect the expected type to be a suspend functional type. - if (!parameterType.isSuspendFunctionType(session)) { + if (!parameterType.isSuspendOrKSuspendFunctionType(session)) { return this } - val expectedFunctionalType = parameterType.customFunctionalTypeToSimpleFunctionalType(session) + val expectedFunctionalType = parameterType.customFunctionTypeToSimpleFunctionType(session) if (this is IrVararg) { // element-wise conversion if and only if we can build 1-to-1 mapping for elements. return applyConversionOnVararg(argument) { firVarargArgument -> @@ -546,9 +546,9 @@ internal class AdapterGenerator( argument: FirExpression ): IrSimpleFunctionSymbol? { val argumentType = argument.typeRef.coneType - val argumentTypeWithInvoke = argumentType.findSubtypeOfSimpleFunctionalType(session, expectedFunctionalType) ?: return null + val argumentTypeWithInvoke = argumentType.findSubtypeOfBasicFunctionType(session, expectedFunctionalType) ?: return null - return if (argumentTypeWithInvoke.isSomeFunctionalType(session)) { + return if (argumentTypeWithInvoke.isSomeFunctionType(session)) { (argumentTypeWithInvoke as? ConeClassLikeType)?.findBaseInvokeSymbol(session, scopeSession) } else { argumentTypeWithInvoke.findContributedInvokeSymbol( 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 f77c4b5b19a..585b04c66b5 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 @@ -188,7 +188,7 @@ class CallAndReferenceGenerator( // This would cause ClassCastException in case of usual type approximation, // because '{ X1 & ... & Xm }' would be approximated to 'Nothing'. // JVM_OLD just relies on type mapping for generic argument types in such case. - if (!kotlinType.isReflectFunctionalType(session)) + if (!kotlinType.isReflectFunctionType(session)) return kotlinType if (kotlinType !is ConeSimpleKotlinType) return kotlinType diff --git a/compiler/fir/providers/src/org/jetbrains/kotlin/fir/resolve/providers/impl/FirCachingCompositeSymbolProvider.kt b/compiler/fir/providers/src/org/jetbrains/kotlin/fir/resolve/providers/impl/FirCachingCompositeSymbolProvider.kt index 00431221835..1bb268b6327 100644 --- a/compiler/fir/providers/src/org/jetbrains/kotlin/fir/resolve/providers/impl/FirCachingCompositeSymbolProvider.kt +++ b/compiler/fir/providers/src/org/jetbrains/kotlin/fir/resolve/providers/impl/FirCachingCompositeSymbolProvider.kt @@ -18,7 +18,7 @@ import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol -import org.jetbrains.kotlin.fir.types.functionalTypeService +import org.jetbrains.kotlin.fir.types.functionTypeService import org.jetbrains.kotlin.name.CallableId import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.FqName @@ -116,7 +116,7 @@ class FirCachingCompositeSymbolProvider( } private fun isNameForFunctionClass(classId: ClassId): Boolean { - return session.functionalTypeService.getKindByClassNamePrefix(classId.packageFqName, classId.shortClassName.asString()) != null + return session.functionTypeService.getKindByClassNamePrefix(classId.packageFqName, classId.shortClassName.asString()) != null } @OptIn(FirSymbolProviderInternals::class) diff --git a/compiler/fir/providers/src/org/jetbrains/kotlin/fir/resolve/providers/impl/FirExtensionSyntheticFunctionalInterfaceProvider.kt b/compiler/fir/providers/src/org/jetbrains/kotlin/fir/resolve/providers/impl/FirExtensionSyntheticFunctionInterfaceProvider.kt similarity index 86% rename from compiler/fir/providers/src/org/jetbrains/kotlin/fir/resolve/providers/impl/FirExtensionSyntheticFunctionalInterfaceProvider.kt rename to compiler/fir/providers/src/org/jetbrains/kotlin/fir/resolve/providers/impl/FirExtensionSyntheticFunctionInterfaceProvider.kt index 8cf241ae8e9..e759ce64e80 100644 --- a/compiler/fir/providers/src/org/jetbrains/kotlin/fir/resolve/providers/impl/FirExtensionSyntheticFunctionalInterfaceProvider.kt +++ b/compiler/fir/providers/src/org/jetbrains/kotlin/fir/resolve/providers/impl/FirExtensionSyntheticFunctionInterfaceProvider.kt @@ -5,9 +5,9 @@ package org.jetbrains.kotlin.fir.resolve.providers.impl -import org.jetbrains.kotlin.builtins.functions.FunctionalTypeKind +import org.jetbrains.kotlin.builtins.functions.FunctionTypeKind import org.jetbrains.kotlin.builtins.functions.isBuiltin -import org.jetbrains.kotlin.builtins.functions.isSuspendType +import org.jetbrains.kotlin.builtins.functions.isSuspendOrKSuspendFunction import org.jetbrains.kotlin.descriptors.ClassKind import org.jetbrains.kotlin.descriptors.EffectiveVisibility import org.jetbrains.kotlin.descriptors.Modality @@ -39,14 +39,14 @@ import org.jetbrains.kotlin.types.Variance import org.jetbrains.kotlin.util.OperatorNameConventions /* - * Provides functional interfaces for functional kinds from compiler plugins + * Provides function interfaces for function kinds from compiler plugins */ -class FirExtensionSyntheticFunctionalInterfaceProvider( +class FirExtensionSyntheticFunctionInterfaceProvider( session: FirSession, moduleData: FirModuleData, kotlinScopeProvider: FirKotlinScopeProvider -) : FirSyntheticFunctionalInterfaceProviderBase(session, moduleData, kotlinScopeProvider) { - override fun FunctionalTypeKind.isAcceptable(): Boolean { +) : FirSyntheticFunctionInterfaceProviderBase(session, moduleData, kotlinScopeProvider) { + override fun FunctionTypeKind.isAcceptable(): Boolean { return !this.isBuiltin } } @@ -54,17 +54,17 @@ class FirExtensionSyntheticFunctionalInterfaceProvider( /* * Provides kotlin.FunctionN, kotlin.coroutines.SuspendFunctionN, kotlin.reflect.KFunctionN and kotlin.reflect.KSuspendFunctionN */ -class FirBuiltinSyntheticFunctionalInterfaceProvider( +class FirBuiltinSyntheticFunctionInterfaceProvider( session: FirSession, moduleData: FirModuleData, kotlinScopeProvider: FirKotlinScopeProvider -) : FirSyntheticFunctionalInterfaceProviderBase(session, moduleData, kotlinScopeProvider) { - override fun FunctionalTypeKind.isAcceptable(): Boolean { +) : FirSyntheticFunctionInterfaceProviderBase(session, moduleData, kotlinScopeProvider) { + override fun FunctionTypeKind.isAcceptable(): Boolean { return this.isBuiltin } } -abstract class FirSyntheticFunctionalInterfaceProviderBase( +abstract class FirSyntheticFunctionInterfaceProviderBase( session: FirSession, val moduleData: FirModuleData, val kotlinScopeProvider: FirKotlinScopeProvider @@ -83,7 +83,7 @@ abstract class FirSyntheticFunctionalInterfaceProviderBase( override fun getTopLevelPropertySymbolsTo(destination: MutableList, packageFqName: FqName, name: Name) {} override fun getPackage(fqName: FqName): FqName? { - return fqName.takeIf { session.functionalTypeService.hasKindWithSpecificPackage(it) } + return fqName.takeIf { session.functionTypeService.hasKindWithSpecificPackage(it) } } override fun computePackageSetWithTopLevelCallables(): Set { @@ -91,7 +91,7 @@ abstract class FirSyntheticFunctionalInterfaceProviderBase( } /** - * This method has no sence for synthetic functional interfaces + * This method has no sense for synthetic function interfaces */ override fun knownTopLevelClassifiersInPackage(packageFqName: FqName): Set? { return emptySet() @@ -101,20 +101,20 @@ abstract class FirSyntheticFunctionalInterfaceProviderBase( return emptySet() } - private val cache = moduleData.session.firCachesFactory.createCache(::createSyntheticFunctionalInterface) + private val cache = moduleData.session.firCachesFactory.createCache(::createSyntheticFunctionInterface) - protected abstract fun FunctionalTypeKind.isAcceptable(): Boolean + protected abstract fun FunctionTypeKind.isAcceptable(): Boolean - private fun createSyntheticFunctionalInterface(classId: ClassId): FirRegularClassSymbol? { + private fun createSyntheticFunctionInterface(classId: ClassId): FirRegularClassSymbol? { return with(classId) { val className = relativeClassName.asString() - val kind = session.functionalTypeService.getKindByClassNamePrefix(packageFqName, className) ?: return null + val kind = session.functionTypeService.getKindByClassNamePrefix(packageFqName, className) ?: return null if (!kind.isAcceptable()) return null val prefix = kind.classNamePrefix val arity = className.substring(prefix.length).toIntOrNull() ?: return null FirRegularClassSymbol(classId).apply symbol@{ buildRegularClass klass@{ - moduleData = this@FirSyntheticFunctionalInterfaceProviderBase.moduleData + moduleData = this@FirSyntheticFunctionInterfaceProviderBase.moduleData origin = FirDeclarationOrigin.BuiltIns name = relativeClassName.shortName() status = FirResolvedDeclarationStatusImpl( @@ -136,7 +136,7 @@ abstract class FirSyntheticFunctionalInterfaceProviderBase( typeParameters.addAll( (1..arity).map { buildTypeParameter { - moduleData = this@FirSyntheticFunctionalInterfaceProviderBase.moduleData + moduleData = this@FirSyntheticFunctionInterfaceProviderBase.moduleData resolvePhase = FirResolvePhase.ANALYZED_DEPENDENCIES origin = FirDeclarationOrigin.BuiltIns name = Name.identifier("P$it") @@ -150,7 +150,7 @@ abstract class FirSyntheticFunctionalInterfaceProviderBase( ) typeParameters.add( buildTypeParameter { - moduleData = this@FirSyntheticFunctionalInterfaceProviderBase.moduleData + moduleData = this@FirSyntheticFunctionInterfaceProviderBase.moduleData resolvePhase = FirResolvePhase.ANALYZED_DEPENDENCIES origin = FirDeclarationOrigin.BuiltIns name = Name.identifier("R") @@ -175,13 +175,13 @@ abstract class FirSyntheticFunctionalInterfaceProviderBase( isInline = false isTailRec = false isExternal = false - isSuspend = kind.isSuspendType + isSuspend = kind.isSuspendOrKSuspendFunction } val typeArguments = typeParameters.map { ConeTypeParameterTypeImpl(it.symbol.toLookupTag(), false).toFirResolvedTypeRef() } - fun createSuperType(kind: FunctionalTypeKind): FirResolvedTypeRef { + fun createSuperType(kind: FunctionTypeKind): FirResolvedTypeRef { return kind.classId(arity).toLookupTag() .constructClassType(typeArguments.map { it.type }.toTypedArray(), isNullable = false) .toFirResolvedTypeRef() @@ -200,7 +200,7 @@ abstract class FirSyntheticFunctionalInterfaceProviderBase( addDeclaration( buildSimpleFunction { - moduleData = this@FirSyntheticFunctionalInterfaceProviderBase.moduleData + moduleData = this@FirSyntheticFunctionInterfaceProviderBase.moduleData resolvePhase = FirResolvePhase.ANALYZED_DEPENDENCIES origin = FirDeclarationOrigin.BuiltIns returnTypeRef = typeArguments.last() @@ -213,7 +213,7 @@ abstract class FirSyntheticFunctionalInterfaceProviderBase( valueParameters += typeArguments.dropLast(1).mapIndexed { index, typeArgument -> val parameterName = Name.identifier("p${index + 1}") buildValueParameter { - moduleData = this@FirSyntheticFunctionalInterfaceProviderBase.moduleData + moduleData = this@FirSyntheticFunctionInterfaceProviderBase.moduleData containingFunctionSymbol = this@buildSimpleFunction.symbol origin = FirDeclarationOrigin.BuiltIns resolvePhase = FirResolvePhase.ANALYZED_DEPENDENCIES @@ -242,5 +242,5 @@ abstract class FirSyntheticFunctionalInterfaceProviderBase( } } - private fun FunctionalTypeKind.classId(arity: Int) = ClassId(packageFqName, numberedClassName(arity)) + private fun FunctionTypeKind.classId(arity: Int) = ClassId(packageFqName, numberedClassName(arity)) } diff --git a/compiler/fir/providers/src/org/jetbrains/kotlin/fir/types/ConeInferenceContext.kt b/compiler/fir/providers/src/org/jetbrains/kotlin/fir/types/ConeInferenceContext.kt index 2cbc7a0080f..634608ab951 100644 --- a/compiler/fir/providers/src/org/jetbrains/kotlin/fir/types/ConeInferenceContext.kt +++ b/compiler/fir/providers/src/org/jetbrains/kotlin/fir/types/ConeInferenceContext.kt @@ -5,7 +5,7 @@ package org.jetbrains.kotlin.fir.types -import org.jetbrains.kotlin.builtins.functions.FunctionalTypeKind +import org.jetbrains.kotlin.builtins.functions.FunctionTypeKind import org.jetbrains.kotlin.descriptors.Modality import org.jetbrains.kotlin.fir.declarations.utils.modality import org.jetbrains.kotlin.fir.diagnostics.ConeIntermediateDiagnostic @@ -67,7 +67,7 @@ interface ConeInferenceContext : TypeSystemInferenceExtensionContext, ConeTypeCo ): SimpleTypeMarker { val attributesList = attributes?.filterIsInstanceTo, MutableList>>(mutableListOf()) val coneAttributes: ConeAttributes = if (isExtensionFunction) { - require(constructor is ConeClassLikeLookupTag && constructor.isSomeFunctionalType(session)) + require(constructor is ConeClassLikeLookupTag && constructor.isSomeFunctionType(session)) // We don't want to create new instance of ConeAttributes which // contains only CompilerConeAttributes.ExtensionFunctionType // to avoid memory consumption @@ -224,10 +224,10 @@ interface ConeInferenceContext : TypeSystemInferenceExtensionContext, ConeTypeCo return this.typeConstructor().isUnitTypeConstructor() && !this.isNullable } - override fun KotlinTypeMarker.isBuiltinFunctionalTypeOrSubtype(): Boolean { + override fun KotlinTypeMarker.isBuiltinFunctionTypeOrSubtype(): Boolean { require(this is ConeKotlinType) return this.isTypeOrSubtypeOf { - (it.lowerBoundIfFlexible() as ConeKotlinType).isSomeFunctionalType(session) + (it.lowerBoundIfFlexible() as ConeKotlinType).isSomeFunctionType(session) } } @@ -464,7 +464,7 @@ interface ConeInferenceContext : TypeSystemInferenceExtensionContext, ConeTypeCo override fun KotlinTypeMarker.isFunctionOrKFunctionWithAnySuspendability(): Boolean { require(this is ConeKotlinType) - return this.isSomeFunctionalType(session) + return this.isSomeFunctionType(session) } fun ConeKotlinType.isTypeOrSubtypeOf(predicate: (ConeKotlinType) -> Boolean): Boolean { @@ -495,34 +495,35 @@ interface ConeInferenceContext : TypeSystemInferenceExtensionContext, ConeTypeCo return (this.lowerBoundIfFlexible() as? ConeKotlinType)?.isExtensionFunctionType(session) == true } - override fun KotlinTypeMarker.extractArgumentsForFunctionalTypeOrSubtype(): List { - val builtInFunctionalType = getFunctionalTypeFromSupertypes() as ConeKotlinType + override fun KotlinTypeMarker.extractArgumentsForFunctionTypeOrSubtype(): List { + val builtInFunctionType = getFunctionTypeFromSupertypes() as ConeKotlinType return buildList { // excluding return type - for (index in 0 until builtInFunctionalType.argumentsCount() - 1) { - add(builtInFunctionalType.getArgument(index).getType()) + for (index in 0 until builtInFunctionType.argumentsCount() - 1) { + add(builtInFunctionType.getArgument(index).getType()) } } } - override fun KotlinTypeMarker.getFunctionalTypeFromSupertypes(): KotlinTypeMarker { + override fun KotlinTypeMarker.getFunctionTypeFromSupertypes(): KotlinTypeMarker { require(this is ConeKotlinType) - assert(this.isBuiltinFunctionalTypeOrSubtype()) { + assert(this.isBuiltinFunctionTypeOrSubtype()) { "Not a function type or subtype: ${this.renderForDebugging()}" } return fullyExpandedType(session).let { val simpleType = it.lowerBoundIfFlexible() - if ((simpleType as ConeKotlinType).isSomeFunctionalType(session)) + if ((simpleType as ConeKotlinType).isSomeFunctionType(session)) this else { var functionalSupertype: KotlinTypeMarker? = null simpleType.anySuperTypeConstructor { type -> simpleType.fastCorrespondingSupertypes(type.typeConstructor())?.any { superType -> - val isFunctional = (superType as ConeKotlinType).isSomeFunctionalType(session) - if (isFunctional) + val isFunction = (superType as ConeKotlinType).isSomeFunctionType(session) + if (isFunction) { functionalSupertype = superType - isFunctional + } + isFunction } ?: false } functionalSupertype ?: error("Failed to find functional supertype for $simpleType") @@ -530,16 +531,16 @@ interface ConeInferenceContext : TypeSystemInferenceExtensionContext, ConeTypeCo } } - override fun KotlinTypeMarker.functionalTypeKind(): FunctionalTypeKind? { + override fun KotlinTypeMarker.functionTypeKind(): FunctionTypeKind? { require(this is ConeKotlinType) - return this.functionalTypeKind(session) + return this.functionTypeKind(session) } - override fun getNonReflectFunctionTypeConstructor(parametersNumber: Int, kind: FunctionalTypeKind): TypeConstructorMarker { + override fun getNonReflectFunctionTypeConstructor(parametersNumber: Int, kind: FunctionTypeKind): TypeConstructorMarker { return kind.nonReflectKind().numberedClassId(parametersNumber).toLookupTag() } - override fun getReflectFunctionTypeConstructor(parametersNumber: Int, kind: FunctionalTypeKind): TypeConstructorMarker { + override fun getReflectFunctionTypeConstructor(parametersNumber: Int, kind: FunctionTypeKind): TypeConstructorMarker { return kind.reflectKind().numberedClassId(parametersNumber).toLookupTag() } diff --git a/compiler/fir/providers/src/org/jetbrains/kotlin/fir/types/FirFunctionalTypeKindServiceImpl.kt b/compiler/fir/providers/src/org/jetbrains/kotlin/fir/types/FirFunctionTypeKindServiceImpl.kt similarity index 68% rename from compiler/fir/providers/src/org/jetbrains/kotlin/fir/types/FirFunctionalTypeKindServiceImpl.kt rename to compiler/fir/providers/src/org/jetbrains/kotlin/fir/types/FirFunctionTypeKindServiceImpl.kt index f6911cb61d3..67b63477b22 100644 --- a/compiler/fir/providers/src/org/jetbrains/kotlin/fir/types/FirFunctionalTypeKindServiceImpl.kt +++ b/compiler/fir/providers/src/org/jetbrains/kotlin/fir/types/FirFunctionTypeKindServiceImpl.kt @@ -5,30 +5,30 @@ package org.jetbrains.kotlin.fir.types -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.fir.FirSession import org.jetbrains.kotlin.fir.declarations.toAnnotationClassId import org.jetbrains.kotlin.fir.declarations.utils.isSuspend -import org.jetbrains.kotlin.fir.extensions.FirFunctionalTypeKindExtension +import org.jetbrains.kotlin.fir.extensions.FirFunctionTypeKindExtension import org.jetbrains.kotlin.fir.extensions.extensionService -import org.jetbrains.kotlin.fir.extensions.functionalTypeKindExtensions +import org.jetbrains.kotlin.fir.extensions.functionTypeKindExtensions import org.jetbrains.kotlin.fir.symbols.impl.FirAnonymousFunctionSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol import org.jetbrains.kotlin.name.ClassId -class FirFunctionalTypeKindServiceImpl(private val session: FirSession) : FirFunctionalTypeKindService() { - private val nonReflectKindsFromExtensions = mutableListOf() +class FirFunctionTypeKindServiceImpl(private val session: FirSession) : FirFunctionTypeKindService() { + private val nonReflectKindsFromExtensions = mutableListOf() - override val extractor: FunctionalTypeKindExtractor = run { + override val extractor: FunctionTypeKindExtractor = run { val kinds = buildList { - add(FunctionalTypeKind.Function) - add(FunctionalTypeKind.SuspendFunction) - add(FunctionalTypeKind.KFunction) - add(FunctionalTypeKind.KSuspendFunction) + add(FunctionTypeKind.Function) + add(FunctionTypeKind.SuspendFunction) + add(FunctionTypeKind.KFunction) + add(FunctionTypeKind.KSuspendFunction) - val registrar = object : FirFunctionalTypeKindExtension.FunctionalTypeKindRegistrar { - override fun registerKind(nonReflectKind: FunctionalTypeKind, reflectKind: FunctionalTypeKind) { + val registrar = object : FirFunctionTypeKindExtension.FunctionTypeKindRegistrar { + override fun registerKind(nonReflectKind: FunctionTypeKind, reflectKind: FunctionTypeKind) { require(nonReflectKind.reflectKind() == reflectKind) require(reflectKind.nonReflectKind() == nonReflectKind) add(nonReflectKind) @@ -37,7 +37,7 @@ class FirFunctionalTypeKindServiceImpl(private val session: FirSession) : FirFun } } - for (extension in session.extensionService.functionalTypeKindExtensions) { + for (extension in session.extensionService.functionTypeKindExtensions) { with(extension) { registrar.registerKinds() } } }.also { kinds -> @@ -47,18 +47,18 @@ class FirFunctionalTypeKindServiceImpl(private val session: FirSession) : FirFun } } - FunctionalTypeKindExtractor(kinds) + FunctionTypeKindExtractor(kinds) } - override fun extractSingleSpecialKindForFunction(functionSymbol: FirFunctionSymbol<*>): FunctionalTypeKind? { + override fun extractSingleSpecialKindForFunction(functionSymbol: FirFunctionSymbol<*>): FunctionTypeKind? { if (nonReflectKindsFromExtensions.isEmpty()) { - return FunctionalTypeKind.SuspendFunction.takeIf { functionSymbol.isSuspend } + return FunctionTypeKind.SuspendFunction.takeIf { functionSymbol.isSuspend } } return extractAllSpecialKindsForFunction(functionSymbol).singleOrNull() } - override fun extractAllSpecialKindsForFunction(functionSymbol: FirFunctionSymbol<*>): List { + override fun extractAllSpecialKindsForFunction(functionSymbol: FirFunctionSymbol<*>): List { return extractSpecialKindsImpl( functionSymbol, { isSuspend }, @@ -71,7 +71,7 @@ class FirFunctionalTypeKindServiceImpl(private val session: FirSession) : FirFun ) } - override fun extractAllSpecialKindsForFunctionalTypeRef(typeRef: FirFunctionTypeRef): List { + override fun extractAllSpecialKindsForFunctionTypeRef(typeRef: FirFunctionTypeRef): List { return extractSpecialKindsImpl(typeRef, { isSuspend }, { annotations.mapNotNull { it.toAnnotationClassId(session) } }) } @@ -79,10 +79,10 @@ class FirFunctionalTypeKindServiceImpl(private val session: FirSession) : FirFun source: T, isSuspend: T.() -> Boolean, annotations: T.() -> List - ): List { + ): List { return buildList { if (source.isSuspend()) { - add(FunctionalTypeKind.SuspendFunction) + add(FunctionTypeKind.SuspendFunction) } if (nonReflectKindsFromExtensions.isNotEmpty()) { for (annotationClassId in source.annotations()) { diff --git a/compiler/fir/providers/src/org/jetbrains/kotlin/fir/types/FunctionalTypeUtils.kt b/compiler/fir/providers/src/org/jetbrains/kotlin/fir/types/FunctionalTypeUtils.kt index 88118c9ae2e..88598164da0 100644 --- a/compiler/fir/providers/src/org/jetbrains/kotlin/fir/types/FunctionalTypeUtils.kt +++ b/compiler/fir/providers/src/org/jetbrains/kotlin/fir/types/FunctionalTypeUtils.kt @@ -5,8 +5,8 @@ package org.jetbrains.kotlin.fir.types -import org.jetbrains.kotlin.builtins.functions.FunctionalTypeKind -import org.jetbrains.kotlin.builtins.functions.isRegularFunction +import org.jetbrains.kotlin.builtins.functions.FunctionTypeKind +import org.jetbrains.kotlin.builtins.functions.isBasicFunctionOrKFunction import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.declarations.FirClass import org.jetbrains.kotlin.fir.declarations.FirFunction @@ -28,85 +28,80 @@ import org.jetbrains.kotlin.types.AbstractTypeChecker import org.jetbrains.kotlin.util.OperatorNameConventions import org.jetbrains.kotlin.utils.addToStdlib.runUnless -// ---------------------------------------------- is type is a functional type ---------------------------------------------- +// ---------------------------------------------- is type is a function type ---------------------------------------------- -fun ConeKotlinType.functionalTypeKind(session: FirSession): FunctionalTypeKind? { +fun ConeKotlinType.functionTypeKind(session: FirSession): FunctionTypeKind? { if (this !is ConeClassLikeType) return null - return fullyExpandedType(session).lookupTag.functionalTypeKind(session) + return fullyExpandedType(session).lookupTag.functionTypeKind(session) } -private fun ConeClassLikeLookupTag.functionalTypeKind(session: FirSession): FunctionalTypeKind? { +private fun ConeClassLikeLookupTag.functionTypeKind(session: FirSession): FunctionTypeKind? { val classId = classId - return session.functionalTypeService.getKindByClassNamePrefix(classId.packageFqName, classId.shortClassName.asString()) + return session.functionTypeService.getKindByClassNamePrefix(classId.packageFqName, classId.shortClassName.asString()) } -private inline fun ConeKotlinType.isFunctionalTypeWithPredicate( +private inline fun ConeKotlinType.isFunctionTypeWithPredicate( session: FirSession, - errorOnNotFunctionalType: Boolean = false, - predicate: (FunctionalTypeKind) -> Boolean + errorOnNotFunctionType: Boolean = false, + predicate: (FunctionTypeKind) -> Boolean ): Boolean { - val kind = functionalTypeKind(session) - ?: if (errorOnNotFunctionalType) error("$this is not a functional type") else return false + val kind = functionTypeKind(session) + ?: if (errorOnNotFunctionType) error("$this is not a function type") else return false return predicate(kind) } // Function -fun ConeKotlinType.isSimpleFunctionType(session: FirSession): Boolean { - return isFunctionalTypeWithPredicate(session) { it == FunctionalTypeKind.Function } -} - -// Function, SuspendFunction, [Custom]Function -fun ConeKotlinType.isNonReflectFunctionalType(session: FirSession): Boolean { - return isFunctionalTypeWithPredicate(session) { !it.isReflectType } +fun ConeKotlinType.isBasicFunctionType(session: FirSession): Boolean { + return isFunctionTypeWithPredicate(session) { it == FunctionTypeKind.Function } } // SuspendFunction, KSuspendFunction -fun ConeKotlinType.isSuspendFunctionType(session: FirSession): Boolean { - return isFunctionalTypeWithPredicate(session) { - it == FunctionalTypeKind.SuspendFunction || it == FunctionalTypeKind.KSuspendFunction +fun ConeKotlinType.isSuspendOrKSuspendFunctionType(session: FirSession): Boolean { + return isFunctionTypeWithPredicate(session) { + it == FunctionTypeKind.SuspendFunction || it == FunctionTypeKind.KSuspendFunction } } // KFunction, KSuspendFunction, K[Custom]Function -fun ConeKotlinType.isReflectFunctionalType(session: FirSession): Boolean { - return isFunctionalTypeWithPredicate(session) { it.isReflectType } +fun ConeKotlinType.isReflectFunctionType(session: FirSession): Boolean { + return isFunctionTypeWithPredicate(session) { it.isReflectType } +} + +// Function, SuspendFunction, [Custom]Function +fun ConeKotlinType.isNonReflectFunctionType(session: FirSession): Boolean { + return isFunctionTypeWithPredicate(session) { !it.isReflectType } } // Function, SuspendFunction, [Custom]Function, KFunction, KSuspendFunction, K[Custom]Function -fun ConeKotlinType.isSomeFunctionalType(session: FirSession): Boolean { - return functionalTypeKind(session) != null +fun ConeKotlinType.isSomeFunctionType(session: FirSession): Boolean { + return functionTypeKind(session) != null } // Function, SuspendFunction, [Custom]Function, KFunction, KSuspendFunction, K[Custom]Function -fun ConeClassLikeLookupTag.isSomeFunctionalType(session: FirSession): Boolean { - return functionalTypeKind(session) != null -} - -// Function, KFunction -private fun ConeKotlinType.isSimpleFunctionalType(session: FirSession, errorOnNotFunctionalType: Boolean): Boolean { - return isFunctionalTypeWithPredicate(session, errorOnNotFunctionalType) { it.isRegularFunction } +fun ConeClassLikeLookupTag.isSomeFunctionType(session: FirSession): Boolean { + return functionTypeKind(session) != null } // SuspendFunction, [Custom]Function, KSuspendFunction, K[Custom]Function -fun ConeKotlinType.isNotSimpleFunctionalType(session: FirSession): Boolean { - return isFunctionalTypeWithPredicate(session, errorOnNotFunctionalType = false) { !it.isRegularFunction } +fun ConeKotlinType.isNotBasicFunctionType(session: FirSession): Boolean { + return isFunctionTypeWithPredicate(session, errorOnNotFunctionType = false) { !it.isBasicFunctionOrKFunction } } -// ---------------------------------------------- functional type conversions ---------------------------------------------- +// ---------------------------------------------- function type conversions ---------------------------------------------- /* * SuspendFunction/[Custom]Function -> Function * KSuspendFunction/K[Custom]Function -> KFunction */ -fun ConeKotlinType.customFunctionalTypeToSimpleFunctionalType(session: FirSession): ConeClassLikeType { - val kind = functionalTypeKind(session) - require(kind != null && kind != FunctionalTypeKind.Function && kind != FunctionalTypeKind.KFunction) +fun ConeKotlinType.customFunctionTypeToSimpleFunctionType(session: FirSession): ConeClassLikeType { + val kind = functionTypeKind(session) + require(kind != null && kind != FunctionTypeKind.Function && kind != FunctionTypeKind.KFunction) val newKind = if (kind.isReflectType) { - FunctionalTypeKind.KFunction + FunctionTypeKind.KFunction } else { - FunctionalTypeKind.Function + FunctionTypeKind.Function } - return createFunctionalTypeWithNewKind(session, newKind) + return createFunctionTypeWithNewKind(session, newKind) } /* @@ -114,68 +109,73 @@ fun ConeKotlinType.customFunctionalTypeToSimpleFunctionalType(session: FirSessio * KSuspendFunction -> SuspendFunction * K[Custom]Function -> [Custom]Function */ -fun ConeKotlinType.reflectFunctionalTypeToNonReflectFunctionalType(session: FirSession): ConeClassLikeType { - val kind = functionalTypeKind(session) +fun ConeKotlinType.reflectFunctionTypeToNonReflectFunctionType(session: FirSession): ConeClassLikeType { + val kind = functionTypeKind(session) require(kind != null && kind.isReflectType) - return createFunctionalTypeWithNewKind(session, kind.nonReflectKind()) + return createFunctionTypeWithNewKind(session, kind.nonReflectKind()) } -private fun ConeKotlinType.createFunctionalTypeWithNewKind(session: FirSession, kind: FunctionalTypeKind): ConeClassLikeType { +private fun ConeKotlinType.createFunctionTypeWithNewKind(session: FirSession, kind: FunctionTypeKind): ConeClassLikeType { val expandedType = fullyExpandedType(session) - val functionalTypeId = ClassId(kind.packageFqName, kind.numberedClassName(expandedType.typeArguments.size - 1)) - return functionalTypeId.toLookupTag().constructClassType( + val functionTypeId = ClassId(kind.packageFqName, kind.numberedClassName(expandedType.typeArguments.size - 1)) + return functionTypeId.toLookupTag().constructClassType( expandedType.typeArguments, isNullable = false, attributes = expandedType.attributes ) } -// ---------------------------------------------- functional type subtyping ---------------------------------------------- +// ---------------------------------------------- function type subtyping ---------------------------------------------- -// expectedFunctionalType is kotlin.FunctionN or kotlin.reflect.KFunctionN -fun ConeKotlinType.findSubtypeOfSimpleFunctionalType(session: FirSession, expectedFunctionalType: ConeClassLikeType): ConeKotlinType? { - require(expectedFunctionalType.isSimpleFunctionalType(session, errorOnNotFunctionalType = true)) - return findSubtypeOfSimpleFunctionalTypeImpl(session, expectedFunctionalType) +// expectedfunctionType is kotlin.FunctionN or kotlin.reflect.KFunctionN +fun ConeKotlinType.findSubtypeOfBasicFunctionType(session: FirSession, expectedFunctionType: ConeClassLikeType): ConeKotlinType? { + require(expectedFunctionType.isFunctionOrKFunctionType(session, errorOnNotFunctionType = true)) + return findSubtypeOfBasicFunctionTypeImpl(session, expectedFunctionType) } -private fun ConeKotlinType.findSubtypeOfSimpleFunctionalTypeImpl( +// Function, KFunction +private fun ConeKotlinType.isFunctionOrKFunctionType(session: FirSession, errorOnNotFunctionType: Boolean): Boolean { + return isFunctionTypeWithPredicate(session, errorOnNotFunctionType) { it.isBasicFunctionOrKFunction } +} + +private fun ConeKotlinType.findSubtypeOfBasicFunctionTypeImpl( session: FirSession, - expectedFunctionalType: ConeClassLikeType + expectedFunctionType: ConeClassLikeType ): ConeKotlinType? { return when (this) { is ConeClassLikeType -> { when { - // Expect the argument type is a simple functional type. - isNotSimpleFunctionalType(session) -> null - isSubtypeOfFunctionalType(session, expectedFunctionalType) -> this + // Expect the argument type is a simple function type. + isNotBasicFunctionType(session) -> null + isSubtypeOfFunctionType(session, expectedFunctionType) -> this else -> null } } is ConeIntersectionType -> { - runUnless(intersectedTypes.any { it.isNotSimpleFunctionalType(session) }) { - intersectedTypes.find { it.findSubtypeOfSimpleFunctionalTypeImpl(session, expectedFunctionalType) != null } + runUnless(intersectedTypes.any { it.isNotBasicFunctionType(session) }) { + intersectedTypes.find { it.findSubtypeOfBasicFunctionTypeImpl(session, expectedFunctionType) != null } } } is ConeTypeParameterType -> { val bounds = lookupTag.typeParameterSymbol.resolvedBounds.map { it.coneType } - runUnless(bounds.any { it.isNotSimpleFunctionalType(session) }) { - bounds.find { it.findSubtypeOfSimpleFunctionalTypeImpl(session, expectedFunctionalType) != null } + runUnless(bounds.any { it.isNotBasicFunctionType(session) }) { + bounds.find { it.findSubtypeOfBasicFunctionTypeImpl(session, expectedFunctionType) != null } } } else -> null } } -private fun ConeKotlinType.isSubtypeOfFunctionalType(session: FirSession, expectedFunctionalType: ConeClassLikeType): Boolean { - return AbstractTypeChecker.isSubtypeOf(session.typeContext, this, expectedFunctionalType.replaceArgumentsWithStarProjections()) +private fun ConeKotlinType.isSubtypeOfFunctionType(session: FirSession, expectedFunctionType: ConeClassLikeType): Boolean { + return AbstractTypeChecker.isSubtypeOf(session.typeContext, this, expectedFunctionType.replaceArgumentsWithStarProjections()) } -// ---------------------------------------------- functional type scope utils ---------------------------------------------- +// ---------------------------------------------- function type scope utils ---------------------------------------------- fun ConeClassLikeType.findBaseInvokeSymbol(session: FirSession, scopeSession: ScopeSession): FirNamedFunctionSymbol? { - require(this.isSomeFunctionalType(session)) + require(this.isSomeFunctionType(session)) val functionN = (lookupTag.toSymbol(session)?.fir as? FirClass) ?: return null var baseInvokeSymbol: FirNamedFunctionSymbol? = null functionN.unsubstitutedScope( @@ -192,10 +192,10 @@ fun ConeClassLikeType.findBaseInvokeSymbol(session: FirSession, scopeSession: Sc fun ConeKotlinType.findContributedInvokeSymbol( session: FirSession, scopeSession: ScopeSession, - expectedFunctionalType: ConeClassLikeType, + expectedFunctionType: ConeClassLikeType, shouldCalculateReturnTypesOfFakeOverrides: Boolean ): FirFunctionSymbol<*>? { - val baseInvokeSymbol = expectedFunctionalType.findBaseInvokeSymbol(session, scopeSession) ?: return null + val baseInvokeSymbol = expectedFunctionType.findBaseInvokeSymbol(session, scopeSession) ?: return null val fakeOverrideTypeCalculator = if (shouldCalculateReturnTypesOfFakeOverrides) { FakeOverrideTypeCalculator.Forced @@ -227,10 +227,10 @@ fun ConeKotlinType.findContributedInvokeSymbol( return if (overriddenInvoke != null) declaredInvoke else null } -// ---------------------------------------------- functional type type argument extraction ---------------------------------------------- +// ---------------------------------------------- function type type argument extraction ---------------------------------------------- fun ConeKotlinType.receiverType(session: FirSession): ConeKotlinType? { - if (!isSomeFunctionalType(session) || !isExtensionFunctionType(session)) return null + if (!isSomeFunctionType(session) || !isExtensionFunctionType(session)) return null return fullyExpandedType(session).let { expanded -> expanded.typeArguments[expanded.contextReceiversNumberForFunctionType].typeOrDefault(session.builtinTypes.nothingType.type) } @@ -255,8 +255,8 @@ private fun ConeTypeProjection.typeOrDefault(default: ConeKotlinType): ConeKotli // ----------------- TODO fir utils -fun FirFunction.specialFunctionalTypeKind(session: FirSession): FunctionalTypeKind? { +fun FirFunction.specialFunctionTypeKind(session: FirSession): FunctionTypeKind? { return (symbol as? FirNamedFunctionSymbol)?.let { - session.functionalTypeService.extractSingleSpecialKindForFunction(it) + session.functionTypeService.extractSingleSpecialKindForFunction(it) } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirOverloadByLambdaReturnTypeResolver.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirOverloadByLambdaReturnTypeResolver.kt index 350e12b02df..05fc4680352 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirOverloadByLambdaReturnTypeResolver.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirOverloadByLambdaReturnTypeResolver.kt @@ -18,7 +18,7 @@ import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirAbstractBodyResolveTransformer import org.jetbrains.kotlin.fir.types.classId import org.jetbrains.kotlin.fir.types.coneType -import org.jetbrains.kotlin.fir.types.isSomeFunctionalType +import org.jetbrains.kotlin.fir.types.isSomeFunctionType import org.jetbrains.kotlin.resolve.calls.inference.components.ConstraintSystemCompletionMode import org.jetbrains.kotlin.resolve.descriptorUtil.OVERLOAD_RESOLUTION_BY_LAMBDA_ANNOTATION_CLASS_ID import org.jetbrains.kotlin.utils.addToStdlib.same @@ -104,7 +104,7 @@ class FirOverloadByLambdaReturnTypeResolver( .values.singleOrNull()?.toMap() ?: return null if (!lambdas.values.same { it.parameters.size }) return null - if (!lambdas.values.all { it.expectedType?.isSomeFunctionalType(session) == true }) return null + if (!lambdas.values.all { it.expectedType?.isSomeFunctionType(session) == true }) return null val originalCalleeReference = call.calleeReference diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/FirSamConversionTransformerExtension.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/FirSamConversionTransformerExtension.kt index 9e38920789f..a021dc8ca46 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/FirSamConversionTransformerExtension.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/FirSamConversionTransformerExtension.kt @@ -23,7 +23,7 @@ abstract class FirSamConversionTransformerExtension(session: FirSession) : FirEx final override val extensionType: KClass = FirSamConversionTransformerExtension::class - abstract fun getCustomFunctionalTypeForSamConversion(function: FirSimpleFunction): ConeLookupTagBasedType? + abstract fun getCustomFunctionTypeForSamConversion(function: FirSimpleFunction): ConeLookupTagBasedType? fun interface Factory : FirExtension.Factory } 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 d2ce84d7194..a9bd7d43382 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 @@ -7,7 +7,7 @@ package org.jetbrains.kotlin.fir.resolve import org.jetbrains.kotlin.KtFakeSourceElementKind import org.jetbrains.kotlin.KtSourceElement -import org.jetbrains.kotlin.builtins.functions.FunctionalTypeKind +import org.jetbrains.kotlin.builtins.functions.FunctionTypeKind import org.jetbrains.kotlin.config.LanguageFeature import org.jetbrains.kotlin.descriptors.ClassKind import org.jetbrains.kotlin.descriptors.Modality @@ -88,9 +88,9 @@ fun FirAnonymousFunction.addReturnToLastStatementIfNeeded() { } /** - * [kind] == null means that [FunctionalTypeKind.Function] will be used + * [kind] == null means that [FunctionTypeKind.Function] will be used */ -fun FirFunction.constructFunctionalType(kind: FunctionalTypeKind? = null): ConeLookupTagBasedType { +fun FirFunction.constructFunctionType(kind: FunctionTypeKind? = null): ConeLookupTagBasedType { val receiverTypeRef = when (this) { is FirSimpleFunction -> receiverParameter is FirAnonymousFunction -> receiverParameter @@ -107,28 +107,28 @@ fun FirFunction.constructFunctionalType(kind: FunctionalTypeKind? = null): ConeL } val rawReturnType = (this as FirCallableDeclaration).returnTypeRef.coneType - return createFunctionalType( - kind ?: FunctionalTypeKind.Function, parameters, receiverTypeRef?.coneType, rawReturnType, + return createFunctionType( + kind ?: FunctionTypeKind.Function, parameters, receiverTypeRef?.coneType, rawReturnType, contextReceivers = contextReceivers.map { it.typeRef.coneType } ) } /** - * [kind] == null means that [FunctionalTypeKind.Function] will be used + * [kind] == null means that [FunctionTypeKind.Function] will be used */ -fun FirAnonymousFunction.constructFunctionalTypeRef(session: FirSession, kind: FunctionalTypeKind? = null): FirResolvedTypeRef { +fun FirAnonymousFunction.constructFunctionTypeRef(session: FirSession, kind: FunctionTypeKind? = null): FirResolvedTypeRef { var diagnostic: ConeDiagnostic? = null - val kinds = session.functionalTypeService.extractAllSpecialKindsForFunction(symbol) + val kinds = session.functionTypeService.extractAllSpecialKindsForFunction(symbol) val kindFromDeclaration = when(kinds.size) { 0 -> null 1 -> kinds.single() else -> { - diagnostic = ConeAmbiguousFunctionalTypeKinds(kinds) - FunctionalTypeKind.Function + diagnostic = ConeAmbiguousFunctionTypeKinds(kinds) + FunctionTypeKind.Function } } - val type = constructFunctionalType(kindFromDeclaration ?: kind) - val source = this@constructFunctionalTypeRef.source?.fakeElement(KtFakeSourceElementKind.ImplicitTypeRef) + val type = constructFunctionType(kindFromDeclaration ?: kind) + val source = this@constructFunctionTypeRef.source?.fakeElement(KtFakeSourceElementKind.ImplicitTypeRef) return if (diagnostic == null) { buildResolvedTypeRef { this.source = source @@ -143,8 +143,8 @@ fun FirAnonymousFunction.constructFunctionalTypeRef(session: FirSession, kind: F } } -fun createFunctionalType( - kind: FunctionalTypeKind, +fun createFunctionType( + kind: FunctionTypeKind, parameters: List, receiverType: ConeKotlinType?, rawReturnType: ConeKotlinType, @@ -158,7 +158,7 @@ fun createFunctionalType( add(rawReturnType) } - val functionalTypeId = ClassId(kind.packageFqName, kind.numberedClassName(receiverAndParameterTypes.size - 1)) + val functionTypeId = ClassId(kind.packageFqName, kind.numberedClassName(receiverAndParameterTypes.size - 1)) val attributes = when { contextReceivers.isNotEmpty() -> ConeAttributes.create( buildList { @@ -172,7 +172,7 @@ fun createFunctionalType( else -> ConeAttributes.Empty } return ConeClassLikeTypeImpl( - functionalTypeId.toLookupTag(), + functionTypeId.toLookupTag(), receiverAndParameterTypes.toTypedArray(), isNullable = false, attributes = attributes @@ -592,7 +592,7 @@ fun FirFunction.getAsForbiddenNamedArgumentsTarget( result } // referenced function of a Kotlin function type - FirDeclarationOrigin.BuiltIns -> runIf(dispatchReceiverClassLookupTagOrNull()?.isSomeFunctionalType(session) == true) { + FirDeclarationOrigin.BuiltIns -> runIf(dispatchReceiverClassLookupTagOrNull()?.isSomeFunctionType(session) == true) { ForbiddenNamedArgumentsTarget.INVOKE_ON_FUNCTION_TYPE } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/SamResolution.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/SamResolution.kt index af9332f3f2a..e7db400d22d 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/SamResolution.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/SamResolution.kt @@ -5,7 +5,7 @@ package org.jetbrains.kotlin.fir.resolve -import org.jetbrains.kotlin.builtins.functions.FunctionalTypeKind +import org.jetbrains.kotlin.builtins.functions.FunctionTypeKind import org.jetbrains.kotlin.descriptors.ClassKind import org.jetbrains.kotlin.descriptors.EffectiveVisibility import org.jetbrains.kotlin.descriptors.Modality @@ -263,7 +263,7 @@ class FirSamResolver( // TODO: val shouldConvertFirstParameterToDescriptor = samWithReceiverResolvers.any { it.shouldConvertFirstSamParameterToReceiver(abstractMethod) } val typeFromExtension = samConversionTransformers.firstNotNullOfOrNull { - it.getCustomFunctionalTypeForSamConversion(abstractMethod) + it.getCustomFunctionTypeForSamConversion(abstractMethod) } SAMInfo(abstractMethod.symbol, typeFromExtension ?: abstractMethod.getFunctionTypeForAbstractMethod(session)) @@ -415,8 +415,8 @@ private fun FirSimpleFunction.getFunctionTypeForAbstractMethod(session: FirSessi val contextReceiversTypes = contextReceivers.map { it.typeRef.coneTypeSafe() ?: ConeErrorType(ConeIntermediateDiagnostic("No type for context receiver $it")) } - val kind = session.functionalTypeService.extractSingleSpecialKindForFunction(symbol) ?: FunctionalTypeKind.Function - return createFunctionalType( + val kind = session.functionTypeService.extractSingleSpecialKindForFunction(symbol) ?: FunctionTypeKind.Function + return createFunctionType( kind, parameterTypes, receiverType = receiverParameter?.typeRef?.coneType, diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/Arguments.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/Arguments.kt index 02cd1902df2..db8fcfa7fe5 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/Arguments.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/Arguments.kt @@ -5,7 +5,7 @@ package org.jetbrains.kotlin.fir.resolve.calls -import org.jetbrains.kotlin.builtins.functions.isRegularFunction +import org.jetbrains.kotlin.builtins.functions.isBasicFunctionOrKFunction import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration import org.jetbrains.kotlin.fir.declarations.FirValueParameter @@ -13,7 +13,7 @@ import org.jetbrains.kotlin.fir.expressions.* import org.jetbrains.kotlin.fir.lookupTracker import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference import org.jetbrains.kotlin.fir.resolve.ScopeSession -import org.jetbrains.kotlin.fir.resolve.createFunctionalType +import org.jetbrains.kotlin.fir.resolve.createFunctionType import org.jetbrains.kotlin.fir.resolve.dfa.unwrapSmartcastExpression import org.jetbrains.kotlin.fir.resolve.fullyExpandedType import org.jetbrains.kotlin.fir.resolve.inference.model.ConeArgumentConstraintPosition @@ -271,7 +271,7 @@ fun Candidate.resolvePlainArgumentType( )?.let { argumentTypeForApplicabilityCheck = it substitutor.substituteOrSelf(argumentTypeForApplicabilityCheck) - usesFunctionalConversion = true + usesFunctionConversion = true } } @@ -287,21 +287,21 @@ private fun argumentTypeWithCustomConversion( argumentType: ConeKotlinType ): ConeKotlinType? { // Expect the expected type to be a not regular functional type (e.g. suspend or custom) - val expectedTypeKind = expectedType.functionalTypeKind(session) ?: return null - if (expectedTypeKind.isRegularFunction) return null + val expectedTypeKind = expectedType.functionTypeKind(session) ?: return null + if (expectedTypeKind.isBasicFunctionOrKFunction) return null // We want to check the argument type against non-suspend functional type. - val expectedFunctionalType = expectedType.customFunctionalTypeToSimpleFunctionalType(session) + val expectedFunctionType = expectedType.customFunctionTypeToSimpleFunctionType(session) - val argumentTypeWithInvoke = argumentType.findSubtypeOfSimpleFunctionalType(session, expectedFunctionalType) + val argumentTypeWithInvoke = argumentType.findSubtypeOfBasicFunctionType(session, expectedFunctionType) return argumentTypeWithInvoke?.findContributedInvokeSymbol( session, scopeSession, - expectedFunctionalType, + expectedFunctionType, shouldCalculateReturnTypesOfFakeOverrides = false )?.let { invokeSymbol -> - createFunctionalType( + createFunctionType( expectedTypeKind, invokeSymbol.fir.valueParameters.map { it.returnTypeRef.coneType }, null, @@ -495,7 +495,7 @@ private fun Candidate.getExpectedTypeWithSAMConversion( candidateExpectedType: ConeKotlinType, context: ResolutionContext ): ConeKotlinType? { - if (candidateExpectedType.isSomeFunctionalType(session)) return null + if (candidateExpectedType.isSomeFunctionType(session)) return null // TODO: resolvedCall.registerArgumentWithSamConversion(argument, SamConversionDescription(convertedTypeByOriginal, convertedTypeByCandidate!!)) @@ -518,7 +518,7 @@ fun FirExpression.isFunctional( else -> { // Either a functional type or a subtype of a class that has a contributed `invoke`. val coneType = typeRef.coneTypeSafe() ?: return false - if (coneType.isSomeFunctionalType(session)) { + if (coneType.isSomeFunctionType(session)) { return true } val classLikeExpectedFunctionType = expectedFunctionType?.lowerBoundIfFlexible() as? ConeClassLikeType diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/CallableReferenceResolution.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/CallableReferenceResolution.kt index bb868f2ff04..5629bb8eb60 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/CallableReferenceResolution.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/CallableReferenceResolution.kt @@ -7,8 +7,8 @@ package org.jetbrains.kotlin.fir.resolve.calls import org.jetbrains.kotlin.KtFakeSourceElementKind import org.jetbrains.kotlin.KtSourceElement -import org.jetbrains.kotlin.builtins.functions.FunctionalTypeKind -import org.jetbrains.kotlin.builtins.functions.isRegularFunction +import org.jetbrains.kotlin.builtins.functions.FunctionTypeKind +import org.jetbrains.kotlin.builtins.functions.isBasicFunctionOrKFunction import org.jetbrains.kotlin.config.LanguageFeature import org.jetbrains.kotlin.fir.* import org.jetbrains.kotlin.fir.declarations.* @@ -19,7 +19,7 @@ import org.jetbrains.kotlin.fir.expressions.FirResolvedQualifier import org.jetbrains.kotlin.fir.expressions.builder.buildNamedArgumentExpression import org.jetbrains.kotlin.fir.resolve.BodyResolveComponents import org.jetbrains.kotlin.fir.resolve.DoubleColonLHS -import org.jetbrains.kotlin.fir.resolve.createFunctionalType +import org.jetbrains.kotlin.fir.resolve.createFunctionType import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeUnsupportedCallableReferenceTarget import org.jetbrains.kotlin.fir.resolve.inference.extractInputOutputTypesFromCallableReferenceExpectedType import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol @@ -131,12 +131,12 @@ private fun buildReflectionType( } - val baseFunctionalTypeKind = callableReferenceAdaptation?.suspendConversionStrategy?.kind - ?: fir.specialFunctionalTypeKind(context.session) - ?: FunctionalTypeKind.Function + val baseFunctionTypeKind = callableReferenceAdaptation?.suspendConversionStrategy?.kind + ?: fir.specialFunctionTypeKind(context.session) + ?: FunctionTypeKind.Function - return createFunctionalType( - baseFunctionalTypeKind.reflectKind(), + return createFunctionType( + baseFunctionTypeKind.reflectKind(), parameters, receiverType = receiverType.takeIf { fir.receiverParameter != null }, rawReturnType = returnType, @@ -255,11 +255,11 @@ private fun BodyResolveComponents.getCallableReferenceAdaptation( else mappedArguments - val expectedTypeFunctionalKind = expectedType.functionalTypeKind(session)?.takeUnless { it.isRegularFunction } - val functionKind = function.specialFunctionalTypeKind(session) + val expectedTypeFunctionKind = expectedType.functionTypeKind(session)?.takeUnless { it.isBasicFunctionOrKFunction } + val functionKind = function.specialFunctionTypeKind(session) - val conversionStrategy = if (expectedTypeFunctionalKind != null && functionKind == null) { - CallableReferenceConversionStrategy.CustomConversion(expectedTypeFunctionalKind) + val conversionStrategy = if (expectedTypeFunctionKind != null && functionKind == null) { + CallableReferenceConversionStrategy.CustomConversion(expectedTypeFunctionKind) } else { CallableReferenceConversionStrategy.NoConversion } @@ -277,14 +277,14 @@ private fun BodyResolveComponents.getCallableReferenceAdaptation( sealed class CallableReferenceConversionStrategy { - abstract val kind: FunctionalTypeKind? + abstract val kind: FunctionTypeKind? object NoConversion : CallableReferenceConversionStrategy() { - override val kind: FunctionalTypeKind? + override val kind: FunctionTypeKind? get() = null } - class CustomConversion(override val kind: FunctionalTypeKind) : CallableReferenceConversionStrategy() + class CustomConversion(override val kind: FunctionTypeKind) : CallableReferenceConversionStrategy() } private fun varargParameterTypeByExpectedParameter( diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/Candidate.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/Candidate.kt index 10946376cef..bfb1be619e5 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/Candidate.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/Candidate.kt @@ -62,13 +62,13 @@ class Candidate( internal var callableReferenceAdaptation: CallableReferenceAdaptation? = null set(value) { field = value - usesFunctionalConversion = value?.suspendConversionStrategy is CallableReferenceConversionStrategy.CustomConversion + usesFunctionConversion = value?.suspendConversionStrategy is CallableReferenceConversionStrategy.CustomConversion if (value != null) { numDefaults = value.defaults } } - var usesFunctionalConversion: Boolean = false + var usesFunctionConversion: Boolean = false var argumentMapping: LinkedHashMap? = null var numDefaults: Int = 0 diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ConeOverloadConflictResolver.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ConeOverloadConflictResolver.kt index 6b72992a0ea..7c725028390 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ConeOverloadConflictResolver.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ConeOverloadConflictResolver.kt @@ -94,7 +94,7 @@ class ConeOverloadConflictResolver( } if (discriminateSuspendConversions) { - val filtered = candidates.filterTo(mutableSetOf()) { !it.usesFunctionalConversion } + val filtered = candidates.filterTo(mutableSetOf()) { !it.usesFunctionConversion } when (filtered.size) { 1 -> return filtered 0, candidates.size -> { diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ResolutionStages.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ResolutionStages.kt index 2ad9bed3d90..c2602fbf5c4 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ResolutionStages.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ResolutionStages.kt @@ -297,7 +297,7 @@ object CheckDslScopeViolation : ResolutionStage() { // ``` // `useX()` is a call to `invoke` with `useX` as the dispatch receiver. In the FIR tree, extension receiver is represented as an // implicit `this` expression passed as the first argument. - if (candidate.dispatchReceiverValue?.type?.fullyExpandedType(context.session)?.isSomeFunctionalType(context.session) == true && + if (candidate.dispatchReceiverValue?.type?.fullyExpandedType(context.session)?.isSomeFunctionType(context.session) == true && (candidate.symbol as? FirNamedFunctionSymbol)?.name == OperatorNameConventions.INVOKE ) { val firstArg = candidate.argumentMapping?.keys?.firstOrNull() as? FirThisReceiverExpression ?: return diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/ConstraintSystemCompleter.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/ConstraintSystemCompleter.kt index 29376612432..916d8d63754 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/ConstraintSystemCompleter.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/ConstraintSystemCompleter.kt @@ -133,7 +133,7 @@ class ConstraintSystemCompleter(components: BodyResolveComponents, private val c // Stage 4: create atoms with revised expected types if needed for (argument in postponedArgumentsWithRevisableType) { - val argumentWasTransformed = transformToAtomWithNewFunctionalExpectedType( + val argumentWasTransformed = transformToAtomWithNewFunctionExpectedType( this, context, argument ) @@ -214,7 +214,7 @@ class ConstraintSystemCompleter(components: BodyResolveComponents, private val c return variableForFixation?.hasProperConstraint == true } - private fun transformToAtomWithNewFunctionalExpectedType( + private fun transformToAtomWithNewFunctionExpectedType( c: ConstraintSystemCompletionContext, resolutionContext: ResolutionContext, argument: PostponedAtomWithRevisableExpectedType, 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 cb80da55462..d106755a551 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 @@ -14,7 +14,7 @@ import org.jetbrains.kotlin.fir.resolve.BodyResolveComponents import org.jetbrains.kotlin.fir.resolve.calls.Candidate import org.jetbrains.kotlin.fir.types.* -fun extractLambdaInfoFromFunctionalType( +fun extractLambdaInfoFromFunctionType( expectedType: ConeKotlinType?, expectedTypeRef: FirTypeRef?, argument: FirAnonymousFunction, @@ -26,7 +26,7 @@ fun extractLambdaInfoFromFunctionalType( val session = components.session if (expectedType == null) return null if (expectedType is ConeFlexibleType) { - return extractLambdaInfoFromFunctionalType( + return extractLambdaInfoFromFunctionType( expectedType.lowerBound, expectedTypeRef, argument, @@ -36,8 +36,8 @@ fun extractLambdaInfoFromFunctionalType( duringCompletion ) } - val expectedFunctionalKind = expectedType.functionalTypeKind(session) ?: return null - val actualFunctionalKind = session.functionalTypeService.extractSingleSpecialKindForFunction(argument.symbol) + val expectedFunctionKind = expectedType.functionTypeKind(session) ?: return null + val actualFunctionKind = session.functionTypeService.extractSingleSpecialKindForFunction(argument.symbol) val singleStatement = argument.body?.statements?.singleOrNull() as? FirReturnExpression if (argument.returnType == null && singleStatement != null && @@ -101,7 +101,7 @@ fun extractLambdaInfoFromFunctionalType( return ResolvedLambdaAtom( argument, expectedType, - actualFunctionalKind ?: expectedFunctionalKind, + actualFunctionKind ?: expectedFunctionKind, receiverType, contextReceivers, parameters, diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/PostponedArguments.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/PostponedArguments.kt index f35293ae195..213644db40d 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/PostponedArguments.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/PostponedArguments.kt @@ -5,7 +5,7 @@ package org.jetbrains.kotlin.fir.resolve.inference -import org.jetbrains.kotlin.builtins.functions.FunctionalTypeKind +import org.jetbrains.kotlin.builtins.functions.FunctionTypeKind import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.declarations.FirAnonymousFunction import org.jetbrains.kotlin.fir.expressions.FirAnonymousFunctionExpression @@ -14,7 +14,7 @@ import org.jetbrains.kotlin.fir.resolve.calls.ArgumentTypeMismatch import org.jetbrains.kotlin.fir.resolve.calls.Candidate import org.jetbrains.kotlin.fir.resolve.calls.CheckerSink import org.jetbrains.kotlin.fir.resolve.calls.ResolutionContext -import org.jetbrains.kotlin.fir.resolve.createFunctionalType +import org.jetbrains.kotlin.fir.resolve.createFunctionType import org.jetbrains.kotlin.fir.resolve.inference.model.ConeArgumentConstraintPosition import org.jetbrains.kotlin.fir.resolve.inference.model.ConeExplicitTypeParameterConstraintPosition import org.jetbrains.kotlin.fir.types.* @@ -51,7 +51,7 @@ fun Candidate.preprocessLambdaArgument( val anonymousFunction = argument.anonymousFunction val resolvedArgument = - extractLambdaInfoFromFunctionalType( + extractLambdaInfoFromFunctionType( expectedType, expectedTypeRef, anonymousFunction, @@ -63,8 +63,8 @@ fun Candidate.preprocessLambdaArgument( if (expectedType != null) { val parameters = resolvedArgument.parameters - val lambdaType = createFunctionalType( - resolvedArgument.expectedFunctionalTypeKind ?: FunctionalTypeKind.Function, + val lambdaType = createFunctionType( + resolvedArgument.expectedFunctionTypeKind ?: FunctionTypeKind.Function, if (resolvedArgument.coerceFirstParameterToExtensionReceiver) parameters.drop(1) else parameters, resolvedArgument.receiver, resolvedArgument.returnType, @@ -107,8 +107,8 @@ private fun extractLambdaInfo( session: FirSession, candidate: Candidate? ): ResolvedLambdaAtom { - val expectedFunctionalKind = expectedType?.lowerBoundIfFlexible()?.functionalTypeKind(session) - val isFunctionSupertype = expectedFunctionalKind != null + val expectedFunctionKind = expectedType?.lowerBoundIfFlexible()?.functionTypeKind(session) + val isFunctionSupertype = expectedFunctionKind != null val typeVariable = ConeTypeVariableForLambdaReturnType(argument, "_L") @@ -133,7 +133,7 @@ private fun extractLambdaInfo( return ResolvedLambdaAtom( argument, expectedType, - expectedFunctionalKind, + expectedFunctionKind, receiverType, contextReceivers, parameters, diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/PostponedAtoms.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/PostponedAtoms.kt index 0a54a689679..2a4ec6a8ee3 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/PostponedAtoms.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/PostponedAtoms.kt @@ -5,7 +5,7 @@ package org.jetbrains.kotlin.fir.resolve.inference -import org.jetbrains.kotlin.builtins.functions.FunctionalTypeKind +import org.jetbrains.kotlin.builtins.functions.FunctionTypeKind import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.declarations.FirAnonymousFunction @@ -40,7 +40,7 @@ sealed class PostponedResolvedAtom : PostponedResolvedAtomMarker { class ResolvedLambdaAtom( override val atom: FirAnonymousFunction, expectedType: ConeKotlinType?, - val expectedFunctionalTypeKind: FunctionalTypeKind?, + val expectedFunctionTypeKind: FunctionTypeKind?, val receiver: ConeKotlinType?, val contextReceivers: List, val parameters: List, @@ -178,7 +178,7 @@ internal fun extractInputOutputTypesFromCallableReferenceExpectedType( if (expectedType == null) return null return when { - expectedType.isSomeFunctionalType(session) -> + expectedType.isSomeFunctionType(session) -> InputOutputTypes(expectedType.valueParameterTypesIncludingReceiver(session), expectedType.returnType(session)) // ReflectionTypes.isBaseTypeForNumberedReferenceTypes(expectedType) -> diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/providers/impl/FirTypeResolverImpl.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/providers/impl/FirTypeResolverImpl.kt index 046d10383ba..0c3491e1952 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/providers/impl/FirTypeResolverImpl.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/providers/impl/FirTypeResolverImpl.kt @@ -6,7 +6,7 @@ package org.jetbrains.kotlin.fir.resolve.providers.impl import org.jetbrains.kotlin.KtSourceElement -import org.jetbrains.kotlin.builtins.functions.FunctionalTypeKind +import org.jetbrains.kotlin.builtins.functions.FunctionTypeKind import org.jetbrains.kotlin.fir.* import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.impl.FirOuterClassTypeParameterRef @@ -19,7 +19,6 @@ import org.jetbrains.kotlin.fir.resolve.calls.AbstractCandidate import org.jetbrains.kotlin.fir.resolve.calls.ReceiverValue import org.jetbrains.kotlin.fir.resolve.calls.ResolutionDiagnostic import org.jetbrains.kotlin.fir.resolve.diagnostics.* -import org.jetbrains.kotlin.fir.resolve.providers.symbolProvider import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor import org.jetbrains.kotlin.fir.resolve.transformers.ScopeClassDeclaration import org.jetbrains.kotlin.fir.symbols.ConeTypeParameterLookupTag @@ -30,7 +29,6 @@ import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.fir.types.impl.ConeClassLikeTypeImpl import org.jetbrains.kotlin.fir.types.impl.ConeTypeParameterTypeImpl import org.jetbrains.kotlin.name.ClassId -import org.jetbrains.kotlin.name.StandardClassIds import org.jetbrains.kotlin.resolve.calls.inference.model.ConstraintSystemError import org.jetbrains.kotlin.resolve.calls.tasks.ExplicitReceiverKind import org.jetbrains.kotlin.resolve.calls.tower.CandidateApplicability @@ -445,20 +443,20 @@ class FirTypeResolverImpl(private val session: FirSession) : FirTypeResolver() { } } - private fun createFunctionalType(typeRef: FirFunctionTypeRef): Pair { + private fun createFunctionType(typeRef: FirFunctionTypeRef): Pair { val parameters = typeRef.contextReceiverTypeRefs.map { it.coneType } + listOfNotNull(typeRef.receiverTypeRef?.coneType) + typeRef.parameters.map { it.returnTypeRef.coneType.withParameterNameAnnotation(it, session) } + listOf(typeRef.returnTypeRef.coneType) - val functionalKinds = session.functionalTypeService.extractAllSpecialKindsForFunctionalTypeRef(typeRef) + val functionKinds = session.functionTypeService.extractAllSpecialKindsForFunctionTypeRef(typeRef) var diagnostic: ConeDiagnostic? = null - val kind = when (functionalKinds.size) { - 0 -> FunctionalTypeKind.Function - 1 -> functionalKinds.single() + val kind = when (functionKinds.size) { + 0 -> FunctionTypeKind.Function + 1 -> functionKinds.single() else -> { - diagnostic = ConeAmbiguousFunctionalTypeKinds(functionalKinds) - FunctionalTypeKind.Function + diagnostic = ConeAmbiguousFunctionTypeKinds(functionKinds) + FunctionTypeKind.Function } } @@ -505,7 +503,7 @@ class FirTypeResolverImpl(private val session: FirSession) : FirTypeResolver() { isOperandOfIsOperator, ) to (result as? TypeResolutionResult.Resolved)?.typeCandidate?.diagnostic } - is FirFunctionTypeRef -> createFunctionalType(typeRef) + is FirFunctionTypeRef -> createFunctionType(typeRef) is FirDynamicTypeRef -> ConeDynamicType.create(session) to null is FirIntersectionTypeRef -> { val leftType = typeRef.leftType.coneType diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirCallCompletionResultsWriterTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirCallCompletionResultsWriterTransformer.kt index feba21d2221..b70d8b35bf4 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirCallCompletionResultsWriterTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirCallCompletionResultsWriterTransformer.kt @@ -6,7 +6,7 @@ package org.jetbrains.kotlin.fir.resolve.transformers import org.jetbrains.kotlin.KtFakeSourceElementKind -import org.jetbrains.kotlin.builtins.functions.FunctionalTypeKind +import org.jetbrains.kotlin.builtins.functions.FunctionTypeKind import org.jetbrains.kotlin.fakeElement import org.jetbrains.kotlin.fir.* import org.jetbrains.kotlin.fir.declarations.* @@ -561,7 +561,7 @@ class FirCallCompletionResultsWriterTransformer( // From the argument mapping, the expected type of this anonymous function would be: when { // a built-in functional type, no-brainer - expectedArgumentType.isSomeFunctionalType(session) -> expectedArgumentType + expectedArgumentType.isSomeFunctionType(session) -> expectedArgumentType // fun interface (a.k.a. SAM), then unwrap it and build a functional type from that interface function expectedArgumentType is ConeClassLikeType -> { val firRegularClass = @@ -570,8 +570,8 @@ class FirCallCompletionResultsWriterTransformer( firRegularClass?.let answer@{ val functionType = samResolver.getFunctionTypeForPossibleSamType(firRegularClass.defaultType()) ?: return@answer null - val kind = functionType.functionalTypeKind(session) ?: FunctionalTypeKind.Function - createFunctionalType( + val kind = functionType.functionTypeKind(session) ?: FunctionTypeKind.Function + createFunctionType( kind, functionType.typeArguments.dropLast(1).map { it as ConeKotlinType }, null, @@ -617,9 +617,9 @@ class FirCallCompletionResultsWriterTransformer( } if (needUpdateLambdaType) { - val kind = expectedType?.functionalTypeKind(session) - ?: result.typeRef.coneTypeSafe()?.functionalTypeKind(session) - result.replaceTypeRef(result.constructFunctionalTypeRef(session, kind)) + val kind = expectedType?.functionTypeKind(session) + ?: result.typeRef.coneTypeSafe()?.functionTypeKind(session) + result.replaceTypeRef(result.constructFunctionTypeRef(session, kind)) session.lookupTracker?.recordTypeResolveAsLookup(result.typeRef, result.source, context.file.source) } // Have to delay this until the type is written to avoid adding a return if the type is Unit. diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSpecificTypeResolverTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSpecificTypeResolverTransformer.kt index 65704a54efd..60e899897fd 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSpecificTypeResolverTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSpecificTypeResolverTransformer.kt @@ -123,7 +123,7 @@ class FirSpecificTypeResolverTransformer( type = resolvedType } this.diagnostic = diagnostic ?: (resolvedType as? ConeErrorType)?.diagnostic - ?: ConeSimpleDiagnostic("Unresolved functional type: ${functionTypeRef.render()}") + ?: ConeSimpleDiagnostic("Unresolved function type: ${functionTypeRef.render()}") } } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/InvocationKindTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/InvocationKindTransformer.kt index ddbd950837a..0f3b3928595 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/InvocationKindTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/InvocationKindTransformer.kt @@ -19,7 +19,7 @@ import org.jetbrains.kotlin.fir.expressions.FirFunctionCall import org.jetbrains.kotlin.fir.expressions.FirWrappedArgumentExpression import org.jetbrains.kotlin.fir.resolve.calls.FirNamedReferenceWithCandidate import org.jetbrains.kotlin.fir.types.coneType -import org.jetbrains.kotlin.fir.types.isNonReflectFunctionalType +import org.jetbrains.kotlin.fir.types.isNonReflectFunctionType tailrec fun FirExpression.unwrapAnonymousFunctionExpression(): FirAnonymousFunction? = when (this) { is FirAnonymousFunctionExpression -> anonymousFunction @@ -47,7 +47,7 @@ fun FirFunctionCall.replaceLambdaArgumentInvocationKinds(session: FirSession) { val kind = byParameter[parameter] ?: EventOccurrencesRange.UNKNOWN.takeIf { // Inline functional parameters have to be called in-place; that's the only permitted operation on them. isInline && !parameter.isNoinline && !parameter.isCrossinline && - parameter.returnTypeRef.coneType.isNonReflectFunctionalType(session) + parameter.returnTypeRef.coneType.isNonReflectFunctionType(session) } ?: continue lambda.replaceInvocationKind(kind) } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirDeclarationsResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirDeclarationsResolveTransformer.kt index b72fbb00ff2..04061e29b43 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirDeclarationsResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirDeclarationsResolveTransformer.kt @@ -33,7 +33,7 @@ import org.jetbrains.kotlin.fir.resolve.dfa.unwrapSmartcastExpression import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeLocalVariableNoTypeOrInitializer import org.jetbrains.kotlin.fir.resolve.inference.FirStubTypeTransformer import org.jetbrains.kotlin.fir.resolve.inference.ResolvedLambdaAtom -import org.jetbrains.kotlin.fir.resolve.inference.extractLambdaInfoFromFunctionalType +import org.jetbrains.kotlin.fir.resolve.inference.extractLambdaInfoFromFunctionType import org.jetbrains.kotlin.fir.resolve.substitution.createTypeSubstitutorByTypeConstructor import org.jetbrains.kotlin.fir.resolve.transformers.FirCallCompletionResultsWriterTransformer import org.jetbrains.kotlin.fir.resolve.transformers.FirStatusResolver @@ -763,7 +763,7 @@ open class FirDeclarationsResolveTransformer(transformer: FirAbstractBodyResolve data: ResolutionMode ): FirAnonymousFunction { val resolvedLambdaAtom = (expectedTypeRef as? FirResolvedTypeRef)?.let { - extractLambdaInfoFromFunctionalType( + extractLambdaInfoFromFunctionType( it.type, it, anonymousFunction, returnTypeVariable = null, components, candidate = null, duringCompletion = false ) } @@ -806,7 +806,7 @@ open class FirDeclarationsResolveTransformer(transformer: FirAbstractBodyResolve session.lookupTracker?.recordTypeResolveAsLookup(lambda.returnTypeRef, lambda.source, context.file.source) } - lambda.replaceTypeRef(lambda.constructFunctionalTypeRef(session, resolvedLambdaAtom?.expectedFunctionalTypeKind)) + lambda.replaceTypeRef(lambda.constructFunctionTypeRef(session, resolvedLambdaAtom?.expectedFunctionTypeKind)) session.lookupTracker?.recordTypeResolveAsLookup(lambda.typeRef, lambda.source, context.file.source) lambda.addReturnToLastStatementIfNeeded() return lambda @@ -859,7 +859,7 @@ open class FirDeclarationsResolveTransformer(transformer: FirAbstractBodyResolve lambda: FirAnonymousFunction ): List { if (expectedType == null) return lambda.valueParameters - if (!expectedType.isNonReflectFunctionalType(session)) return lambda.valueParameters + if (!expectedType.isNonReflectFunctionType(session)) return lambda.valueParameters val parameterTypes = expectedType.typeArguments .mapTo(mutableListOf()) { it.type ?: session.builtinTypes.nullableAnyType.type } .also { it.removeLastOrNull() } diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/diagnostics/ConeSimpleDiagnostic.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/diagnostics/ConeSimpleDiagnostic.kt index 6087606d926..99f51c50079 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/diagnostics/ConeSimpleDiagnostic.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/diagnostics/ConeSimpleDiagnostic.kt @@ -6,7 +6,7 @@ package org.jetbrains.kotlin.fir.diagnostics import org.jetbrains.kotlin.KtSourceElement -import org.jetbrains.kotlin.builtins.functions.FunctionalTypeKind +import org.jetbrains.kotlin.builtins.functions.FunctionTypeKind import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol import org.jetbrains.kotlin.fir.types.ConeKotlinType import org.jetbrains.kotlin.name.Name @@ -52,9 +52,9 @@ object ConeDanglingModifierOnTopLevel : ConeDiagnostic { get() = "Top level declaration expected" } -class ConeAmbiguousFunctionalTypeKinds(val kinds: List) : ConeDiagnostic { +class ConeAmbiguousFunctionTypeKinds(val kinds: List) : ConeDiagnostic { override val reason: String - get() = "There are multiple functional kinds for functional type ref" + get() = "There are multiple function kinds for functional type ref" } enum class DiagnosticKind { diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/extensions/FirFunctionTypeKindExtension.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/extensions/FirFunctionTypeKindExtension.kt new file mode 100644 index 00000000000..13e48033827 --- /dev/null +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/extensions/FirFunctionTypeKindExtension.kt @@ -0,0 +1,32 @@ +/* + * 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.fir.extensions + +import org.jetbrains.kotlin.builtins.functions.FunctionTypeKind +import org.jetbrains.kotlin.fir.FirSession +import kotlin.reflect.KClass + +abstract class FirFunctionTypeKindExtension(session: FirSession) : FirExtension(session) { + companion object { + val NAME = FirExtensionPointName("CustomFunctionTypeKindExtension") + } + + final override val name: FirExtensionPointName + get() = NAME + + final override val extensionType: KClass + get() = FirFunctionTypeKindExtension::class + + interface FunctionTypeKindRegistrar { + fun registerKind(nonReflectKind: FunctionTypeKind, reflectKind: FunctionTypeKind) + } + + abstract fun FunctionTypeKindRegistrar.registerKinds() + + fun interface Factory : FirExtension.Factory +} + +val FirExtensionService.functionTypeKindExtensions: List by FirExtensionService.registeredExtensions() diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/extensions/FirFunctionalTypeKindExtension.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/extensions/FirFunctionalTypeKindExtension.kt deleted file mode 100644 index 82a9e2ab202..00000000000 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/extensions/FirFunctionalTypeKindExtension.kt +++ /dev/null @@ -1,32 +0,0 @@ -/* - * 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.fir.extensions - -import org.jetbrains.kotlin.builtins.functions.FunctionalTypeKind -import org.jetbrains.kotlin.fir.FirSession -import kotlin.reflect.KClass - -abstract class FirFunctionalTypeKindExtension(session: FirSession) : FirExtension(session) { - companion object { - val NAME = FirExtensionPointName("CustomFunctionalTypeKindExtension") - } - - final override val name: FirExtensionPointName - get() = NAME - - final override val extensionType: KClass - get() = FirFunctionalTypeKindExtension::class - - interface FunctionalTypeKindRegistrar { - fun registerKind(nonReflectKind: FunctionalTypeKind, reflectKind: FunctionalTypeKind) - } - - abstract fun FunctionalTypeKindRegistrar.registerKinds() - - fun interface Factory : FirExtension.Factory -} - -val FirExtensionService.functionalTypeKindExtensions: List by FirExtensionService.registeredExtensions() diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/renderer/FirRenderer.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/renderer/FirRenderer.kt index b21e79e22ac..7698b3f0a73 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/renderer/FirRenderer.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/renderer/FirRenderer.kt @@ -5,7 +5,7 @@ package org.jetbrains.kotlin.fir.renderer -import org.jetbrains.kotlin.builtins.functions.FunctionalTypeKindExtractor +import org.jetbrains.kotlin.builtins.functions.FunctionTypeKindExtractor import org.jetbrains.kotlin.builtins.functions.AllowedToUsedOnlyInK1 import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget import org.jetbrains.kotlin.fir.* @@ -749,7 +749,7 @@ class FirRenderer( resolvedTypeRef.type, l@{ val classId = it.classId ?: return@l null - FunctionalTypeKindExtractor.Default.getFunctionalClassKind(classId.packageFqName, classId.shortClassName.asString()) + FunctionTypeKindExtractor.Default.getFunctionalClassKind(classId.packageFqName, classId.shortClassName.asString()) } ) } diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirFunctionalTypeKindService.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirFunctionTypeKindService.kt similarity index 58% rename from compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirFunctionalTypeKindService.kt rename to compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirFunctionTypeKindService.kt index 3a05ff261c4..cd0bee83d72 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirFunctionalTypeKindService.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirFunctionTypeKindService.kt @@ -5,17 +5,17 @@ package org.jetbrains.kotlin.fir.types -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.fir.FirSession import org.jetbrains.kotlin.fir.FirSessionComponent import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol import org.jetbrains.kotlin.name.FqName -abstract class FirFunctionalTypeKindService : FirSessionComponent { - protected abstract val extractor: FunctionalTypeKindExtractor +abstract class FirFunctionTypeKindService : FirSessionComponent { + protected abstract val extractor: FunctionTypeKindExtractor - fun getKindByClassNamePrefix(packageFqName: FqName, className: String): FunctionalTypeKind? { + fun getKindByClassNamePrefix(packageFqName: FqName, className: String): FunctionTypeKind? { return extractor.getFunctionalClassKindWithArity(packageFqName, className)?.kind } @@ -23,9 +23,9 @@ abstract class FirFunctionalTypeKindService : FirSessionComponent { return extractor.hasKindWithSpecificPackage(packageFqName) } - abstract fun extractSingleSpecialKindForFunction(functionSymbol: FirFunctionSymbol<*>): FunctionalTypeKind? - abstract fun extractAllSpecialKindsForFunction(functionSymbol: FirFunctionSymbol<*>): List - abstract fun extractAllSpecialKindsForFunctionalTypeRef(typeRef: FirFunctionTypeRef): List + abstract fun extractSingleSpecialKindForFunction(functionSymbol: FirFunctionSymbol<*>): FunctionTypeKind? + abstract fun extractAllSpecialKindsForFunction(functionSymbol: FirFunctionSymbol<*>): List + abstract fun extractAllSpecialKindsForFunctionTypeRef(typeRef: FirFunctionTypeRef): List } -val FirSession.functionalTypeService: FirFunctionalTypeKindService by FirSession.sessionComponentAccessor() +val FirSession.functionTypeService: FirFunctionTypeKindService by FirSession.sessionComponentAccessor() diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/SuspendFunctionAsSupertypeChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/SuspendFunctionAsSupertypeChecker.kt index 3f401519870..9ecbb484d4e 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/SuspendFunctionAsSupertypeChecker.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/SuspendFunctionAsSupertypeChecker.kt @@ -5,7 +5,7 @@ package org.jetbrains.kotlin.resolve.checkers import org.jetbrains.kotlin.builtins.functions.FunctionClassDescriptor -import org.jetbrains.kotlin.builtins.functions.FunctionalTypeKind +import org.jetbrains.kotlin.builtins.functions.FunctionTypeKind import org.jetbrains.kotlin.config.LanguageFeature import org.jetbrains.kotlin.descriptors.ClassDescriptor import org.jetbrains.kotlin.descriptors.DeclarationDescriptor @@ -22,14 +22,14 @@ object SuspendFunctionAsSupertypeChecker : DeclarationChecker { val functionalSupertypes = descriptor.getAllSuperClassifiers().filterIsInstance().toList() if (functionalSupertypes.none { - it.functionKind == FunctionalTypeKind.SuspendFunction || - it.functionKind == FunctionalTypeKind.KSuspendFunction + it.functionKind == FunctionTypeKind.SuspendFunction || + it.functionKind == FunctionTypeKind.KSuspendFunction } ) return if (functionalSupertypes.any { - it.functionKind == FunctionalTypeKind.Function || - it.functionKind == FunctionalTypeKind.KFunction + it.functionKind == FunctionTypeKind.Function || + it.functionKind == FunctionTypeKind.KFunction } ) { val reportOn = (declaration as? KtClassOrObject)?.getSuperTypeList() ?: declaration diff --git a/compiler/resolution.common/src/org/jetbrains/kotlin/resolve/calls/inference/components/PostponedArgumentInputTypesResolver.kt b/compiler/resolution.common/src/org/jetbrains/kotlin/resolve/calls/inference/components/PostponedArgumentInputTypesResolver.kt index 264c39612cd..79d1edb3c94 100644 --- a/compiler/resolution.common/src/org/jetbrains/kotlin/resolve/calls/inference/components/PostponedArgumentInputTypesResolver.kt +++ b/compiler/resolution.common/src/org/jetbrains/kotlin/resolve/calls/inference/components/PostponedArgumentInputTypesResolver.kt @@ -5,8 +5,8 @@ package org.jetbrains.kotlin.resolve.calls.inference.components -import org.jetbrains.kotlin.builtins.functions.FunctionalTypeKind -import org.jetbrains.kotlin.builtins.functions.isRegularFunction +import org.jetbrains.kotlin.builtins.functions.FunctionTypeKind +import org.jetbrains.kotlin.builtins.functions.isBasicFunctionOrKFunction import org.jetbrains.kotlin.config.LanguageFeature import org.jetbrains.kotlin.config.LanguageVersionSettings import org.jetbrains.kotlin.resolve.calls.inference.model.* @@ -30,7 +30,7 @@ class PostponedArgumentInputTypesResolver( val parametersFromConstraints: Set>?, val annotations: List?, val isExtensionFunction: Boolean, - val functionalTypeKind: FunctionalTypeKind, + val functionTypeKind: FunctionTypeKind, val isNullable: Boolean ) @@ -44,7 +44,7 @@ class PostponedArgumentInputTypesResolver( variableDependencyProvider: TypeVariableDependencyInformationProvider ): List { fun List.extractFunctionalTypes() = mapNotNull { constraint -> - TypeWithKind(constraint.type.getFunctionalTypeFromSupertypes(), constraint.kind) + TypeWithKind(constraint.type.getFunctionTypeFromSupertypes(), constraint.kind) } val typeVariableTypeConstructor = variable.typeVariable.freshTypeConstructor() @@ -53,7 +53,7 @@ class PostponedArgumentInputTypesResolver( return dependentVariables.flatMap { type -> val constraints = notFixedTypeVariables[type]?.constraints ?: return@flatMap emptyList() - val constraintsWithFunctionalType = constraints.filter { it.type.isBuiltinFunctionalTypeOrSubtype() } + val constraintsWithFunctionalType = constraints.filter { it.type.isBuiltinFunctionTypeOrSubtype() } constraintsWithFunctionalType.extractFunctionalTypes() } } @@ -75,7 +75,7 @@ class PostponedArgumentInputTypesResolver( if (argument is LambdaWithTypeVariableAsExpectedTypeMarker) argument.parameterTypesFromDeclaration else null val parameterTypesFromConstraints = functionalTypesFromConstraints.mapTo(SmartSet.create()) { typeWithKind -> - typeWithKind.type.extractArgumentsForFunctionalTypeOrSubtype().map { + typeWithKind.type.extractArgumentsForFunctionTypeOrSubtype().map { // We should use opposite kind as lambda's parameters are contravariant TypeWithKind(it, typeWithKind.direction.opposite()) } @@ -96,16 +96,16 @@ class PostponedArgumentInputTypesResolver( parameterTypesFromDeclaration, ) - var functionalTypeKind: FunctionalTypeKind? = null + var functionTypeKind: FunctionTypeKind? = null var isNullable = false if (functionalTypesFromConstraints.isNotEmpty()) { isNullable = true for (funType in functionalTypesFromConstraints) { - if (functionalTypeKind == null) { - funType.type.functionalTypeKind()?.takeUnless { it.isRegularFunction }?.let { functionalTypeKind = it } + if (functionTypeKind == null) { + funType.type.functionTypeKind()?.takeUnless { it.isBasicFunctionOrKFunction }?.let { functionTypeKind = it } } if (isNullable && !funType.type.isMarkedNullable()) isNullable = false - if ((functionalTypeKind != null) && !isNullable) break + if ((functionTypeKind != null) && !isNullable) break } } @@ -126,7 +126,7 @@ class PostponedArgumentInputTypesResolver( parameterTypesFromConstraints, annotations = annotations, isExtensionFunction, - functionalTypeKind ?: FunctionalTypeKind.Function, + functionTypeKind ?: FunctionTypeKind.Function, isNullable = isNullable ) } @@ -258,7 +258,7 @@ class PostponedArgumentInputTypesResolver( private fun Context.computeResultingFunctionalConstructor( argument: PostponedAtomWithRevisableExpectedType, parametersNumber: Int, - functionalTypeKind: FunctionalTypeKind, + functionTypeKind: FunctionTypeKind, resultTypeResolver: ResultTypeResolver ): TypeConstructorMarker { val expectedType = argument.expectedType @@ -268,7 +268,7 @@ class PostponedArgumentInputTypesResolver( return when (argument) { is LambdaWithTypeVariableAsExpectedTypeMarker -> - getNonReflectFunctionTypeConstructor(parametersNumber, functionalTypeKind) + getNonReflectFunctionTypeConstructor(parametersNumber, functionTypeKind) is PostponedCallableReferenceMarker -> { val computedResultType = resultTypeResolver.findResultType( this@computeResultingFunctionalConstructor, @@ -277,10 +277,10 @@ class PostponedArgumentInputTypesResolver( ) // Avoid KFunction<...>/Function<...> types - if (computedResultType.isBuiltinFunctionalTypeOrSubtype() && computedResultType.argumentsCount() > 1) { + if (computedResultType.isBuiltinFunctionTypeOrSubtype() && computedResultType.argumentsCount() > 1) { computedResultType.typeConstructor() } else { - getReflectFunctionTypeConstructor(parametersNumber, functionalTypeKind) + getReflectFunctionTypeConstructor(parametersNumber, functionTypeKind) } } else -> throw IllegalStateException("Unsupported postponed argument type of $argument") @@ -382,7 +382,7 @@ class PostponedArgumentInputTypesResolver( val functionalConstructor = computeResultingFunctionalConstructor( argument, variablesForParameterTypes.size, - parameterTypesInfo.functionalTypeKind, + parameterTypesInfo.functionTypeKind, resultTypeResolver ) @@ -558,7 +558,7 @@ class PostponedArgumentInputTypesResolver( dependencyProvider: TypeVariableDependencyInformationProvider, resolvedAtomByTypeVariableProvider: ResolvedAtomProvider, ): Boolean = with(resolutionTypeSystemContext) { - val relatedVariables = type.extractArgumentsForFunctionalTypeOrSubtype() + val relatedVariables = type.extractArgumentsForFunctionTypeOrSubtype() .flatMap { getAllDeeplyRelatedTypeVariables(it, dependencyProvider) } val variableForFixation = variableFixationFinder.findFirstVariableForFixation( this@fixNextReadyVariableForParameterType, diff --git a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/tasks/synthesizedInvokes.kt b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/tasks/synthesizedInvokes.kt index 014fa78aa65..7b9553c714a 100644 --- a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/tasks/synthesizedInvokes.kt +++ b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/tasks/synthesizedInvokes.kt @@ -16,7 +16,7 @@ package org.jetbrains.kotlin.resolve.calls.tasks -import org.jetbrains.kotlin.builtins.getFunctionalClassKind +import org.jetbrains.kotlin.builtins.getFunctionTypeKind import org.jetbrains.kotlin.builtins.isBuiltinFunctionClass import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor import org.jetbrains.kotlin.descriptors.ClassDescriptor @@ -90,5 +90,5 @@ fun isSynthesizedInvoke(descriptor: DeclarationDescriptor): Boolean { } return real.kind == CallableMemberDescriptor.Kind.SYNTHESIZED && - real.containingDeclaration.getFunctionalClassKind() != null + real.containingDeclaration.getFunctionTypeKind() != null } diff --git a/compiler/visualizer/render-fir/src/org/jetbrains/kotlin/compiler/visualizer/FirVisualizer.kt b/compiler/visualizer/render-fir/src/org/jetbrains/kotlin/compiler/visualizer/FirVisualizer.kt index 25969d0a17b..8a423f0fbbe 100644 --- a/compiler/visualizer/render-fir/src/org/jetbrains/kotlin/compiler/visualizer/FirVisualizer.kt +++ b/compiler/visualizer/render-fir/src/org/jetbrains/kotlin/compiler/visualizer/FirVisualizer.kt @@ -339,7 +339,7 @@ class FirVisualizer(private val firFile: FirFile) : BaseRenderer() { val projectionBuilder = StringBuilder() ConeTypeRendererForDebugging(projectionBuilder).renderAsPossibleFunctionType( this, - { it.functionalTypeKind(session) } + { it.functionTypeKind(session) } ) { localTypeProjectionRenderer(projectionBuilder) } diff --git a/core/compiler.common.jvm/src/org/jetbrains/kotlin/builtins/jvm/JavaToKotlinClassMap.kt b/core/compiler.common.jvm/src/org/jetbrains/kotlin/builtins/jvm/JavaToKotlinClassMap.kt index d5ac3a73160..43cccbf5a8b 100644 --- a/core/compiler.common.jvm/src/org/jetbrains/kotlin/builtins/jvm/JavaToKotlinClassMap.kt +++ b/core/compiler.common.jvm/src/org/jetbrains/kotlin/builtins/jvm/JavaToKotlinClassMap.kt @@ -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.FunctionalTypeKind +import org.jetbrains.kotlin.builtins.functions.FunctionTypeKind import org.jetbrains.kotlin.name.* import org.jetbrains.kotlin.resolve.jvm.JvmPrimitiveType object JavaToKotlinClassMap { private val NUMBERED_FUNCTION_PREFIX: String = - FunctionalTypeKind.Function.packageFqName.toString() + "." + FunctionalTypeKind.Function.classNamePrefix + FunctionTypeKind.Function.packageFqName.toString() + "." + FunctionTypeKind.Function.classNamePrefix private val NUMBERED_K_FUNCTION_PREFIX: String = - FunctionalTypeKind.KFunction.packageFqName.toString() + "." + FunctionalTypeKind.KFunction.classNamePrefix + FunctionTypeKind.KFunction.packageFqName.toString() + "." + FunctionTypeKind.KFunction.classNamePrefix private val NUMBERED_SUSPEND_FUNCTION_PREFIX: String = - FunctionalTypeKind.SuspendFunction.packageFqName.toString() + "." + FunctionalTypeKind.SuspendFunction.classNamePrefix + FunctionTypeKind.SuspendFunction.packageFqName.toString() + "." + FunctionTypeKind.SuspendFunction.classNamePrefix private val NUMBERED_K_SUSPEND_FUNCTION_PREFIX: String = - FunctionalTypeKind.KSuspendFunction.packageFqName.toString() + "." + FunctionalTypeKind.KSuspendFunction.classNamePrefix + FunctionTypeKind.KSuspendFunction.packageFqName.toString() + "." + FunctionTypeKind.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 = FunctionalTypeKind.KSuspendFunction + val kSuspendFunction = FunctionTypeKind.KSuspendFunction val kSuspendFun = kSuspendFunction.packageFqName.toString() + "." + kSuspendFunction.classNamePrefix addKotlinToJava(FqName(kSuspendFun + i), K_FUNCTION_CLASS_ID) } diff --git a/core/compiler.common/src/org/jetbrains/kotlin/builtins/StandardNames.kt b/core/compiler.common/src/org/jetbrains/kotlin/builtins/StandardNames.kt index e508d9166c3..b5569495804 100644 --- a/core/compiler.common/src/org/jetbrains/kotlin/builtins/StandardNames.kt +++ b/core/compiler.common/src/org/jetbrains/kotlin/builtins/StandardNames.kt @@ -6,7 +6,7 @@ package org.jetbrains.kotlin.builtins import org.jetbrains.kotlin.builtins.StandardNames.FqNames.reflect -import org.jetbrains.kotlin.builtins.functions.FunctionalTypeKind +import org.jetbrains.kotlin.builtins.functions.FunctionTypeKind 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(FunctionalTypeKind.KFunction.classNamePrefix + parameterCount) + return reflect(FunctionTypeKind.KFunction.classNamePrefix + parameterCount) } @JvmStatic @@ -263,7 +263,7 @@ object StandardNames { @JvmStatic fun getSuspendFunctionName(parameterCount: Int): String { - return FunctionalTypeKind.SuspendFunction.classNamePrefix + parameterCount + return FunctionTypeKind.SuspendFunction.classNamePrefix + parameterCount } @JvmStatic @@ -273,7 +273,7 @@ object StandardNames { @JvmStatic fun getKSuspendFunctionName(parameterCount: Int): FqNameUnsafe { - return reflect(FunctionalTypeKind.KSuspendFunction.classNamePrefix + parameterCount) + return reflect(FunctionTypeKind.KSuspendFunction.classNamePrefix + parameterCount) } @JvmStatic diff --git a/core/compiler.common/src/org/jetbrains/kotlin/builtins/functions/FunctionalTypeKind.kt b/core/compiler.common/src/org/jetbrains/kotlin/builtins/functions/FunctionTypeKind.kt similarity index 79% rename from core/compiler.common/src/org/jetbrains/kotlin/builtins/functions/FunctionalTypeKind.kt rename to core/compiler.common/src/org/jetbrains/kotlin/builtins/functions/FunctionTypeKind.kt index 1ddd85adece..ad9108e8ed5 100644 --- a/core/compiler.common/src/org/jetbrains/kotlin/builtins/functions/FunctionalTypeKind.kt +++ b/core/compiler.common/src/org/jetbrains/kotlin/builtins/functions/FunctionTypeKind.kt @@ -11,7 +11,7 @@ import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name /** - * [FunctionalTypeKind] describes a family of various similar functional types (like kotlin.FunctionN) + * [FunctionTypeKind] 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 * @@ -38,7 +38,7 @@ import org.jetbrains.kotlin.name.Name * 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( +abstract class FunctionTypeKind internal constructor( val packageFqName: FqName, val classNamePrefix: String, val isReflectType: Boolean, @@ -69,7 +69,7 @@ abstract class FunctionalTypeKind internal constructor( * * Should be overridden for reflect kinds */ - open fun nonReflectKind(): FunctionalTypeKind { + open fun nonReflectKind(): FunctionTypeKind { return if (isReflectType) error("Should be overridden explicitly") else this } @@ -79,7 +79,7 @@ abstract class FunctionalTypeKind internal constructor( * * Should be overridden for non reflect kinds */ - open fun reflectKind(): FunctionalTypeKind { + open fun reflectKind(): FunctionTypeKind { return if (isReflectType) this else error("Should be overridden explicitly") } @@ -93,16 +93,16 @@ abstract class FunctionalTypeKind internal constructor( // ------------------------------------------- Builtin functional kinds ------------------------------------------- - object Function : FunctionalTypeKind( + object Function : FunctionTypeKind( StandardNames.BUILT_INS_PACKAGE_FQ_NAME, "Function", isReflectType = false, annotationOnInvokeClassId = null ) { - override fun reflectKind(): FunctionalTypeKind = KFunction + override fun reflectKind(): FunctionTypeKind = KFunction } - object SuspendFunction : FunctionalTypeKind( + object SuspendFunction : FunctionTypeKind( StandardNames.COROUTINES_PACKAGE_FQ_NAME, "SuspendFunction", isReflectType = false, @@ -111,39 +111,39 @@ abstract class FunctionalTypeKind internal constructor( override val prefixForTypeRender: String get() = "suspend" - override fun reflectKind(): FunctionalTypeKind = KSuspendFunction + override fun reflectKind(): FunctionTypeKind = KSuspendFunction } - object KFunction : FunctionalTypeKind( + object KFunction : FunctionTypeKind( StandardNames.KOTLIN_REFLECT_FQ_NAME, "KFunction", isReflectType = true, annotationOnInvokeClassId = null ) { - override fun nonReflectKind(): FunctionalTypeKind = Function + override fun nonReflectKind(): FunctionTypeKind = Function } - object KSuspendFunction : FunctionalTypeKind( + object KSuspendFunction : FunctionTypeKind( StandardNames.KOTLIN_REFLECT_FQ_NAME, "KSuspendFunction", isReflectType = true, annotationOnInvokeClassId = null ) { - override fun nonReflectKind(): FunctionalTypeKind = SuspendFunction + override fun nonReflectKind(): FunctionTypeKind = SuspendFunction } } -val FunctionalTypeKind.isBuiltin: Boolean +val FunctionTypeKind.isBuiltin: Boolean get() = when (this) { - FunctionalTypeKind.Function, - FunctionalTypeKind.SuspendFunction, - FunctionalTypeKind.KFunction, - FunctionalTypeKind.KSuspendFunction -> true + FunctionTypeKind.Function, + FunctionTypeKind.SuspendFunction, + FunctionTypeKind.KFunction, + FunctionTypeKind.KSuspendFunction -> true else -> false } -val FunctionalTypeKind.isSuspendType: Boolean - get() = this.nonReflectKind() == FunctionalTypeKind.SuspendFunction +val FunctionTypeKind.isSuspendOrKSuspendFunction: Boolean + get() = this.nonReflectKind() == FunctionTypeKind.SuspendFunction -val FunctionalTypeKind.isRegularFunction: Boolean - get() = this.nonReflectKind() == FunctionalTypeKind.Function +val FunctionTypeKind.isBasicFunctionOrKFunction: Boolean + get() = this.nonReflectKind() == FunctionTypeKind.Function diff --git a/core/compiler.common/src/org/jetbrains/kotlin/builtins/functions/FunctionalTypeKindExtractor.kt b/core/compiler.common/src/org/jetbrains/kotlin/builtins/functions/FunctionTypeKindExtractor.kt similarity index 81% rename from core/compiler.common/src/org/jetbrains/kotlin/builtins/functions/FunctionalTypeKindExtractor.kt rename to core/compiler.common/src/org/jetbrains/kotlin/builtins/functions/FunctionTypeKindExtractor.kt index 2ee8036d564..a07514a5b68 100644 --- a/core/compiler.common/src/org/jetbrains/kotlin/builtins/functions/FunctionalTypeKindExtractor.kt +++ b/core/compiler.common/src/org/jetbrains/kotlin/builtins/functions/FunctionTypeKindExtractor.kt @@ -10,7 +10,7 @@ import org.jetbrains.kotlin.name.FqName @RequiresOptIn annotation class AllowedToUsedOnlyInK1 -class FunctionalTypeKindExtractor(kinds: List) { +class FunctionTypeKindExtractor(kinds: List) { companion object { /** * This instance should be used only in: @@ -19,19 +19,19 @@ class FunctionalTypeKindExtractor(kinds: List) { */ @JvmStatic @AllowedToUsedOnlyInK1 - val Default = FunctionalTypeKindExtractor( + val Default = FunctionTypeKindExtractor( listOf( - FunctionalTypeKind.Function, - FunctionalTypeKind.SuspendFunction, - FunctionalTypeKind.KFunction, - FunctionalTypeKind.KSuspendFunction, + FunctionTypeKind.Function, + FunctionTypeKind.SuspendFunction, + FunctionTypeKind.KFunction, + FunctionTypeKind.KSuspendFunction, ) ) } private val knownKindsByPackageFqName = kinds.groupBy { it.packageFqName } - fun getFunctionalClassKind(packageFqName: FqName, className: String): FunctionalTypeKind? { + fun getFunctionalClassKind(packageFqName: FqName, className: String): FunctionTypeKind? { return getFunctionalClassKindWithArity(packageFqName, className)?.kind } @@ -49,7 +49,7 @@ class FunctionalTypeKindExtractor(kinds: List) { return packageFqName in knownKindsByPackageFqName } - data class KindWithArity(val kind: FunctionalTypeKind, val arity: Int) + data class KindWithArity(val kind: FunctionTypeKind, val arity: Int) private fun toInt(s: String): Int? { if (s.isEmpty()) return null diff --git a/core/compiler.common/src/org/jetbrains/kotlin/types/model/TypeSystemContext.kt b/core/compiler.common/src/org/jetbrains/kotlin/types/model/TypeSystemContext.kt index 81b2ca3f595..a9192ea76ac 100644 --- a/core/compiler.common/src/org/jetbrains/kotlin/types/model/TypeSystemContext.kt +++ b/core/compiler.common/src/org/jetbrains/kotlin/types/model/TypeSystemContext.kt @@ -5,7 +5,7 @@ package org.jetbrains.kotlin.types.model -import org.jetbrains.kotlin.builtins.functions.FunctionalTypeKind +import org.jetbrains.kotlin.builtins.functions.FunctionTypeKind import org.jetbrains.kotlin.resolve.checkers.EmptyIntersectionTypeChecker import org.jetbrains.kotlin.resolve.checkers.EmptyIntersectionTypeInfo import org.jetbrains.kotlin.types.* @@ -165,7 +165,7 @@ interface TypeSystemInferenceExtensionContext : TypeSystemContext, TypeSystemBui fun KotlinTypeMarker.isUnit(): Boolean - fun KotlinTypeMarker.isBuiltinFunctionalTypeOrSubtype(): Boolean + fun KotlinTypeMarker.isBuiltinFunctionTypeOrSubtype(): Boolean fun createCapturedType( constructorProjection: TypeArgumentMarker, @@ -252,17 +252,17 @@ interface TypeSystemInferenceExtensionContext : TypeSystemContext, TypeSystemBui fun KotlinTypeMarker.isFunctionOrKFunctionWithAnySuspendability(): Boolean - fun KotlinTypeMarker.functionalTypeKind(): FunctionalTypeKind? + fun KotlinTypeMarker.functionTypeKind(): FunctionTypeKind? fun KotlinTypeMarker.isExtensionFunctionType(): Boolean - fun KotlinTypeMarker.extractArgumentsForFunctionalTypeOrSubtype(): List + fun KotlinTypeMarker.extractArgumentsForFunctionTypeOrSubtype(): List - fun KotlinTypeMarker.getFunctionalTypeFromSupertypes(): KotlinTypeMarker + fun KotlinTypeMarker.getFunctionTypeFromSupertypes(): KotlinTypeMarker - fun getNonReflectFunctionTypeConstructor(parametersNumber: Int, kind: FunctionalTypeKind): TypeConstructorMarker + fun getNonReflectFunctionTypeConstructor(parametersNumber: Int, kind: FunctionTypeKind): TypeConstructorMarker - fun getReflectFunctionTypeConstructor(parametersNumber: Int, kind: FunctionalTypeKind): TypeConstructorMarker + fun getReflectFunctionTypeConstructor(parametersNumber: Int, kind: FunctionTypeKind): TypeConstructorMarker // ------------------------------------------------- diff --git a/core/descriptors/src/org/jetbrains/kotlin/builtins/KotlinBuiltIns.java b/core/descriptors/src/org/jetbrains/kotlin/builtins/KotlinBuiltIns.java index 737ebd7b251..f0734f754d6 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.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)); } diff --git a/core/descriptors/src/org/jetbrains/kotlin/builtins/functionTypes.kt b/core/descriptors/src/org/jetbrains/kotlin/builtins/functionTypes.kt index d03415ef169..53c49d4c50b 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/builtins/functionTypes.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/builtins/functionTypes.kt @@ -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 { 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 242307e6d8a..d4d3d6d40ea 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/builtins/functions/BuiltInFictitiousFunctionClassFactory.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/builtins/functions/BuiltInFictitiousFunctionClassFactory.kt @@ -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() 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 3cc0170d981..fbdbc452609 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/builtins/functions/FunctionClassDescriptor.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/builtins/functions/FunctionClassDescriptor.kt @@ -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 { // 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() } 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 c6aa00bad70..425d0765e4f 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) { - 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() } } diff --git a/core/descriptors/src/org/jetbrains/kotlin/types/checker/ClassicTypeSystemContext.kt b/core/descriptors/src/org/jetbrains/kotlin/types/checker/ClassicTypeSystemContext.kt index 86ef6c008f0..05c83a11ab7 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/types/checker/ClassicTypeSystemContext.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/types/checker/ClassicTypeSystemContext.kt @@ -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 { + override fun KotlinTypeMarker.extractArgumentsForFunctionTypeOrSubtype(): List { 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 } 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 2c4ae916627..946b9411407 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,7 +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.FunctionalTypeKind; +import org.jetbrains.kotlin.builtins.functions.FunctionTypeKind; import org.jetbrains.kotlin.config.LanguageVersion; import org.jetbrains.kotlin.descriptors.*; import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor; @@ -338,7 +338,7 @@ public final class ExpressionVisitor extends TranslatorVisitor { default: { if (descriptor instanceof FunctionClassDescriptor) { FunctionClassDescriptor functionClassDescriptor = (FunctionClassDescriptor) descriptor; - if (functionClassDescriptor.getFunctionKind() == FunctionalTypeKind.Function.INSTANCE) { + if (functionClassDescriptor.getFunctionKind() == FunctionTypeKind.Function.INSTANCE) { ClassDescriptor primitivesObject = findPrimitiveClassesObject(context); assert primitivesObject != null; FunctionDescriptor function = DescriptorUtils.getFunctionByName( diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/CallArgumentTranslator.kt b/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/CallArgumentTranslator.kt index 759de29b536..b934ddb0652 100644 --- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/CallArgumentTranslator.kt +++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/CallArgumentTranslator.kt @@ -7,7 +7,7 @@ package org.jetbrains.kotlin.js.translate.reference import org.jetbrains.kotlin.builtins.PrimitiveType import org.jetbrains.kotlin.builtins.functions.FunctionInvokeDescriptor -import org.jetbrains.kotlin.builtins.getFunctionalClassKind +import org.jetbrains.kotlin.builtins.getFunctionTypeKind import org.jetbrains.kotlin.config.LanguageFeature import org.jetbrains.kotlin.descriptors.ClassDescriptor import org.jetbrains.kotlin.descriptors.FunctionDescriptor @@ -185,7 +185,7 @@ class CallArgumentTranslator private constructor( val parenthisedArgumentExpression = arg.getArgumentExpression() val param = argsToParameters[arg]!!.original - val isLambda = resolvedCall.resultingDescriptor.let { it.getFunctionalClassKind() != null || it is FunctionInvokeDescriptor } + val isLambda = resolvedCall.resultingDescriptor.let { it.getFunctionTypeKind() != null || it is FunctionInvokeDescriptor } val parameterType = if (!isLambda) param.varargElementType ?: param.type else context.currentModule.builtIns.anyType var argJs = Translation.translateAsExpression(parenthisedArgumentExpression!!, argumentContext) diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/utils/TranslationUtils.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/utils/TranslationUtils.java index a8d406a2150..06d25f66d7a 100644 --- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/utils/TranslationUtils.java +++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/utils/TranslationUtils.java @@ -40,7 +40,6 @@ import org.jetbrains.kotlin.resolve.BindingContextUtils; import org.jetbrains.kotlin.resolve.DescriptorUtils; import org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilsKt; import org.jetbrains.kotlin.resolve.inline.InlineUtil; -import org.jetbrains.kotlin.resolve.source.KotlinSourceElementKt; import org.jetbrains.kotlin.resolve.source.PsiSourceElementKt; import org.jetbrains.kotlin.types.DynamicTypesKt; import org.jetbrains.kotlin.types.KotlinType; @@ -434,7 +433,7 @@ public final class TranslationUtils { public static KotlinType getReturnTypeForCoercion(@NotNull CallableDescriptor descriptor, boolean forcePrivate) { descriptor = descriptor.getOriginal(); - if (FunctionTypesKt.getFunctionalClassKind(descriptor) != null || descriptor instanceof AnonymousFunctionDescriptor) { + if (FunctionTypesKt.getFunctionTypeKind(descriptor) != null || descriptor instanceof AnonymousFunctionDescriptor) { return getAnyTypeFromSameModule(descriptor); } diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/BuiltInFictitiousFunctionIrClassFactory.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/BuiltInFictitiousFunctionIrClassFactory.kt index fb2cf111122..f58dceed59b 100644 --- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/BuiltInFictitiousFunctionIrClassFactory.kt +++ b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/BuiltInFictitiousFunctionIrClassFactory.kt @@ -8,7 +8,7 @@ package org.jetbrains.kotlin.backend.konan import org.jetbrains.kotlin.backend.konan.descriptors.findPackage import org.jetbrains.kotlin.builtins.FunctionInterfacePackageFragment import org.jetbrains.kotlin.builtins.functions.FunctionClassDescriptor -import org.jetbrains.kotlin.builtins.functions.FunctionalTypeKind +import org.jetbrains.kotlin.builtins.functions.FunctionTypeKind import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.incremental.components.NoLookupLocation import org.jetbrains.kotlin.ir.declarations.* @@ -168,7 +168,7 @@ internal class BuiltInFictitiousFunctionIrClassFactory( val builtFunctionNClasses get() = builtClassesMap.entries.mapNotNull { (descriptor, irClass) -> with(descriptor) { - if (functionKind == FunctionalTypeKind.Function) + if (functionKind == FunctionTypeKind.Function) FunctionalInterface(irClass, descriptor, arity) else null } diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/objcexport/CustomTypeMapper.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/objcexport/CustomTypeMapper.kt index c242e0c2a3c..f752231bd1c 100644 --- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/objcexport/CustomTypeMapper.kt +++ b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/objcexport/CustomTypeMapper.kt @@ -6,8 +6,8 @@ package org.jetbrains.kotlin.backend.konan.objcexport import org.jetbrains.kotlin.builtins.StandardNames -import org.jetbrains.kotlin.builtins.functions.FunctionalTypeKind -import org.jetbrains.kotlin.builtins.getFunctionalClassKind +import org.jetbrains.kotlin.builtins.functions.FunctionTypeKind +import org.jetbrains.kotlin.builtins.getFunctionTypeKind import org.jetbrains.kotlin.descriptors.ClassDescriptor import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.FqName @@ -16,7 +16,7 @@ import org.jetbrains.kotlin.types.KotlinType import org.jetbrains.kotlin.types.TypeUtils internal fun ClassDescriptor.isMappedFunctionClass() = - this.getFunctionalClassKind() == FunctionalTypeKind.Function && + this.getFunctionTypeKind() == FunctionTypeKind.Function && // Type parameters include return type. declaredTypeParameters.size - 1 < CustomTypeMappers.functionTypeMappersArityLimit diff --git a/plugins/fir-plugin-prototype/src/org/jetbrains/kotlin/fir/plugin/FirPluginPrototypeExtensionRegistrar.kt b/plugins/fir-plugin-prototype/src/org/jetbrains/kotlin/fir/plugin/FirPluginPrototypeExtensionRegistrar.kt index e84c83644de..7853d17794d 100644 --- a/plugins/fir-plugin-prototype/src/org/jetbrains/kotlin/fir/plugin/FirPluginPrototypeExtensionRegistrar.kt +++ b/plugins/fir-plugin-prototype/src/org/jetbrains/kotlin/fir/plugin/FirPluginPrototypeExtensionRegistrar.kt @@ -12,7 +12,7 @@ import org.jetbrains.kotlin.fir.extensions.FirExtensionRegistrar import org.jetbrains.kotlin.fir.extensions.FirExtensionRegistrarAdapter import org.jetbrains.kotlin.fir.plugin.generators.* import org.jetbrains.kotlin.fir.plugin.types.FirNumberSignAttributeExtension -import org.jetbrains.kotlin.fir.plugin.types.ComposableLikeFunctionalTypeKindExtension +import org.jetbrains.kotlin.fir.plugin.types.ComposableLikeFunctionTypeKindExtension import org.jetbrains.kotlin.ir.plugin.GeneratedDeclarationsIrBodyFiller class FirPluginPrototypeExtensionRegistrar : FirExtensionRegistrar() { @@ -24,7 +24,7 @@ class FirPluginPrototypeExtensionRegistrar : FirExtensionRegistrar() { +::PluginAdditionalCheckers +::FirNumberSignAttributeExtension +::AlgebraReceiverInjector - +::ComposableLikeFunctionalTypeKindExtension + +::ComposableLikeFunctionTypeKindExtension // Declaration generators +::TopLevelDeclarationsGenerator diff --git a/plugins/fir-plugin-prototype/src/org/jetbrains/kotlin/fir/plugin/types/ComposableLikeFunctionalTypeKindExtension.kt b/plugins/fir-plugin-prototype/src/org/jetbrains/kotlin/fir/plugin/types/ComposableLikeFunctionTypeKindExtension.kt similarity index 65% rename from plugins/fir-plugin-prototype/src/org/jetbrains/kotlin/fir/plugin/types/ComposableLikeFunctionalTypeKindExtension.kt rename to plugins/fir-plugin-prototype/src/org/jetbrains/kotlin/fir/plugin/types/ComposableLikeFunctionTypeKindExtension.kt index 6db97eac5e5..b4322ca514e 100644 --- a/plugins/fir-plugin-prototype/src/org/jetbrains/kotlin/fir/plugin/types/ComposableLikeFunctionalTypeKindExtension.kt +++ b/plugins/fir-plugin-prototype/src/org/jetbrains/kotlin/fir/plugin/types/ComposableLikeFunctionTypeKindExtension.kt @@ -5,16 +5,16 @@ package org.jetbrains.kotlin.fir.plugin.types -import org.jetbrains.kotlin.builtins.functions.FunctionalTypeKind +import org.jetbrains.kotlin.builtins.functions.FunctionTypeKind import org.jetbrains.kotlin.fir.FirSession -import org.jetbrains.kotlin.fir.extensions.FirFunctionalTypeKindExtension +import org.jetbrains.kotlin.fir.extensions.FirFunctionTypeKindExtension import org.jetbrains.kotlin.fir.plugin.fqn import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name -class ComposableLikeFunctionalTypeKindExtension(session: FirSession) : FirFunctionalTypeKindExtension(session) { - override fun FunctionalTypeKindRegistrar.registerKinds() { +class ComposableLikeFunctionTypeKindExtension(session: FirSession) : FirFunctionTypeKindExtension(session) { + override fun FunctionTypeKindRegistrar.registerKinds() { registerKind(ComposableFunction, KComposableFunction) } } @@ -22,7 +22,7 @@ class ComposableLikeFunctionalTypeKindExtension(session: FirSession) : FirFuncti private val COMPOSABLE_PACKAGE_FQN = FqName.topLevel(Name.identifier("some")) private val MY_COMPOSABLE_ANNOTATION_CLASS_ID = ClassId.topLevel("MyComposable".fqn()) -object ComposableFunction : FunctionalTypeKind( +object ComposableFunction : FunctionTypeKind( COMPOSABLE_PACKAGE_FQN, "MyComposableFunction", MY_COMPOSABLE_ANNOTATION_CLASS_ID, @@ -31,14 +31,14 @@ object ComposableFunction : FunctionalTypeKind( override val prefixForTypeRender: String get() = "@MyComposable" - override fun reflectKind(): FunctionalTypeKind = KComposableFunction + override fun reflectKind(): FunctionTypeKind = KComposableFunction } -object KComposableFunction : FunctionalTypeKind( +object KComposableFunction : FunctionTypeKind( COMPOSABLE_PACKAGE_FQN, "KMyComposableFunction", MY_COMPOSABLE_ANNOTATION_CLASS_ID, isReflectType = true ) { - override fun nonReflectKind(): FunctionalTypeKind = ComposableFunction + override fun nonReflectKind(): FunctionTypeKind = ComposableFunction } diff --git a/plugins/fir-plugin-prototype/testData/diagnostics/functionalTypes/ambigousKinds.fir.txt b/plugins/fir-plugin-prototype/testData/diagnostics/functionalTypes/ambigousKinds.fir.txt index b51df49723e..23f42af9e21 100644 --- a/plugins/fir-plugin-prototype/testData/diagnostics/functionalTypes/ambigousKinds.fir.txt +++ b/plugins/fir-plugin-prototype/testData/diagnostics/functionalTypes/ambigousKinds.fir.txt @@ -1,3 +1,3 @@ FILE: ambigousKinds.kt - public final fun incorrect(block: ): R|kotlin/Unit| { + public final fun incorrect(block: ): R|kotlin/Unit| { } diff --git a/plugins/fir-plugin-prototype/testData/diagnostics/functionalTypes/ambigousKinds.kt b/plugins/fir-plugin-prototype/testData/diagnostics/functionalTypes/ambigousKinds.kt index a24a1a87c8f..5344498547f 100644 --- a/plugins/fir-plugin-prototype/testData/diagnostics/functionalTypes/ambigousKinds.kt +++ b/plugins/fir-plugin-prototype/testData/diagnostics/functionalTypes/ambigousKinds.kt @@ -1,3 +1,3 @@ import org.jetbrains.kotlin.fir.plugin.MyComposable -fun incorrect(block: @MyComposable suspend () -> Unit) {} +fun incorrect(block: @MyComposable suspend () -> Unit) {} diff --git a/plugins/parcelize/parcelize-compiler/parcelize.k2/src/org/jetbrains/kotlin/parcelize/fir/diagnostics/FirParcelizePropertyChecker.kt b/plugins/parcelize/parcelize-compiler/parcelize.k2/src/org/jetbrains/kotlin/parcelize/fir/diagnostics/FirParcelizePropertyChecker.kt index 4f1b11bb976..ac713150fe3 100644 --- a/plugins/parcelize/parcelize-compiler/parcelize.k2/src/org/jetbrains/kotlin/parcelize/fir/diagnostics/FirParcelizePropertyChecker.kt +++ b/plugins/parcelize/parcelize-compiler/parcelize.k2/src/org/jetbrains/kotlin/parcelize/fir/diagnostics/FirParcelizePropertyChecker.kt @@ -114,7 +114,7 @@ object FirParcelizePropertyChecker : FirPropertyChecker() { type.anySuperTypeConstructor { it is ConeKotlinType && (it.classId?.asFqNameString() in BuiltinParcelableTypes.PARCELABLE_SUPERTYPE_FQNAMES || - it.isSomeFunctionalType(session)) + it.isSomeFunctionType(session)) } } } diff --git a/plugins/sam-with-receiver/sam-with-receiver.k2/src/org/jetbrains/kotlin/samWithReceiver/k2/FirSamWithReceiverConventionTransformer.kt b/plugins/sam-with-receiver/sam-with-receiver.k2/src/org/jetbrains/kotlin/samWithReceiver/k2/FirSamWithReceiverConventionTransformer.kt index 34df3743e9b..4810563b4cd 100644 --- a/plugins/sam-with-receiver/sam-with-receiver.k2/src/org/jetbrains/kotlin/samWithReceiver/k2/FirSamWithReceiverConventionTransformer.kt +++ b/plugins/sam-with-receiver/sam-with-receiver.k2/src/org/jetbrains/kotlin/samWithReceiver/k2/FirSamWithReceiverConventionTransformer.kt @@ -5,29 +5,29 @@ package org.jetbrains.kotlin.samWithReceiver.k2 -import org.jetbrains.kotlin.builtins.functions.FunctionalTypeKind +import org.jetbrains.kotlin.builtins.functions.FunctionTypeKind import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.containingClassLookupTag import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction import org.jetbrains.kotlin.fir.resolve.FirSamConversionTransformerExtension -import org.jetbrains.kotlin.fir.resolve.createFunctionalType +import org.jetbrains.kotlin.fir.resolve.createFunctionType import org.jetbrains.kotlin.fir.resolve.toFirRegularClassSymbol import org.jetbrains.kotlin.fir.types.ConeLookupTagBasedType import org.jetbrains.kotlin.fir.types.coneType -import org.jetbrains.kotlin.fir.types.functionalTypeService +import org.jetbrains.kotlin.fir.types.functionTypeService import org.jetbrains.kotlin.utils.addToStdlib.runIf class FirSamWithReceiverConventionTransformer( private val annotations: List, session: FirSession ) : FirSamConversionTransformerExtension(session) { - override fun getCustomFunctionalTypeForSamConversion(function: FirSimpleFunction): ConeLookupTagBasedType? { + override fun getCustomFunctionTypeForSamConversion(function: FirSimpleFunction): ConeLookupTagBasedType? { val containingClassSymbol = function.containingClassLookupTag()?.toFirRegularClassSymbol(session) ?: return null return runIf(containingClassSymbol.resolvedAnnotationClassIds.any { it.asSingleFqName().asString() in annotations }) { val parameterTypes = function.valueParameters.map { it.returnTypeRef.coneType } if (parameterTypes.isEmpty()) return null - val kind = session.functionalTypeService.extractSingleSpecialKindForFunction(function.symbol) ?: FunctionalTypeKind.Function - createFunctionalType( + val kind = session.functionTypeService.extractSingleSpecialKindForFunction(function.symbol) ?: FunctionTypeKind.Function + createFunctionType( kind, parameters = parameterTypes.subList(1, parameterTypes.size), receiverType = parameterTypes[0], diff --git a/plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/impl/compilationContext.kt b/plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/impl/compilationContext.kt index 8a1e1e632a3..77d3f49cf38 100644 --- a/plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/impl/compilationContext.kt +++ b/plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/impl/compilationContext.kt @@ -8,7 +8,7 @@ package org.jetbrains.kotlin.scripting.compiler.plugin.impl import com.intellij.openapi.Disposable -import org.jetbrains.kotlin.builtins.functions.FunctionalTypeKind +import org.jetbrains.kotlin.builtins.functions.FunctionTypeKind import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys import org.jetbrains.kotlin.cli.common.arguments.K2JVMCompilerArguments import org.jetbrains.kotlin.cli.common.arguments.parseCommandLineArguments @@ -45,11 +45,11 @@ import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction import org.jetbrains.kotlin.fir.extensions.FirExtensionRegistrar import org.jetbrains.kotlin.fir.extensions.extensionService import org.jetbrains.kotlin.fir.resolve.FirSamConversionTransformerExtension -import org.jetbrains.kotlin.fir.resolve.createFunctionalType +import org.jetbrains.kotlin.fir.resolve.createFunctionType import org.jetbrains.kotlin.fir.resolve.toFirRegularClassSymbol import org.jetbrains.kotlin.fir.types.ConeLookupTagBasedType import org.jetbrains.kotlin.fir.types.coneType -import org.jetbrains.kotlin.fir.types.functionalTypeService +import org.jetbrains.kotlin.fir.types.functionTypeService import org.jetbrains.kotlin.platform.TargetPlatform import org.jetbrains.kotlin.platform.jvm.isJvm import org.jetbrains.kotlin.psi.KtFile @@ -154,13 +154,13 @@ internal class FirScriptingSamWithReceiverExtensionRegistrar() : FirExtensionReg } } - override fun getCustomFunctionalTypeForSamConversion(function: FirSimpleFunction): ConeLookupTagBasedType? { + override fun getCustomFunctionTypeForSamConversion(function: FirSimpleFunction): ConeLookupTagBasedType? { val containingClassSymbol = function.containingClassLookupTag()?.toFirRegularClassSymbol(session) ?: return null return runIf(containingClassSymbol.resolvedAnnotationClassIds.any { it.asSingleFqName().asString() in knownAnnotations }) { val parameterTypes = function.valueParameters.map { it.returnTypeRef.coneType } if (parameterTypes.isEmpty()) return null - val kind = session.functionalTypeService.extractSingleSpecialKindForFunction(function.symbol) ?: FunctionalTypeKind.Function - createFunctionalType( + val kind = session.functionTypeService.extractSingleSpecialKindForFunction(function.symbol) ?: FunctionTypeKind.Function + createFunctionType( kind, parameters = parameterTypes.subList(1, parameterTypes.size), receiverType = parameterTypes[0],