From 0d50f71fb8e89291b848fe5eca5d5f7e8f50b924 Mon Sep 17 00:00:00 2001 From: Mikhail Glukhikh Date: Thu, 22 Dec 2022 12:53:32 +0100 Subject: [PATCH] K2: expand type aliases in annotation position #KT-55615 Fixed --- .../fir/components/KtFirSymbolInfoProvider.kt | 6 +- ...FileStructureElementDiagnosticRetriever.kt | 3 +- .../jvm/checkers/FirJvmAnnotationHelper.kt | 8 +- .../declaration/FirJvmDefaultChecker.kt | 15 ++-- .../FirJvmFieldApplicabilityChecker.kt | 12 +-- .../FirJvmInlineApplicabilityChecker.kt | 2 +- .../declaration/FirJvmRecordChecker.kt | 3 +- .../declaration/FirJvmStaticChecker.kt | 2 +- .../FirJvmSyntheticApplicabilityChecker.kt | 2 +- .../declaration/FirOverloadsChecker.kt | 5 +- .../FirRepeatableAnnotationChecker.kt | 22 +++--- .../FirStrictfpApplicabilityChecker.kt | 2 +- .../FirSynchronizedAnnotationChecker.kt | 8 +- .../FirVolatileAnnotationChecker.kt | 4 +- .../FirInterfaceDefaultMethodCallChecker.kt | 11 ++- .../FirJvmPolymorphicSignatureCallChecker.kt | 2 +- ...otectedInSuperClassCompanionCallChecker.kt | 2 +- .../native/checkers/FirNativeHelpers.kt | 4 +- .../checkers/FirNativeObjCNameChecker.kt | 23 +++--- .../FirNativeObjCNameOverridesChecker.kt | 6 +- ...irNativeObjCRefinementAnnotationChecker.kt | 10 ++- .../FirNativeObjCRefinementChecker.kt | 2 +- ...FirNativeObjCRefinementOverridesChecker.kt | 2 +- .../native/checkers/FirNativeThrowsChecker.kt | 4 +- .../analysis/checkers/FirAnnotationHelpers.kt | 42 +++++----- .../fir/analysis/checkers/FirConstChecks.kt | 7 +- .../fir/analysis/checkers/FirHelpers.kt | 4 +- .../checkers/FirSinceKotlinHelpers.kt | 6 +- .../FirAnnotationClassDeclarationChecker.kt | 7 +- .../FirInlineDeclarationChecker.kt | 7 +- .../FirOptInAnnotationClassChecker.kt | 11 +-- .../FirOptInMarkedDeclarationChecker.kt | 2 +- .../declaration/FirPublishedApiChecker.kt | 2 +- .../FirTypeParameterBoundsChecker.kt | 2 +- .../FirOptInAnnotationCallChecker.kt | 2 +- .../expression/FirOptInUsageBaseChecker.kt | 26 ++++--- .../expression/FirSuspendCallChecker.kt | 2 +- .../type/FirOptInUsageTypeRefChecker.kt | 4 +- .../deserialization/ClassDeserialization.kt | 4 +- .../deserialization/FirMemberDeserializer.kt | 8 +- .../fir/serialization/FirElementSerializer.kt | 2 +- .../backend/jvm/FirJvmSerializerExtension.kt | 2 +- .../fir/backend/Fir2IrDeclarationStorage.kt | 2 +- .../kotlin/fir/backend/Fir2IrTypeConverter.kt | 2 +- .../generators/CallAndReferenceGenerator.kt | 3 +- .../generators/DelegatedMemberGenerator.kt | 8 +- .../fir/lazy/AbstractFir2IrLazyFunction.kt | 4 +- .../kotlin/fir/java/FirJavaFacade.kt | 2 +- .../kotlin/fir/java/JvmSupertypeUpdater.kt | 4 +- .../fir/java/declarations/FirJavaField.kt | 3 +- .../JvmClassFileBasedSymbolProvider.kt | 3 +- .../java/enhancement/SignatureEnhancement.kt | 4 +- .../scopes/JavaClassUseSiteMemberScope.kt | 3 +- .../fir/declarations/FirAnnotationUtils.kt | 78 ++++++++++--------- .../fir/declarations/deprecationUtils.kt | 38 +++++---- .../kotlin/fir/resolve/LookupTagUtils.kt | 4 +- .../kotlin/fir/resolve/calls/Synthetics.kt | 3 +- .../resolve/providers/FirSymbolProvider.kt | 5 +- .../scopes/impl/FirFakeOverrideGenerator.kt | 3 +- .../fir/resolve/calls/ResolutionStages.kt | 7 +- .../fir/resolve/calls/tower/TowerLevels.kt | 2 +- .../inference/FirBuilderInferenceSession.kt | 7 +- .../providers/impl/FirTypeResolverImpl.kt | 2 +- .../FirStatusResolveTransformer.kt | 3 +- ...FirSpecificAnnotationResolveTransformer.kt | 5 +- .../box/annotations/jvmAnnotationFlags.kt | 3 - .../annotations/Volatile.fir.kt | 35 --------- .../testsWithStdLib/annotations/Volatile.kt | 1 + .../plugin/SupertypeWithArgumentGenerator.kt | 2 +- .../compiler/fir/FirSerializableProperty.kt | 8 +- .../SerializationFirSupertypesExtension.kt | 2 +- .../compiler/fir/SerializationFirUtils.kt | 72 ++++++++--------- .../FirSerializationPluginClassChecker.kt | 32 ++++---- .../checkers/SerializationFirCheckerUtils.kt | 16 ++-- .../services/ContextualSerializersProvider.kt | 12 +-- .../FirSerializablePropertiesProvider.kt | 4 +- .../FirParcelizePropertyChecker.kt | 11 +-- 77 files changed, 345 insertions(+), 348 deletions(-) delete mode 100644 compiler/testData/diagnostics/testsWithStdLib/annotations/Volatile.fir.kt diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirSymbolInfoProvider.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirSymbolInfoProvider.kt index 4f0a22f05e6..f2d4f80c4ed 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirSymbolInfoProvider.kt +++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirSymbolInfoProvider.kt @@ -95,19 +95,19 @@ internal class KtFirSymbolInfoProvider( } private fun getJvmName(property: FirProperty, isSetter: Boolean): Name { - if (property.hasAnnotation(StandardClassIds.Annotations.JvmField)) return property.name + if (property.hasAnnotation(StandardClassIds.Annotations.JvmField, analysisSession.useSiteSession)) return property.name return Name.identifier(getJvmNameAsString(property, isSetter)) } private fun getJvmNameAsString(property: FirProperty, isSetter: Boolean): String { val useSiteTarget = if (isSetter) AnnotationUseSiteTarget.PROPERTY_SETTER else AnnotationUseSiteTarget.PROPERTY_GETTER - val jvmNameFromProperty = property.getJvmNameFromAnnotation(useSiteTarget) + val jvmNameFromProperty = property.getJvmNameFromAnnotation(analysisSession.useSiteSession, useSiteTarget) if (jvmNameFromProperty != null) { return jvmNameFromProperty } val accessor = if (isSetter) property.setter else property.getter - val jvmNameFromAccessor = accessor?.getJvmNameFromAnnotation() + val jvmNameFromAccessor = accessor?.getJvmNameFromAnnotation(analysisSession.useSiteSession) if (jvmNameFromAccessor != null) { return jvmNameFromAccessor } diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostics/FileStructureElementDiagnosticRetriever.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostics/FileStructureElementDiagnosticRetriever.kt index 16e1131b7fc..be76e704af7 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostics/FileStructureElementDiagnosticRetriever.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostics/FileStructureElementDiagnosticRetriever.kt @@ -60,11 +60,10 @@ internal class SingleNonLocalDeclarationDiagnosticRetriever( return true } - @Suppress("IntroduceWhenSubject") return when { structureElementDeclaration !is FirRegularClass -> true structureElementDeclaration == declaration -> true - declaration.hasAnnotation(StandardClassIds.Annotations.Suppress) -> { + declaration.hasAnnotation(StandardClassIds.Annotations.Suppress, context.session) -> { useRegularComponents = false true } diff --git a/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/FirJvmAnnotationHelper.kt b/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/FirJvmAnnotationHelper.kt index 4fb049b59e9..ce715722f93 100644 --- a/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/FirJvmAnnotationHelper.kt +++ b/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/FirJvmAnnotationHelper.kt @@ -7,14 +7,18 @@ package org.jetbrains.kotlin.fir.analysis.jvm.checkers import org.jetbrains.kotlin.config.JvmDefaultMode import org.jetbrains.kotlin.fir.FirAnnotationContainer +import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.declarations.FirDeclaration import org.jetbrains.kotlin.fir.declarations.getAnnotationByClassId import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol import org.jetbrains.kotlin.name.StandardClassIds -fun FirBasedSymbol.isCompiledToJvmDefault(jvmDefaultMode: JvmDefaultMode): Boolean where D : FirAnnotationContainer, D : FirDeclaration { +fun FirBasedSymbol.isCompiledToJvmDefault( + session: FirSession, + jvmDefaultMode: JvmDefaultMode +): Boolean where D : FirAnnotationContainer, D : FirDeclaration { // TODO: Fix support for all cases - if (getAnnotationByClassId(StandardClassIds.Annotations.JvmDefault) != null) return true + if (getAnnotationByClassId(StandardClassIds.Annotations.JvmDefault, session) != null) return true return jvmDefaultMode.forAllMethodsWithBody } diff --git a/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirJvmDefaultChecker.kt b/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirJvmDefaultChecker.kt index 24f013d6cab..ee253cd3263 100644 --- a/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirJvmDefaultChecker.kt +++ b/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirJvmDefaultChecker.kt @@ -14,7 +14,6 @@ import org.jetbrains.kotlin.fir.analysis.checkers.context.findClosest import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirBasicDeclarationChecker import org.jetbrains.kotlin.fir.analysis.checkers.unsubstitutedScope import org.jetbrains.kotlin.fir.analysis.diagnostics.jvm.FirJvmErrors -import org.jetbrains.kotlin.fir.analysis.jvm.checkers.isCompiledToJvmDefault import org.jetbrains.kotlin.fir.analysis.jvm.checkers.isJvm6 import org.jetbrains.kotlin.fir.containingClassLookupTag import org.jetbrains.kotlin.fir.declarations.* @@ -33,7 +32,8 @@ import org.jetbrains.kotlin.name.JvmNames.JVM_DEFAULT_WITH_COMPATIBILITY_CLASS_I object FirJvmDefaultChecker : FirBasicDeclarationChecker() { override fun check(declaration: FirDeclaration, context: CheckerContext, reporter: DiagnosticReporter) { val jvmDefaultMode = context.session.jvmDefaultModeState - val defaultAnnotation = declaration.getAnnotationByClassId(JVM_DEFAULT_CLASS_ID) + val session = context.session + val defaultAnnotation = declaration.getAnnotationByClassId(JVM_DEFAULT_CLASS_ID, session) if (defaultAnnotation != null) { val containingDeclaration = context.findClosest() @@ -53,7 +53,7 @@ object FirJvmDefaultChecker : FirBasicDeclarationChecker() { } } } else { - val annotationNoCompatibility = declaration.getAnnotationByClassId(JVM_DEFAULT_NO_COMPATIBILITY_CLASS_ID) + val annotationNoCompatibility = declaration.getAnnotationByClassId(JVM_DEFAULT_NO_COMPATIBILITY_CLASS_ID, session) if (annotationNoCompatibility != null) { val source = annotationNoCompatibility.source when { @@ -77,7 +77,7 @@ object FirJvmDefaultChecker : FirBasicDeclarationChecker() { } } } - val annotationWithCompatibility = declaration.getAnnotationByClassId(JVM_DEFAULT_WITH_COMPATIBILITY_CLASS_ID) + val annotationWithCompatibility = declaration.getAnnotationByClassId(JVM_DEFAULT_WITH_COMPATIBILITY_CLASS_ID, session) if (annotationWithCompatibility != null) { val source = annotationWithCompatibility.source when { @@ -121,7 +121,7 @@ object FirJvmDefaultChecker : FirBasicDeclarationChecker() { unsubstitutedScope.processFunctionsByName(member.name) {} val overriddenFunctions = unsubstitutedScope.getDirectOverriddenFunctions(member.symbol) - if (overriddenFunctions.any { it.getAnnotationByClassId(JVM_DEFAULT_CLASS_ID) != null }) { + if (overriddenFunctions.any { it.getAnnotationByClassId(JVM_DEFAULT_CLASS_ID, context.session) != null }) { reporter.reportOn(declaration.source, FirJvmErrors.JVM_DEFAULT_REQUIRED_FOR_OVERRIDE, context) } else if (jvmDefaultMode.isEnabled) { for (overriddenFunction in overriddenFunctions) { @@ -147,9 +147,4 @@ object FirJvmDefaultChecker : FirBasicDeclarationChecker() { ArrayList>(1).also { it.add(this) } } } - - fun FirCallableSymbol<*>.isCompiledToJvmDefaultWithProperMode(jvmDefaultMode: JvmDefaultMode): Boolean { - // TODO: Fix support for all cases - return isCompiledToJvmDefault(jvmDefaultMode) - } } 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 d2759a3e88f..1730aadacf4 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 @@ -40,8 +40,8 @@ import org.jetbrains.kotlin.name.StandardClassIds object FirJvmFieldApplicabilityChecker : FirPropertyChecker() { override fun check(declaration: FirProperty, context: CheckerContext, reporter: DiagnosticReporter) { - val annotation = declaration.getAnnotationByClassId(JVM_FIELD_ANNOTATION_CLASS_ID) ?: return val session = context.session + val annotation = declaration.getAnnotationByClassId(JVM_FIELD_ANNOTATION_CLASS_ID, session) ?: return val containingClassSymbol = declaration.containingClassLookupTag()?.toFirRegularClassSymbol(session) val problem = when { @@ -57,7 +57,7 @@ object FirJvmFieldApplicabilityChecker : FirPropertyChecker() { if (!session.languageVersionSettings.supportsFeature(LanguageFeature.JvmFieldInInterface)) { INSIDE_COMPANION_OF_INTERFACE } else { - if (!isInterfaceCompanionWithPublicJvmFieldProperties(containingClassSymbol)) { + if (!isInterfaceCompanionWithPublicJvmFieldProperties(containingClassSymbol, session)) { NOT_PUBLIC_VAL_WITH_JVMFIELD } else { return @@ -110,7 +110,7 @@ object FirJvmFieldApplicabilityChecker : FirPropertyChecker() { return outerClassKind == ClassKind.INTERFACE || outerClassKind == ClassKind.ANNOTATION_CLASS } - private fun isInterfaceCompanionWithPublicJvmFieldProperties(containingClass: FirRegularClassSymbol): Boolean { + private fun isInterfaceCompanionWithPublicJvmFieldProperties(containingClass: FirRegularClassSymbol, session: FirSession): Boolean { for (symbol in containingClass.declarationSymbols) { if (symbol !is FirPropertySymbol) continue @@ -118,7 +118,7 @@ object FirJvmFieldApplicabilityChecker : FirPropertyChecker() { return false } - if (!symbol.hasJvmFieldAnnotation()) { + if (!symbol.hasJvmFieldAnnotation(session)) { return false } } @@ -126,8 +126,8 @@ object FirJvmFieldApplicabilityChecker : FirPropertyChecker() { return true } - private fun FirPropertySymbol.hasJvmFieldAnnotation(): Boolean { - return getAnnotationByClassId(JVM_FIELD_ANNOTATION_CLASS_ID) != null + private fun FirPropertySymbol.hasJvmFieldAnnotation(session: FirSession): Boolean { + return getAnnotationByClassId(JVM_FIELD_ANNOTATION_CLASS_ID, session) != null } private fun isInsideJvmMultifileClassFile(context: CheckerContext): Boolean { diff --git a/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirJvmInlineApplicabilityChecker.kt b/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirJvmInlineApplicabilityChecker.kt index f1585f041a5..d8c4dad9215 100644 --- a/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirJvmInlineApplicabilityChecker.kt +++ b/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirJvmInlineApplicabilityChecker.kt @@ -20,7 +20,7 @@ import org.jetbrains.kotlin.resolve.JVM_INLINE_ANNOTATION_CLASS_ID object FirJvmInlineApplicabilityChecker : FirRegularClassChecker() { override fun check(declaration: FirRegularClass, context: CheckerContext, reporter: DiagnosticReporter) { - val annotation = declaration.getAnnotationByClassId(JVM_INLINE_ANNOTATION_CLASS_ID) + val annotation = declaration.getAnnotationByClassId(JVM_INLINE_ANNOTATION_CLASS_ID, context.session) if (annotation != null && !declaration.isInline) { reporter.reportOn(annotation.source, FirJvmErrors.JVM_INLINE_WITHOUT_VALUE_CLASS, context) } else if (annotation == null && declaration.isInline && !declaration.isExpect) { diff --git a/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirJvmRecordChecker.kt b/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirJvmRecordChecker.kt index cb248f0e423..891111ef207 100644 --- a/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirJvmRecordChecker.kt +++ b/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirJvmRecordChecker.kt @@ -23,7 +23,6 @@ import org.jetbrains.kotlin.fir.types.ConeClassLikeType import org.jetbrains.kotlin.fir.types.classId import org.jetbrains.kotlin.fir.types.coneType import org.jetbrains.kotlin.fir.types.coneTypeSafe -import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.JvmNames.JVM_RECORD_ANNOTATION_CLASS_ID import org.jetbrains.kotlin.name.StandardClassIds @@ -37,7 +36,7 @@ object FirJvmRecordChecker : FirRegularClassChecker() { } } - val annotationSource = declaration.getAnnotationByClassId(JVM_RECORD_ANNOTATION_CLASS_ID)?.source ?: return + val annotationSource = declaration.getAnnotationByClassId(JVM_RECORD_ANNOTATION_CLASS_ID, context.session)?.source ?: return val languageVersionSettings = context.session.languageVersionSettings if (!languageVersionSettings.supportsFeature(LanguageFeature.JvmRecordSupport)) { diff --git a/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirJvmStaticChecker.kt b/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirJvmStaticChecker.kt index 05443f05098..4235d8e7e2e 100644 --- a/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirJvmStaticChecker.kt +++ b/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirJvmStaticChecker.kt @@ -48,7 +48,7 @@ object FirJvmStaticChecker : FirBasicDeclarationChecker() { } fun checkIfAnnotated(it: FirDeclaration) { - if (!it.hasAnnotation(StandardClassIds.Annotations.JvmStatic)) { + if (!it.hasAnnotation(StandardClassIds.Annotations.JvmStatic, context.session)) { return } val targetSource = it.source ?: declaration.source diff --git a/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirJvmSyntheticApplicabilityChecker.kt b/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirJvmSyntheticApplicabilityChecker.kt index 3b9e64c12c8..8771b6a6444 100644 --- a/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirJvmSyntheticApplicabilityChecker.kt +++ b/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirJvmSyntheticApplicabilityChecker.kt @@ -17,7 +17,7 @@ import org.jetbrains.kotlin.name.JvmNames.JVM_SYNTHETIC_ANNOTATION_CLASS_ID object FirJvmSyntheticApplicabilityChecker : FirPropertyChecker() { override fun check(declaration: FirProperty, context: CheckerContext, reporter: DiagnosticReporter) { - val annotation = declaration.delegateFieldSymbol?.getAnnotationByClassId(JVM_SYNTHETIC_ANNOTATION_CLASS_ID) + val annotation = declaration.delegateFieldSymbol?.getAnnotationByClassId(JVM_SYNTHETIC_ANNOTATION_CLASS_ID, context.session) if (annotation != null && annotation.useSiteTarget == AnnotationUseSiteTarget.PROPERTY_DELEGATE_FIELD) { reporter.reportOn(annotation.source, FirJvmErrors.JVM_SYNTHETIC_ON_DELEGATE, context) } diff --git a/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirOverloadsChecker.kt b/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirOverloadsChecker.kt index d7e4e57fb00..43ed2d84235 100644 --- a/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirOverloadsChecker.kt +++ b/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirOverloadsChecker.kt @@ -27,11 +27,12 @@ import org.jetbrains.kotlin.name.JvmNames.JVM_OVERLOADS_CLASS_ID object FirOverloadsChecker : FirFunctionChecker() { override fun check(declaration: FirFunction, context: CheckerContext, reporter: DiagnosticReporter) { - val annotation = declaration.getAnnotationByClassId(JVM_OVERLOADS_CLASS_ID) ?: return + val session = context.session + val annotation = declaration.getAnnotationByClassId(JVM_OVERLOADS_CLASS_ID, session) ?: return //todo need to have expect declaration here to check if it has default values if (declaration.isActual) return - val containingDeclaration = declaration.getContainingClassSymbol(context.session) + val containingDeclaration = declaration.getContainingClassSymbol(session) when { containingDeclaration?.classKind == ClassKind.INTERFACE -> reporter.reportOn(annotation.source, FirJvmErrors.OVERLOADS_INTERFACE, context) diff --git a/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirRepeatableAnnotationChecker.kt b/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirRepeatableAnnotationChecker.kt index d8a3d4aa80d..753cdd65d77 100644 --- a/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirRepeatableAnnotationChecker.kt +++ b/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirRepeatableAnnotationChecker.kt @@ -11,13 +11,13 @@ import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget import org.jetbrains.kotlin.descriptors.annotations.KotlinTarget import org.jetbrains.kotlin.diagnostics.DiagnosticReporter import org.jetbrains.kotlin.diagnostics.reportOn +import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.analysis.checkers.containsRepeatableAnnotation import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirBasicDeclarationChecker import org.jetbrains.kotlin.fir.analysis.checkers.getAllowedAnnotationTargets import org.jetbrains.kotlin.fir.analysis.checkers.getAnnotationRetention import org.jetbrains.kotlin.fir.analysis.checkers.unsubstitutedScope -import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors import org.jetbrains.kotlin.fir.analysis.diagnostics.jvm.FirJvmErrors import org.jetbrains.kotlin.fir.analysis.jvm.checkers.isJvm6 import org.jetbrains.kotlin.fir.declarations.* @@ -48,7 +48,7 @@ object FirRepeatableAnnotationChecker : FirBasicDeclarationChecker() { val session = context.session for (annotation in annotations) { val classId = annotation.classId ?: continue - val annotationClassId = annotation.toAnnotationClassId() ?: continue + val annotationClassId = annotation.toAnnotationClassId(session) ?: continue if (annotationClassId.isLocal) continue val annotationClass = session.symbolProvider.getClassLikeSymbolByClassId(annotationClassId) ?: continue @@ -60,7 +60,7 @@ object FirRepeatableAnnotationChecker : FirBasicDeclarationChecker() { if (duplicateAnnotation && annotationClass.containsRepeatableAnnotation(session) && - annotationClass.getAnnotationRetention() != AnnotationRetention.SOURCE + annotationClass.getAnnotationRetention(session) != AnnotationRetention.SOURCE ) { if (context.isJvm6()) { reporter.reportOn(annotation.source, FirJvmErrors.REPEATED_ANNOTATION_TARGET6, context) @@ -68,7 +68,7 @@ object FirRepeatableAnnotationChecker : FirBasicDeclarationChecker() { // It's not allowed to have both a repeated annotation (applied more than once) and its container // on the same element. // See https://docs.oracle.com/javase/specs/jls/se16/html/jls-9.html#jls-9.7.5. - val explicitContainer = annotationClass.resolveContainerAnnotation() + val explicitContainer = annotationClass.resolveContainerAnnotation(session) if (explicitContainer != null && annotations.any { it.classId == explicitContainer }) { reporter.reportOn( annotation.source, @@ -99,9 +99,9 @@ object FirRepeatableAnnotationChecker : FirBasicDeclarationChecker() { } } - private fun FirClassLikeSymbol<*>.resolveContainerAnnotation(): ClassId? { - val repeatableAnnotation = getAnnotationByClassId(StandardClassIds.Annotations.Repeatable) - ?: getAnnotationByClassId(StandardClassIds.Annotations.Java.Repeatable) + private fun FirClassLikeSymbol<*>.resolveContainerAnnotation(session: FirSession): ClassId? { + val repeatableAnnotation = getAnnotationByClassId(StandardClassIds.Annotations.Repeatable, session) + ?: getAnnotationByClassId(StandardClassIds.Annotations.Java.Repeatable, session) ?: return null return repeatableAnnotation.resolveContainerAnnotation() } @@ -202,8 +202,8 @@ object FirRepeatableAnnotationChecker : FirBasicDeclarationChecker() { context: CheckerContext, reporter: DiagnosticReporter ) { - val annotationRetention = annotationClass.symbol.getAnnotationRetention() - val containerRetention = containerClass.getAnnotationRetention() + val annotationRetention = annotationClass.symbol.getAnnotationRetention(context.session) + val containerRetention = containerClass.getAnnotationRetention(context.session) if (containerRetention < annotationRetention) { reporter.reportOn( annotationSource, @@ -224,8 +224,8 @@ object FirRepeatableAnnotationChecker : FirBasicDeclarationChecker() { context: CheckerContext, reporter: DiagnosticReporter ) { - val annotationTargets = annotationClass.getAllowedAnnotationTargets() - val containerTargets = containerClass.getAllowedAnnotationTargets() + val annotationTargets = annotationClass.getAllowedAnnotationTargets(context.session) + val containerTargets = containerClass.getAllowedAnnotationTargets(context.session) // See https://docs.oracle.com/javase/specs/jls/se16/html/jls-9.html#jls-9.6.3. // (TBH, the rules about TYPE/TYPE_USE and TYPE_PARAMETER/TYPE_USE don't seem to make a lot of sense, but it's JLS diff --git a/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirStrictfpApplicabilityChecker.kt b/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirStrictfpApplicabilityChecker.kt index c16eacc415d..1644d86c6e0 100644 --- a/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirStrictfpApplicabilityChecker.kt +++ b/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirStrictfpApplicabilityChecker.kt @@ -16,7 +16,7 @@ import org.jetbrains.kotlin.name.JvmNames.STRICTFP_ANNOTATION_CLASS_ID object FirStrictfpApplicabilityChecker : FirClassChecker() { override fun check(declaration: FirClass, context: CheckerContext, reporter: DiagnosticReporter) { - val annotation = declaration.getAnnotationByClassId(STRICTFP_ANNOTATION_CLASS_ID) ?: return + val annotation = declaration.getAnnotationByClassId(STRICTFP_ANNOTATION_CLASS_ID, context.session) ?: return reporter.reportOn(annotation.source, FirJvmErrors.STRICTFP_ON_CLASS, context) } } \ No newline at end of file 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 c30f8bf1429..c191df2057b 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 @@ -5,7 +5,6 @@ package org.jetbrains.kotlin.fir.analysis.jvm.checkers.declaration -import org.jetbrains.kotlin.config.LanguageFeature import org.jetbrains.kotlin.descriptors.ClassKind import org.jetbrains.kotlin.fir.analysis.checkers.classKind import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext @@ -26,20 +25,21 @@ import org.jetbrains.kotlin.name.JvmNames.SYNCHRONIZED_ANNOTATION_CLASS_ID object FirSynchronizedAnnotationChecker : FirFunctionChecker() { override fun check(declaration: FirFunction, context: CheckerContext, reporter: DiagnosticReporter) { - val annotation = declaration.getAnnotationByClassId(SYNCHRONIZED_ANNOTATION_CLASS_ID) ?: return + val session = context.session + val annotation = declaration.getAnnotationByClassId(SYNCHRONIZED_ANNOTATION_CLASS_ID, session) ?: return if (declaration.isInline) { reporter.reportOn(annotation.source, FirJvmErrors.SYNCHRONIZED_ON_INLINE, context) return } if (declaration.isSuspend || - (declaration as? FirAnonymousFunction)?.typeRef?.coneType?.isSuspendFunctionType(context.session) == true + (declaration as? FirAnonymousFunction)?.typeRef?.coneType?.isSuspendFunctionType(session) == true ) { reporter.reportOn(annotation.source, FirJvmErrors.SYNCHRONIZED_ON_SUSPEND, context) return } - val containingClass = declaration.getContainingClassSymbol(context.session) ?: return + val containingClass = declaration.getContainingClassSymbol(session) ?: return if (containingClass.classKind == ClassKind.INTERFACE) { reporter.reportOn(annotation.source, FirJvmErrors.SYNCHRONIZED_IN_INTERFACE, context) } else if (declaration.isAbstract) { diff --git a/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirVolatileAnnotationChecker.kt b/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirVolatileAnnotationChecker.kt index b96667abf5b..ecdeb378dac 100644 --- a/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirVolatileAnnotationChecker.kt +++ b/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirVolatileAnnotationChecker.kt @@ -19,12 +19,12 @@ object FirVolatileAnnotationChecker : FirPropertyChecker() { override fun check(declaration: FirProperty, context: CheckerContext, reporter: DiagnosticReporter) { if (declaration.source?.kind != KtRealSourceElementKind) return - val fieldAnnotation = declaration.getAnnotationByClassId(VOLATILE_ANNOTATION_CLASS_ID) + val fieldAnnotation = declaration.getAnnotationByClassId(VOLATILE_ANNOTATION_CLASS_ID, context.session) if (fieldAnnotation != null && !declaration.isVar) { reporter.reportOn(fieldAnnotation.source, FirJvmErrors.VOLATILE_ON_VALUE, context) } - val delegateAnnotation = declaration.delegateFieldSymbol?.getAnnotationByClassId(VOLATILE_ANNOTATION_CLASS_ID) + val delegateAnnotation = declaration.delegateFieldSymbol?.getAnnotationByClassId(VOLATILE_ANNOTATION_CLASS_ID, context.session) if (delegateAnnotation != null) { reporter.reportOn(delegateAnnotation.source, FirJvmErrors.VOLATILE_ON_DELEGATE, context) } diff --git a/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/expression/FirInterfaceDefaultMethodCallChecker.kt b/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/expression/FirInterfaceDefaultMethodCallChecker.kt index 14559c58ea8..8ec9de62853 100644 --- a/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/expression/FirInterfaceDefaultMethodCallChecker.kt +++ b/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/expression/FirInterfaceDefaultMethodCallChecker.kt @@ -30,8 +30,9 @@ object FirInterfaceDefaultMethodCallChecker : FirQualifiedAccessExpressionChecke val classId = symbol?.callableId?.classId ?: return if (classId.isLocal) return + val session = context.session fun getTypeSymbol(): FirRegularClassSymbol? { - return context.session.symbolProvider.getClassLikeSymbolByClassId(classId) as? FirRegularClassSymbol + return session.symbolProvider.getClassLikeSymbolByClassId(classId) as? FirRegularClassSymbol } val supportsDefaults = !context.isJvm6() @@ -49,11 +50,13 @@ object FirInterfaceDefaultMethodCallChecker : FirQualifiedAccessExpressionChecke if (typeSymbol == null) typeSymbol = getTypeSymbol() ?: return - val jvmDefaultMode = context.session.jvmDefaultModeState - if (typeSymbol.isInterface && (typeSymbol.origin is FirDeclarationOrigin.Java || symbol.isCompiledToJvmDefault(jvmDefaultMode))) { + val jvmDefaultMode = session.jvmDefaultModeState + if (typeSymbol.isInterface && + (typeSymbol.origin is FirDeclarationOrigin.Java || symbol.isCompiledToJvmDefault(session, jvmDefaultMode)) + ) { if (containingDeclaration.isInterface) { val containingMember = context.findContainingMember()?.symbol - if (containingMember?.isCompiledToJvmDefault(jvmDefaultMode) == false) { + if (containingMember?.isCompiledToJvmDefault(session, jvmDefaultMode) == false) { reporter.reportOn(expression.source, FirJvmErrors.INTERFACE_CANT_CALL_DEFAULT_METHOD_VIA_SUPER, context) return } diff --git a/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/expression/FirJvmPolymorphicSignatureCallChecker.kt b/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/expression/FirJvmPolymorphicSignatureCallChecker.kt index 0a3002d3c72..abe47b9501a 100644 --- a/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/expression/FirJvmPolymorphicSignatureCallChecker.kt +++ b/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/expression/FirJvmPolymorphicSignatureCallChecker.kt @@ -23,7 +23,7 @@ object FirJvmPolymorphicSignatureCallChecker : FirFunctionCallChecker() { override fun check(expression: FirFunctionCall, context: CheckerContext, reporter: DiagnosticReporter) { if (!context.session.languageVersionSettings.supportsFeature(LanguageFeature.PolymorphicSignature)) return val callableSymbol = expression.calleeReference.toResolvedCallableSymbol() ?: return - if (callableSymbol.getAnnotationByClassId(polymorphicSignatureClassId) == null) return + if (callableSymbol.getAnnotationByClassId(polymorphicSignatureClassId, context.session) == null) return for (valueArgument in expression.arguments) { if (valueArgument is FirVarargArgumentsExpression) { diff --git a/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/expression/FirJvmProtectedInSuperClassCompanionCallChecker.kt b/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/expression/FirJvmProtectedInSuperClassCompanionCallChecker.kt index 401fb9a5130..c96dc89cb95 100644 --- a/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/expression/FirJvmProtectedInSuperClassCompanionCallChecker.kt +++ b/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/expression/FirJvmProtectedInSuperClassCompanionCallChecker.kt @@ -45,7 +45,7 @@ object FirJvmProtectedInSuperClassCompanionCallChecker : FirQualifiedAccessCheck resolvedSymbol.visibility } if (visibility != Visibilities.Protected) return - if (resolvedSymbol.getAnnotationByClassId(JVM_STATIC_ANNOTATION_CLASS_ID) != null) return + if (resolvedSymbol.getAnnotationByClassId(JVM_STATIC_ANNOTATION_CLASS_ID, context.session) != null) return if (!dispatchClassSymbol.isCompanion) return val companionContainingClassSymbol = dispatchClassSymbol.getContainingDeclarationSymbol(context.session) as? FirRegularClassSymbol ?: return diff --git a/compiler/fir/checkers/checkers.native/src/org/jetbrains/kotlin/fir/analysis/native/checkers/FirNativeHelpers.kt b/compiler/fir/checkers/checkers.native/src/org/jetbrains/kotlin/fir/analysis/native/checkers/FirNativeHelpers.kt index e04b9aa9285..e9f1a16ab7b 100644 --- a/compiler/fir/checkers/checkers.native/src/org/jetbrains/kotlin/fir/analysis/native/checkers/FirNativeHelpers.kt +++ b/compiler/fir/checkers/checkers.native/src/org/jetbrains/kotlin/fir/analysis/native/checkers/FirNativeHelpers.kt @@ -14,12 +14,12 @@ import org.jetbrains.kotlin.fir.declarations.getAnnotationByClassId import org.jetbrains.kotlin.name.ClassId fun DiagnosticReporter.reportIfHasAnnotation( -declaration: FirDeclaration, + declaration: FirDeclaration, annotationClassId: ClassId, error: KtDiagnosticFactory0, context: CheckerContext ) { - val annotation = declaration.getAnnotationByClassId(annotationClassId) + val annotation = declaration.getAnnotationByClassId(annotationClassId, context.session) if (annotation != null) { reportOn(annotation.source, error, context) } diff --git a/compiler/fir/checkers/checkers.native/src/org/jetbrains/kotlin/fir/analysis/native/checkers/FirNativeObjCNameChecker.kt b/compiler/fir/checkers/checkers.native/src/org/jetbrains/kotlin/fir/analysis/native/checkers/FirNativeObjCNameChecker.kt index 59ec80b62c7..e05c79f1e80 100644 --- a/compiler/fir/checkers/checkers.native/src/org/jetbrains/kotlin/fir/analysis/native/checkers/FirNativeObjCNameChecker.kt +++ b/compiler/fir/checkers/checkers.native/src/org/jetbrains/kotlin/fir/analysis/native/checkers/FirNativeObjCNameChecker.kt @@ -9,6 +9,7 @@ import org.jetbrains.kotlin.descriptors.ClassKind import org.jetbrains.kotlin.diagnostics.DiagnosticReporter import org.jetbrains.kotlin.diagnostics.reportOn import org.jetbrains.kotlin.fir.FirAnnotationContainer +import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirBasicDeclarationChecker import org.jetbrains.kotlin.fir.analysis.checkers.unsubstitutedScope @@ -51,7 +52,7 @@ object FirNativeObjCNameChecker : FirBasicDeclarationChecker() { private fun checkDeclaration(declaration: FirDeclaration, context: CheckerContext, reporter: DiagnosticReporter) { if (declaration is FirValueParameter) return // those are checked with the FirFunction - val objCNames = declaration.symbol.getObjCNames().filterNotNull() + val objCNames = declaration.symbol.getObjCNames(context.session).filterNotNull() if (objCNames.isEmpty()) return if (declaration is FirCallableDeclaration && declaration.isOverride) { for (objCName in objCNames) { @@ -115,20 +116,20 @@ object FirNativeObjCNameChecker : FirBasicDeclarationChecker() { } } - private fun FirAnnotationContainer.getObjCName(): ObjCName? = - getAnnotationByClassId(objCNameClassId)?.let(::ObjCName) + private fun FirAnnotationContainer.getObjCName(session: FirSession): ObjCName? = + getAnnotationByClassId(objCNameClassId, session)?.let(::ObjCName) - private fun FirBasedSymbol<*>.getObjCName(): ObjCName? = - getAnnotationByClassId(objCNameClassId)?.let(::ObjCName) + private fun FirBasedSymbol<*>.getObjCName(session: FirSession): ObjCName? = + getAnnotationByClassId(objCNameClassId, session)?.let(::ObjCName) - fun FirBasedSymbol<*>.getObjCNames(): List = when (this) { + fun FirBasedSymbol<*>.getObjCNames(session: FirSession): List = when (this) { is FirFunctionSymbol<*> -> buildList { - add((this@getObjCNames as FirBasedSymbol<*>).getObjCName()) - add(resolvedReceiverTypeRef?.getObjCName()) - add(receiverParameter?.getObjCName()) - valueParameterSymbols.forEach { add(it.getObjCName()) } + add((this@getObjCNames as FirBasedSymbol<*>).getObjCName(session)) + add(resolvedReceiverTypeRef?.getObjCName(session)) + add(receiverParameter?.getObjCName(session)) + valueParameterSymbols.forEach { add(it.getObjCName(session)) } } - else -> listOf(getObjCName()) + else -> listOf(getObjCName(session)) } } diff --git a/compiler/fir/checkers/checkers.native/src/org/jetbrains/kotlin/fir/analysis/native/checkers/FirNativeObjCNameOverridesChecker.kt b/compiler/fir/checkers/checkers.native/src/org/jetbrains/kotlin/fir/analysis/native/checkers/FirNativeObjCNameOverridesChecker.kt index cf6a39431c9..076b5299bdf 100644 --- a/compiler/fir/checkers/checkers.native/src/org/jetbrains/kotlin/fir/analysis/native/checkers/FirNativeObjCNameOverridesChecker.kt +++ b/compiler/fir/checkers/checkers.native/src/org/jetbrains/kotlin/fir/analysis/native/checkers/FirNativeObjCNameOverridesChecker.kt @@ -44,9 +44,11 @@ object FirNativeObjCNameOverridesChecker : FirClassChecker() { ) { val overriddenSymbols = firTypeScope.retrieveDirectOverriddenOf(memberSymbol) if (overriddenSymbols.isEmpty()) return - val objCNames = overriddenSymbols.map { it.getFirstBaseSymbol(firTypeScope).getObjCNames() } + val objCNames = overriddenSymbols.map { it.getFirstBaseSymbol(firTypeScope).getObjCNames(context.session) } if (!objCNames.allNamesEquals()) { - val containingDeclarations = overriddenSymbols.mapNotNull { it.containingClassLookupTag()?.toFirRegularClassSymbol(context.session) } + val containingDeclarations = overriddenSymbols.mapNotNull { + it.containingClassLookupTag()?.toFirRegularClassSymbol(context.session) + } reporter.reportOn( declarationToReport.source, INCOMPATIBLE_OBJC_NAME_OVERRIDE, diff --git a/compiler/fir/checkers/checkers.native/src/org/jetbrains/kotlin/fir/analysis/native/checkers/FirNativeObjCRefinementAnnotationChecker.kt b/compiler/fir/checkers/checkers.native/src/org/jetbrains/kotlin/fir/analysis/native/checkers/FirNativeObjCRefinementAnnotationChecker.kt index b3393ec6f7d..4133c639d2a 100644 --- a/compiler/fir/checkers/checkers.native/src/org/jetbrains/kotlin/fir/analysis/native/checkers/FirNativeObjCRefinementAnnotationChecker.kt +++ b/compiler/fir/checkers/checkers.native/src/org/jetbrains/kotlin/fir/analysis/native/checkers/FirNativeObjCRefinementAnnotationChecker.kt @@ -9,6 +9,7 @@ import org.jetbrains.kotlin.descriptors.ClassKind import org.jetbrains.kotlin.descriptors.annotations.KotlinTarget import org.jetbrains.kotlin.diagnostics.DiagnosticReporter import org.jetbrains.kotlin.diagnostics.reportOn +import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirRegularClassChecker import org.jetbrains.kotlin.fir.analysis.checkers.getAllowedAnnotationTargets @@ -24,7 +25,8 @@ object FirNativeObjCRefinementAnnotationChecker : FirRegularClassChecker() { override fun check(declaration: FirRegularClass, context: CheckerContext, reporter: DiagnosticReporter) { if (declaration.classKind != ClassKind.ANNOTATION_CLASS) return - val (objCAnnotation, swiftAnnotation) = declaration.findMetaAnnotations() + val session = context.session + val (objCAnnotation, swiftAnnotation) = declaration.findMetaAnnotations(session) if (objCAnnotation == null && swiftAnnotation == null) return if (objCAnnotation != null && swiftAnnotation != null) { reporter.reportOn( @@ -33,7 +35,7 @@ object FirNativeObjCRefinementAnnotationChecker : FirRegularClassChecker() { context ) } - val targets = declaration.getAllowedAnnotationTargets() + val targets = declaration.getAllowedAnnotationTargets(session) val unsupportedTargets = targets - supportedTargets if (unsupportedTargets.isNotEmpty()) { objCAnnotation?.let { reporter.reportOn(it.source, FirNativeErrors.INVALID_OBJC_REFINEMENT_TARGETS, context) } @@ -41,11 +43,11 @@ object FirNativeObjCRefinementAnnotationChecker : FirRegularClassChecker() { } } - private fun FirRegularClass.findMetaAnnotations(): Pair { + private fun FirRegularClass.findMetaAnnotations(session: FirSession): Pair { var objCAnnotation: FirAnnotation? = null var swiftAnnotation: FirAnnotation? = null for (annotation in annotations) { - when (annotation.toAnnotationClassId()) { + when (annotation.toAnnotationClassId(session)) { hidesFromObjCClassId -> objCAnnotation = annotation refinesInSwiftClassId -> swiftAnnotation = annotation } diff --git a/compiler/fir/checkers/checkers.native/src/org/jetbrains/kotlin/fir/analysis/native/checkers/FirNativeObjCRefinementChecker.kt b/compiler/fir/checkers/checkers.native/src/org/jetbrains/kotlin/fir/analysis/native/checkers/FirNativeObjCRefinementChecker.kt index 58bbda5848b..b4ddc7fc01f 100644 --- a/compiler/fir/checkers/checkers.native/src/org/jetbrains/kotlin/fir/analysis/native/checkers/FirNativeObjCRefinementChecker.kt +++ b/compiler/fir/checkers/checkers.native/src/org/jetbrains/kotlin/fir/analysis/native/checkers/FirNativeObjCRefinementChecker.kt @@ -46,7 +46,7 @@ object FirNativeObjCRefinementChecker : FirCallableDeclarationChecker() { for (annotation in annotations) { val metaAnnotations = annotation.coneClassLikeType?.lookupTag?.toSymbol(session)?.resolvedAnnotationsWithClassIds.orEmpty() for (metaAnnotation in metaAnnotations) { - when (metaAnnotation.toAnnotationClassId()) { + when (metaAnnotation.toAnnotationClassId(session)) { hidesFromObjCClassId -> { objCAnnotations.add(annotation) break diff --git a/compiler/fir/checkers/checkers.native/src/org/jetbrains/kotlin/fir/analysis/native/checkers/FirNativeObjCRefinementOverridesChecker.kt b/compiler/fir/checkers/checkers.native/src/org/jetbrains/kotlin/fir/analysis/native/checkers/FirNativeObjCRefinementOverridesChecker.kt index 0af271b2d90..7f4249cd145 100644 --- a/compiler/fir/checkers/checkers.native/src/org/jetbrains/kotlin/fir/analysis/native/checkers/FirNativeObjCRefinementOverridesChecker.kt +++ b/compiler/fir/checkers/checkers.native/src/org/jetbrains/kotlin/fir/analysis/native/checkers/FirNativeObjCRefinementOverridesChecker.kt @@ -85,7 +85,7 @@ object FirNativeObjCRefinementOverridesChecker : FirClassChecker() { for (annotation in resolvedAnnotationsWithClassIds) { val metaAnnotations = annotation.coneClassLikeType?.lookupTag?.toSymbol(session)?.resolvedAnnotationsWithClassIds.orEmpty() for (metaAnnotation in metaAnnotations) { - when (metaAnnotation.toAnnotationClassId()) { + when (metaAnnotation.toAnnotationClassId(session)) { hidesFromObjCClassId -> { hasObjC = true break diff --git a/compiler/fir/checkers/checkers.native/src/org/jetbrains/kotlin/fir/analysis/native/checkers/FirNativeThrowsChecker.kt b/compiler/fir/checkers/checkers.native/src/org/jetbrains/kotlin/fir/analysis/native/checkers/FirNativeThrowsChecker.kt index dd8cb620bf0..c04df8eb849 100644 --- a/compiler/fir/checkers/checkers.native/src/org/jetbrains/kotlin/fir/analysis/native/checkers/FirNativeThrowsChecker.kt +++ b/compiler/fir/checkers/checkers.native/src/org/jetbrains/kotlin/fir/analysis/native/checkers/FirNativeThrowsChecker.kt @@ -45,7 +45,7 @@ object FirNativeThrowsChecker : FirBasicDeclarationChecker() { ) override fun check(declaration: FirDeclaration, context: CheckerContext, reporter: DiagnosticReporter) { - val throwsAnnotation = declaration.getAnnotationByClassId(throwsClassId) as? FirAnnotationCall + val throwsAnnotation = declaration.getAnnotationByClassId(throwsClassId, context.session) as? FirAnnotationCall if (!checkInheritance(declaration, throwsAnnotation, context, reporter)) return @@ -123,7 +123,7 @@ object FirNativeThrowsChecker : FirBasicDeclarationChecker() { val annotation = if (overriddenFunction.isSubstitutionOrIntersectionOverride) { null } else { - overriddenFunction.getAnnotationByClassId(throwsClassId) as? FirAnnotationCall + overriddenFunction.getAnnotationByClassId(throwsClassId, context.session) as? FirAnnotationCall } getInheritedThrows(annotation, overriddenFunction) } 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 faec65e95a0..99a41873c3e 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 @@ -32,8 +32,8 @@ import org.jetbrains.kotlin.name.StandardClassIds.Annotations.ParameterNames import org.jetbrains.kotlin.resolve.UseSiteTargetsList import org.jetbrains.kotlin.resolve.checkers.OptInNames -fun FirRegularClass.getRetention(): AnnotationRetention { - return getRetentionAnnotation()?.getRetention() ?: AnnotationRetention.RUNTIME +fun FirRegularClass.getRetention(session: FirSession): AnnotationRetention { + return getRetentionAnnotation(session)?.getRetention() ?: AnnotationRetention.RUNTIME } fun FirAnnotation.getRetention(): AnnotationRetention { @@ -51,24 +51,24 @@ fun FirAnnotation.getAllowedAnnotationTargets(session: FirSession): Set()?.lookupTag ?: return null val annotationClassSymbol = lookupTag.toSymbol(session) as? FirRegularClassSymbol ?: return null - if (annotationClassSymbol.getAnnotationByClassId(OptInNames.REQUIRES_OPT_IN_CLASS_ID) == null) { + if (annotationClassSymbol.getAnnotationByClassId(OptInNames.REQUIRES_OPT_IN_CLASS_ID, session) == null) { return null } return annotationClassSymbol } -fun FirRegularClass.getAllowedAnnotationTargets(): Set { - return symbol.getAllowedAnnotationTargets() +fun FirRegularClass.getAllowedAnnotationTargets(session: FirSession): Set { + return symbol.getAllowedAnnotationTargets(session) } -fun FirClassLikeSymbol<*>.getAllowedAnnotationTargets(): Set { - val targetAnnotation = getTargetAnnotation() ?: return defaultAnnotationTargets +fun FirClassLikeSymbol<*>.getAllowedAnnotationTargets(session: FirSession): Set { + val targetAnnotation = getTargetAnnotation(session) ?: return defaultAnnotationTargets val arguments = targetAnnotation.findArgumentByName(ParameterNames.targetAllowedTargets)?.unfoldArrayOrVararg().orEmpty() return arguments.mapNotNullTo(mutableSetOf()) { argument -> @@ -78,16 +78,16 @@ fun FirClassLikeSymbol<*>.getAllowedAnnotationTargets(): Set { } } -fun FirDeclaration.getRetentionAnnotation(): FirAnnotation? { - return getAnnotationByClassId(StandardClassIds.Annotations.Retention) +fun FirDeclaration.getRetentionAnnotation(session: FirSession): FirAnnotation? { + return getAnnotationByClassId(StandardClassIds.Annotations.Retention, session) } -fun FirDeclaration.getTargetAnnotation(): FirAnnotation? { - return getAnnotationByClassId(StandardClassIds.Annotations.Target) +fun FirDeclaration.getTargetAnnotation(session: FirSession): FirAnnotation? { + return getAnnotationByClassId(StandardClassIds.Annotations.Target, session) } -fun FirClassLikeSymbol<*>.getTargetAnnotation(): FirAnnotation? { - return getAnnotationByClassId(StandardClassIds.Annotations.Target) +fun FirClassLikeSymbol<*>.getTargetAnnotation(session: FirSession): FirAnnotation? { + return getAnnotationByClassId(StandardClassIds.Annotations.Target, session) } fun FirExpression.extractClassesFromArgument(session: FirSession): List { @@ -123,7 +123,7 @@ fun checkRepeatedAnnotation( } fun FirAnnotation.isRepeatable(session: FirSession): Boolean { - val annotationClassId = this.toAnnotationClassId() ?: return false + val annotationClassId = this.toAnnotationClassId(session) ?: return false if (annotationClassId.isLocal) return false val annotationClass = session.symbolProvider.getClassLikeSymbolByClassId(annotationClassId) ?: return false @@ -131,18 +131,18 @@ fun FirAnnotation.isRepeatable(session: FirSession): Boolean { } fun FirClassLikeSymbol<*>.containsRepeatableAnnotation(session: FirSession): Boolean { - if (getAnnotationByClassId(StandardClassIds.Annotations.Repeatable) != null) return true - if (getAnnotationByClassId(StandardClassIds.Annotations.Java.Repeatable) != null || - getAnnotationByClassId(StandardClassIds.Annotations.JvmRepeatable) != null + if (getAnnotationByClassId(StandardClassIds.Annotations.Repeatable, session) != null) return true + if (getAnnotationByClassId(StandardClassIds.Annotations.Java.Repeatable, session) != null || + getAnnotationByClassId(StandardClassIds.Annotations.JvmRepeatable, session) != null ) { return session.languageVersionSettings.supportsFeature(LanguageFeature.RepeatableAnnotations) || - getAnnotationRetention() == AnnotationRetention.SOURCE && origin is FirDeclarationOrigin.Java + getAnnotationRetention(session) == AnnotationRetention.SOURCE && origin is FirDeclarationOrigin.Java } return false } -fun FirClassLikeSymbol<*>.getAnnotationRetention(): AnnotationRetention { - return getAnnotationByClassId(StandardClassIds.Annotations.Retention)?.getRetention() ?: AnnotationRetention.RUNTIME +fun FirClassLikeSymbol<*>.getAnnotationRetention(session: FirSession): AnnotationRetention { + return getAnnotationByClassId(StandardClassIds.Annotations.Retention, session)?.getRetention() ?: AnnotationRetention.RUNTIME } fun FirAnnotationContainer.getDefaultUseSiteTarget( 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 6e708f39b44..b3d79f83cc7 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 @@ -14,7 +14,6 @@ import org.jetbrains.kotlin.fir.declarations.utils.modality import org.jetbrains.kotlin.fir.expressions.* import org.jetbrains.kotlin.fir.expressions.impl.FirNoReceiverExpression import org.jetbrains.kotlin.fir.references.FirErrorNamedReference -import org.jetbrains.kotlin.fir.references.FirResolvedErrorReference import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference import org.jetbrains.kotlin.fir.references.toResolvedCallableSymbol import org.jetbrains.kotlin.fir.resolve.toSymbol @@ -126,7 +125,9 @@ internal fun checkConstantArguments( val symbol = calleeReference.resolvedSymbol as? FirNamedFunctionSymbol ?: return ConstantArgumentKind.NOT_CONST @OptIn(SymbolInternals::class) - if (symbol.fir.getAnnotationByClassId(INTRINSIC_CONST_EVALUATION_ANNOTATION) == null) return ConstantArgumentKind.NOT_CONST + if (symbol.fir.getAnnotationByClassId(INTRINSIC_CONST_EVALUATION_ANNOTATION, session) == null) { + return ConstantArgumentKind.NOT_CONST + } for (exp in expression.arguments.plus(expression.dispatchReceiver).plus(expression.extensionReceiver)) { if (exp is FirNoReceiverExpression) continue @@ -152,7 +153,7 @@ internal fun checkConstantArguments( @OptIn(SymbolInternals::class) val property = propertySymbol.fir when { - property.unwrapFakeOverrides().getAnnotationByClassId(INTRINSIC_CONST_EVALUATION_ANNOTATION) != null -> { + property.unwrapFakeOverrides().getAnnotationByClassId(INTRINSIC_CONST_EVALUATION_ANNOTATION, session) != null -> { return checkConstantArguments(expression.dispatchReceiver, session) } propertySymbol.isLocal || propertySymbol.callableId.className?.isRoot == false -> return ConstantArgumentKind.NOT_CONST diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirHelpers.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirHelpers.kt index 7470fdfde16..d39bcb1011f 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirHelpers.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirHelpers.kt @@ -293,8 +293,8 @@ val FirValueParameter.hasValOrVar: Boolean fun KotlinTypeMarker.isSupertypeOf(context: TypeCheckerProviderContext, type: KotlinTypeMarker?): Boolean = type != null && AbstractTypeChecker.isSubtypeOf(context, type, this) -fun FirMemberDeclaration.isInlineOnly(): Boolean = - isInline && hasAnnotation(INLINE_ONLY_ANNOTATION_CLASS_ID) +fun FirMemberDeclaration.isInlineOnly(session: FirSession): Boolean = + isInline && hasAnnotation(INLINE_ONLY_ANNOTATION_CLASS_ID, session) fun isSubtypeForTypeMismatch(context: ConeInferenceContext, subtype: ConeKotlinType, supertype: ConeKotlinType): Boolean { val subtypeFullyExpanded = subtype.fullyExpandedType(context.session) diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirSinceKotlinHelpers.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirSinceKotlinHelpers.kt index d9b9fa7762d..1d566128d91 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirSinceKotlinHelpers.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirSinceKotlinHelpers.kt @@ -64,7 +64,9 @@ private fun FirDeclaration.getOwnSinceKotlinVersion(session: FirSession): FirSin // TODO: use-site targeted annotations fun FirDeclaration.consider() { - val sinceKotlinSingleArgument = getAnnotationByClassId(StandardClassIds.Annotations.SinceKotlin)?.findArgumentByName(StandardClassIds.Annotations.ParameterNames.sinceKotlinVersion) + val sinceKotlinSingleArgument = getAnnotationByClassId(StandardClassIds.Annotations.SinceKotlin, session)?.findArgumentByName( + StandardClassIds.Annotations.ParameterNames.sinceKotlinVersion + ) val apiVersion = ((sinceKotlinSingleArgument as? FirConstExpression<*>)?.value as? String)?.let(ApiVersion.Companion::parse) if (apiVersion != null) { // TODO: combine wasExperimentalMarkerClasses in case of several associated declarations with the same maximal API version @@ -97,7 +99,7 @@ private fun FirDeclaration.getOwnSinceKotlinVersion(session: FirSession): FirSin } private fun FirDeclaration.loadWasExperimentalMarkerClasses(session: FirSession): List { - val wasExperimental = getAnnotationByClassId(OptInNames.WAS_EXPERIMENTAL_CLASS_ID) ?: return emptyList() + val wasExperimental = getAnnotationByClassId(OptInNames.WAS_EXPERIMENTAL_CLASS_ID, session) ?: return emptyList() val annotationClasses = wasExperimental.findArgumentByName(OptInNames.WAS_EXPERIMENTAL_ANNOTATION_CLASS) ?: return emptyList() return annotationClasses.extractClassesFromArgument(session) } diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirAnnotationClassDeclarationChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirAnnotationClassDeclarationChecker.kt index 81f6d9d5a87..4d5248ac2f7 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirAnnotationClassDeclarationChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirAnnotationClassDeclarationChecker.kt @@ -44,10 +44,11 @@ object FirAnnotationClassDeclarationChecker : FirRegularClassChecker() { checkAnnotationClassMember(member, context, reporter) } - if (declaration.getRetention() != AnnotationRetention.SOURCE && - KotlinTarget.EXPRESSION in declaration.getAllowedAnnotationTargets() + val session = context.session + if (declaration.getRetention(session) != AnnotationRetention.SOURCE && + KotlinTarget.EXPRESSION in declaration.getAllowedAnnotationTargets(session) ) { - val target = declaration.getRetentionAnnotation() ?: declaration.getTargetAnnotation() ?: declaration + val target = declaration.getRetentionAnnotation(session) ?: declaration.getTargetAnnotation(session) ?: declaration reporter.reportOn(target.source, FirErrors.RESTRICTED_RETENTION_FOR_EXPRESSION_ANNOTATION, context) } 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 3eaa333cd57..89fe64a840a 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 @@ -433,15 +433,16 @@ abstract class FirInlineDeclarationChecker : FirFunctionChecker() { private fun checkNothingToInline(function: FirSimpleFunction, context: CheckerContext, reporter: DiagnosticReporter) { if (function.isExpect || function.isSuspend) return if (function.typeParameters.any { it.symbol.isReified }) return + val session = context.session val hasInlinableParameters = function.valueParameters.any { param -> val type = param.returnTypeRef.coneType !param.isNoinline && !type.isNullable - && (type.isFunctionalType(context.session) || type.isSuspendFunctionType(context.session)) + && (type.isFunctionalType(session) || type.isSuspendFunctionType(session)) } if (hasInlinableParameters) return - if (function.isInlineOnly()) return - if (function.returnTypeRef.needsMultiFieldValueClassFlattening(context.session)) return + if (function.isInlineOnly(session)) return + if (function.returnTypeRef.needsMultiFieldValueClassFlattening(session)) return reporter.reportOn(function.source, FirErrors.NOTHING_TO_INLINE, context) } diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirOptInAnnotationClassChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirOptInAnnotationClassChecker.kt index 26cf1773680..01d83483b72 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirOptInAnnotationClassChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirOptInAnnotationClassChecker.kt @@ -20,15 +20,16 @@ import org.jetbrains.kotlin.resolve.checkers.OptInNames object FirOptInAnnotationClassChecker : FirRegularClassChecker() { override fun check(declaration: FirRegularClass, context: CheckerContext, reporter: DiagnosticReporter) { if (declaration.classKind != ClassKind.ANNOTATION_CLASS) return - if (declaration.getAnnotationByClassId(OptInNames.REQUIRES_OPT_IN_CLASS_ID) == null) return - if (declaration.getRetention() == AnnotationRetention.SOURCE) { - val target = declaration.getRetentionAnnotation() + val session = context.session + if (declaration.getAnnotationByClassId(OptInNames.REQUIRES_OPT_IN_CLASS_ID, session) == null) return + if (declaration.getRetention(session) == AnnotationRetention.SOURCE) { + val target = declaration.getRetentionAnnotation(session) reporter.reportOn(target?.source, FirErrors.OPT_IN_MARKER_WITH_WRONG_RETENTION, context) } - val wrongTargets = declaration.getAllowedAnnotationTargets().intersect(OptInDescription.WRONG_TARGETS_FOR_MARKER) + val wrongTargets = declaration.getAllowedAnnotationTargets(session).intersect(OptInDescription.WRONG_TARGETS_FOR_MARKER) if (wrongTargets.isNotEmpty()) { - val target = declaration.getTargetAnnotation() + val target = declaration.getTargetAnnotation(session) reporter.reportOn( target?.source, FirErrors.OPT_IN_MARKER_WITH_WRONG_TARGET, diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirOptInMarkedDeclarationChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirOptInMarkedDeclarationChecker.kt index ad76770313c..459961a6d82 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirOptInMarkedDeclarationChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirOptInMarkedDeclarationChecker.kt @@ -25,7 +25,7 @@ object FirOptInMarkedDeclarationChecker : FirBasicDeclarationChecker() { } if (useSiteTarget == SETTER_PARAMETER || (useSiteTarget != PROPERTY && useSiteTarget != PROPERTY_SETTER && declaration is FirValueParameter && - KotlinTarget.VALUE_PARAMETER in annotationClass.getAllowedAnnotationTargets()) + KotlinTarget.VALUE_PARAMETER in annotationClass.getAllowedAnnotationTargets(context.session)) ) { reporter.reportOn(annotation.source, FirErrors.OPT_IN_MARKER_ON_WRONG_TARGET, "parameter", context) } diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirPublishedApiChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirPublishedApiChecker.kt index a03315a8372..256d8dcd9e3 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirPublishedApiChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirPublishedApiChecker.kt @@ -22,7 +22,7 @@ object FirPublishedApiChecker : FirBasicDeclarationChecker() { if (declaration !is FirMemberDeclaration) return if (declaration is FirValueParameter) return if (declaration.visibility == Visibilities.Internal) return - val annotation = declaration.getAnnotationByClassId(StandardClassIds.Annotations.PublishedApi) ?: return + val annotation = declaration.getAnnotationByClassId(StandardClassIds.Annotations.PublishedApi, context.session) ?: return reporter.reportOn(annotation.source, FirErrors.NON_INTERNAL_PUBLISHED_API, context) } } diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirTypeParameterBoundsChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirTypeParameterBoundsChecker.kt index 5eb7c17b97c..6f90417a0ee 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirTypeParameterBoundsChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirTypeParameterBoundsChecker.kt @@ -34,7 +34,7 @@ object FirTypeParameterBoundsChecker : FirTypeParameterChecker() { checkFinalUpperBounds(declaration, containingDeclaration, context, reporter) checkExtensionFunctionTypeBound(declaration, context, reporter) - if ((containingDeclaration as? FirMemberDeclaration)?.isInlineOnly() != true) { + if ((containingDeclaration as? FirMemberDeclaration)?.isInlineOnly(context.session) != true) { checkOnlyOneTypeParameterBound(declaration, context, reporter) } diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirOptInAnnotationCallChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirOptInAnnotationCallChecker.kt index 60b3af0d762..c297dd16b1a 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirOptInAnnotationCallChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirOptInAnnotationCallChecker.kt @@ -98,7 +98,7 @@ object FirOptInAnnotationCallChecker : FirAnnotationCallChecker() { context: CheckerContext ) { with(FirOptInUsageBaseChecker) { - if (classSymbol.loadExperimentalityForMarkerAnnotation() == null) { + if (classSymbol.loadExperimentalityForMarkerAnnotation(context.session) == null) { reporter.reportOn( source, FirErrors.OPT_IN_ARGUMENT_IS_NOT_MARKER, diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirOptInUsageBaseChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirOptInUsageBaseChecker.kt index 51d66580afc..64df203d857 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirOptInUsageBaseChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirOptInUsageBaseChecker.kt @@ -63,10 +63,13 @@ object FirOptInUsageBaseChecker { } // Note: receiver is an OptIn marker class and parameter is an annotated member owner class / self class name - fun FirRegularClassSymbol.loadExperimentalityForMarkerAnnotation(annotatedOwnerClassName: String? = null): Experimentality? { + fun FirRegularClassSymbol.loadExperimentalityForMarkerAnnotation( + session: FirSession, + annotatedOwnerClassName: String? = null + ): Experimentality? { lazyResolveToPhase(FirResolvePhase.BODY_RESOLVE) @OptIn(SymbolInternals::class) - return fir.loadExperimentalityForMarkerAnnotation(annotatedOwnerClassName) + return fir.loadExperimentalityForMarkerAnnotation(session, annotatedOwnerClassName) } fun FirBasedSymbol<*>.loadExperimentalitiesFromAnnotationTo(session: FirSession, result: MutableCollection) { @@ -90,14 +93,14 @@ object FirOptInUsageBaseChecker { result.addIfNotNull( annotationType.lookupTag.toFirRegularClassSymbol( session - )?.loadExperimentalityForMarkerAnnotation(className) + )?.loadExperimentalityForMarkerAnnotation(session, className) ) if (fromSupertype) { if (annotationType.lookupTag.classId == OptInNames.SUBCLASS_OPT_IN_REQUIRED_CLASS_ID) { val annotationClass = annotation.findArgumentByName(OptInNames.OPT_IN_ANNOTATION_CLASS) ?: continue result.addIfNotNull( annotationClass.extractClassFromArgument(session) - ?.loadExperimentalityForMarkerAnnotation()?.copy(fromSupertype = true) + ?.loadExperimentalityForMarkerAnnotation(session)?.copy(fromSupertype = true) ) } } @@ -159,12 +162,12 @@ object FirOptInUsageBaseChecker { fir.loadExperimentalitiesFromAnnotationTo(session, result, fromSupertype) - if (fir.getAnnotationByClassId(OptInNames.WAS_EXPERIMENTAL_CLASS_ID) != null) { + if (fir.getAnnotationByClassId(OptInNames.WAS_EXPERIMENTAL_CLASS_ID, session) != null) { val accessibility = fir.checkSinceKotlinVersionAccessibility(context) if (accessibility is FirSinceKotlinAccessibility.NotAccessibleButWasExperimental) { accessibility.markerClasses.forEach { it.lazyResolveToPhase(FirResolvePhase.STATUS) - result.addIfNotNull(it.fir.loadExperimentalityForMarkerAnnotation()) + result.addIfNotNull(it.fir.loadExperimentalityForMarkerAnnotation(session)) } } } @@ -241,8 +244,11 @@ object FirOptInUsageBaseChecker { } // Note: receiver is an OptIn marker class and parameter is an annotated member owner class / self class name - private fun FirRegularClass.loadExperimentalityForMarkerAnnotation(annotatedOwnerClassName: String? = null): Experimentality? { - val experimental = getAnnotationByClassId(OptInNames.REQUIRES_OPT_IN_CLASS_ID) + private fun FirRegularClass.loadExperimentalityForMarkerAnnotation( + session: FirSession, + annotatedOwnerClassName: String? = null + ): Experimentality? { + val experimental = getAnnotationByClassId(OptInNames.REQUIRES_OPT_IN_CLASS_ID, session) ?: return null val levelArgument = experimental.findArgumentByName(LEVEL) as? FirQualifiedAccessExpression @@ -321,11 +327,11 @@ object FirOptInUsageBaseChecker { annotationClassId: ClassId, fromSupertype: Boolean ): Boolean { - return getAnnotationByClassId(annotationClassId) != null || isAnnotatedWithOptIn(session, annotationClassId) || + return getAnnotationByClassId(annotationClassId, session) != null || isAnnotatedWithOptIn(annotationClassId, session) || fromSupertype && isAnnotatedWithSubclassOptInRequired(session, annotationClassId) } - private fun FirAnnotationContainer.isAnnotatedWithOptIn(session: FirSession, annotationClassId: ClassId): Boolean { + private fun FirAnnotationContainer.isAnnotatedWithOptIn(annotationClassId: ClassId, session: FirSession): Boolean { for (annotation in annotations) { val coneType = annotation.annotationTypeRef.coneType as? ConeClassLikeType if (coneType?.lookupTag?.classId != OptInNames.OPT_IN_CLASS_ID) { 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 543eafa0bb7..7d1fe5754e8 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 @@ -189,7 +189,7 @@ object FirSuspendCallChecker : FirQualifiedAccessExpressionChecker() { when (this) { is ConeClassLikeType -> { val regularClassSymbol = fullyExpandedType(session).lookupTag.toFirRegularClassSymbol(session) ?: return false - if (regularClassSymbol.getAnnotationByClassId(StandardClassIds.Annotations.RestrictsSuspension) != null) { + if (regularClassSymbol.getAnnotationByClassId(StandardClassIds.Annotations.RestrictsSuspension, session) != null) { return true } return regularClassSymbol.resolvedSuperTypes.any { it.isRestrictSuspensionReceiver(session) } diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/type/FirOptInUsageTypeRefChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/type/FirOptInUsageTypeRefChecker.kt index d703f0e2d89..c28fa90aada 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/type/FirOptInUsageTypeRefChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/type/FirOptInUsageTypeRefChecker.kt @@ -40,7 +40,9 @@ object FirOptInUsageTypeRefChecker : FirTypeRefChecker() { if (lastAnnotationCall == null || lastAnnotationCall.annotationTypeRef !== typeRef) { if (classId == OptInNames.REQUIRES_OPT_IN_CLASS_ID || classId == OptInNames.OPT_IN_CLASS_ID) { reporter.reportOn(source, OPT_IN_CAN_ONLY_BE_USED_AS_ANNOTATION, context) - } else if (symbol is FirRegularClassSymbol && symbol.fir.getAnnotationByClassId(OptInNames.REQUIRES_OPT_IN_CLASS_ID) != null) { + } else if (symbol is FirRegularClassSymbol && + symbol.fir.getAnnotationByClassId(OptInNames.REQUIRES_OPT_IN_CLASS_ID, context.session) != null + ) { reporter.reportOn(source, OPT_IN_MARKER_CAN_ONLY_BE_USED_AS_ANNOTATION_OR_ARGUMENT_IN_OPT_IN, context) } } 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 e72c1024b39..b45433e5b7b 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 @@ -8,13 +8,11 @@ package org.jetbrains.kotlin.fir.deserialization import org.jetbrains.kotlin.builtins.jvm.JvmBuiltInsSignatures import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.fir.* -import org.jetbrains.kotlin.fir.caches.firCachesFactory import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.builder.* import org.jetbrains.kotlin.fir.declarations.comparators.FirMemberDeclarationComparator import org.jetbrains.kotlin.fir.declarations.impl.FirResolvedDeclarationStatusImpl import org.jetbrains.kotlin.fir.declarations.utils.* -import org.jetbrains.kotlin.fir.expressions.FirAnnotation import org.jetbrains.kotlin.fir.scopes.FirScopeProvider import org.jetbrains.kotlin.fir.symbols.ConeTypeParameterLookupTag import org.jetbrains.kotlin.fir.symbols.impl.ConeClassLikeLookupTagImpl @@ -231,7 +229,7 @@ fun deserializeClassToSymbol( sourceElement = containerSource - replaceDeprecationsProvider(getDeprecationsProvider(session.firCachesFactory)) + replaceDeprecationsProvider(getDeprecationsProvider(session)) classProto.getExtensionOrNull(JvmProtoBuf.classModuleName)?.let { idx -> moduleName = nameResolver.getString(idx) diff --git a/compiler/fir/fir-deserialization/src/org/jetbrains/kotlin/fir/deserialization/FirMemberDeserializer.kt b/compiler/fir/fir-deserialization/src/org/jetbrains/kotlin/fir/deserialization/FirMemberDeserializer.kt index c2ffb404bb4..e9c231f2cdc 100644 --- a/compiler/fir/fir-deserialization/src/org/jetbrains/kotlin/fir/deserialization/FirMemberDeserializer.kt +++ b/compiler/fir/fir-deserialization/src/org/jetbrains/kotlin/fir/deserialization/FirMemberDeserializer.kt @@ -8,7 +8,6 @@ package org.jetbrains.kotlin.fir.deserialization import org.jetbrains.kotlin.descriptors.Modality import org.jetbrains.kotlin.fir.FirModuleData import org.jetbrains.kotlin.fir.FirSession -import org.jetbrains.kotlin.fir.caches.firCachesFactory import org.jetbrains.kotlin.fir.containingClassForStaticMemberAttr import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.builder.* @@ -16,7 +15,6 @@ import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyGetter import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertySetter import org.jetbrains.kotlin.fir.declarations.impl.FirResolvedDeclarationStatusImpl import org.jetbrains.kotlin.fir.declarations.utils.sourceElement -import org.jetbrains.kotlin.fir.expressions.FirAnnotation import org.jetbrains.kotlin.fir.expressions.FirExpression import org.jetbrains.kotlin.fir.expressions.builder.buildExpressionStub import org.jetbrains.kotlin.fir.resolve.defaultType @@ -431,7 +429,7 @@ class FirMemberDeserializer(private val c: FirDeserializationContext) { } this.containerSource = c.containerSource this.initializer = c.constDeserializer.loadConstant(proto, symbol.callableId, c.nameResolver) - deprecationsProvider = annotations.getDeprecationsProviderFromAnnotations(fromJava = false, c.session.firCachesFactory) + deprecationsProvider = annotations.getDeprecationsProviderFromAnnotations(c.session, fromJava = false) proto.contextReceiverTypes(c.typeTable).mapTo(contextReceivers, ::loadContextReceiver) }.apply { @@ -514,7 +512,7 @@ class FirMemberDeserializer(private val c: FirDeserializationContext) { ) annotations += c.annotationDeserializer.loadFunctionAnnotations(c.containerSource, proto, local.nameResolver, local.typeTable) - deprecationsProvider = annotations.getDeprecationsProviderFromAnnotations(fromJava = false, c.session.firCachesFactory) + deprecationsProvider = annotations.getDeprecationsProviderFromAnnotations(c.session, fromJava = false) this.containerSource = c.containerSource proto.contextReceiverTypes(c.typeTable).mapTo(contextReceivers, ::loadContextReceiver) @@ -594,7 +592,7 @@ class FirMemberDeserializer(private val c: FirDeserializationContext) { annotations += c.annotationDeserializer.loadConstructorAnnotations(c.containerSource, proto, local.nameResolver, local.typeTable) containerSource = c.containerSource - deprecationsProvider = annotations.getDeprecationsProviderFromAnnotations(fromJava = false, c.session.firCachesFactory) + deprecationsProvider = annotations.getDeprecationsProviderFromAnnotations(c.session, fromJava = false) contextReceivers.addAll(createContextReceiversForClass(classProto)) }.build().apply { 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 703b2e46472..3370e53d9fe 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 @@ -907,7 +907,7 @@ class FirElementSerializer private constructor( private fun MutableVersionRequirementTable.serializeVersionRequirements(annotations: List): List = annotations .filter { - it.toAnnotationClassId()?.asSingleFqName() == RequireKotlinConstants.FQ_NAME + it.toAnnotationClassId(session)?.asSingleFqName() == RequireKotlinConstants.FQ_NAME } .mapNotNull(::serializeVersionRequirementFromRequireKotlin) .map(::get) 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 e36de3f0b5c..b7594d53dce 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 @@ -275,7 +275,7 @@ class FirJvmSerializerExtension( } private fun FirProperty.isJvmFieldPropertyInInterfaceCompanion(): Boolean { - if (!hasJvmFieldAnnotation) return false + if (!hasJvmFieldAnnotation(session)) return false val containerSymbol = (dispatchReceiverType as? ConeClassLikeType)?.lookupTag?.toFirRegularClassSymbol(session) // Note: companions are anyway forbidden in local classes 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 41dac84d68c..384bbfb081a 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 @@ -785,7 +785,7 @@ class Fir2IrDeclarationStorage( hasExplicitBackingField -> backingField?.visibility ?: status.visibility isLateInit -> setter?.visibility ?: status.visibility isConst -> status.visibility - hasJvmFieldAnnotation -> status.visibility + hasJvmFieldAnnotation(session) -> status.visibility else -> Visibilities.Private } diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrTypeConverter.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrTypeConverter.kt index 4d415f16cb2..73bfafed449 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrTypeConverter.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrTypeConverter.kt @@ -135,7 +135,7 @@ class Fir2IrTypeConverter( } } - if (isExtensionFunctionType && annotations.getAnnotationsByClassId(ExtensionFunctionType).isEmpty()) { + if (isExtensionFunctionType && annotations.getAnnotationsByClassId(ExtensionFunctionType, session).isEmpty()) { builtIns.extensionFunctionTypeAnnotationConstructorCall()?.let { typeAnnotations += it } 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 58a6a48b8be..e9d37e618da 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 @@ -642,6 +642,7 @@ class CallAndReferenceGenerator( fun convertToIrConstructorCall(annotation: FirAnnotation): IrExpression { val coneType = annotation.annotationTypeRef.coneTypeSafe() + ?.fullyExpandedType(session) as? ConeLookupTagBasedType val type = coneType?.toIrType() val symbol = type?.classifierOrNull return annotation.convertWithOffsets { startOffset, endOffset -> @@ -693,7 +694,7 @@ class CallAndReferenceGenerator( return buildAnnotationCall { useSiteTarget = this@toAnnotationCall.useSiteTarget annotationTypeRef = this@toAnnotationCall.annotationTypeRef - val symbol = annotationTypeRef.coneType.toSymbol(session) as? FirRegularClassSymbol ?: return null + val symbol = annotationTypeRef.coneType.fullyExpandedType(session).toSymbol(session) as? FirRegularClassSymbol ?: return null val constructorSymbol = symbol.declarationSymbols.firstIsInstanceOrNull() ?: return null val argumentToParameterToMapping = constructorSymbol.valueParameterSymbols.mapNotNull { val parameter = it.fir diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/DelegatedMemberGenerator.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/DelegatedMemberGenerator.kt index 49bbe725c7f..b6b3e75d5c1 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/DelegatedMemberGenerator.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/DelegatedMemberGenerator.kt @@ -334,14 +334,14 @@ class DelegatedMemberGenerator( val wrappedSymbol = wrapped.symbol as? S ?: return null @Suppress("UNCHECKED_CAST") - return (wrappedSymbol.unwrapCallRepresentative().fir as D).takeIf { !shouldSkipDelegationFor(it) } + return (wrappedSymbol.unwrapCallRepresentative().fir as D).takeIf { !shouldSkipDelegationFor(it, session) } } - private fun shouldSkipDelegationFor(unwrapped: FirCallableDeclaration): Boolean { + private fun shouldSkipDelegationFor(unwrapped: FirCallableDeclaration, session: FirSession): Boolean { // See org.jetbrains.kotlin.resolve.jvm.JvmDelegationFilter return (unwrapped is FirSimpleFunction && unwrapped.isDefaultJavaMethod()) || - unwrapped.hasAnnotation(JVM_DEFAULT_CLASS_ID) || - unwrapped.hasAnnotation(PLATFORM_DEPENDENT_CLASS_ID) + unwrapped.hasAnnotation(JVM_DEFAULT_CLASS_ID, session) || + unwrapped.hasAnnotation(PLATFORM_DEPENDENT_CLASS_ID, session) } private fun FirSimpleFunction.isDefaultJavaMethod(): Boolean = diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/lazy/AbstractFir2IrLazyFunction.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/lazy/AbstractFir2IrLazyFunction.kt index 37dad8aa029..ec538466f83 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/lazy/AbstractFir2IrLazyFunction.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/lazy/AbstractFir2IrLazyFunction.kt @@ -95,8 +95,8 @@ abstract class AbstractFir2IrLazyFunction( } private fun hasJvmStaticAnnotation(): Boolean { - return fir.hasAnnotation(JVM_STATIC_CLASS_ID) || - (fir as? FirPropertyAccessor)?.propertySymbol?.fir?.hasAnnotation(JVM_STATIC_CLASS_ID) == true + return fir.hasAnnotation(JVM_STATIC_CLASS_ID, session) || + (fir as? FirPropertyAccessor)?.propertySymbol?.fir?.hasAnnotation(JVM_STATIC_CLASS_ID, session) == true } protected fun createThisReceiverParameter(thisType: IrType, explicitReceiver: FirReceiverParameter? = null): IrValueParameter { diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/FirJavaFacade.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/FirJavaFacade.kt index ff2ebaff24d..b1f0262400a 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/FirJavaFacade.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/FirJavaFacade.kt @@ -199,7 +199,7 @@ abstract class FirJavaFacade( } } firJavaClass.replaceSuperTypeRefs(enhancedSuperTypes) - firJavaClass.replaceDeprecationsProvider(firJavaClass.getDeprecationsProvider(session.firCachesFactory)) + firJavaClass.replaceDeprecationsProvider(firJavaClass.getDeprecationsProvider(session)) return firJavaClass } diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JvmSupertypeUpdater.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JvmSupertypeUpdater.kt index 80f46b9e8be..f61b33e7876 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JvmSupertypeUpdater.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JvmSupertypeUpdater.kt @@ -35,7 +35,9 @@ class JvmSupertypeUpdater(private val session: FirSession) : PlatformSupertypeUp private val jvmRecordUpdater = DelegatedConstructorCallTransformer(session) override fun updateSupertypesIfNeeded(firClass: FirClass, scopeSession: ScopeSession) { - if (!(firClass is FirRegularClass && firClass.isData && firClass.hasAnnotationSafe(StandardClassIds.Annotations.JvmRecord))) return + if (firClass !is FirRegularClass || !firClass.isData || + !firClass.hasAnnotationSafe(StandardClassIds.Annotations.JvmRecord, session) + ) return var anyFound = false var hasExplicitSuperClass = false val newSuperTypeRefs = firClass.superTypeRefs.mapTo(mutableListOf()) { diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/declarations/FirJavaField.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/declarations/FirJavaField.kt index 011bd84a286..74b1228c461 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/declarations/FirJavaField.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/declarations/FirJavaField.kt @@ -11,7 +11,6 @@ import org.jetbrains.kotlin.descriptors.Visibility import org.jetbrains.kotlin.fir.FirImplementationDetail import org.jetbrains.kotlin.fir.FirModuleData import org.jetbrains.kotlin.fir.builder.FirBuilderDsl -import org.jetbrains.kotlin.fir.caches.firCachesFactory import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.builder.FirFieldBuilder import org.jetbrains.kotlin.fir.expressions.FirAnnotation @@ -65,7 +64,7 @@ class FirJavaField @FirImplementationDetail constructor( get() = lazyInitializer.value override val deprecationsProvider: DeprecationsProvider by lazy { - annotations.getDeprecationsProviderFromAnnotations(fromJava = true, moduleData.session.firCachesFactory) + annotations.getDeprecationsProviderFromAnnotations(moduleData.session, fromJava = true) } override val contextReceivers: List diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/deserialization/JvmClassFileBasedSymbolProvider.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/deserialization/JvmClassFileBasedSymbolProvider.kt index 591f524acfa..cbc347d6017 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/deserialization/JvmClassFileBasedSymbolProvider.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/deserialization/JvmClassFileBasedSymbolProvider.kt @@ -9,7 +9,6 @@ import org.jetbrains.kotlin.descriptors.SourceElement import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.ThreadSafeMutableState import org.jetbrains.kotlin.fir.builder.toMutableOrEmpty -import org.jetbrains.kotlin.fir.caches.firCachesFactory import org.jetbrains.kotlin.fir.declarations.FirDeclarationOrigin import org.jetbrains.kotlin.fir.declarations.getDeprecationsProvider import org.jetbrains.kotlin.fir.deserialization.* @@ -158,7 +157,7 @@ class JvmClassFileBasedSymbolProvider( kotlinClass.byteContent, ) symbol.fir.replaceAnnotations(annotations.toMutableOrEmpty()) - symbol.fir.replaceDeprecationsProvider(symbol.fir.getDeprecationsProvider(session.firCachesFactory)) + symbol.fir.replaceDeprecationsProvider(symbol.fir.getDeprecationsProvider(session)) } private fun String?.toPath(): Path? { diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/SignatureEnhancement.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/SignatureEnhancement.kt index a9e95f896e9..b28ad301a82 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/SignatureEnhancement.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/SignatureEnhancement.kt @@ -169,7 +169,7 @@ class FirSignatureEnhancement( delegateGetter = enhancedGetterSymbol.fir as FirSimpleFunction delegateSetter = enhancedSetterSymbol?.fir as FirSimpleFunction? status = firElement.status - deprecationsProvider = getDeprecationsProviderFromAccessors(delegateGetter, delegateSetter, session.firCachesFactory) + deprecationsProvider = getDeprecationsProviderFromAccessors(session, delegateGetter, delegateSetter) }.symbol } else -> { @@ -332,7 +332,7 @@ class FirSignatureEnhancement( } this.valueParameters += newValueParameters annotations += firMethod.annotations - deprecationsProvider = annotations.getDeprecationsProviderFromAnnotations(fromJava = true, session.firCachesFactory) + deprecationsProvider = annotations.getDeprecationsProviderFromAnnotations(session, fromJava = true) }.build().apply { if (isJavaRecordComponent) { this.isJavaRecordComponent = true diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/scopes/JavaClassUseSiteMemberScope.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/scopes/JavaClassUseSiteMemberScope.kt index bb39cbed8c9..552394acb4b 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/scopes/JavaClassUseSiteMemberScope.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/scopes/JavaClassUseSiteMemberScope.kt @@ -8,7 +8,6 @@ package org.jetbrains.kotlin.fir.java.scopes import org.jetbrains.kotlin.builtins.StandardNames import org.jetbrains.kotlin.descriptors.Modality import org.jetbrains.kotlin.fir.* -import org.jetbrains.kotlin.fir.caches.firCachesFactory import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.builder.buildSimpleFunctionCopy import org.jetbrains.kotlin.fir.declarations.impl.FirDeclarationStatusImpl @@ -89,7 +88,7 @@ class JavaClassUseSiteMemberScope( chooseModalityForAccessor(property, delegateGetter) } ) - deprecationsProvider = getDeprecationsProviderFromAccessors(delegateGetter, delegateSetter, session.firCachesFactory) + deprecationsProvider = getDeprecationsProviderFromAccessors(session, delegateGetter, delegateSetter) }.symbol } } diff --git a/compiler/fir/providers/src/org/jetbrains/kotlin/fir/declarations/FirAnnotationUtils.kt b/compiler/fir/providers/src/org/jetbrains/kotlin/fir/declarations/FirAnnotationUtils.kt index 03e8f793f0b..590d500f8b0 100644 --- a/compiler/fir/providers/src/org/jetbrains/kotlin/fir/declarations/FirAnnotationUtils.kt +++ b/compiler/fir/providers/src/org/jetbrains/kotlin/fir/declarations/FirAnnotationUtils.kt @@ -22,21 +22,21 @@ import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.name.StandardClassIds -private fun FirAnnotation.toAnnotationLookupTag(): ConeClassLikeLookupTag? = +private fun FirAnnotation.toAnnotationLookupTag(session: FirSession): ConeClassLikeLookupTag? = // this cast fails when we have generic-typed annotations @T - (annotationTypeRef.coneType as? ConeClassLikeType)?.lookupTag + (annotationTypeRef.coneType as? ConeClassLikeType)?.fullyExpandedType(session)?.lookupTag -private fun FirAnnotation.toAnnotationLookupTagSafe(): ConeClassLikeLookupTag? = - annotationTypeRef.coneTypeSafe()?.lookupTag +private fun FirAnnotation.toAnnotationLookupTagSafe(session: FirSession): ConeClassLikeLookupTag? = + annotationTypeRef.coneTypeSafe()?.fullyExpandedType(session)?.lookupTag -fun FirAnnotation.toAnnotationClassId(): ClassId? = - toAnnotationLookupTag()?.classId +fun FirAnnotation.toAnnotationClassId(session: FirSession): ClassId? = + toAnnotationLookupTag(session)?.classId -fun FirAnnotation.toAnnotationClassIdSafe(): ClassId? = - toAnnotationLookupTagSafe()?.classId +private fun FirAnnotation.toAnnotationClassIdSafe(session: FirSession): ClassId? = + toAnnotationLookupTagSafe(session)?.classId private fun FirAnnotation.toAnnotationClass(session: FirSession): FirRegularClass? = - toAnnotationLookupTag()?.toSymbol(session)?.fir as? FirRegularClass + toAnnotationLookupTag(session)?.toSymbol(session)?.fir as? FirRegularClass // TODO: this is temporary solution, we need something better private val FirExpression.callableNameOfMetaAnnotationArgument: Name? @@ -52,22 +52,22 @@ fun FirAnnotationContainer.nonSourceAnnotations(session: FirSession): List val firAnnotationClass = annotation.toAnnotationClass(session) firAnnotationClass != null && firAnnotationClass.annotations.none { meta -> - meta.toAnnotationClassId() == StandardClassIds.Annotations.Retention && + meta.toAnnotationClassId(session) == StandardClassIds.Annotations.Retention && meta.findArgumentByName(StandardClassIds.Annotations.ParameterNames.retentionValue) ?.callableNameOfMetaAnnotationArgument == sourceName } } -inline val FirProperty.hasJvmFieldAnnotation: Boolean - get() = annotations.any { it.isJvmFieldAnnotation } +@Suppress("NOTHING_TO_INLINE") +inline fun FirProperty.hasJvmFieldAnnotation(session: FirSession): Boolean = annotations.any { it.isJvmFieldAnnotation(session) } -val FirAnnotation.isJvmFieldAnnotation: Boolean - get() = toAnnotationClassId() == StandardClassIds.Annotations.JvmField +fun FirAnnotation.isJvmFieldAnnotation(session: FirSession): Boolean = + toAnnotationClassId(session) == StandardClassIds.Annotations.JvmField fun FirAnnotation.useSiteTargetsFromMetaAnnotation(session: FirSession): Set { return toAnnotationClass(session) ?.annotations - ?.find { it.toAnnotationClassId() == StandardClassIds.Annotations.Target } + ?.find { it.toAnnotationClassId(session) == StandardClassIds.Annotations.Target } ?.findArgumentByName(StandardClassIds.Annotations.ParameterNames.targetAllowedTargets) ?.unwrapVarargValue() ?.toAnnotationUseSiteTargets() @@ -101,45 +101,47 @@ private val USE_SITE_TARGET_NAME_MAP = mapOf( private val DEFAULT_USE_SITE_TARGETS: Set = USE_SITE_TARGET_NAME_MAP.values.fold(setOf()) { a, b -> a + b } - setOf(AnnotationUseSiteTarget.FILE) -fun FirDeclaration.hasAnnotation(classId: ClassId): Boolean { - return annotations.hasAnnotation(classId) +fun FirDeclaration.hasAnnotation(classId: ClassId, session: FirSession): Boolean { + return annotations.hasAnnotation(classId, session) } -fun FirDeclaration.hasAnnotationSafe(classId: ClassId): Boolean { - return annotations.hasAnnotationSafe(classId) +fun FirDeclaration.hasAnnotationSafe(classId: ClassId, session: FirSession): Boolean { + return annotations.hasAnnotationSafe(classId, session) } -fun FirBasedSymbol<*>.hasAnnotation(classId: ClassId): Boolean { - return resolvedAnnotationsWithClassIds.hasAnnotation(classId) +fun FirBasedSymbol<*>.hasAnnotation(classId: ClassId, session: FirSession): Boolean { + return resolvedAnnotationsWithClassIds.hasAnnotation(classId, session) } -fun List.hasAnnotation(classId: ClassId): Boolean { - return this.any { it.toAnnotationClassId() == classId } +fun List.hasAnnotation(classId: ClassId, session: FirSession): Boolean { + return this.any { it.toAnnotationClassId(session) == classId } } -fun List.hasAnnotationSafe(classId: ClassId): Boolean { - return this.any { it.toAnnotationClassIdSafe() == classId } +fun List.hasAnnotationSafe(classId: ClassId, session: FirSession): Boolean { + return this.any { it.toAnnotationClassIdSafe(session) == classId } } -fun FirBasedSymbol.getAnnotationByClassId(classId: ClassId): FirAnnotation? where D : FirAnnotationContainer, D : FirDeclaration { - return fir.getAnnotationByClassId(classId) +fun FirBasedSymbol.getAnnotationByClassId( + classId: ClassId, + session: FirSession +): FirAnnotation? where D : FirAnnotationContainer, D : FirDeclaration { + return fir.getAnnotationByClassId(classId, session) } -fun FirAnnotationContainer.getAnnotationByClassId(classId: ClassId): FirAnnotation? { - return annotations.getAnnotationByClassId(classId) +fun FirAnnotationContainer.getAnnotationByClassId(classId: ClassId, session: FirSession): FirAnnotation? { + return annotations.getAnnotationByClassId(classId, session) } -fun List.getAnnotationByClassId(classId: ClassId): FirAnnotation? { - return find { - it.annotationTypeRef.coneTypeSafe()?.lookupTag?.classId == classId - } +fun List.getAnnotationByClassId(classId: ClassId, session: FirSession): FirAnnotation? { + return getAnnotationsByClassId(classId, session).firstOrNull() } -fun FirAnnotationContainer.getAnnotationsByClassId(classId: ClassId): List = annotations.getAnnotationsByClassId(classId) +fun FirAnnotationContainer.getAnnotationsByClassId(classId: ClassId, session: FirSession): List = + annotations.getAnnotationsByClassId(classId, session) -fun List.getAnnotationsByClassId(classId: ClassId): List { +fun List.getAnnotationsByClassId(classId: ClassId, session: FirSession): List { return filter { - it.annotationTypeRef.coneTypeSafe()?.lookupTag?.classId == classId + it.annotationTypeRef.coneTypeSafe()?.fullyExpandedType(session)?.lookupTag?.classId == classId } } @@ -201,8 +203,8 @@ fun FirGetClassCall.getTargetType(): ConeKotlinType? { return typeRef.coneType.typeArguments.getOrNull(0)?.type } -fun FirAnnotationContainer.getJvmNameFromAnnotation(target: AnnotationUseSiteTarget? = null): String? { - val annotationCalls = getAnnotationsByClassId(StandardClassIds.Annotations.JvmName) +fun FirAnnotationContainer.getJvmNameFromAnnotation(session: FirSession, target: AnnotationUseSiteTarget? = null): String? { + val annotationCalls = getAnnotationsByClassId(StandardClassIds.Annotations.JvmName, session) return annotationCalls.firstNotNullOfOrNull { call -> call.getStringArgument(StandardClassIds.Annotations.ParameterNames.jvmNameName) ?.takeIf { target == null || call.useSiteTarget == target } diff --git a/compiler/fir/providers/src/org/jetbrains/kotlin/fir/declarations/deprecationUtils.kt b/compiler/fir/providers/src/org/jetbrains/kotlin/fir/declarations/deprecationUtils.kt index 2c41c6d50d9..543fa673c9e 100644 --- a/compiler/fir/providers/src/org/jetbrains/kotlin/fir/declarations/deprecationUtils.kt +++ b/compiler/fir/providers/src/org/jetbrains/kotlin/fir/declarations/deprecationUtils.kt @@ -11,6 +11,7 @@ import org.jetbrains.kotlin.fir.FirAnnotationContainer import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.caches.FirCachesFactory +import org.jetbrains.kotlin.fir.caches.firCachesFactory import org.jetbrains.kotlin.fir.expressions.* import org.jetbrains.kotlin.fir.languageVersionSettings import org.jetbrains.kotlin.fir.references.FirNamedReference @@ -90,33 +91,36 @@ fun FirBasedSymbol<*>.getDeprecation(apiVersion: ApiVersion, callSite: FirElemen } } -fun FirAnnotationContainer.getDeprecationsProvider(firCachesFactory: FirCachesFactory): DeprecationsProvider { - return extractDeprecationInfoPerUseSite().toDeprecationsProvider(firCachesFactory) +fun FirAnnotationContainer.getDeprecationsProvider(session: FirSession): DeprecationsProvider { + return extractDeprecationInfoPerUseSite(session).toDeprecationsProvider(session.firCachesFactory) } -fun FirAnnotationContainer.extractDeprecationInfoPerUseSite(): DeprecationAnnotationInfoPerUseSiteStorage { +fun FirAnnotationContainer.extractDeprecationInfoPerUseSite(session: FirSession): DeprecationAnnotationInfoPerUseSiteStorage { val fromJava = this is FirDeclaration && this.isJavaOrEnhancement return buildDeprecationAnnotationInfoPerUseSiteStorage { - add(annotations.extractDeprecationAnnotationInfoPerUseSite(fromJava)) + add(annotations.extractDeprecationAnnotationInfoPerUseSite(session, fromJava)) if (this@extractDeprecationInfoPerUseSite is FirProperty) { - add(getDeprecationsAnnotationInfoByUseSiteFromAccessors(getter, setter)) + add(getDeprecationsAnnotationInfoByUseSiteFromAccessors(session, getter, setter)) } } } + fun getDeprecationsProviderFromAccessors( + session: FirSession, getter: FirFunction?, - setter: FirFunction?, - firCachesFactory: FirCachesFactory + setter: FirFunction? ): DeprecationsProvider { - return getDeprecationsAnnotationInfoByUseSiteFromAccessors(getter, setter).toDeprecationsProvider(firCachesFactory) + return getDeprecationsAnnotationInfoByUseSiteFromAccessors(session, getter, setter).toDeprecationsProvider(session.firCachesFactory) } + fun getDeprecationsAnnotationInfoByUseSiteFromAccessors( + session: FirSession, getter: FirFunction?, setter: FirFunction? ): DeprecationAnnotationInfoPerUseSiteStorage { return buildDeprecationAnnotationInfoPerUseSiteStorage { - val setterDeprecations = setter?.extractDeprecationInfoPerUseSite() + val setterDeprecations = setter?.extractDeprecationInfoPerUseSite(session) setterDeprecations?.storage?.forEach { (useSite, infos) -> if (useSite == null) { add(AnnotationUseSiteTarget.PROPERTY_SETTER, infos) @@ -124,7 +128,7 @@ fun getDeprecationsAnnotationInfoByUseSiteFromAccessors( add(useSite, infos) } } - val getterDeprecations = getter?.extractDeprecationInfoPerUseSite() + val getterDeprecations = getter?.extractDeprecationInfoPerUseSite(session) getterDeprecations?.storage?.forEach { (useSite, infos) -> if (useSite == null) { add(AnnotationUseSiteTarget.PROPERTY_GETTER, infos) @@ -136,11 +140,11 @@ fun getDeprecationsAnnotationInfoByUseSiteFromAccessors( } fun List.getDeprecationsProviderFromAnnotations( - fromJava: Boolean, - firCachesFactory: FirCachesFactory + session: FirSession, + fromJava: Boolean ): DeprecationsProvider { - val deprecationAnnotationByUseSite = extractDeprecationAnnotationInfoPerUseSite(fromJava) - return deprecationAnnotationByUseSite.toDeprecationsProvider(firCachesFactory) + val deprecationAnnotationByUseSite = extractDeprecationAnnotationInfoPerUseSite(session, fromJava) + return deprecationAnnotationByUseSite.toDeprecationsProvider(session.firCachesFactory) } fun FirBasedSymbol<*>.getDeprecationForCallSite( @@ -175,7 +179,7 @@ private fun FirAnnotation.getDeprecationLevel(): DeprecationLevelValue? { } private fun List.extractDeprecationAnnotationInfoPerUseSite( - fromJava: Boolean + session: FirSession, fromJava: Boolean ): DeprecationAnnotationInfoPerUseSiteStorage { @Suppress("RemoveExplicitTypeArguments") val annotations = buildList> { @@ -199,7 +203,9 @@ private fun List.extractDeprecationAnnotationInfoPerUseSite( } else { val deprecationLevel = deprecated.getDeprecationLevel() ?: DeprecationLevelValue.WARNING val propagatesToOverride = !fromJavaAnnotation && !fromJava - val deprecatedSinceKotlin = getAnnotationsByClassId(StandardClassIds.Annotations.DeprecatedSinceKotlin).firstOrNull() + val deprecatedSinceKotlin = getAnnotationsByClassId( + StandardClassIds.Annotations.DeprecatedSinceKotlin, session + ).firstOrNull() val message = deprecated.getStringArgument(ParameterNames.deprecatedMessage) val deprecatedInfo = diff --git a/compiler/fir/providers/src/org/jetbrains/kotlin/fir/resolve/LookupTagUtils.kt b/compiler/fir/providers/src/org/jetbrains/kotlin/fir/resolve/LookupTagUtils.kt index 98e305cc1a3..5123f76ef9c 100644 --- a/compiler/fir/providers/src/org/jetbrains/kotlin/fir/resolve/LookupTagUtils.kt +++ b/compiler/fir/providers/src/org/jetbrains/kotlin/fir/resolve/LookupTagUtils.kt @@ -76,11 +76,11 @@ fun FirSymbolProvider.getSymbolByLookupTag(lookupTag: ConeClassLikeLookupTag): F return lookupTag.toSymbol(session) } -fun ConeKotlinType.withParameterNameAnnotation(parameter: FirFunctionTypeParameter): ConeKotlinType { +fun ConeKotlinType.withParameterNameAnnotation(parameter: FirFunctionTypeParameter, session: FirSession): ConeKotlinType { val name = parameter.name if (name == null || name == SpecialNames.NO_NAME_PROVIDED || name == SpecialNames.UNDERSCORE_FOR_UNUSED_VAR) return this // Existing @ParameterName annotation takes precedence - if (attributes.customAnnotations.getAnnotationsByClassId(StandardNames.FqNames.parameterNameClassId).isNotEmpty()) return this + if (attributes.customAnnotations.getAnnotationsByClassId(StandardNames.FqNames.parameterNameClassId, session).isNotEmpty()) return this val fakeSource = parameter.source?.fakeElement(KtFakeSourceElementKind.ParameterNameAnnotationCall) val parameterNameAnnotationCall = buildAnnotation { diff --git a/compiler/fir/providers/src/org/jetbrains/kotlin/fir/resolve/calls/Synthetics.kt b/compiler/fir/providers/src/org/jetbrains/kotlin/fir/resolve/calls/Synthetics.kt index 172c3d8eeda..024433972df 100644 --- a/compiler/fir/providers/src/org/jetbrains/kotlin/fir/resolve/calls/Synthetics.kt +++ b/compiler/fir/providers/src/org/jetbrains/kotlin/fir/resolve/calls/Synthetics.kt @@ -6,7 +6,6 @@ package org.jetbrains.kotlin.fir.resolve.calls import org.jetbrains.kotlin.fir.* -import org.jetbrains.kotlin.fir.caches.firCachesFactory import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.synthetic.buildSyntheticProperty import org.jetbrains.kotlin.fir.declarations.utils.isStatic @@ -138,7 +137,7 @@ class FirSyntheticPropertiesScope private constructor( ) delegateGetter = getter delegateSetter = matchingSetter - deprecationsProvider = getDeprecationsProviderFromAccessors(getter, matchingSetter, session.firCachesFactory) + deprecationsProvider = getDeprecationsProviderFromAccessors(session, getter, matchingSetter) } val syntheticSymbol = property.symbol (baseScope as? FirUnstableSmartcastTypeScope)?.apply { diff --git a/compiler/fir/providers/src/org/jetbrains/kotlin/fir/resolve/providers/FirSymbolProvider.kt b/compiler/fir/providers/src/org/jetbrains/kotlin/fir/resolve/providers/FirSymbolProvider.kt index 61b361d4a60..325fe17a3f0 100644 --- a/compiler/fir/providers/src/org/jetbrains/kotlin/fir/resolve/providers/FirSymbolProvider.kt +++ b/compiler/fir/providers/src/org/jetbrains/kotlin/fir/resolve/providers/FirSymbolProvider.kt @@ -7,6 +7,7 @@ package org.jetbrains.kotlin.fir.resolve.providers import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.FirSessionComponent +import org.jetbrains.kotlin.fir.resolve.fullyExpandedType import org.jetbrains.kotlin.fir.resolve.getSymbolByLookupTag import org.jetbrains.kotlin.fir.scopes.FirScope import org.jetbrains.kotlin.fir.scopes.getDeclaredConstructors @@ -16,6 +17,7 @@ import org.jetbrains.kotlin.fir.scopes.impl.declaredMemberScope import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol import org.jetbrains.kotlin.fir.symbols.impl.* import org.jetbrains.kotlin.fir.types.ConeLookupTagBasedType +import org.jetbrains.kotlin.fir.types.ConeSimpleKotlinType import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.fir.types.coneTypeSafe import org.jetbrains.kotlin.name.ClassId @@ -78,7 +80,8 @@ fun FirSymbolProvider.getClassDeclaredPropertySymbols(classId: ClassId, name: Na } inline fun > FirSymbolProvider.getSymbolByTypeRef(typeRef: FirTypeRef): T? { - val lookupTag = typeRef.coneTypeSafe()?.lookupTag ?: return null + val lookupTag = (typeRef.coneTypeSafe()?.fullyExpandedType(session) as? ConeLookupTagBasedType)?.lookupTag + ?: return null return getSymbolByLookupTag(lookupTag) as? T } diff --git a/compiler/fir/providers/src/org/jetbrains/kotlin/fir/scopes/impl/FirFakeOverrideGenerator.kt b/compiler/fir/providers/src/org/jetbrains/kotlin/fir/scopes/impl/FirFakeOverrideGenerator.kt index 192c57800a6..69ab056b828 100644 --- a/compiler/fir/providers/src/org/jetbrains/kotlin/fir/scopes/impl/FirFakeOverrideGenerator.kt +++ b/compiler/fir/providers/src/org/jetbrains/kotlin/fir/scopes/impl/FirFakeOverrideGenerator.kt @@ -8,7 +8,6 @@ package org.jetbrains.kotlin.fir.scopes.impl import org.jetbrains.kotlin.descriptors.Modality import org.jetbrains.kotlin.descriptors.Visibility import org.jetbrains.kotlin.fir.* -import org.jetbrains.kotlin.fir.caches.firCachesFactory import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.builder.* import org.jetbrains.kotlin.fir.declarations.synthetic.FirSyntheticProperty @@ -566,7 +565,7 @@ object FirFakeOverrideGenerator { delegateGetter = getter delegateSetter = setter status = baseProperty.status - deprecationsProvider = getDeprecationsProviderFromAccessors(getter, setter, session.firCachesFactory) + deprecationsProvider = getDeprecationsProviderFromAccessors(session, getter, setter) }.apply { containingClassForStaticMemberAttr = derivedClassLookupTag.takeIf { shouldOverrideSetContainingClass(baseProperty) } }.symbol 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 ccc7aa3f2a5..03fd8e1b992 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 @@ -401,7 +401,7 @@ object CheckDslScopeViolation : ResolutionStage() { val annotationClass = annotation.annotationTypeRef.coneType.fullyExpandedType(context.session).toSymbol(context.session) as? FirClassSymbol ?: continue - if (annotationClass.hasAnnotation(dslMarkerClassId)) { + if (annotationClass.hasAnnotation(dslMarkerClassId, context.session)) { add(annotationClass.classId) } } @@ -608,7 +608,7 @@ internal object PostponedVariablesInitializerResolutionStage : ResolutionStage() // TODO: convert type argument mapping to map [FirTypeParameterSymbol, FirTypedProjection?] if (candidate.typeArgumentMapping is TypeArgumentMapping.Mapped) return for (parameter in argumentMapping.values) { - if (!parameter.hasBuilderInferenceAnnotation()) continue + if (!parameter.hasBuilderInferenceAnnotation(context.session)) continue val type = parameter.returnTypeRef.coneType val receiverType = type.receiverType(callInfo.session) ?: continue val dontUseBuilderInferenceIfPossible = @@ -665,7 +665,8 @@ internal object ProcessDynamicExtensionAnnotation : ResolutionStage() { val argumentIsDynamic = extensionReceiver.type is ConeDynamicType val parameterIsDynamic = (candidate.symbol as? FirCallableSymbol)?.resolvedReceiverTypeRef?.type is ConeDynamicType if (parameterIsDynamic != argumentIsDynamic || - parameterIsDynamic && !candidate.symbol.hasAnnotation(DYNAMIC_EXTENSION_ANNOTATION_CLASS_ID)) { + parameterIsDynamic && !candidate.symbol.hasAnnotation(DYNAMIC_EXTENSION_ANNOTATION_CLASS_ID, context.session) + ) { candidate.addDiagnostic(HiddenCandidate) } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/tower/TowerLevels.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/tower/TowerLevels.kt index d3c115f6716..7ef93aa315b 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/tower/TowerLevels.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/tower/TowerLevels.kt @@ -391,7 +391,7 @@ class ScopeTowerLevel( processor: TowerScopeLevelProcessor ) { val candidateReceiverTypeRef = candidate.fir.receiverParameter?.typeRef - if (withHideMembersOnly && candidate.getAnnotationByClassId(HidesMembers) == null) { + if (withHideMembersOnly && candidate.getAnnotationByClassId(HidesMembers, session) == null) { return } val receiverExpected = withHideMembersOnly || areThereExtensionReceiverOptions() diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/FirBuilderInferenceSession.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/FirBuilderInferenceSession.kt index 0605b917220..d4a1bfead0c 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/FirBuilderInferenceSession.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/FirBuilderInferenceSession.kt @@ -6,6 +6,7 @@ package org.jetbrains.kotlin.fir.resolve.inference import org.jetbrains.kotlin.fir.FirElement +import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.declarations.FirAnonymousFunction import org.jetbrains.kotlin.fir.declarations.FirDeclaration import org.jetbrains.kotlin.fir.declarations.hasAnnotation @@ -35,6 +36,7 @@ class FirBuilderInferenceSession( resolutionContext: ResolutionContext, private val stubsForPostponedVariables: Map, ) : FirInferenceSessionForChainedResolve(resolutionContext) { + private val session = resolutionContext.session private val commonCalls: MutableList> = mutableListOf() private var lambdaImplicitReceivers: MutableList = mutableListOf() @@ -72,7 +74,7 @@ class FirBuilderInferenceSession( return when { extensionReceiver == null && dispatchReceiver == null -> false dispatchReceiver?.type?.containsStubType() == true -> true - extensionReceiver?.type?.containsStubType() == true -> symbol.fir.hasBuilderInferenceAnnotation() + extensionReceiver?.type?.containsStubType() == true -> symbol.fir.hasBuilderInferenceAnnotation(session) else -> false } } @@ -272,4 +274,5 @@ class FirStubTypeTransformer( private val BUILDER_INFERENCE_ANNOTATION_CLASS_ID: ClassId = ClassId.topLevel(BUILDER_INFERENCE_ANNOTATION_FQ_NAME) -fun FirDeclaration.hasBuilderInferenceAnnotation(): Boolean = hasAnnotation(BUILDER_INFERENCE_ANNOTATION_CLASS_ID) +fun FirDeclaration.hasBuilderInferenceAnnotation(session: FirSession): Boolean = + hasAnnotation(BUILDER_INFERENCE_ANNOTATION_CLASS_ID, session) 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 0a28c11adba..c8bc714d771 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 @@ -467,7 +467,7 @@ class FirTypeResolverImpl(private val session: FirSession) : FirTypeResolver() { val parameters = typeRef.contextReceiverTypeRefs.map { it.coneType } + listOfNotNull(typeRef.receiverTypeRef?.coneType) + - typeRef.parameters.map { it.returnTypeRef.coneType.withParameterNameAnnotation(it) } + + typeRef.parameters.map { it.returnTypeRef.coneType.withParameterNameAnnotation(it, session) } + listOf(typeRef.returnTypeRef.coneType) val classId = if (typeRef.isSuspend) { StandardClassIds.SuspendFunctionN(typeRef.parametersCount) diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirStatusResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirStatusResolveTransformer.kt index 830696f0ec8..807741a451a 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirStatusResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirStatusResolveTransformer.kt @@ -6,7 +6,6 @@ package org.jetbrains.kotlin.fir.resolve.transformers import org.jetbrains.kotlin.fir.FirSession -import org.jetbrains.kotlin.fir.caches.firCachesFactory import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.utils.isInline import org.jetbrains.kotlin.fir.expressions.FirBlock @@ -488,7 +487,7 @@ abstract class AbstractFirStatusResolveTransformer( private fun calculateDeprecations(simpleFunction: FirCallableDeclaration) { if (simpleFunction.deprecationsProvider is UnresolvedDeprecationProvider) { - simpleFunction.replaceDeprecationsProvider(simpleFunction.getDeprecationsProvider(session.firCachesFactory)) + simpleFunction.replaceDeprecationsProvider(simpleFunction.getDeprecationsProvider(session)) } } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/AbstractFirSpecificAnnotationResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/AbstractFirSpecificAnnotationResolveTransformer.kt index bda75c89c24..89eca6f49b8 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/AbstractFirSpecificAnnotationResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/AbstractFirSpecificAnnotationResolveTransformer.kt @@ -11,7 +11,6 @@ import org.jetbrains.kotlin.fir.FirAnnotationContainer import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.PrivateForInline -import org.jetbrains.kotlin.fir.caches.firCachesFactory import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.expressions.FirAnnotation import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall @@ -194,7 +193,9 @@ internal abstract class AbstractFirSpecificAnnotationResolveTransformer( private fun calculateDeprecations(classLikeDeclaration: FirClassLikeDeclaration) { if (classLikeDeclaration.deprecationsProvider == UnresolvedDeprecationProvider) { - classLikeDeclaration.replaceDeprecationsProvider(classLikeDeclaration.getDeprecationsProvider(session.firCachesFactory)) + classLikeDeclaration.replaceDeprecationsProvider( + classLikeDeclaration.getDeprecationsProvider(session) + ) } } diff --git a/compiler/testData/codegen/box/annotations/jvmAnnotationFlags.kt b/compiler/testData/codegen/box/annotations/jvmAnnotationFlags.kt index 925e471778b..07322cc30af 100644 --- a/compiler/testData/codegen/box/annotations/jvmAnnotationFlags.kt +++ b/compiler/testData/codegen/box/annotations/jvmAnnotationFlags.kt @@ -1,8 +1,5 @@ // TARGET_BACKEND: JVM -// due to KT-55615 -// IGNORE_BACKEND_K2: JVM_IR - // WITH_STDLIB // FULL_JDK diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/Volatile.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/annotations/Volatile.fir.kt deleted file mode 100644 index d67a2392182..00000000000 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/Volatile.fir.kt +++ /dev/null @@ -1,35 +0,0 @@ -// !DIAGNOSTICS: -UNUSED_ANONYMOUS_PARAMETER -import kotlin.jvm.Volatile as JvmVolatile -import kotlin.concurrent.Volatile -import kotlin.properties.Delegates - -@OptIn(ExperimentalStdlibApi::class) -class ConcurrentVolatile { - @Volatile val x = 0 - // ok - @Volatile var y = 1 - - @delegate:Volatile var z: String by Delegates.observable("?") { prop, old, new -> old.hashCode() } - - @field:Volatile val w = 2 - - @Volatile - var noBacking: String - get() = "" - set(value) {} -} - -class JvmVolatile { - @JvmVolatile val x = 0 - // ok - @JvmVolatile var y = 1 - - @delegate:JvmVolatile var z: String by Delegates.observable("?") { prop, old, new -> old.hashCode() } - - @field:JvmVolatile val w = 2 - - @JvmVolatile - var noBacking: String - get() = "" - set(value) {} -} diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/Volatile.kt b/compiler/testData/diagnostics/testsWithStdLib/annotations/Volatile.kt index 489d4ca8bf0..e6620f7a3d4 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/Volatile.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/Volatile.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // !DIAGNOSTICS: -UNUSED_ANONYMOUS_PARAMETER import kotlin.jvm.Volatile as JvmVolatile import kotlin.concurrent.Volatile diff --git a/plugins/fir-plugin-prototype/src/org/jetbrains/kotlin/fir/plugin/SupertypeWithArgumentGenerator.kt b/plugins/fir-plugin-prototype/src/org/jetbrains/kotlin/fir/plugin/SupertypeWithArgumentGenerator.kt index 3e3b78c3d14..6fbb11dd1e5 100644 --- a/plugins/fir-plugin-prototype/src/org/jetbrains/kotlin/fir/plugin/SupertypeWithArgumentGenerator.kt +++ b/plugins/fir-plugin-prototype/src/org/jetbrains/kotlin/fir/plugin/SupertypeWithArgumentGenerator.kt @@ -42,7 +42,7 @@ class SupertypeWithArgumentGenerator(session: FirSession) : FirSupertypeGenerati ): List { if (resolvedSupertypes.any { it.type.classId == supertypeClassId }) return emptyList() - val annotation = classLikeDeclaration.getAnnotationByClassId(annotationClassId) ?: return emptyList() + val annotation = classLikeDeclaration.getAnnotationByClassId(annotationClassId, session) ?: return emptyList() val getClassArgument = (annotation as? FirAnnotationCall)?.argument as? FirGetClassCall ?: return emptyList() val typeToResolve = buildUserTypeFromQualifierParts(isMarkedNullable = false) { diff --git a/plugins/kotlinx-serialization/kotlinx-serialization.k2/src/org/jetbrains/kotlinx/serialization/compiler/fir/FirSerializableProperty.kt b/plugins/kotlinx-serialization/kotlinx-serialization.k2/src/org/jetbrains/kotlinx/serialization/compiler/fir/FirSerializableProperty.kt index 04c604248f8..073fbf152bb 100644 --- a/plugins/kotlinx-serialization/kotlinx-serialization.k2/src/org/jetbrains/kotlinx/serialization/compiler/fir/FirSerializableProperty.kt +++ b/plugins/kotlinx-serialization/kotlinx-serialization.k2/src/org/jetbrains/kotlinx/serialization/compiler/fir/FirSerializableProperty.kt @@ -21,16 +21,16 @@ class FirSerializableProperty( override val isConstructorParameterWithDefault: Boolean, declaresDefaultValue: Boolean ) : ISerializableProperty { - override val name: String = propertySymbol.serialNameValue ?: propertySymbol.name.asString() + override val name: String = propertySymbol.getSerialNameValue(session) ?: propertySymbol.name.asString() override val originalDescriptorName: Name get() = propertySymbol.name - override val optional: Boolean = !propertySymbol.serialRequired && declaresDefaultValue + override val optional: Boolean = !propertySymbol.getSerialRequired(session) && declaresDefaultValue - override val transient: Boolean = propertySymbol.hasSerialTransient || !propertySymbol.hasBackingField + override val transient: Boolean = propertySymbol.hasSerialTransient(session) || !propertySymbol.hasBackingField - val serializableWith: ConeKotlinType? = propertySymbol.serializableWith + val serializableWith: ConeKotlinType? = propertySymbol.getSerializableWith(session) ?: analyzeSpecialSerializers(session, propertySymbol.resolvedAnnotationsWithArguments)?.defaultType() } diff --git a/plugins/kotlinx-serialization/kotlinx-serialization.k2/src/org/jetbrains/kotlinx/serialization/compiler/fir/SerializationFirSupertypesExtension.kt b/plugins/kotlinx-serialization/kotlinx-serialization.k2/src/org/jetbrains/kotlinx/serialization/compiler/fir/SerializationFirSupertypesExtension.kt index 324432c2025..a5a5c3a0508 100644 --- a/plugins/kotlinx-serialization/kotlinx-serialization.k2/src/org/jetbrains/kotlinx/serialization/compiler/fir/SerializationFirSupertypesExtension.kt +++ b/plugins/kotlinx-serialization/kotlinx-serialization.k2/src/org/jetbrains/kotlinx/serialization/compiler/fir/SerializationFirSupertypesExtension.kt @@ -46,7 +46,7 @@ class SerializationFirSupertypesExtension(session: FirSession) : FirSupertypeGen if (resolvedSupertypes.any { it.type.classId == kSerializerClassId || it.type.classId == generatedSerializerClassId }) return emptyList() return if (session.predicateBasedProvider.matches(serializerFor, classLikeDeclaration)) { - val getClassArgument = classLikeDeclaration.serializerFor ?: return emptyList() + val getClassArgument = classLikeDeclaration.getSerializerFor(session) ?: return emptyList() val serializerConeType = resolveConeTypeFromArgument(getClassArgument) listOf( diff --git a/plugins/kotlinx-serialization/kotlinx-serialization.k2/src/org/jetbrains/kotlinx/serialization/compiler/fir/SerializationFirUtils.kt b/plugins/kotlinx-serialization/kotlinx-serialization.k2/src/org/jetbrains/kotlinx/serialization/compiler/fir/SerializationFirUtils.kt index 69110cfd3c0..0d142e86c9b 100644 --- a/plugins/kotlinx-serialization/kotlinx-serialization.k2/src/org/jetbrains/kotlinx/serialization/compiler/fir/SerializationFirUtils.kt +++ b/plugins/kotlinx-serialization/kotlinx-serialization.k2/src/org/jetbrains/kotlinx/serialization/compiler/fir/SerializationFirUtils.kt @@ -39,43 +39,45 @@ object AnnotationParameterNames { // ---------------------- annotations utils ---------------------- +context(FirSession) val FirBasedSymbol<*>.isSerialInfoAnnotation: Boolean - get() = hasAnnotation(serialInfoClassId) - || hasAnnotation(inheritableSerialInfoClassId) - || hasAnnotation(metaSerializableAnnotationClassId) + get() = hasAnnotation(serialInfoClassId, this@FirSession) + || hasAnnotation(inheritableSerialInfoClassId, this@FirSession) + || hasAnnotation(metaSerializableAnnotationClassId, this@FirSession) -val FirBasedSymbol<*>.isInheritableSerialInfoAnnotation: Boolean - get() = hasAnnotation(inheritableSerialInfoClassId) +fun FirBasedSymbol<*>.isInheritableSerialInfoAnnotation(session: FirSession): Boolean = + hasAnnotation(inheritableSerialInfoClassId, session) -val FirBasedSymbol<*>.serialNameAnnotation: FirAnnotation? - get() = resolvedAnnotationsWithArguments.getAnnotationByClassId(serialNameAnnotationClassId) +fun FirBasedSymbol<*>.getSerialNameAnnotation(session: FirSession): FirAnnotation? = + resolvedAnnotationsWithArguments.getAnnotationByClassId(serialNameAnnotationClassId, session) -val FirBasedSymbol<*>.serialNameValue: String? - get() = serialNameAnnotation?.getStringArgument(AnnotationParameterNames.VALUE) +fun FirBasedSymbol<*>.getSerialNameValue(session: FirSession): String? = + getSerialNameAnnotation(session)?.getStringArgument(AnnotationParameterNames.VALUE) -val FirBasedSymbol<*>.serialRequired: Boolean - get() = hasAnnotation(SerializationAnnotations.requiredAnnotationClassId) +fun FirBasedSymbol<*>.getSerialRequired(session: FirSession): Boolean = + hasAnnotation(SerializationAnnotations.requiredAnnotationClassId, session) -val FirBasedSymbol<*>.hasSerialTransient: Boolean - get() = serialTransientAnnotation != null +fun FirBasedSymbol<*>.hasSerialTransient(session: FirSession): Boolean = getSerialTransientAnnotation(session) != null -val FirBasedSymbol<*>.serialTransientAnnotation: FirAnnotation? - get() = getAnnotationByClassId(SerializationAnnotations.serialTransientClassId) +fun FirBasedSymbol<*>.getSerialTransientAnnotation(session: FirSession): FirAnnotation? = + getAnnotationByClassId(SerializationAnnotations.serialTransientClassId, session) +context(FirSession) +@Suppress("IncorrectFormatting") // KTIJ-22227 val FirClassSymbol<*>.hasSerializableAnnotation: Boolean - get() = serializableAnnotation(needArguments = false) != null + get() = serializableAnnotation(needArguments = false, this@FirSession) != null -fun FirBasedSymbol<*>.serializableAnnotation(needArguments: Boolean): FirAnnotation? { +fun FirBasedSymbol<*>.serializableAnnotation(needArguments: Boolean, session: FirSession): FirAnnotation? { val annotations = if (needArguments) resolvedAnnotationsWithClassIds else resolvedAnnotationsWithArguments - return annotations.serializableAnnotation() + return annotations.serializableAnnotation(session) } -fun List.serializableAnnotation(): FirAnnotation? { - return getAnnotationByClassId(SerializationAnnotations.serializableAnnotationClassId) +fun List.serializableAnnotation(session: FirSession): FirAnnotation? { + return getAnnotationByClassId(SerializationAnnotations.serializableAnnotationClassId, session) } -val FirClassSymbol<*>.hasSerializableAnnotationWithoutArgs: Boolean - get() = serializableAnnotation(needArguments = false)?.let { +fun FirClassSymbol<*>.hasSerializableAnnotationWithoutArgs(session: FirSession): Boolean = + serializableAnnotation(needArguments = false, session)?.let { if (it is FirAnnotationCall) { it.arguments.isEmpty() } else { @@ -83,27 +85,26 @@ val FirClassSymbol<*>.hasSerializableAnnotationWithoutArgs: Boolean } } ?: false -internal val FirBasedSymbol<*>.serializableWith: ConeKotlinType? - get() = serializableAnnotation(needArguments = true)?.getKClassArgument(AnnotationParameterNames.WITH) +internal fun FirBasedSymbol<*>.getSerializableWith(session: FirSession): ConeKotlinType? = + serializableAnnotation(needArguments = true, session)?.getKClassArgument(AnnotationParameterNames.WITH) -internal val List.serializableWith: ConeKotlinType? - get() = serializableAnnotation()?.getKClassArgument(AnnotationParameterNames.WITH) +internal fun List.getSerializableWith(session: FirSession): ConeKotlinType? = + serializableAnnotation(session)?.getKClassArgument(AnnotationParameterNames.WITH) fun FirAnnotation.getGetKClassArgument(name: Name): FirGetClassCall? { return findArgumentByName(name) as? FirGetClassCall } -internal val FirClassSymbol<*>.serializerAnnotation: FirAnnotation? - get() = getAnnotationByClassId(SerializationAnnotations.serializerAnnotationClassId) +internal fun FirClassSymbol<*>.getSerializerAnnotation(session: FirSession): FirAnnotation? = + getAnnotationByClassId(SerializationAnnotations.serializerAnnotationClassId, session) // ---------------------- class utils ---------------------- -internal val FirClassSymbol<*>.serializerForClass: ConeKotlinType? - get() = resolvedAnnotationsWithArguments - .getAnnotationByClassId(SerializationAnnotations.serializerAnnotationClassId) - ?.getKClassArgument(AnnotationParameterNames.FOR_CLASS) +internal fun FirClassSymbol<*>.getSerializerForClass(session: FirSession): ConeKotlinType? = resolvedAnnotationsWithArguments + .getAnnotationByClassId(SerializationAnnotations.serializerAnnotationClassId, session) + ?.getKClassArgument(AnnotationParameterNames.FOR_CLASS) -internal val FirClassLikeDeclaration.serializerFor: FirGetClassCall? - get() = getAnnotationByClassId(SerializationAnnotations.serializerAnnotationClassId) +internal fun FirClassLikeDeclaration.getSerializerFor(session: FirSession): FirGetClassCall? = + getAnnotationByClassId(SerializationAnnotations.serializerAnnotationClassId, session) ?.getGetKClassArgument(AnnotationParameterNames.FOR_CLASS) context(FirSession) @@ -147,7 +148,8 @@ internal val FirClassSymbol<*>.isInternalSerializable: Boolean context(FirSession) val FirClassSymbol<*>.hasSerializableOrMetaAnnotationWithoutArgs: Boolean - get() = hasSerializableAnnotationWithoutArgs || (!hasSerializableAnnotation && hasMetaSerializableAnnotation) + get() = hasSerializableAnnotationWithoutArgs(this@FirSession) || + (!hasSerializableAnnotation && hasMetaSerializableAnnotation) context(FirSession) @Suppress("IncorrectFormatting") // KTIJ-22227 diff --git a/plugins/kotlinx-serialization/kotlinx-serialization.k2/src/org/jetbrains/kotlinx/serialization/compiler/fir/checkers/FirSerializationPluginClassChecker.kt b/plugins/kotlinx-serialization/kotlinx-serialization.k2/src/org/jetbrains/kotlinx/serialization/compiler/fir/checkers/FirSerializationPluginClassChecker.kt index 85113b8f576..093c5eef118 100644 --- a/plugins/kotlinx-serialization/kotlinx-serialization.k2/src/org/jetbrains/kotlinx/serialization/compiler/fir/checkers/FirSerializationPluginClassChecker.kt +++ b/plugins/kotlinx-serialization/kotlinx-serialization.k2/src/org/jetbrains/kotlinx/serialization/compiler/fir/checkers/FirSerializationPluginClassChecker.kt @@ -9,7 +9,6 @@ import org.jetbrains.kotlin.KtSourceElement import org.jetbrains.kotlin.config.KotlinCompilerVersion import org.jetbrains.kotlin.descriptors.ClassKind import org.jetbrains.kotlin.diagnostics.* -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirClassChecker import org.jetbrains.kotlin.fir.analysis.checkers.isSingleFieldValueClass @@ -20,7 +19,6 @@ import org.jetbrains.kotlin.fir.expressions.* import org.jetbrains.kotlin.fir.moduleData import org.jetbrains.kotlin.fir.resolve.defaultType import org.jetbrains.kotlin.fir.resolve.fullyExpandedType -import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol import org.jetbrains.kotlin.fir.symbols.impl.* import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.name.* @@ -28,7 +26,7 @@ import org.jetbrains.kotlin.resolve.jvm.annotations.TRANSIENT_ANNOTATION_CLASS_I import org.jetbrains.kotlin.types.AbstractTypeChecker import org.jetbrains.kotlinx.serialization.compiler.diagnostic.RuntimeVersions import org.jetbrains.kotlinx.serialization.compiler.fir.* -import org.jetbrains.kotlinx.serialization.compiler.fir.serializerForClass +import org.jetbrains.kotlinx.serialization.compiler.fir.getSerializerForClass import org.jetbrains.kotlinx.serialization.compiler.fir.services.dependencySerializationInfoProvider import org.jetbrains.kotlinx.serialization.compiler.fir.services.findTypeSerializerOrContextUnchecked import org.jetbrains.kotlinx.serialization.compiler.fir.services.serializablePropertiesProvider @@ -73,11 +71,11 @@ object FirSerializationPluginClassChecker : FirClassChecker() { context(CheckerContext) @Suppress("IncorrectFormatting") // KTIJ-22227 private fun checkExternalSerializer(classSymbol: FirClassSymbol<*>, reporter: DiagnosticReporter) { - val serializableKType = classSymbol.serializerForClass ?: return + val serializableKType = classSymbol.getSerializerForClass(session) ?: return val serializableClassSymbol = serializableKType.toRegularClassSymbol(session) ?: return val properties = session.serializablePropertiesProvider.getSerializablePropertiesForClass(serializableClassSymbol) if (!properties.isExternallySerializable) { - val source = classSymbol.serializerAnnotation?.source ?: classSymbol.source + val source = classSymbol.getSerializerAnnotation(session)?.source ?: classSymbol.source val error = if (serializableClassSymbol.moduleData == session.moduleData) { FirSerializationErrors.EXTERNAL_CLASS_NOT_SERIALIZABLE } else { @@ -93,7 +91,7 @@ object FirSerializationPluginClassChecker : FirClassChecker() { private fun checkInheritedAnnotations(classSymbol: FirClassSymbol<*>, reporter: DiagnosticReporter) { fun annotationsFilter(annotations: List): List> { return annotations - .filter { it.annotationTypeRef.toRegularClassSymbol(session)?.isInheritableSerialInfoAnnotation == true } + .filter { it.annotationTypeRef.toRegularClassSymbol(session)?.isInheritableSerialInfoAnnotation(session) == true } .mapNotNull { annotation -> annotation.classId?.let { it to annotation } } } @@ -196,7 +194,7 @@ object FirSerializationPluginClassChecker : FirClassChecker() { if (classSymbol.resolvedSuperTypes.any { it.classId == JAVA_SERIALIZABLE_ID }) return // do not check for (property in properties) { if (property.transient) continue - val incorrectTransient = property.propertySymbol.annotations.getAnnotationByClassId(TRANSIENT_ANNOTATION_CLASS_ID) + val incorrectTransient = property.propertySymbol.annotations.getAnnotationByClassId(TRANSIENT_ANNOTATION_CLASS_ID, session) if (incorrectTransient != null) { reporter.reportOn( source = incorrectTransient.source ?: property.propertySymbol.source, @@ -277,8 +275,8 @@ object FirSerializationPluginClassChecker : FirClassChecker() { private fun checkCompanionSerializerDependency(classSymbol: FirClassSymbol<*>, reporter: DiagnosticReporter) = with(session) { if (classSymbol !is FirRegularClassSymbol) return val companionObjectSymbol = classSymbol.companionObjectSymbol ?: return - val serializerForInCompanion = companionObjectSymbol.serializerForClass?.toRegularClassSymbol(session) ?: return - val serializableWith: ConeKotlinType? = classSymbol.serializableWith + val serializerForInCompanion = companionObjectSymbol.getSerializerForClass(session)?.toRegularClassSymbol(session) ?: return + val serializableWith: ConeKotlinType? = classSymbol.getSerializableWith(session) if (classSymbol.hasSerializableOrMetaAnnotationWithoutArgs) { if (serializerForInCompanion.classId == classSymbol.classId) { // @Serializable class Foo / @Serializer(Foo::class) companion object — prohibited due to problems with recursive resolve @@ -289,7 +287,7 @@ object FirSerializationPluginClassChecker : FirClassChecker() { ) } else { // @Serializable class Foo / @Serializer(Bar::class) companion object — prohibited as vague and confusing - val source = companionObjectSymbol.serializerAnnotation?.source + val source = companionObjectSymbol.getSerializerAnnotation(session)?.source reporter.reportOn( source, FirSerializationErrors.COMPANION_OBJECT_SERIALIZER_INSIDE_OTHER_SERIALIZABLE_CLASS, @@ -303,7 +301,7 @@ object FirSerializationPluginClassChecker : FirClassChecker() { } else { // @Serializable(anySer) class Foo / @Serializer(anyOtherClass) companion object — prohibited as vague and confusing reporter.reportOn( - companionObjectSymbol.serializerAnnotation?.source, + companionObjectSymbol.getSerializerAnnotation(session)?.source, FirSerializationErrors.COMPANION_OBJECT_SERIALIZER_INSIDE_OTHER_SERIALIZABLE_CLASS, classSymbol.defaultType(), serializerForInCompanion.defaultType() @@ -312,7 +310,7 @@ object FirSerializationPluginClassChecker : FirClassChecker() { } else { // (regular) class Foo / @Serializer(something) companion object - not recommended reporter.reportOn( - companionObjectSymbol.serializerAnnotation?.source, + companionObjectSymbol.getSerializerAnnotation(session)?.source, FirSerializationErrors.COMPANION_OBJECT_SERIALIZER_INSIDE_NON_SERIALIZABLE_CLASS, classSymbol.defaultType(), serializerForInCompanion.defaultType() @@ -324,7 +322,7 @@ object FirSerializationPluginClassChecker : FirClassChecker() { context(CheckerContext) @Suppress("IncorrectFormatting") // KTIJ-22227 private fun checkClassWithCustomSerializer(classSymbol: FirClassSymbol<*>, reporter: DiagnosticReporter) { - val serializerType = classSymbol.serializableWith?.fullyExpandedType(session) ?: return + val serializerType = classSymbol.getSerializableWith(session)?.fullyExpandedType(session) ?: return checkCustomSerializerMatch(classSymbol, source = null, classSymbol.defaultType(), serializerType, reporter) checkCustomSerializerIsNotLocal(source = null, classSymbol, serializerType, reporter) } @@ -343,12 +341,12 @@ object FirSerializationPluginClassChecker : FirClassChecker() { if (!classSymbol.isEnumClass) return val entryBySerialName = mutableMapOf() for (enumEntrySymbol in classSymbol.collectEnumEntries()) { - val serialNameAnnotation = enumEntrySymbol.serialNameAnnotation + val serialNameAnnotation = enumEntrySymbol.getSerialNameAnnotation(session) val serialName = serialNameAnnotation?.getStringArgument(AnnotationParameterNames.VALUE) ?: enumEntrySymbol.name.asString() val firstEntry = entryBySerialName[serialName] if (firstEntry != null) { reporter.reportOn( - source = serialNameAnnotation?.source ?: firstEntry.serialNameAnnotation?.source ?: enumEntrySymbol.source, + source = serialNameAnnotation?.source ?: firstEntry.getSerialNameAnnotation(session)?.source ?: enumEntrySymbol.source, FirSerializationErrors.DUPLICATE_SERIAL_NAME_ENUM, classSymbol, serialName, @@ -394,7 +392,7 @@ object FirSerializationPluginClassChecker : FirClassChecker() { private fun checkTransients(classSymbol: FirClassSymbol<*>, reporter: DiagnosticReporter) { for (propertySymbol in classSymbol.declarationSymbols.filterIsInstance()) { val isInitialized = propertySymbol.isLateInit || declarationHasInitializer(propertySymbol) - val transientAnnotation = propertySymbol.serialTransientAnnotation ?: continue + val transientAnnotation = propertySymbol.getSerialTransientAnnotation(session) ?: continue val hasBackingField = propertySymbol.hasBackingField if (!hasBackingField) { reporter.reportOn(transientAnnotation.source ?: propertySymbol.source, FirSerializationErrors.TRANSIENT_IS_REDUNDANT) @@ -441,7 +439,7 @@ object FirSerializationPluginClassChecker : FirClassChecker() { reporter ) checkCustomSerializerIsNotLocal( - source = propertySymbol.serializableAnnotation(needArguments = false)?.source, + source = propertySymbol.serializableAnnotation(needArguments = false, session)?.source, classSymbol, customSerializerType, reporter diff --git a/plugins/kotlinx-serialization/kotlinx-serialization.k2/src/org/jetbrains/kotlinx/serialization/compiler/fir/checkers/SerializationFirCheckerUtils.kt b/plugins/kotlinx-serialization/kotlinx-serialization.k2/src/org/jetbrains/kotlinx/serialization/compiler/fir/checkers/SerializationFirCheckerUtils.kt index 71ec1f4e850..11cae278c1e 100644 --- a/plugins/kotlinx-serialization/kotlinx-serialization.k2/src/org/jetbrains/kotlinx/serialization/compiler/fir/checkers/SerializationFirCheckerUtils.kt +++ b/plugins/kotlinx-serialization/kotlinx-serialization.k2/src/org/jetbrains/kotlinx/serialization/compiler/fir/checkers/SerializationFirCheckerUtils.kt @@ -32,7 +32,7 @@ import org.jetbrains.kotlin.fir.types.toRegularClassSymbol import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.name.StandardClassIds import org.jetbrains.kotlinx.serialization.compiler.fir.* -import org.jetbrains.kotlinx.serialization.compiler.fir.serializableWith +import org.jetbrains.kotlinx.serialization.compiler.fir.getSerializableWith import org.jetbrains.kotlinx.serialization.compiler.fir.services.dependencySerializationInfoProvider import org.jetbrains.kotlinx.serialization.compiler.resolve.SerialEntityNames import org.jetbrains.kotlinx.serialization.compiler.resolve.SerializationAnnotations @@ -46,7 +46,7 @@ internal val FirClassSymbol<*>?.classSerializer: FirClassSymbol<*>? get() { if (this == null) return null // serializer annotation on class? - serializableWith?.let { return it.toRegularClassSymbol(session) } + getSerializableWith(session)?.let { return it.toRegularClassSymbol(session) } // companion object serializer? if (this is FirRegularClassSymbol && with(session) { isInternallySerializableObject }) return companionObjectSymbol // can infer @Poly? @@ -93,7 +93,7 @@ internal val FirAnnotation.annotationClassSymbol: FirRegularClassSymbol? context(CheckerContext) @Suppress("IncorrectFormatting") // KTIJ-22227 internal val FirAnnotation.isMetaSerializableAnnotation: Boolean - get() = annotationClassSymbol?.hasAnnotation(SerializationAnnotations.metaSerializableAnnotationClassId) ?: false + get() = annotationClassSymbol?.hasAnnotation(SerializationAnnotations.metaSerializableAnnotationClassId, session) ?: false context(CheckerContext) @@ -107,7 +107,7 @@ context(CheckerContext) @Suppress("IncorrectFormatting") // KTIJ-22227 internal val FirClassSymbol<*>.serializableOrMetaAnnotationSource: KtSourceElement? get() { - serializableAnnotation(needArguments = false)?.source?.let { return it } + serializableAnnotation(needArguments = false, session)?.source?.let { return it } metaSerializableAnnotation(needArguments = false)?.source?.let { return it } return null } @@ -115,7 +115,9 @@ internal val FirClassSymbol<*>.serializableOrMetaAnnotationSource: KtSourceEleme context(CheckerContext) @Suppress("IncorrectFormatting") // KTIJ-22227 internal val FirBasedSymbol<*>.hasAnySerialAnnotation: Boolean - get() = serialNameValue != null || resolvedAnnotationsWithClassIds.any { it.annotationClassSymbol?.isSerialInfoAnnotation == true } + get() = getSerialNameValue(session) != null || resolvedAnnotationsWithClassIds.any { + with(session) { it.annotationClassSymbol?.isSerialInfoAnnotation == true } + } // ---------------------- class utils ---------------------- @@ -155,13 +157,13 @@ internal val FirClassSymbol<*>.serializableAnnotationIsUseless: Boolean context(CheckerContext) @Suppress("IncorrectFormatting") // KTIJ-22227 internal val ConeKotlinType.serializableWith: ConeKotlinType? - get() = customAnnotations.serializableWith ?: toRegularClassSymbol(session)?.serializableWith + get() = customAnnotations.getSerializableWith(session) ?: toRegularClassSymbol(session)?.getSerializableWith(session) context(CheckerContext) @Suppress("IncorrectFormatting") // KTIJ-22227 internal val ConeKotlinType.overriddenSerializer: ConeKotlinType? - get() = toRegularClassSymbol(session)?.serializableWith + get() = toRegularClassSymbol(session)?.getSerializableWith(session) // ---------------------- others ---------------------- diff --git a/plugins/kotlinx-serialization/kotlinx-serialization.k2/src/org/jetbrains/kotlinx/serialization/compiler/fir/services/ContextualSerializersProvider.kt b/plugins/kotlinx-serialization/kotlinx-serialization.k2/src/org/jetbrains/kotlinx/serialization/compiler/fir/services/ContextualSerializersProvider.kt index 44eed55b020..63473975630 100644 --- a/plugins/kotlinx-serialization/kotlinx-serialization.k2/src/org/jetbrains/kotlinx/serialization/compiler/fir/services/ContextualSerializersProvider.kt +++ b/plugins/kotlinx-serialization/kotlinx-serialization.k2/src/org/jetbrains/kotlinx/serialization/compiler/fir/services/ContextualSerializersProvider.kt @@ -63,7 +63,9 @@ class ContextualSerializersProvider(session: FirSession) : FirExtensionSessionCo } private fun getKClassListFromFileAnnotation(file: FirFile, annotationClassId: ClassId): List { - val annotation = file.symbol.resolvedAnnotationsWithArguments.getAnnotationByClassId(annotationClassId) ?: return emptyList() + val annotation = file.symbol.resolvedAnnotationsWithArguments.getAnnotationByClassId( + annotationClassId, session + ) ?: return emptyList() val arguments = when (val argument = annotation.argumentMapping.mapping.values.firstOrNull()) { is FirArrayOfCall -> argument.arguments is FirVarargArgumentsExpression -> argument.arguments @@ -79,7 +81,7 @@ context(CheckerContext) fun findTypeSerializerOrContextUnchecked(type: ConeKotlinType): FirClassSymbol<*>? { if (type.isTypeParameter) return null val annotations = type.fullyExpandedType(session).customAnnotations - annotations.serializableWith?.let { return it.toRegularClassSymbol(session) } + annotations.getSerializableWith(session)?.let { return it.toRegularClassSymbol(session) } val classSymbol = type.toRegularClassSymbol(session) ?: return null val currentFile = currentFile val provider = session.contextualSerializersProvider @@ -98,12 +100,12 @@ fun findTypeSerializerOrContextUnchecked(type: ConeKotlinType): FirClassSymbol<* * if [annotations] contains @Contextual or @Polymorphic annotation */ fun analyzeSpecialSerializers(session: FirSession, annotations: List): FirClassSymbol<*>? = when { - annotations.hasAnnotation(SerializationAnnotations.contextualClassId) || - annotations.hasAnnotation(SerializationAnnotations.contextualOnPropertyClassId) -> { + annotations.hasAnnotation(SerializationAnnotations.contextualClassId, session) || + annotations.hasAnnotation(SerializationAnnotations.contextualOnPropertyClassId, session) -> { session.dependencySerializationInfoProvider.getClassFromSerializationPackage(SpecialBuiltins.Names.contextSerializer) } // can be annotation on type usage, e.g. List<@Polymorphic Any> - annotations.hasAnnotation(SerializationAnnotations.polymorphicClassId) -> { + annotations.hasAnnotation(SerializationAnnotations.polymorphicClassId, session) -> { session.dependencySerializationInfoProvider.getClassFromSerializationPackage(SpecialBuiltins.Names.polymorphicSerializer) } diff --git a/plugins/kotlinx-serialization/kotlinx-serialization.k2/src/org/jetbrains/kotlinx/serialization/compiler/fir/services/FirSerializablePropertiesProvider.kt b/plugins/kotlinx-serialization/kotlinx-serialization.k2/src/org/jetbrains/kotlinx/serialization/compiler/fir/services/FirSerializablePropertiesProvider.kt index 6d56497f067..c4e94bcdfa2 100644 --- a/plugins/kotlinx-serialization/kotlinx-serialization.k2/src/org/jetbrains/kotlinx/serialization/compiler/fir/services/FirSerializablePropertiesProvider.kt +++ b/plugins/kotlinx-serialization/kotlinx-serialization.k2/src/org/jetbrains/kotlinx/serialization/compiler/fir/services/FirSerializablePropertiesProvider.kt @@ -57,9 +57,9 @@ class FirSerializablePropertiesProvider(session: FirSession) : FirExtensionSessi fun isPropertySerializable(propertySymbol: FirPropertySymbol): Boolean { return when { - isInternalSerializable -> !propertySymbol.hasSerialTransient + isInternalSerializable -> !propertySymbol.hasSerialTransient(session) propertySymbol.visibility == Visibilities.Private -> false - else -> (propertySymbol.isVar && propertySymbol.hasSerialTransient) || propertySymbol in primaryConstructorProperties + else -> (propertySymbol.isVar && propertySymbol.hasSerialTransient(session)) || propertySymbol in primaryConstructorProperties } } 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 30af1fb50f9..d33bd7e8cf9 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 @@ -33,15 +33,16 @@ import org.jetbrains.kotlin.parcelize.ParcelizeNames.PARCELER_ID object FirParcelizePropertyChecker : FirPropertyChecker() { override fun check(declaration: FirProperty, context: CheckerContext, reporter: DiagnosticReporter) { - val containingClassSymbol = declaration.dispatchReceiverType?.toRegularClassSymbol(context.session) ?: return + val session = context.session + val containingClassSymbol = declaration.dispatchReceiverType?.toRegularClassSymbol(session) ?: return - if (containingClassSymbol.isParcelize(context.session)) { + if (containingClassSymbol.isParcelize(session)) { val fromPrimaryConstructor = declaration.fromPrimaryConstructor ?: false if ( !fromPrimaryConstructor && (declaration.hasBackingField || declaration.delegate != null) && !declaration.hasIgnoredOnParcel() && - !containingClassSymbol.hasCustomParceler(context.session) + !containingClassSymbol.hasCustomParceler(session) ) { reporter.reportOn(declaration.source, KtErrorsParcelize.PROPERTY_WONT_BE_SERIALIZED, context) } @@ -50,9 +51,9 @@ object FirParcelizePropertyChecker : FirPropertyChecker() { } } - if (declaration.name == CREATOR_NAME && containingClassSymbol.isCompanion && declaration.hasJvmFieldAnnotation) { + if (declaration.name == CREATOR_NAME && containingClassSymbol.isCompanion && declaration.hasJvmFieldAnnotation(session)) { val outerClass = context.containingDeclarations.asReversed().getOrNull(1) as? FirRegularClass - if (outerClass != null && outerClass.symbol.isParcelize(context.session)) { + if (outerClass != null && outerClass.symbol.isParcelize(session)) { reporter.reportOn(declaration.source, KtErrorsParcelize.CREATOR_DEFINITION_IS_NOT_ALLOWED, context) } }