From 7a347b11e33bd205143aceee5901d86525ccd942 Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Tue, 14 Sep 2021 12:12:42 +0300 Subject: [PATCH] [FIR] Use StandardClassIds instead of StandardNames everywhere it's possible --- .../FirJvmFieldApplicabilityChecker.kt | 3 +- .../expression/FirJavaAnnotationsChecker.kt | 19 ++- .../analysis/checkers/FirAnnotationHelpers.kt | 10 +- .../declaration/FirOperatorModifierChecker.kt | 6 +- .../expression/FirSuspendCallChecker.kt | 17 ++- .../deserialization/ClassDeserialization.kt | 16 +-- .../deserialization/FirTypeDeserializer.kt | 2 +- .../fir/deserialization/suspendTypeUtils.kt | 12 -- .../impl/FirBuiltinSymbolProvider.kt | 3 +- .../fir/serialization/FirElementSerializer.kt | 5 +- .../kotlin/fir/backend/IrBuiltInsOverFir.kt | 108 ++++++++---------- .../jetbrains/kotlin/fir/java/JavaUtils.kt | 14 +-- .../kotlin/fir/resolve/ResolveUtils.kt | 5 +- .../impl/FirCloneableSymbolProvider.kt | 22 +--- .../providers/impl/FirTypeResolverImpl.kt | 6 +- .../types/ConeFlexibleTypeBoundsChecker.kt | 4 +- .../kotlin/fir/types/ConeInferenceContext.kt | 17 +-- .../kotlin/fir/types/ConeTypeContext.kt | 9 +- .../jetbrains/kotlin/name/StandardClassIds.kt | 59 ++++++++-- 19 files changed, 165 insertions(+), 172 deletions(-) delete mode 100644 compiler/fir/fir-deserialization/src/org/jetbrains/kotlin/fir/deserialization/suspendTypeUtils.kt diff --git a/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirJvmFieldApplicabilityChecker.kt b/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirJvmFieldApplicabilityChecker.kt index 2a2f693466d..e043b2a514b 100644 --- a/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirJvmFieldApplicabilityChecker.kt +++ b/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirJvmFieldApplicabilityChecker.kt @@ -38,6 +38,7 @@ import org.jetbrains.kotlin.fir.types.classId import org.jetbrains.kotlin.fir.types.coneType import org.jetbrains.kotlin.load.java.JvmAbi.JVM_FIELD_ANNOTATION_CLASS_ID import org.jetbrains.kotlin.name.JvmNames.JVM_MULTIFILE_CLASS_ID +import org.jetbrains.kotlin.name.StandardClassIds object FirJvmFieldApplicabilityChecker : FirPropertyChecker() { override fun check(declaration: FirProperty, context: CheckerContext, reporter: DiagnosticReporter) { @@ -88,7 +89,7 @@ object FirJvmFieldApplicabilityChecker : FirPropertyChecker() { } private fun FirRegularClassSymbol.isDontMangleClass(): Boolean { - return this.classId.relativeClassName.asString() == StandardNames.RESULT_FQ_NAME.asString() + return this.classId == StandardClassIds.Result } private fun FirProperty.isOverridable(containingClass: FirRegularClassSymbol?): Boolean { diff --git a/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/expression/FirJavaAnnotationsChecker.kt b/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/expression/FirJavaAnnotationsChecker.kt index 03c07bb5311..66d555fc36e 100644 --- a/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/expression/FirJavaAnnotationsChecker.kt +++ b/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/expression/FirJavaAnnotationsChecker.kt @@ -5,7 +5,6 @@ package org.jetbrains.kotlin.fir.analysis.jvm.checkers.expression -import org.jetbrains.kotlin.builtins.StandardNames import org.jetbrains.kotlin.fir.FirRealSourceElementKind import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext import org.jetbrains.kotlin.fir.analysis.checkers.expression.FirAnnotationChecker @@ -20,19 +19,17 @@ import org.jetbrains.kotlin.fir.expressions.FirWrappedArgumentExpression import org.jetbrains.kotlin.fir.expressions.impl.FirResolvedArgumentList import org.jetbrains.kotlin.fir.types.ConeClassLikeType import org.jetbrains.kotlin.fir.types.coneTypeSafe -import org.jetbrains.kotlin.load.java.JvmAnnotationNames -import org.jetbrains.kotlin.load.java.JvmAnnotationNames.DEFAULT_ANNOTATION_MEMBER_NAME import org.jetbrains.kotlin.name.ClassId -import org.jetbrains.kotlin.name.FqName +import org.jetbrains.kotlin.name.StandardClassIds.Annotations object FirJavaAnnotationsChecker : FirAnnotationChecker() { - private val javaToKotlinNameMap: Map = + private val javaToKotlinNameMap: Map = mapOf( - ClassId.topLevel(JvmAnnotationNames.TARGET_ANNOTATION) to StandardNames.FqNames.target, - ClassId.topLevel(JvmAnnotationNames.RETENTION_ANNOTATION) to StandardNames.FqNames.retention, - ClassId.topLevel(JvmAnnotationNames.DEPRECATED_ANNOTATION) to StandardNames.FqNames.deprecated, - ClassId.topLevel(JvmAnnotationNames.DOCUMENTED_ANNOTATION) to StandardNames.FqNames.mustBeDocumented + Annotations.Java.Target to Annotations.Target, + Annotations.Java.Retention to Annotations.Retention, + Annotations.Java.Deprecated to Annotations.Deprecated, + Annotations.Java.Documented to Annotations.MustBeDocumented, ) override fun check(expression: FirAnnotation, context: CheckerContext, reporter: DiagnosticReporter) { @@ -42,14 +39,14 @@ object FirJavaAnnotationsChecker : FirAnnotationChecker() { val lookupTag = expression.annotationTypeRef.coneTypeSafe()?.lookupTag ?: return javaToKotlinNameMap[lookupTag.classId]?.let { betterName -> - reporter.reportOn(expression.source, FirJvmErrors.DEPRECATED_JAVA_ANNOTATION, betterName, context) + reporter.reportOn(expression.source, FirJvmErrors.DEPRECATED_JAVA_ANNOTATION, betterName.asSingleFqName(), context) } if (expression is FirAnnotationCall) { val argumentList = expression.argumentList if (argumentList is FirResolvedArgumentList) { for ((key, value) in argumentList.mapping) { - if (value.name != DEFAULT_ANNOTATION_MEMBER_NAME && key !is FirWrappedArgumentExpression) { + if (value.name != Annotations.ParameterNames.value && key !is FirWrappedArgumentExpression) { reporter.reportOn(key.source, FirJvmErrors.POSITIONED_VALUE_ARGUMENT_FOR_JAVA_ANNOTATION, context) } } diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirAnnotationHelpers.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirAnnotationHelpers.kt index f43faf13568..88aa7477198 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirAnnotationHelpers.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirAnnotationHelpers.kt @@ -85,15 +85,15 @@ fun FirClassLikeSymbol<*>.getAllowedAnnotationTargets(): Set { } fun FirAnnotatedDeclaration.getRetentionAnnotation(): FirAnnotation? { - return getAnnotationByClassId(StandardNames.FqNames.retentionClassId) + return getAnnotationByClassId(StandardClassIds.Annotations.Retention) } fun FirAnnotatedDeclaration.getTargetAnnotation(): FirAnnotation? { - return getAnnotationByClassId(StandardNames.FqNames.targetClassId) + return getAnnotationByClassId(StandardClassIds.Annotations.Target) } fun FirClassLikeSymbol<*>.getTargetAnnotation(): FirAnnotation? { - return getAnnotationByClassId(StandardNames.FqNames.targetClassId) + return getAnnotationByClassId(StandardClassIds.Annotations.Target) } fun FirExpression.extractClassesFromArgument(): List { @@ -127,7 +127,7 @@ fun FirAnnotation.isRepeatable(session: FirSession): Boolean { } fun FirClassLikeSymbol<*>.containsRepeatableAnnotation(session: FirSession): Boolean { - if (getAnnotationByClassId(StandardNames.FqNames.repeatableClassId) != null) return true + if (getAnnotationByClassId(StandardClassIds.Annotations.Repeatable) != null) return true if (getAnnotationByClassId(StandardClassIds.Annotations.Java.Repeatable) != null || getAnnotationByClassId(StandardClassIds.Annotations.JvmRepeatable) != null ) { @@ -138,7 +138,7 @@ fun FirClassLikeSymbol<*>.containsRepeatableAnnotation(session: FirSession): Boo } fun FirClassLikeSymbol<*>.getAnnotationRetention(): AnnotationRetention { - return getAnnotationByClassId(StandardNames.FqNames.retentionClassId)?.getRetention() ?: AnnotationRetention.RUNTIME + return getAnnotationByClassId(StandardClassIds.Annotations.Retention)?.getRetention() ?: AnnotationRetention.RUNTIME } fun FirAnnotationContainer.getDefaultUseSiteTarget( diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirOperatorModifierChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirOperatorModifierChecker.kt index 241e1db8281..e24d3840f78 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirOperatorModifierChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirOperatorModifierChecker.kt @@ -10,7 +10,6 @@ package org.jetbrains.kotlin.fir.analysis.checkers.declaration -import org.jetbrains.kotlin.builtins.StandardNames import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext import org.jetbrains.kotlin.fir.analysis.checkers.declaration.Checks.Returns import org.jetbrains.kotlin.fir.analysis.checkers.declaration.Checks.ValueParametersCount @@ -35,6 +34,7 @@ import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.fir.types.impl.ConeClassLikeTypeImpl import org.jetbrains.kotlin.lexer.KtTokens import org.jetbrains.kotlin.name.Name +import org.jetbrains.kotlin.name.StandardClassIds import org.jetbrains.kotlin.util.OperatorNameConventions.ASSIGNMENT_OPERATIONS import org.jetbrains.kotlin.util.OperatorNameConventions.BINARY_OPERATION_NAMES import org.jetbrains.kotlin.util.OperatorNameConventions.COMPARE_TO @@ -145,7 +145,7 @@ private object Checks { } private val kPropertyType = ConeClassLikeTypeImpl( - ConeClassLikeLookupTagImpl(StandardNames.FqNames.kProperty), + ConeClassLikeLookupTagImpl(StandardClassIds.KProperty), arrayOf(ConeStarProjection), isNullable = false ) @@ -187,7 +187,7 @@ private object OperatorFunctionChecks { Checks.full("must override ''equals()'' in Any") { ctx, function -> val containingClassSymbol = function.containingClass()?.toFirRegularClassSymbol(ctx.session) ?: return@full true function.overriddenFunctions(containingClassSymbol, ctx).any { - it.containingClass()?.classId?.asSingleFqName() == StandardNames.FqNames.any.toSafe() + it.containingClass()?.classId == StandardClassIds.Any } } ) 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 b149db72fcb..ae78c998849 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 @@ -6,14 +6,16 @@ package org.jetbrains.kotlin.fir.analysis.checkers.expression import org.jetbrains.kotlin.KtNodeTypes -import org.jetbrains.kotlin.builtins.StandardNames import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn import org.jetbrains.kotlin.fir.analysis.getChild -import org.jetbrains.kotlin.fir.declarations.* +import org.jetbrains.kotlin.fir.declarations.FirAnonymousFunction +import org.jetbrains.kotlin.fir.declarations.FirFunction +import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction +import org.jetbrains.kotlin.fir.declarations.getAnnotationByClassId import org.jetbrains.kotlin.fir.declarations.utils.isSuspend import org.jetbrains.kotlin.fir.declarations.utils.superConeTypes import org.jetbrains.kotlin.fir.expressions.* @@ -32,16 +34,11 @@ import org.jetbrains.kotlin.fir.types.ConeKotlinType import org.jetbrains.kotlin.fir.types.ConeTypeParameterType import org.jetbrains.kotlin.fir.types.coneType import org.jetbrains.kotlin.name.CallableId -import org.jetbrains.kotlin.name.ClassId -import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.name.StandardClassIds import org.jetbrains.kotlin.utils.addToStdlib.lastIsInstanceOrNull object FirSuspendCallChecker : FirQualifiedAccessExpressionChecker() { - private val RESTRICTS_SUSPENSION_CLASS_ID = - ClassId(StandardNames.COROUTINES_PACKAGE_FQ_NAME, Name.identifier("RestrictsSuspension")) - - private val BUILTIN_SUSPEND_NAME = StandardClassIds.suspend.callableName + private val BUILTIN_SUSPEND_NAME = StandardClassIds.Callables.suspend.callableName internal val KOTLIN_SUSPEND_BUILT_IN_FUNCTION_CALLABLE_ID = CallableId(StandardClassIds.BASE_KOTLIN_PACKAGE, BUILTIN_SUSPEND_NAME) @@ -56,7 +53,7 @@ object FirSuspendCallChecker : FirQualifiedAccessExpressionChecker() { if (reference is FirResolvedCallableReference) return when (symbol) { is FirNamedFunctionSymbol -> if (!symbol.isSuspend) return - is FirPropertySymbol -> if (symbol.callableId != StandardClassIds.coroutineContext) return + is FirPropertySymbol -> if (symbol.callableId != StandardClassIds.Callables.coroutineContext) return else -> return } val enclosingSuspendFunction = findEnclosingSuspendFunction(context) @@ -177,7 +174,7 @@ object FirSuspendCallChecker : FirQualifiedAccessExpressionChecker() { when (this) { is ConeClassLikeType -> { val regularClassSymbol = fullyExpandedType(session).lookupTag.toFirRegularClassSymbol(session) ?: return false - if (regularClassSymbol.getAnnotationByClassId(RESTRICTS_SUSPENSION_CLASS_ID) != null) { + if (regularClassSymbol.getAnnotationByClassId(StandardClassIds.Annotations.RestrictsSuspension) != null) { return true } return regularClassSymbol.superConeTypes.any { it.isRestrictSuspensionReceiver(session) } diff --git a/compiler/fir/fir-deserialization/src/org/jetbrains/kotlin/fir/deserialization/ClassDeserialization.kt b/compiler/fir/fir-deserialization/src/org/jetbrains/kotlin/fir/deserialization/ClassDeserialization.kt index 3357c22c9ca..43bbeabafe6 100644 --- a/compiler/fir/fir-deserialization/src/org/jetbrains/kotlin/fir/deserialization/ClassDeserialization.kt +++ b/compiler/fir/fir-deserialization/src/org/jetbrains/kotlin/fir/deserialization/ClassDeserialization.kt @@ -5,7 +5,6 @@ package org.jetbrains.kotlin.fir.deserialization -import org.jetbrains.kotlin.builtins.StandardNames import org.jetbrains.kotlin.builtins.jvm.JvmBuiltInsSignatures import org.jetbrains.kotlin.descriptors.ClassKind import org.jetbrains.kotlin.descriptors.EffectiveVisibility @@ -20,8 +19,6 @@ import org.jetbrains.kotlin.fir.declarations.utils.addDeclarations import org.jetbrains.kotlin.fir.declarations.utils.moduleName import org.jetbrains.kotlin.fir.declarations.utils.sourceElement import org.jetbrains.kotlin.fir.expressions.FirAnnotation -import org.jetbrains.kotlin.fir.resolve.providers.impl.FirCloneableSymbolProvider.Companion.CLONE -import org.jetbrains.kotlin.fir.resolve.providers.impl.FirCloneableSymbolProvider.Companion.CLONEABLE_CLASS_ID import org.jetbrains.kotlin.fir.scopes.FirScopeProvider import org.jetbrains.kotlin.fir.symbols.ConeTypeParameterLookupTag import org.jetbrains.kotlin.fir.symbols.impl.ConeClassLikeLookupTagImpl @@ -37,10 +34,7 @@ import org.jetbrains.kotlin.load.kotlin.KotlinJvmBinarySourceElement import org.jetbrains.kotlin.metadata.ProtoBuf import org.jetbrains.kotlin.metadata.deserialization.* import org.jetbrains.kotlin.metadata.jvm.JvmProtoBuf -import org.jetbrains.kotlin.name.CallableId -import org.jetbrains.kotlin.name.ClassId -import org.jetbrains.kotlin.name.FqName -import org.jetbrains.kotlin.name.Name +import org.jetbrains.kotlin.name.* import org.jetbrains.kotlin.serialization.deserialization.ProtoEnumFlags import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedContainerSource import org.jetbrains.kotlin.serialization.deserialization.getName @@ -254,11 +248,11 @@ private fun FirRegularClassBuilder.addSerializableIfNeeded(classId: ClassId) { } private fun FirRegularClassBuilder.addCloneForArrayIfNeeded(classId: ClassId, dispatchReceiver: ConeClassLikeType?) { - if (classId.packageFqName != StandardNames.BUILT_INS_PACKAGE_FQ_NAME) return + if (classId.packageFqName != StandardClassIds.BASE_KOTLIN_PACKAGE) return if (classId.shortClassName !in ARRAY_CLASSES) return superTypeRefs += buildResolvedTypeRef { type = ConeClassLikeTypeImpl( - ConeClassLikeLookupTagImpl(CLONEABLE_CLASS_ID), + ConeClassLikeLookupTagImpl(StandardClassIds.Cloneable), typeArguments = emptyArray(), isNullable = false ) @@ -286,8 +280,8 @@ private fun FirRegularClassBuilder.addCloneForArrayIfNeeded(classId: ClassId, di status = FirResolvedDeclarationStatusImpl(Visibilities.Public, Modality.FINAL, EffectiveVisibility.Public).apply { isOverride = true } - name = CLONE - symbol = FirNamedFunctionSymbol(CallableId(classId, CLONE)) + name = StandardClassIds.Callables.clone.callableName + symbol = FirNamedFunctionSymbol(CallableId(classId, name)) dispatchReceiverType = dispatchReceiver!! } } 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 17e59953aea..706602c0ff6 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 @@ -171,7 +171,7 @@ class FirTypeDeserializer( ): ConeClassLikeType? { fun ConeClassLikeType.isContinuation(): Boolean { if (this.typeArguments.size != 1) return false - if (this.lookupTag.classId != CONTINUATION_INTERFACE_CLASS_ID) return false + if (this.lookupTag.classId != StandardClassIds.Continuation) return false return true } diff --git a/compiler/fir/fir-deserialization/src/org/jetbrains/kotlin/fir/deserialization/suspendTypeUtils.kt b/compiler/fir/fir-deserialization/src/org/jetbrains/kotlin/fir/deserialization/suspendTypeUtils.kt deleted file mode 100644 index 1724555bec2..00000000000 --- a/compiler/fir/fir-deserialization/src/org/jetbrains/kotlin/fir/deserialization/suspendTypeUtils.kt +++ /dev/null @@ -1,12 +0,0 @@ -/* - * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. - * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. - */ - -package org.jetbrains.kotlin.fir.deserialization - -import org.jetbrains.kotlin.builtins.StandardNames -import org.jetbrains.kotlin.name.ClassId - - -val CONTINUATION_INTERFACE_CLASS_ID = ClassId.topLevel(StandardNames.CONTINUATION_INTERFACE_FQ_NAME) 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 e5d2489654f..ee9fa0a804b 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 @@ -5,7 +5,6 @@ package org.jetbrains.kotlin.fir.resolve.providers.impl -import org.jetbrains.kotlin.builtins.StandardNames import org.jetbrains.kotlin.builtins.functions.FunctionClassKind import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.fir.FirModuleData @@ -58,7 +57,7 @@ open class FirBuiltinSymbolProvider( private fun loadBuiltIns(): List { val classLoader = this::class.java.classLoader val streamProvider = { path: String -> classLoader?.getResourceAsStream(path) ?: ClassLoader.getSystemResourceAsStream(path) } - val packageFqNames = StandardNames.BUILT_INS_PACKAGE_FQ_NAMES + val packageFqNames = StandardClassIds.builtInsPackages return packageFqNames.map { fqName -> val resourcePath = BuiltInSerializerProtocol.getBuiltInsFilePath(fqName) 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 1ea430cba2e..1dbe3aa0d3e 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 @@ -16,7 +16,6 @@ import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.comparators.FirCallableDeclarationComparator import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyAccessor import org.jetbrains.kotlin.fir.declarations.utils.* -import org.jetbrains.kotlin.fir.deserialization.CONTINUATION_INTERFACE_CLASS_ID import org.jetbrains.kotlin.fir.deserialization.projection import org.jetbrains.kotlin.fir.expressions.FirAnnotation import org.jetbrains.kotlin.fir.expressions.FirArgumentList @@ -642,7 +641,7 @@ class FirElementSerializer private constructor( is ConeClassLikeType -> { if (type.isSuspendFunctionType(session)) { val runtimeFunctionType = type.suspendFunctionTypeToFunctionTypeWithContinuation( - session, CONTINUATION_INTERFACE_CLASS_ID + session, StandardClassIds.Continuation ) val functionType = typeProto(runtimeFunctionType) functionType.flags = Flags.getTypeFlags(true, false) @@ -657,7 +656,7 @@ class FirElementSerializer private constructor( } is ConeTypeParameterType -> { val typeParameter = type.lookupTag.typeParameterSymbol.fir - if (typeParameter in (containingDeclaration as? FirMemberDeclaration)?.typeParameters ?: emptyList()) { + if (typeParameter in ((containingDeclaration as? FirMemberDeclaration)?.typeParameters ?: emptyList())) { builder.typeParameterName = getSimpleNameIndex(typeParameter.name) } else { builder.typeParameter = getTypeParameterId(typeParameter) diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/IrBuiltInsOverFir.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/IrBuiltInsOverFir.kt index 24dfcd286d6..934cec3b0ef 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/IrBuiltInsOverFir.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/IrBuiltInsOverFir.kt @@ -8,7 +8,6 @@ package org.jetbrains.kotlin.fir.backend import org.jetbrains.kotlin.backend.common.ir.addFakeOverrides import org.jetbrains.kotlin.backend.common.ir.createImplicitParameterDeclarationWithWrappedDescriptor import org.jetbrains.kotlin.builtins.PrimitiveType -import org.jetbrains.kotlin.builtins.StandardNames import org.jetbrains.kotlin.builtins.UnsignedType import org.jetbrains.kotlin.config.LanguageVersionSettings import org.jetbrains.kotlin.descriptors.ClassKind @@ -38,10 +37,7 @@ import org.jetbrains.kotlin.ir.symbols.impl.IrTypeParameterSymbolImpl import org.jetbrains.kotlin.ir.types.* import org.jetbrains.kotlin.ir.types.impl.IrSimpleTypeImpl import org.jetbrains.kotlin.ir.util.* -import org.jetbrains.kotlin.name.ClassId -import org.jetbrains.kotlin.name.FqName -import org.jetbrains.kotlin.name.Name -import org.jetbrains.kotlin.name.SpecialNames +import org.jetbrains.kotlin.name.* import org.jetbrains.kotlin.types.Variance import org.jetbrains.kotlin.util.OperatorNameConventions import kotlin.reflect.KProperty @@ -55,10 +51,7 @@ class IrBuiltInsOverFir( override val irFactory: IrFactory = components.symbolTable.irFactory - private val kotlinPackage = StandardNames.BUILT_INS_PACKAGE_FQ_NAME - private val kotlinReflectPackage = StandardNames.KOTLIN_REFLECT_FQ_NAME - - private val kotlinCollectionsPackage = StandardNames.COLLECTIONS_PACKAGE_FQ_NAME + private val kotlinPackage = StandardClassIds.BASE_KOTLIN_PACKAGE override val operatorsPackageFragment = createPackage(KOTLIN_INTERNAL_IR_FQN) private val kotlinIrPackage = createPackage(kotlinPackage) @@ -123,7 +116,7 @@ class IrBuiltInsOverFir( createMemberFunction(OperatorNameConventions.PLUS, charType, "other" to intType, isOperator = true) createMemberFunction(OperatorNameConventions.MINUS, charType, "other" to intType, isOperator = true) createMemberFunction(OperatorNameConventions.MINUS, intType, "other" to charType, isOperator = true) - val charRange = referenceClassByFqname(StandardNames.RANGES_PACKAGE_FQ_NAME, "CharRange")!!.owner.defaultType + val charRange = referenceClassByClassId(StandardClassIds.CharRange)!!.owner.defaultType createMemberFunction(OperatorNameConventions.RANGE_TO, charRange, "other" to charType) finalizeClassDefinition() } @@ -198,75 +191,75 @@ class IrBuiltInsOverFir( } override val arrayClass: IrClassSymbol get() = array.klass - private val intRangeType by lazy { referenceClassByFqname(StandardNames.RANGES_PACKAGE_FQ_NAME, "IntRange")!!.owner.defaultType } - private val longRangeType by lazy { referenceClassByFqname(StandardNames.RANGES_PACKAGE_FQ_NAME, "LongRange")!!.owner.defaultType } + private val intRangeType by lazy { referenceClassByClassId(StandardClassIds.IntRange)!!.owner.defaultType } + private val longRangeType by lazy { referenceClassByClassId(StandardClassIds.LongRange)!!.owner.defaultType } - private val annotation by loadClass(kotlinPackage, "Annotation") + private val annotation by loadClass(StandardClassIds.Annotation) override val annotationClass: IrClassSymbol get() = annotation.klass override val annotationType: IrType get() = annotation.type - private val collection by loadClass(kotlinCollectionsPackage, "Collection") + private val collection by loadClass(StandardClassIds.Collection) override val collectionClass: IrClassSymbol get() = collection.klass - private val set by loadClass(kotlinCollectionsPackage, "Set") + private val set by loadClass(StandardClassIds.Set) override val setClass: IrClassSymbol get() = set.klass - private val list by loadClass(kotlinCollectionsPackage, "List") + private val list by loadClass(StandardClassIds.List) override val listClass: IrClassSymbol get() = list.klass - private val map by loadClass(kotlinCollectionsPackage, "Map") + private val map by loadClass(StandardClassIds.Map) override val mapClass: IrClassSymbol get() = map.klass - private val mapEntry by BuiltInsClass({ true to referenceNestedClass(mapClass, "Entry")!! }) + private val mapEntry by BuiltInsClass({ true to referenceClassByClassId(StandardClassIds.MapEntry)!! }) override val mapEntryClass: IrClassSymbol get() = mapEntry.klass - private val iterable by loadClass(StandardNames.FqNames.iterable) + private val iterable by loadClass(StandardClassIds.Iterable) override val iterableClass: IrClassSymbol get() = iterable.klass - private val iterator by loadClass(StandardNames.FqNames.iterator) + private val iterator by loadClass(StandardClassIds.Iterator) override val iteratorClass: IrClassSymbol get() = iterator.klass - private val listIterator by loadClass(StandardNames.FqNames.listIterator) + private val listIterator by loadClass(StandardClassIds.ListIterator) override val listIteratorClass: IrClassSymbol get() = listIterator.klass - private val mutableCollection by loadClass(StandardNames.FqNames.mutableCollection) + private val mutableCollection by loadClass(StandardClassIds.MutableCollection) override val mutableCollectionClass: IrClassSymbol get() = mutableCollection.klass - private val mutableSet by loadClass(StandardNames.FqNames.mutableSet) + private val mutableSet by loadClass(StandardClassIds.MutableSet) override val mutableSetClass: IrClassSymbol get() = mutableSet.klass - private val mutableList by loadClass(StandardNames.FqNames.mutableList) + private val mutableList by loadClass(StandardClassIds.MutableList) override val mutableListClass: IrClassSymbol get() = mutableList.klass - private val mutableMap by loadClass(StandardNames.FqNames.mutableMap) + private val mutableMap by loadClass(StandardClassIds.MutableMap) override val mutableMapClass: IrClassSymbol get() = mutableMap.klass - private val mutableMapEntry by BuiltInsClass({ true to referenceNestedClass(StandardNames.FqNames.mutableMapEntry)!! }) + private val mutableMapEntry by BuiltInsClass({ true to referenceClassByClassId(StandardClassIds.MutableMapEntry)!! }) override val mutableMapEntryClass: IrClassSymbol get() = mutableMapEntry.klass - private val mutableIterable by loadClass(StandardNames.FqNames.mutableIterable) + private val mutableIterable by loadClass(StandardClassIds.MutableIterable) override val mutableIterableClass: IrClassSymbol get() = mutableIterable.klass - private val mutableIterator by loadClass(StandardNames.FqNames.mutableIterator) + private val mutableIterator by loadClass(StandardClassIds.MutableIterator) override val mutableIteratorClass: IrClassSymbol get() = mutableIterator.klass - private val mutableListIterator by loadClass(StandardNames.FqNames.mutableListIterator) + private val mutableListIterator by loadClass(StandardClassIds.MutableListIterator) override val mutableListIteratorClass: IrClassSymbol get() = mutableListIterator.klass - private val comparable by loadClass(StandardNames.FqNames.comparable) + private val comparable by loadClass(StandardClassIds.Comparable) override val comparableClass: IrClassSymbol get() = comparable.klass override val throwableType: IrType by lazy { throwableClass.defaultType } - private val throwable by loadClass(StandardNames.FqNames.throwable) + private val throwable by loadClass(StandardClassIds.Throwable) override val throwableClass: IrClassSymbol get() = throwable.klass - private val kCallable by loadClass(StandardNames.FqNames.kCallable.toSafe()) + private val kCallable by loadClass(StandardClassIds.KCallable) override val kCallableClass: IrClassSymbol get() = kCallable.klass - private val kProperty by loadClass(StandardNames.FqNames.kPropertyFqName.toSafe()) + private val kProperty by loadClass(StandardClassIds.KProperty) override val kPropertyClass: IrClassSymbol get() = kProperty.klass - private val kClass by loadClass(StandardNames.FqNames.kClass.toSafe()) + private val kClass by loadClass(StandardClassIds.KClass) override val kClassClass: IrClassSymbol get() = kClass.klass - private val kProperty0 by loadClass(StandardNames.FqNames.kProperty0.toSafe()) + private val kProperty0 by loadClass(StandardClassIds.KProperty0) override val kProperty0Class: IrClassSymbol get() = kProperty0.klass - private val kProperty1 by loadClass(StandardNames.FqNames.kProperty1.toSafe()) + private val kProperty1 by loadClass(StandardClassIds.KProperty1) override val kProperty1Class: IrClassSymbol get() = kProperty1.klass - private val kProperty2 by loadClass(StandardNames.FqNames.kProperty2.toSafe()) + private val kProperty2 by loadClass(StandardClassIds.KProperty2) override val kProperty2Class: IrClassSymbol get() = kProperty2.klass - private val kMutableProperty0 by loadClass(StandardNames.FqNames.kMutableProperty0.toSafe()) + private val kMutableProperty0 by loadClass(StandardClassIds.KMutableProperty0) override val kMutableProperty0Class: IrClassSymbol get() = kMutableProperty0.klass - private val kMutableProperty1 by loadClass(StandardNames.FqNames.kMutableProperty1.toSafe()) + private val kMutableProperty1 by loadClass(StandardClassIds.KMutableProperty1) override val kMutableProperty1Class: IrClassSymbol get() = kMutableProperty1.klass - private val kMutableProperty2 by loadClass(StandardNames.FqNames.kMutableProperty2.toSafe()) + private val kMutableProperty2 by loadClass(StandardClassIds.KMutableProperty2) override val kMutableProperty2Class: IrClassSymbol get() = kMutableProperty2.klass - private val function by loadClass(kotlinPackage, "Function") + private val function by loadClass(StandardClassIds.Function) override val functionClass: IrClassSymbol get() = function.klass - private val kFunction by loadClass(kotlinReflectPackage, "KFunction") + private val kFunction by loadClass(StandardClassIds.KFunction) override val kFunctionClass: IrClassSymbol get() = kFunction.klass override val primitiveTypeToIrType = mapOf( @@ -442,7 +435,7 @@ class IrBuiltInsOverFir( else -> error("No KProperty for n=$n mutable=$mutable") } - private val enum by loadClass(kotlinPackage, "Enum") + private val enum by loadClass(StandardClassIds.Enum) override val enumClass: IrClassSymbol get() = enum.klass override val intPlusSymbol: IrSimpleFunctionSymbol @@ -503,7 +496,7 @@ class IrBuiltInsOverFir( override val arrayOf: IrSimpleFunctionSymbol get() = kotlinBuiltinFunctions.arrayOf - private fun getFunctionsByKey( + private fun getFunctionsByKey( name: Name, vararg packageNameSegments: String, makeKey: (IrSimpleFunctionSymbol) -> T? @@ -537,19 +530,19 @@ class IrBuiltInsOverFir( private val kSuspendFunctionNMap = mutableMapOf() override fun functionN(arity: Int): IrClass = functionNMap.getOrPut(arity) { - referenceClassByClassId(StandardNames.getFunctionClassId(arity))!!.owner + referenceClassByClassId(StandardClassIds.FunctionN(arity))!!.owner } override fun kFunctionN(arity: Int): IrClass = kFunctionNMap.getOrPut(arity) { - referenceClassByClassId(StandardNames.getKFunctionClassId(arity))!!.owner + referenceClassByClassId(StandardClassIds.KFunctionN(arity))!!.owner } override fun suspendFunctionN(arity: Int): IrClass = suspendFunctionNMap.getOrPut(arity) { - referenceClassByClassId(StandardNames.getSuspendFunctionClassId(arity))!!.owner + referenceClassByClassId(StandardClassIds.SuspendFunctionN(arity))!!.owner } override fun kSuspendFunctionN(arity: Int): IrClass = kSuspendFunctionNMap.getOrPut(arity) { - referenceClassByClassId(StandardNames.getKSuspendFunctionClassId(arity))!!.owner + referenceClassByClassId(StandardClassIds.KSuspendFunctionN(arity))!!.owner } override fun findFunctions(name: Name, vararg packageNameSegments: String): Iterable = @@ -564,6 +557,9 @@ class IrBuiltInsOverFir( override fun findClass(name: Name, packageFqName: FqName): IrClassSymbol? = referenceClassByFqname(packageFqName, name) + private fun referenceClassByFqname(packageName: FqName, identifier: Name) = + referenceClassByClassId(ClassId(packageName, identifier)) + private val builtInClasses by lazy { setOf(anyClass) } @@ -630,8 +626,6 @@ class IrBuiltInsOverFir( } private fun loadClass(classId: ClassId) = BuiltInsClass({ true to referenceClassByClassId(classId)!! }) - private fun loadClass(packageFqName: FqName, name: String) = loadClass(ClassId(packageFqName, Name.identifier(name))) - private fun loadClass(topLevelFqName: FqName) = loadClass(ClassId.topLevel(topLevelFqName)) private fun createClass( parent: IrDeclarationParent, @@ -668,24 +662,12 @@ class IrBuiltInsOverFir( private fun referenceClassByFqname(topLevelFqName: FqName) = referenceClassByClassId(ClassId.topLevel(topLevelFqName)) - private fun referenceClassByFqname(packageName: FqName, identifier: Name) = - referenceClassByClassId(ClassId(packageName, identifier)) - - private fun referenceClassByFqname(packageName: FqName, identifier: String) = - referenceClassByClassId(ClassId(packageName, Name.identifier(identifier))) - private fun referenceClassByClassId(classId: ClassId): IrClassSymbol? { val firSymbol = components.session.symbolProvider.getClassLikeSymbolByClassId(classId) ?: return null val firClassSymbol = firSymbol as? FirClassSymbol ?: return null return components.classifierStorage.getIrClassSymbol(firClassSymbol) } - private fun referenceNestedClass(klass: IrClassSymbol, identifier: String): IrClassSymbol? = - referenceClassByClassId(klass.owner.classId!!.createNestedClassId(Name.identifier(identifier))) - - private fun referenceNestedClass(fqName: FqName): IrClassSymbol? = - referenceClassByClassId(ClassId(fqName.parent().parent(), fqName.parent().shortName()).createNestedClassId(fqName.shortName())) - private fun IrType.getMaybeBuiltinClass(): IrClass? { val lhsClassFqName = classFqName!! return baseIrTypes.find { it.classFqName == lhsClassFqName }?.getClass() @@ -1066,7 +1048,7 @@ class IrBuiltInsOverFir( } private fun IrClass.createStandardNumericAndCharMembers(thisType: IrType) { - createCompanionObject() { + createCompanionObject { val constExprs = getNumericConstantsExpressions(thisType) createProperty("MIN_VALUE", thisType, isConst = true, withGetter = false, fieldInit = constExprs.min) createProperty("MAX_VALUE", thisType, isConst = true, withGetter = false, fieldInit = constExprs.max) diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaUtils.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaUtils.kt index c25fde58566..ef7fc0d7c0a 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaUtils.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaUtils.kt @@ -5,7 +5,6 @@ package org.jetbrains.kotlin.fir.java -import org.jetbrains.kotlin.builtins.StandardNames import org.jetbrains.kotlin.descriptors.ClassKind import org.jetbrains.kotlin.descriptors.Modality import org.jetbrains.kotlin.fir.* @@ -33,6 +32,7 @@ import org.jetbrains.kotlin.load.java.structure.* import org.jetbrains.kotlin.load.java.structure.impl.JavaElementImpl import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.Name +import org.jetbrains.kotlin.name.StandardClassIds import org.jetbrains.kotlin.name.StandardClassIds.Annotations import org.jetbrains.kotlin.name.StandardClassIds.Annotations.ParameterNames import org.jetbrains.kotlin.types.ConstantValueKind @@ -100,7 +100,7 @@ private fun List.mapJavaTargetArguments(session: FirSess if (target !is JavaEnumValueAnnotationArgument) return null resultSet.addAll(JAVA_TARGETS_TO_KOTLIN[target.entryName?.asString()] ?: continue) } - val classId = ClassId.topLevel(StandardNames.FqNames.annotationTarget) + val classId = StandardClassIds.AnnotationTarget resultSet.mapTo(arguments) { buildEnumCall(session, classId, Name.identifier(it.name)) } varargElementType = buildResolvedTypeRef { type = ConeClassLikeTypeImpl( @@ -121,7 +121,7 @@ private val JAVA_RETENTION_TO_KOTLIN = mapOf( private fun JavaAnnotationArgument.mapJavaRetentionArgument(session: FirSession): FirExpression? = JAVA_RETENTION_TO_KOTLIN[(this as? JavaEnumValueAnnotationArgument)?.entryName?.asString()]?.let { - buildEnumCall(session, ClassId.topLevel(StandardNames.FqNames.annotationRetention), Name.identifier(it.name)) + buildEnumCall(session, StandardClassIds.AnnotationRetention, Name.identifier(it.name)) } private fun fillAnnotationArgumentMapping( @@ -167,10 +167,10 @@ private fun JavaAnnotation.toFirAnnotationCall( ): FirAnnotation { return buildAnnotation { val lookupTag = when (classId) { - Annotations.Java.Target -> ClassId.topLevel(StandardNames.FqNames.target) - Annotations.Java.Retention -> ClassId.topLevel(StandardNames.FqNames.retention) - Annotations.Java.Documented -> ClassId.topLevel(StandardNames.FqNames.mustBeDocumented) - Annotations.Java.Deprecated -> ClassId.topLevel(StandardNames.FqNames.deprecated) + Annotations.Java.Target -> Annotations.Target + Annotations.Java.Retention -> Annotations.Retention + Annotations.Java.Documented -> Annotations.MustBeDocumented + Annotations.Java.Deprecated -> Annotations.Deprecated else -> classId }?.let(::ConeClassLikeLookupTagImpl) annotationTypeRef = if (lookupTag != null) { 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 0529dab9533..ef25e78e223 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 @@ -5,7 +5,6 @@ package org.jetbrains.kotlin.fir.resolve -import org.jetbrains.kotlin.builtins.StandardNames import org.jetbrains.kotlin.builtins.functions.FunctionClassKind import org.jetbrains.kotlin.config.LanguageFeature import org.jetbrains.kotlin.descriptors.ClassKind @@ -348,7 +347,7 @@ fun CallableId.isInvoke(): Boolean = isKFunctionInvoke() || callableName.asString() == "invoke" && className?.asString()?.startsWith("Function") == true - && packageName == StandardNames.BUILT_INS_PACKAGE_FQ_NAME + && packageName == StandardClassIds.BASE_KOTLIN_PACKAGE fun CallableId.isKFunctionInvoke(): Boolean = callableName.asString() == "invoke" @@ -549,4 +548,4 @@ fun FirClassLikeDeclaration.getContainingDeclaration(session: FirSession): FirCl } return null -} \ No newline at end of file +} diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/providers/impl/FirCloneableSymbolProvider.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/providers/impl/FirCloneableSymbolProvider.kt index 6ce12896628..9901e814964 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/providers/impl/FirCloneableSymbolProvider.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/providers/impl/FirCloneableSymbolProvider.kt @@ -23,10 +23,7 @@ import org.jetbrains.kotlin.fir.resolve.providers.FirSymbolProviderInternals import org.jetbrains.kotlin.fir.scopes.FirScopeProvider import org.jetbrains.kotlin.fir.symbols.impl.* import org.jetbrains.kotlin.fir.types.builder.buildResolvedTypeRef -import org.jetbrains.kotlin.name.CallableId -import org.jetbrains.kotlin.name.ClassId -import org.jetbrains.kotlin.name.FqName -import org.jetbrains.kotlin.name.Name +import org.jetbrains.kotlin.name.* @NoMutableState class FirCloneableSymbolProvider( @@ -34,13 +31,6 @@ class FirCloneableSymbolProvider( moduleData: FirModuleData, scopeProvider: FirScopeProvider ) : FirSymbolProvider(session) { - companion object { - val CLONEABLE: Name = Name.identifier("Cloneable") - val CLONEABLE_CLASS_ID: ClassId = ClassId(StandardNames.BUILT_INS_PACKAGE_FQ_NAME, CLONEABLE) - - val CLONE: Name = Name.identifier("clone") - } - private val klass = buildRegularClass { resolvePhase = FirResolvePhase.ANALYZED_DEPENDENCIES origin = FirDeclarationOrigin.Library @@ -50,7 +40,7 @@ class FirCloneableSymbolProvider( Modality.ABSTRACT ) classKind = ClassKind.INTERFACE - symbol = FirRegularClassSymbol(CLONEABLE_CLASS_ID) + symbol = FirRegularClassSymbol(StandardClassIds.Cloneable) declarations += buildSimpleFunction { this.moduleData = moduleData resolvePhase = FirResolvePhase.ANALYZED_DEPENDENCIES @@ -59,17 +49,17 @@ class FirCloneableSymbolProvider( type = session.builtinTypes.anyType.type } status = FirDeclarationStatusImpl(Visibilities.Protected, Modality.OPEN) - name = CLONE - symbol = FirNamedFunctionSymbol(CallableId(CLONEABLE_CLASS_ID, CLONE)) + name = StandardClassIds.Callables.clone.callableName + symbol = FirNamedFunctionSymbol(StandardClassIds.Callables.clone) dispatchReceiverType = this@buildRegularClass.symbol.constructType(emptyArray(), isNullable = false) } this.scopeProvider = scopeProvider - name = CLONEABLE + name = StandardClassIds.Cloneable.shortClassName } override fun getClassLikeSymbolByClassId(classId: ClassId): FirClassLikeSymbol<*>? { - return if (classId == CLONEABLE_CLASS_ID) klass.symbol else null + return if (classId == StandardClassIds.Cloneable) klass.symbol else null } @FirSymbolProviderInternals 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 d3aa70c55d6..5a3a3fb8542 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 @@ -5,7 +5,6 @@ package org.jetbrains.kotlin.fir.resolve.providers.impl -import org.jetbrains.kotlin.builtins.StandardNames import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.FirSourceElement import org.jetbrains.kotlin.fir.ThreadSafeMutableState @@ -34,6 +33,7 @@ import org.jetbrains.kotlin.fir.types.impl.ConeClassLikeTypeImpl import org.jetbrains.kotlin.fir.types.impl.ConeTypeParameterTypeImpl import org.jetbrains.kotlin.fir.types.impl.FirImplicitBuiltinTypeRef import org.jetbrains.kotlin.name.ClassId +import org.jetbrains.kotlin.name.StandardClassIds @ThreadSafeMutableState class FirTypeResolverImpl(private val session: FirSession) : FirTypeResolver() { @@ -320,9 +320,9 @@ class FirTypeResolverImpl(private val session: FirSession) : FirTypeResolver() { typeRef.valueParameters.map { it.returnTypeRef.coneType } + listOf(typeRef.returnTypeRef.coneType) val classId = if (typeRef.isSuspend) { - StandardNames.getSuspendFunctionClassId(typeRef.parametersCount) + StandardClassIds.SuspendFunctionN(typeRef.parametersCount) } else { - StandardNames.getFunctionClassId(typeRef.parametersCount) + StandardClassIds.FunctionN(typeRef.parametersCount) } val attributes = typeRef.annotations.computeTypeAttributes() val symbol = resolveBuiltInQualified(classId, session) diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/types/ConeFlexibleTypeBoundsChecker.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/types/ConeFlexibleTypeBoundsChecker.kt index 20fe50e4c31..dc994ebdd17 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/types/ConeFlexibleTypeBoundsChecker.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/types/ConeFlexibleTypeBoundsChecker.kt @@ -5,12 +5,10 @@ package org.jetbrains.kotlin.fir.types -import org.jetbrains.kotlin.builtins.StandardNames -import org.jetbrains.kotlin.name.StandardClassIds import org.jetbrains.kotlin.name.ClassId +import org.jetbrains.kotlin.name.StandardClassIds object ConeFlexibleTypeBoundsChecker { - private val fqNames = StandardNames.FqNames private val baseTypesToMutableEquivalent = mapOf( StandardClassIds.Iterable to StandardClassIds.MutableIterable, StandardClassIds.Iterator to StandardClassIds.MutableIterator, diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/types/ConeInferenceContext.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/types/ConeInferenceContext.kt index 4b4084605d8..5dc935ef727 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/types/ConeInferenceContext.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/types/ConeInferenceContext.kt @@ -5,7 +5,6 @@ package org.jetbrains.kotlin.fir.types -import org.jetbrains.kotlin.builtins.StandardNames import org.jetbrains.kotlin.fir.diagnostics.ConeIntermediateDiagnostic import org.jetbrains.kotlin.fir.isPrimitiveNumberOrUnsignedNumberType import org.jetbrains.kotlin.fir.resolve.calls.NoSubstitutor @@ -487,17 +486,21 @@ interface ConeInferenceContext : TypeSystemInferenceExtensionContext, ConeTypeCo } override fun getFunctionTypeConstructor(parametersNumber: Int, isSuspend: Boolean): TypeConstructorMarker { - val classId = if (isSuspend) - StandardNames.getSuspendFunctionClassId(parametersNumber) - else StandardNames.getFunctionClassId(parametersNumber) + val classId = if (isSuspend) { + StandardClassIds.SuspendFunctionN(parametersNumber) + } else { + StandardClassIds.FunctionN(parametersNumber) + } return session.symbolProvider.getClassLikeSymbolByClassId(classId)?.toLookupTag() ?: error("Can't find Function type") } override fun getKFunctionTypeConstructor(parametersNumber: Int, isSuspend: Boolean): TypeConstructorMarker { - val classId = if (isSuspend) - StandardNames.getKSuspendFunctionClassId(parametersNumber) - else StandardNames.getKFunctionClassId(parametersNumber) + val classId = if (isSuspend) { + StandardClassIds.KSuspendFunctionN(parametersNumber) + } else { + StandardClassIds.KFunctionN(parametersNumber) + } return session.symbolProvider.getClassLikeSymbolByClassId(classId)?.toLookupTag() ?: error("Can't find KFunction type") } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/types/ConeTypeContext.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/types/ConeTypeContext.kt index 3a51be21bbe..6cfdc4d6abd 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/types/ConeTypeContext.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/types/ConeTypeContext.kt @@ -5,6 +5,7 @@ package org.jetbrains.kotlin.fir.types +import org.jetbrains.kotlin.builtins.PrimitiveType import org.jetbrains.kotlin.builtins.StandardNames import org.jetbrains.kotlin.descriptors.ClassKind import org.jetbrains.kotlin.descriptors.Modality @@ -530,14 +531,14 @@ interface ConeTypeContext : TypeSystemContext, TypeSystemOptimizationContext, Ty return substitutedUnderlyingTypeForInlineClass(session, this@ConeTypeContext) } - override fun TypeConstructorMarker.getPrimitiveType() = + override fun TypeConstructorMarker.getPrimitiveType(): PrimitiveType? = getClassFqNameUnsafe()?.let(StandardNames.FqNames.fqNameToPrimitiveType::get) - override fun TypeConstructorMarker.getPrimitiveArrayType() = + override fun TypeConstructorMarker.getPrimitiveArrayType(): PrimitiveType? = getClassFqNameUnsafe()?.let(StandardNames.FqNames.arrayClassFqNameToPrimitiveType::get) - override fun TypeConstructorMarker.isUnderKotlinPackage() = - getClassFqNameUnsafe()?.startsWith(Name.identifier("kotlin")) == true + override fun TypeConstructorMarker.isUnderKotlinPackage(): Boolean = + getClassFqNameUnsafe()?.startsWith(StandardClassIds.BASE_KOTLIN_PACKAGE.shortName()) == true override fun TypeConstructorMarker.getClassFqNameUnsafe(): FqNameUnsafe? { if (this !is ConeClassLikeLookupTag) return null diff --git a/core/compiler.common/src/org/jetbrains/kotlin/name/StandardClassIds.kt b/core/compiler.common/src/org/jetbrains/kotlin/name/StandardClassIds.kt index d8ba054d865..7cbf4286be5 100644 --- a/core/compiler.common/src/org/jetbrains/kotlin/name/StandardClassIds.kt +++ b/core/compiler.common/src/org/jetbrains/kotlin/name/StandardClassIds.kt @@ -5,17 +5,27 @@ package org.jetbrains.kotlin.name -import org.jetbrains.kotlin.builtins.StandardNames - object StandardClassIds { val BASE_KOTLIN_PACKAGE = FqName("kotlin") val BASE_REFLECT_PACKAGE = BASE_KOTLIN_PACKAGE.child(Name.identifier("reflect")) val BASE_COLLECTIONS_PACKAGE = BASE_KOTLIN_PACKAGE.child(Name.identifier("collections")) + val BASE_RANGES_PACKAGE = BASE_KOTLIN_PACKAGE.child(Name.identifier("ranges")) val BASE_JVM_PACKAGE = BASE_KOTLIN_PACKAGE.child(Name.identifier("jvm")) val BASE_JVM_INTERNAL_PACKAGE = BASE_JVM_PACKAGE.child(Name.identifier("internal")) val BASE_ANNOTATION_PACKAGE = BASE_KOTLIN_PACKAGE.child(Name.identifier("annotation")) val BASE_INTERNAL_PACKAGE = BASE_KOTLIN_PACKAGE.child(Name.identifier("internal")) val BASE_INTERNAL_IR_PACKAGE = BASE_INTERNAL_PACKAGE.child(Name.identifier("ir")) + val BASE_COROUTINES_PACKAGE = BASE_KOTLIN_PACKAGE.child(Name.identifier("coroutines")) + + val builtInsPackages = setOf( + BASE_KOTLIN_PACKAGE, + BASE_COLLECTIONS_PACKAGE, + BASE_RANGES_PACKAGE, + BASE_ANNOTATION_PACKAGE, + BASE_REFLECT_PACKAGE, + BASE_INTERNAL_PACKAGE, + BASE_COROUTINES_PACKAGE, + ) val Nothing = "Nothing".baseId() val Unit = "Unit".baseId() @@ -41,6 +51,8 @@ object StandardClassIds { val String = "String".baseId() val Throwable = "Throwable".baseId() + val Cloneable = "Cloneable".baseId() + val KProperty = "KProperty".reflectId() val KMutableProperty = "KMutableProperty".reflectId() val KProperty0 = "KProperty0".reflectId() @@ -72,13 +84,28 @@ object StandardClassIds { val constantAllowedTypes = primitiveTypes + unsignedTypes + String - val Continuation = ClassId(StandardNames.COROUTINES_PACKAGE_FQ_NAME, StandardNames.CONTINUATION_INTERFACE_FQ_NAME.shortName()) + val Continuation = "Continuation".coroutinesId() @Suppress("FunctionName") fun FunctionN(n: Int): ClassId { return "Function$n".baseId() } + @Suppress("FunctionName") + fun SuspendFunctionN(n: Int): ClassId { + return "SuspendFunction$n".coroutinesId() + } + + @Suppress("FunctionName") + fun KFunctionN(n: Int): ClassId { + return "KFunction$n".reflectId() + } + + @Suppress("FunctionName") + fun KSuspendFunctionN(n: Int): ClassId { + return "KSuspendFunction$n".reflectId() + } + val Iterator = "Iterator".collectionsId() val Iterable = "Iterable".collectionsId() val Collection = "Collection".collectionsId() @@ -98,11 +125,15 @@ object StandardClassIds { val MapEntry = Map.createNestedClassId(Name.identifier("Entry")) val MutableMapEntry = MutableMap.createNestedClassId(Name.identifier("MutableEntry")) - val coroutineContext = CallableId(StandardNames.COROUTINES_PACKAGE_FQ_NAME, Name.identifier("coroutineContext")) - val suspend = CallableId(BASE_KOTLIN_PACKAGE, Name.identifier("suspend")) - val Result = "Result".baseId() + val IntRange = "IntRange".rangesId() + val LongRange = "LongRange".rangesId() + val CharRange = "CharRange".rangesId() + + val AnnotationRetention = "AnnotationRetention".annotationId() + val AnnotationTarget = "AnnotationTarget".annotationId() + object Annotations { val Suppress = "Suppress".baseId() val PublishedApi = "PublishedApi".baseId() @@ -110,10 +141,11 @@ object StandardClassIds { val ExtensionFunctionType = "ExtensionFunctionType".baseId() val Deprecated = "Deprecated".baseId() val DeprecatedSinceKotlin = "DeprecatedSinceKotlin".baseId() - val Repeatable = "Repeatable".annotationId() val Retention = "Retention".annotationId() val Target = "Target".annotationId() + val Repeatable = "Repeatable".annotationId() + val MustBeDocumented = "MustBeDocumented".annotationId() val JvmStatic = "JvmStatic".jvmId() val JvmName = "JvmName".jvmId() @@ -124,6 +156,7 @@ object StandardClassIds { val FlexibleNullability = "FlexibleNullability".internalIrId() val EnhancedNullability = "EnhancedNullability".jvmInternalId() + val RestrictsSuspension = "RestrictsSuspension".coroutinesId() object Java { val Deprecated = "Deprecated".javaLangId() @@ -148,6 +181,13 @@ object StandardClassIds { val deprecatedSinceKotlinHiddenSince = Name.identifier("hiddenSince") } } + + object Callables { + val suspend = "suspend".callableId(BASE_KOTLIN_PACKAGE) + val coroutineContext = "coroutineContext".callableId(BASE_COROUTINES_PACKAGE) + + val clone = "clone".callableId(Cloneable) + } } private fun String.baseId() = ClassId(StandardClassIds.BASE_KOTLIN_PACKAGE, Name.identifier(this)) @@ -155,11 +195,16 @@ private fun ClassId.unsignedId() = ClassId(StandardClassIds.BASE_KOTLIN_PACKAGE, private fun String.reflectId() = ClassId(StandardClassIds.BASE_REFLECT_PACKAGE, Name.identifier(this)) private fun Name.primitiveArrayId() = ClassId(StandardClassIds.Array.packageFqName, Name.identifier(identifier + StandardClassIds.Array.shortClassName.identifier)) private fun String.collectionsId() = ClassId(StandardClassIds.BASE_COLLECTIONS_PACKAGE, Name.identifier(this)) +private fun String.rangesId() = ClassId(StandardClassIds.BASE_RANGES_PACKAGE, Name.identifier(this)) private fun String.annotationId() = ClassId(StandardClassIds.BASE_ANNOTATION_PACKAGE, Name.identifier(this)) private fun String.jvmId() = ClassId(StandardClassIds.BASE_JVM_PACKAGE, Name.identifier(this)) private fun String.jvmInternalId() = ClassId(StandardClassIds.BASE_JVM_INTERNAL_PACKAGE, Name.identifier(this)) private fun String.internalId() = ClassId(StandardClassIds.BASE_INTERNAL_PACKAGE, Name.identifier(this)) private fun String.internalIrId() = ClassId(StandardClassIds.BASE_INTERNAL_IR_PACKAGE, Name.identifier(this)) +private fun String.coroutinesId() = ClassId(StandardClassIds.BASE_COROUTINES_PACKAGE, Name.identifier(this)) + +private fun String.callableId(packageName: FqName) = CallableId(packageName, Name.identifier(this)) +private fun String.callableId(classId: ClassId) = CallableId(classId, Name.identifier(this)) private val JAVA_LANG_PACKAGE = FqName("java.lang") private val JAVA_LANG_ANNOTATION_PACKAGE = JAVA_LANG_PACKAGE.child(Name.identifier("annotation"))