diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/renderer/FirIdeRenderer.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/renderer/FirIdeRenderer.kt index 4bbba78836a..801f9fa2c36 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/renderer/FirIdeRenderer.kt +++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/renderer/FirIdeRenderer.kt @@ -5,12 +5,16 @@ package org.jetbrains.kotlin.analysis.api.fir.renderer +import org.jetbrains.kotlin.analysis.api.components.KtDeclarationRendererOptions +import org.jetbrains.kotlin.analysis.api.components.RendererModifier +import org.jetbrains.kotlin.analysis.api.fir.types.PublicTypeApproximator import org.jetbrains.kotlin.descriptors.ClassKind import org.jetbrains.kotlin.descriptors.Modality import org.jetbrains.kotlin.descriptors.Visibilities import org.jetbrains.kotlin.descriptors.Visibility import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.FirSession +import org.jetbrains.kotlin.fir.analysis.checkers.PsiSourceNavigator.getRawName import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.utils.* import org.jetbrains.kotlin.fir.expressions.FirAnnotation @@ -18,10 +22,6 @@ import org.jetbrains.kotlin.fir.expressions.FirBlock import org.jetbrains.kotlin.fir.resolve.defaultType import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.fir.visitors.FirVisitor -import org.jetbrains.kotlin.analysis.api.components.KtDeclarationRendererOptions -import org.jetbrains.kotlin.analysis.api.components.RendererModifier -import org.jetbrains.kotlin.analysis.api.fir.types.PublicTypeApproximator -import org.jetbrains.kotlin.fir.analysis.checkers.PsiSourceNavigator.getRawName import org.jetbrains.kotlin.name.SpecialNames import org.jetbrains.kotlin.name.StandardClassIds import org.jetbrains.kotlin.renderer.render @@ -37,7 +37,7 @@ internal class FirIdeRenderer private constructor( private val typeIdeRenderer: ConeTypeIdeRenderer = ConeTypeIdeRenderer(session, options.typeRendererOptions) - private fun StringBuilder.renderAnnotations(annotated: FirAnnotatedDeclaration) { + private fun StringBuilder.renderAnnotations(annotated: FirDeclaration) { if (RendererModifier.ANNOTATIONS in options.modifiers) { renderAnnotations(typeIdeRenderer, annotated.annotations, session) } diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/annotations/firAnnotationUtils.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/annotations/firAnnotationUtils.kt index 89882d0de92..fa220d595fd 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/annotations/firAnnotationUtils.kt +++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/annotations/firAnnotationUtils.kt @@ -8,31 +8,31 @@ package org.jetbrains.kotlin.analysis.api.fir.symbols.annotations import org.jetbrains.kotlin.analysis.api.fir.utils.FirRefWithValidityCheck import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.ResolveType import org.jetbrains.kotlin.fir.FirSession -import org.jetbrains.kotlin.fir.declarations.FirAnnotatedDeclaration -import org.jetbrains.kotlin.fir.resolve.fullyExpandedType -import org.jetbrains.kotlin.fir.types.classId +import org.jetbrains.kotlin.fir.declarations.FirDeclaration import org.jetbrains.kotlin.fir.declarations.FirRegularClass -import org.jetbrains.kotlin.fir.declarations.resolved import org.jetbrains.kotlin.fir.declarations.primaryConstructorIfAny +import org.jetbrains.kotlin.fir.declarations.resolved import org.jetbrains.kotlin.fir.expressions.* +import org.jetbrains.kotlin.fir.resolve.fullyExpandedType import org.jetbrains.kotlin.fir.resolve.toSymbol 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.name.ClassId internal fun FirAnnotation.getClassId(session: FirSession): ClassId? = coneClassLikeType?.fullyExpandedType(session)?.classId -internal fun FirRefWithValidityCheck.toAnnotationsList() = withFir { fir -> +internal fun FirRefWithValidityCheck.toAnnotationsList() = withFir { fir -> fir.annotations.map { KtFirAnnotationCall(this, it) } } -internal fun FirRefWithValidityCheck.containsAnnotation(classId: ClassId): Boolean = +internal fun FirRefWithValidityCheck.containsAnnotation(classId: ClassId): Boolean = withFirByType(ResolveType.AnnotationType) { fir -> fir.annotations.any { it.getClassId(fir.moduleData.session) == classId } } -internal fun FirRefWithValidityCheck.getAnnotationClassIds(): Collection = +internal fun FirRefWithValidityCheck.getAnnotationClassIds(): Collection = withFirByType(ResolveType.AnnotationType) { fir -> fir.annotations.mapNotNull { it.getClassId(fir.moduleData.session) } } diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/providers/FirIdeBuiltinsAndCloneableSessionProvider.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/providers/FirIdeBuiltinsAndCloneableSessionProvider.kt index 26834b0ee68..b32c29a8709 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/providers/FirIdeBuiltinsAndCloneableSessionProvider.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/providers/FirIdeBuiltinsAndCloneableSessionProvider.kt @@ -5,7 +5,10 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.providers -import org.jetbrains.kotlin.fir.declarations.* +import org.jetbrains.kotlin.fir.declarations.FirClassLikeDeclaration +import org.jetbrains.kotlin.fir.declarations.FirDeclaration +import org.jetbrains.kotlin.fir.declarations.FirFile +import org.jetbrains.kotlin.fir.declarations.FirRegularClass import org.jetbrains.kotlin.fir.resolve.providers.FirProvider import org.jetbrains.kotlin.fir.resolve.providers.FirProviderInternals import org.jetbrains.kotlin.fir.resolve.providers.FirSymbolProvider @@ -25,10 +28,10 @@ internal class FirIdeBuiltinsAndCloneableSessionProvider(override val symbolProv override fun getFirFilesByPackage(fqName: FqName): List = emptyList() @FirProviderInternals - override fun recordGeneratedClass(owner: FirAnnotatedDeclaration, klass: FirRegularClass) = shouldNotBeCalled() + override fun recordGeneratedClass(owner: FirDeclaration, klass: FirRegularClass) = shouldNotBeCalled() @FirProviderInternals - override fun recordGeneratedMember(owner: FirAnnotatedDeclaration, klass: FirDeclaration) = shouldNotBeCalled() + override fun recordGeneratedMember(owner: FirDeclaration, klass: FirDeclaration) = shouldNotBeCalled() override fun getClassNamesInPackage(fqName: FqName): Set = shouldNotBeCalled() diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/providers/FirIdeLibrariesSessionProvider.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/providers/FirIdeLibrariesSessionProvider.kt index ffdc66c9d49..2a2c21581b3 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/providers/FirIdeLibrariesSessionProvider.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/providers/FirIdeLibrariesSessionProvider.kt @@ -5,7 +5,10 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.providers -import org.jetbrains.kotlin.fir.declarations.* +import org.jetbrains.kotlin.fir.declarations.FirClassLikeDeclaration +import org.jetbrains.kotlin.fir.declarations.FirDeclaration +import org.jetbrains.kotlin.fir.declarations.FirFile +import org.jetbrains.kotlin.fir.declarations.FirRegularClass import org.jetbrains.kotlin.fir.resolve.providers.FirProvider import org.jetbrains.kotlin.fir.resolve.providers.FirProviderInternals import org.jetbrains.kotlin.fir.resolve.providers.FirSymbolProvider @@ -27,10 +30,10 @@ internal class FirIdeLibrariesSessionProvider( override fun getFirFilesByPackage(fqName: FqName): List = emptyList() @FirProviderInternals - override fun recordGeneratedClass(owner: FirAnnotatedDeclaration, klass: FirRegularClass) = shouldNotBeCalled() + override fun recordGeneratedClass(owner: FirDeclaration, klass: FirRegularClass) = shouldNotBeCalled() @FirProviderInternals - override fun recordGeneratedMember(owner: FirAnnotatedDeclaration, klass: FirDeclaration) = shouldNotBeCalled() + override fun recordGeneratedMember(owner: FirDeclaration, klass: FirDeclaration) = shouldNotBeCalled() override fun getClassNamesInPackage(fqName: FqName): Set = shouldNotBeCalled() diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/providers/FirIdeProvider.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/providers/FirIdeProvider.kt index 493a9707df6..028101a46b9 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/providers/FirIdeProvider.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/providers/FirIdeProvider.kt @@ -14,7 +14,10 @@ import org.jetbrains.kotlin.analysis.providers.KotlinPackageProvider import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.NoMutableState import org.jetbrains.kotlin.fir.ThreadSafeMutableState -import org.jetbrains.kotlin.fir.declarations.* +import org.jetbrains.kotlin.fir.declarations.FirClassLikeDeclaration +import org.jetbrains.kotlin.fir.declarations.FirDeclaration +import org.jetbrains.kotlin.fir.declarations.FirFile +import org.jetbrains.kotlin.fir.declarations.FirRegularClass import org.jetbrains.kotlin.fir.declarations.synthetic.FirSyntheticProperty import org.jetbrains.kotlin.fir.originalForSubstitutionOverride import org.jetbrains.kotlin.fir.resolve.providers.FirProvider @@ -88,12 +91,12 @@ internal class FirIdeProvider( @FirProviderInternals - override fun recordGeneratedClass(owner: FirAnnotatedDeclaration, klass: FirRegularClass) { + override fun recordGeneratedClass(owner: FirDeclaration, klass: FirRegularClass) { TODO() } @FirProviderInternals - override fun recordGeneratedMember(owner: FirAnnotatedDeclaration, klass: FirDeclaration) { + override fun recordGeneratedMember(owner: FirDeclaration, klass: FirDeclaration) { TODO() } diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/FirDesignatedAnnotationArgumentsResolveTransformerForIDE.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/FirDesignatedAnnotationArgumentsResolveTransformerForIDE.kt index d48709771e4..d02e7289f34 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/FirDesignatedAnnotationArgumentsResolveTransformerForIDE.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/FirDesignatedAnnotationArgumentsResolveTransformerForIDE.kt @@ -5,16 +5,16 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.transformers +import org.jetbrains.kotlin.analysis.low.level.api.fir.FirPhaseRunner +import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDeclarationDesignationWithFile +import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.ResolveTreeBuilder +import org.jetbrains.kotlin.analysis.low.level.api.fir.util.ensurePhase import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.resolve.ResolutionMode import org.jetbrains.kotlin.fir.resolve.ScopeSession import org.jetbrains.kotlin.fir.resolve.transformers.plugin.FirAnnotationArgumentsResolveTransformer import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef -import org.jetbrains.kotlin.analysis.low.level.api.fir.FirPhaseRunner -import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDeclarationDesignationWithFile -import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.ResolveTreeBuilder -import org.jetbrains.kotlin.analysis.low.level.api.fir.util.ensurePhase internal class FirDesignatedAnnotationArgumentsResolveTransformerForIDE( private val designation: FirDeclarationDesignationWithFile, @@ -67,11 +67,9 @@ internal class FirDesignatedAnnotationArgumentsResolveTransformerForIDE( } override fun ensureResolved(declaration: FirDeclaration) { - if (declaration is FirAnnotatedDeclaration) { - val unresolvedAnnotation = declaration.annotations.firstOrNull { it.annotationTypeRef !is FirResolvedTypeRef } - check(unresolvedAnnotation == null) { - "Unexpected annotationTypeRef annotation, expected resolvedType but actual ${unresolvedAnnotation?.annotationTypeRef}" - } + val unresolvedAnnotation = declaration.annotations.firstOrNull { it.annotationTypeRef !is FirResolvedTypeRef } + check(unresolvedAnnotation == null) { + "Unexpected annotationTypeRef annotation, expected resolvedType but actual ${unresolvedAnnotation?.annotationTypeRef}" } when (declaration) { is FirSimpleFunction, is FirConstructor, is FirAnonymousInitializer -> diff --git a/compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/Main.kt b/compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/Main.kt index a75661001e3..1c2a62ee04d 100644 --- a/compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/Main.kt +++ b/compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/Main.kt @@ -69,7 +69,6 @@ fun main(args: Array) { alias("ConstructorChecker") alias("FileChecker") alias("FirTypeParameterChecker") - alias("FirAnnotatedDeclarationChecker") alias("TypeAliasChecker") alias("AnonymousFunctionChecker") alias("PropertyAccessorChecker") diff --git a/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/JvmDeclarationCheckers.kt b/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/JvmDeclarationCheckers.kt index 5b9f2751de6..98c77cced03 100644 --- a/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/JvmDeclarationCheckers.kt +++ b/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/JvmDeclarationCheckers.kt @@ -14,13 +14,9 @@ object JvmDeclarationCheckers : DeclarationCheckers() { FirJvmExternalDeclarationChecker, FirJvmNameChecker, FirJvmDefaultChecker, - FirJvmFunctionDelegateMemberNameClashChecker - ) - - override val annotatedDeclarationCheckers: Set - get() = setOf( + FirJvmFunctionDelegateMemberNameClashChecker, FirJvmStaticChecker, - FirRepeatableAnnotationChecker + FirRepeatableAnnotationChecker, ) override val classCheckers: Set 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 cedbcce2642..73bdc9fa82f 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 @@ -7,13 +7,13 @@ package org.jetbrains.kotlin.fir.analysis.jvm.checkers.declaration import org.jetbrains.kotlin.config.JvmDefaultMode import org.jetbrains.kotlin.descriptors.Modality +import org.jetbrains.kotlin.diagnostics.DiagnosticReporter +import org.jetbrains.kotlin.diagnostics.reportOn import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext 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.diagnostics.DiagnosticReporter import org.jetbrains.kotlin.fir.analysis.diagnostics.jvm.FirJvmErrors -import org.jetbrains.kotlin.diagnostics.reportOn import org.jetbrains.kotlin.fir.analysis.jvm.checkers.isCompiledToJvmDefault import org.jetbrains.kotlin.fir.analysis.jvm.checkers.isJvm6 import org.jetbrains.kotlin.fir.containingClass @@ -22,57 +22,54 @@ import org.jetbrains.kotlin.fir.declarations.utils.isInterface import org.jetbrains.kotlin.fir.declarations.utils.modality import org.jetbrains.kotlin.fir.expressions.FirAnnotation import org.jetbrains.kotlin.fir.java.jvmDefaultModeState +import org.jetbrains.kotlin.fir.resolve.toFirRegularClassSymbol import org.jetbrains.kotlin.fir.resolve.toSymbol import org.jetbrains.kotlin.fir.scopes.getDirectOverriddenFunctions import org.jetbrains.kotlin.fir.scopes.impl.FirClassUseSiteMemberScope import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirIntersectionCallableSymbol -import org.jetbrains.kotlin.fir.resolve.toFirRegularClassSymbol import org.jetbrains.kotlin.name.JvmNames.JVM_DEFAULT_CLASS_ID import org.jetbrains.kotlin.name.JvmNames.JVM_DEFAULT_NO_COMPATIBILITY_CLASS_ID object FirJvmDefaultChecker : FirBasicDeclarationChecker() { override fun check(declaration: FirDeclaration, context: CheckerContext, reporter: DiagnosticReporter) { val jvmDefaultMode = context.session.jvmDefaultModeState - var defaultAnnotation: FirAnnotation? = null val containingDeclaration = context.findClosest() - if (declaration is FirAnnotatedDeclaration) { - val isJvm6 = context.isJvm6() - defaultAnnotation = declaration.getAnnotationByClassId(JVM_DEFAULT_CLASS_ID) + val isJvm6 = context.isJvm6() + val defaultAnnotation = declaration.getAnnotationByClassId(JVM_DEFAULT_CLASS_ID) - if (defaultAnnotation != null) { - if (containingDeclaration !is FirClass || !containingDeclaration.isInterface) { - reporter.reportOn(defaultAnnotation.source, FirJvmErrors.JVM_DEFAULT_NOT_IN_INTERFACE, context) - return - } else if (isJvm6) { - reporter.reportOn(defaultAnnotation.source, FirJvmErrors.JVM_DEFAULT_IN_JVM6_TARGET, "JvmDefault", context) + if (defaultAnnotation != null) { + if (containingDeclaration !is FirClass || !containingDeclaration.isInterface) { + reporter.reportOn(defaultAnnotation.source, FirJvmErrors.JVM_DEFAULT_NOT_IN_INTERFACE, context) + return + } else if (isJvm6) { + reporter.reportOn(defaultAnnotation.source, FirJvmErrors.JVM_DEFAULT_IN_JVM6_TARGET, "JvmDefault", context) + return + } else if (!jvmDefaultMode.isEnabled) { + reporter.reportOn(defaultAnnotation.source, FirJvmErrors.JVM_DEFAULT_IN_DECLARATION, "JvmDefault", context) + return + } + } else { + val annotation = declaration.getAnnotationByClassId(JVM_DEFAULT_NO_COMPATIBILITY_CLASS_ID) + if (annotation != null) { + if (isJvm6) { + reporter.reportOn( + annotation.source, + FirJvmErrors.JVM_DEFAULT_IN_JVM6_TARGET, + "JvmDefaultWithoutCompatibility", + context + ) return } else if (!jvmDefaultMode.isEnabled) { - reporter.reportOn(defaultAnnotation.source, FirJvmErrors.JVM_DEFAULT_IN_DECLARATION, "JvmDefault", context) + reporter.reportOn( + annotation.source, + FirJvmErrors.JVM_DEFAULT_IN_DECLARATION, + "JvmDefaultWithoutCompatibility", + context + ) return } - } else { - val annotation = declaration.getAnnotationByClassId(JVM_DEFAULT_NO_COMPATIBILITY_CLASS_ID) - if (annotation != null) { - if (isJvm6) { - reporter.reportOn( - annotation.source, - FirJvmErrors.JVM_DEFAULT_IN_JVM6_TARGET, - "JvmDefaultWithoutCompatibility", - context - ) - return - } else if (!jvmDefaultMode.isEnabled) { - reporter.reportOn( - annotation.source, - FirJvmErrors.JVM_DEFAULT_IN_DECLARATION, - "JvmDefaultWithoutCompatibility", - context - ) - return - } - } } } diff --git a/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirJvmNameChecker.kt b/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirJvmNameChecker.kt index 58eb0907934..fbe91f3ce6d 100644 --- a/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirJvmNameChecker.kt +++ b/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirJvmNameChecker.kt @@ -5,12 +5,12 @@ package org.jetbrains.kotlin.fir.analysis.jvm.checkers.declaration +import org.jetbrains.kotlin.diagnostics.DiagnosticReporter +import org.jetbrains.kotlin.diagnostics.reportOn 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.getContainingClassSymbol -import org.jetbrains.kotlin.diagnostics.DiagnosticReporter import org.jetbrains.kotlin.fir.analysis.diagnostics.jvm.FirJvmErrors -import org.jetbrains.kotlin.diagnostics.reportOn import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.utils.isInline import org.jetbrains.kotlin.fir.declarations.utils.isOpen @@ -28,10 +28,6 @@ object FirJvmNameChecker : FirBasicDeclarationChecker() { private val NAME = Name.identifier("name") override fun check(declaration: FirDeclaration, context: CheckerContext, reporter: DiagnosticReporter) { - if (declaration !is FirAnnotatedDeclaration) { - return - } - val jvmName = declaration.findJvmNameAnnotation() ?: return val name = jvmName.findArgumentByName(NAME) ?: return @@ -60,7 +56,7 @@ object FirJvmNameChecker : FirBasicDeclarationChecker() { } } - private fun FirAnnotatedDeclaration.findJvmNameAnnotation(): FirAnnotation? { + private fun FirDeclaration.findJvmNameAnnotation(): FirAnnotation? { return annotations.firstOrNull { it.annotationTypeRef.coneType.classId == StandardClassIds.Annotations.JvmName } 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 221a6ae1e33..b4f7c05c9f4 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 @@ -11,12 +11,12 @@ import org.jetbrains.kotlin.descriptors.ClassKind import org.jetbrains.kotlin.descriptors.Visibilities import org.jetbrains.kotlin.descriptors.Visibility import org.jetbrains.kotlin.descriptors.isInterface +import org.jetbrains.kotlin.diagnostics.DiagnosticReporter +import org.jetbrains.kotlin.diagnostics.reportOn import org.jetbrains.kotlin.fir.analysis.checkers.classKind import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext -import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirAnnotatedDeclarationChecker -import org.jetbrains.kotlin.diagnostics.DiagnosticReporter +import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirBasicDeclarationChecker import org.jetbrains.kotlin.fir.analysis.diagnostics.jvm.FirJvmErrors -import org.jetbrains.kotlin.diagnostics.reportOn import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.utils.* import org.jetbrains.kotlin.fir.expressions.FirAnnotation @@ -31,8 +31,8 @@ import org.jetbrains.kotlin.name.SpecialNames import org.jetbrains.kotlin.name.StandardClassIds import org.jetbrains.kotlin.utils.addToStdlib.safeAs -object FirJvmStaticChecker : FirAnnotatedDeclarationChecker() { - override fun check(declaration: FirAnnotatedDeclaration, context: CheckerContext, reporter: DiagnosticReporter) { +object FirJvmStaticChecker : FirBasicDeclarationChecker() { + override fun check(declaration: FirDeclaration, context: CheckerContext, reporter: DiagnosticReporter) { if (declaration is FirConstructor) { // WRONG_DECLARATION_TARGET return @@ -48,7 +48,7 @@ object FirJvmStaticChecker : FirAnnotatedDeclarationChecker() { checkAnnotated(declaration, context, reporter, declaration.source) } - fun checkIfAnnotated(it: FirAnnotatedDeclaration) { + fun checkIfAnnotated(it: FirDeclaration) { if (!it.hasAnnotation(StandardClassIds.Annotations.JvmStatic)) { return } @@ -63,7 +63,7 @@ object FirJvmStaticChecker : FirAnnotatedDeclarationChecker() { } private fun checkAnnotated( - declaration: FirAnnotatedDeclaration, + declaration: FirDeclaration, context: CheckerContext, reporter: DiagnosticReporter, targetSource: KtSourceElement?, @@ -113,7 +113,7 @@ object FirJvmStaticChecker : FirAnnotatedDeclarationChecker() { } private fun checkForInterface( - declaration: FirAnnotatedDeclaration, + declaration: FirDeclaration, context: CheckerContext, reporter: DiagnosticReporter, targetSource: KtSourceElement?, @@ -195,7 +195,7 @@ object FirJvmStaticChecker : FirAnnotatedDeclarationChecker() { } private fun checkStaticOnConstOrJvmField( - declaration: FirAnnotatedDeclaration, + declaration: FirDeclaration, context: CheckerContext, reporter: DiagnosticReporter, targetSource: KtSourceElement?, @@ -239,11 +239,11 @@ object FirJvmStaticChecker : FirAnnotatedDeclarationChecker() { private fun FirClassLikeSymbol<*>.isCompanion() = safeAs()?.isCompanion == true - private fun FirAnnotatedDeclaration.hasAnnotationNamedAs(classId: ClassId): Boolean { + private fun FirDeclaration.hasAnnotationNamedAs(classId: ClassId): Boolean { return findAnnotation(classId) != null } - private fun FirAnnotatedDeclaration.findAnnotation(classId: ClassId): FirAnnotation? { + private fun FirDeclaration.findAnnotation(classId: ClassId): FirAnnotation? { return annotations.firstOrNull { it.annotationTypeRef.coneType.classId == classId } 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 2137da13425..4b2b8bf323a 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 @@ -5,20 +5,19 @@ package org.jetbrains.kotlin.fir.analysis.jvm.checkers.declaration -//import org.jetbrains.kotlin.builtins.StandardNames import org.jetbrains.kotlin.KtSourceElement import org.jetbrains.kotlin.config.LanguageFeature 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.analysis.checkers.containsRepeatableAnnotation import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext -import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirAnnotatedDeclarationChecker +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.diagnostics.DiagnosticReporter import org.jetbrains.kotlin.fir.analysis.diagnostics.jvm.FirJvmErrors -import org.jetbrains.kotlin.diagnostics.reportOn import org.jetbrains.kotlin.fir.analysis.diagnostics.withSuppressedDiagnostics import org.jetbrains.kotlin.fir.analysis.jvm.checkers.isJvm6 import org.jetbrains.kotlin.fir.declarations.* @@ -37,10 +36,10 @@ import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.name.StandardClassIds -object FirRepeatableAnnotationChecker : FirAnnotatedDeclarationChecker() { +object FirRepeatableAnnotationChecker : FirBasicDeclarationChecker() { private val REPEATABLE_ANNOTATION_CONTAINER_NAME = Name.identifier(JvmAbi.REPEATABLE_ANNOTATION_CONTAINER_NAME) - override fun check(declaration: FirAnnotatedDeclaration, context: CheckerContext, reporter: DiagnosticReporter) { + override fun check(declaration: FirDeclaration, context: CheckerContext, reporter: DiagnosticReporter) { val annotationsMap = hashMapOf>() val session = context.session diff --git a/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/checkers/declaration/ComposedDeclarationCheckers.kt b/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/checkers/declaration/ComposedDeclarationCheckers.kt index df52b713137..1834bb83d94 100644 --- a/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/checkers/declaration/ComposedDeclarationCheckers.kt +++ b/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/checkers/declaration/ComposedDeclarationCheckers.kt @@ -33,8 +33,6 @@ class ComposedDeclarationCheckers : DeclarationCheckers() { get() = _fileCheckers override val typeParameterCheckers: Set get() = _typeParameterCheckers - override val annotatedDeclarationCheckers: Set - get() = _annotatedDeclarationCheckers override val typeAliasCheckers: Set get() = _typeAliasCheckers override val anonymousFunctionCheckers: Set @@ -65,7 +63,6 @@ class ComposedDeclarationCheckers : DeclarationCheckers() { private val _constructorCheckers: MutableSet = mutableSetOf() private val _fileCheckers: MutableSet = mutableSetOf() private val _typeParameterCheckers: MutableSet = mutableSetOf() - private val _annotatedDeclarationCheckers: MutableSet = mutableSetOf() private val _typeAliasCheckers: MutableSet = mutableSetOf() private val _anonymousFunctionCheckers: MutableSet = mutableSetOf() private val _propertyAccessorCheckers: MutableSet = mutableSetOf() @@ -88,7 +85,6 @@ class ComposedDeclarationCheckers : DeclarationCheckers() { _constructorCheckers += checkers.constructorCheckers _fileCheckers += checkers.fileCheckers _typeParameterCheckers += checkers.typeParameterCheckers - _annotatedDeclarationCheckers += checkers.annotatedDeclarationCheckers _typeAliasCheckers += checkers.typeAliasCheckers _anonymousFunctionCheckers += checkers.anonymousFunctionCheckers _propertyAccessorCheckers += checkers.propertyAccessorCheckers diff --git a/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/checkers/declaration/DeclarationCheckers.kt b/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/checkers/declaration/DeclarationCheckers.kt index d3fe426fb2f..56619845020 100644 --- a/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/checkers/declaration/DeclarationCheckers.kt +++ b/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/checkers/declaration/DeclarationCheckers.kt @@ -28,7 +28,6 @@ abstract class DeclarationCheckers { open val constructorCheckers: Set = emptySet() open val fileCheckers: Set = emptySet() open val typeParameterCheckers: Set = emptySet() - open val annotatedDeclarationCheckers: Set = emptySet() open val typeAliasCheckers: Set = emptySet() open val anonymousFunctionCheckers: Set = emptySet() open val propertyAccessorCheckers: Set = emptySet() @@ -42,21 +41,20 @@ abstract class DeclarationCheckers { open val variableAssignmentCfaBasedCheckers: Set = emptySet() @CheckersComponentInternal internal val allBasicDeclarationCheckers: Set by lazy { basicDeclarationCheckers } - @CheckersComponentInternal internal val allFunctionCheckers: Set by lazy { functionCheckers + annotatedDeclarationCheckers + basicDeclarationCheckers } - @CheckersComponentInternal internal val allSimpleFunctionCheckers: Set by lazy { simpleFunctionCheckers + functionCheckers + annotatedDeclarationCheckers + basicDeclarationCheckers } - @CheckersComponentInternal internal val allPropertyCheckers: Set by lazy { propertyCheckers + annotatedDeclarationCheckers + basicDeclarationCheckers } - @CheckersComponentInternal internal val allClassCheckers: Set by lazy { classCheckers + annotatedDeclarationCheckers + basicDeclarationCheckers } - @CheckersComponentInternal internal val allRegularClassCheckers: Set by lazy { regularClassCheckers + classCheckers + annotatedDeclarationCheckers + basicDeclarationCheckers } - @CheckersComponentInternal internal val allConstructorCheckers: Set by lazy { constructorCheckers + functionCheckers + annotatedDeclarationCheckers + basicDeclarationCheckers } - @CheckersComponentInternal internal val allFileCheckers: Set by lazy { fileCheckers + annotatedDeclarationCheckers + basicDeclarationCheckers } - @CheckersComponentInternal internal val allTypeParameterCheckers: Set by lazy { typeParameterCheckers + annotatedDeclarationCheckers + basicDeclarationCheckers } - @CheckersComponentInternal internal val allAnnotatedDeclarationCheckers: Set by lazy { annotatedDeclarationCheckers + basicDeclarationCheckers } - @CheckersComponentInternal internal val allTypeAliasCheckers: Set by lazy { typeAliasCheckers + annotatedDeclarationCheckers + basicDeclarationCheckers } - @CheckersComponentInternal internal val allAnonymousFunctionCheckers: Set by lazy { anonymousFunctionCheckers + functionCheckers + annotatedDeclarationCheckers + basicDeclarationCheckers } - @CheckersComponentInternal internal val allPropertyAccessorCheckers: Set by lazy { propertyAccessorCheckers + functionCheckers + annotatedDeclarationCheckers + basicDeclarationCheckers } - @CheckersComponentInternal internal val allBackingFieldCheckers: Set by lazy { backingFieldCheckers + annotatedDeclarationCheckers + basicDeclarationCheckers } - @CheckersComponentInternal internal val allValueParameterCheckers: Set by lazy { valueParameterCheckers + annotatedDeclarationCheckers + basicDeclarationCheckers } - @CheckersComponentInternal internal val allEnumEntryCheckers: Set by lazy { enumEntryCheckers + annotatedDeclarationCheckers + basicDeclarationCheckers } - @CheckersComponentInternal internal val allAnonymousObjectCheckers: Set by lazy { anonymousObjectCheckers + classCheckers + annotatedDeclarationCheckers + basicDeclarationCheckers } + @CheckersComponentInternal internal val allFunctionCheckers: Set by lazy { functionCheckers + basicDeclarationCheckers } + @CheckersComponentInternal internal val allSimpleFunctionCheckers: Set by lazy { simpleFunctionCheckers + functionCheckers + basicDeclarationCheckers } + @CheckersComponentInternal internal val allPropertyCheckers: Set by lazy { propertyCheckers + basicDeclarationCheckers } + @CheckersComponentInternal internal val allClassCheckers: Set by lazy { classCheckers + basicDeclarationCheckers } + @CheckersComponentInternal internal val allRegularClassCheckers: Set by lazy { regularClassCheckers + classCheckers + basicDeclarationCheckers } + @CheckersComponentInternal internal val allConstructorCheckers: Set by lazy { constructorCheckers + functionCheckers + basicDeclarationCheckers } + @CheckersComponentInternal internal val allFileCheckers: Set by lazy { fileCheckers + basicDeclarationCheckers } + @CheckersComponentInternal internal val allTypeParameterCheckers: Set by lazy { typeParameterCheckers + basicDeclarationCheckers } + @CheckersComponentInternal internal val allTypeAliasCheckers: Set by lazy { typeAliasCheckers + basicDeclarationCheckers } + @CheckersComponentInternal internal val allAnonymousFunctionCheckers: Set by lazy { anonymousFunctionCheckers + functionCheckers + basicDeclarationCheckers } + @CheckersComponentInternal internal val allPropertyAccessorCheckers: Set by lazy { propertyAccessorCheckers + functionCheckers + basicDeclarationCheckers } + @CheckersComponentInternal internal val allBackingFieldCheckers: Set by lazy { backingFieldCheckers + basicDeclarationCheckers } + @CheckersComponentInternal internal val allValueParameterCheckers: Set by lazy { valueParameterCheckers + basicDeclarationCheckers } + @CheckersComponentInternal internal val allEnumEntryCheckers: Set by lazy { enumEntryCheckers + basicDeclarationCheckers } + @CheckersComponentInternal internal val allAnonymousObjectCheckers: Set by lazy { anonymousObjectCheckers + classCheckers + basicDeclarationCheckers } @CheckersComponentInternal internal val allAnonymousInitializerCheckers: Set by lazy { anonymousInitializerCheckers + basicDeclarationCheckers } } diff --git a/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirDeclarationCheckerAliases.kt b/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirDeclarationCheckerAliases.kt index 07c21c26057..1f1eb3a1516 100644 --- a/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirDeclarationCheckerAliases.kt +++ b/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirDeclarationCheckerAliases.kt @@ -10,7 +10,6 @@ package org.jetbrains.kotlin.fir.analysis.checkers.declaration * DO NOT MODIFY IT MANUALLY */ -import org.jetbrains.kotlin.fir.declarations.FirAnnotatedDeclaration import org.jetbrains.kotlin.fir.declarations.FirAnonymousFunction import org.jetbrains.kotlin.fir.declarations.FirAnonymousInitializer import org.jetbrains.kotlin.fir.declarations.FirAnonymousObject @@ -38,7 +37,6 @@ typealias FirRegularClassChecker = FirDeclarationChecker typealias FirConstructorChecker = FirDeclarationChecker typealias FirFileChecker = FirDeclarationChecker typealias FirTypeParameterChecker = FirDeclarationChecker -typealias FirAnnotatedDeclarationChecker = FirDeclarationChecker typealias FirTypeAliasChecker = FirDeclarationChecker typealias FirAnonymousFunctionChecker = FirDeclarationChecker typealias FirPropertyAccessorChecker = FirDeclarationChecker diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/CommonDeclarationCheckers.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/CommonDeclarationCheckers.kt index e708abca6f8..e5eeabf5d73 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/CommonDeclarationCheckers.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/CommonDeclarationCheckers.kt @@ -30,6 +30,9 @@ object CommonDeclarationCheckers : DeclarationCheckers() { FirInvalidAndDangerousCharactersChecker, FirAmbiguousAnonymousTypeChecker, FirExplicitApiDeclarationChecker, + FirAnnotationChecker, + FirPublishedApiChecker, + FirOptInMarkedDeclarationChecker, ) override val functionCheckers: Set @@ -138,13 +141,6 @@ object CommonDeclarationCheckers : DeclarationCheckers() { FirTypeParameterSyntaxChecker, ) - override val annotatedDeclarationCheckers: Set - get() = setOf( - FirAnnotationChecker, - FirPublishedApiChecker, - FirOptInMarkedDeclarationChecker, - ) - override val typeAliasCheckers: Set get() = setOf( FirTopLevelTypeAliasChecker, 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 16a6e7455b8..8fcc3398e91 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 @@ -5,7 +5,6 @@ package org.jetbrains.kotlin.fir.analysis.checkers -import org.jetbrains.kotlin.KtFakeSourceElementKind import org.jetbrains.kotlin.config.LanguageFeature import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget import org.jetbrains.kotlin.descriptors.annotations.KotlinTarget @@ -15,8 +14,8 @@ 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.context.findClosest -import org.jetbrains.kotlin.fir.analysis.diagnostics.withSuppressedDiagnostics import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors +import org.jetbrains.kotlin.fir.analysis.diagnostics.withSuppressedDiagnostics import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.impl.FirPrimaryConstructor import org.jetbrains.kotlin.fir.expressions.* @@ -80,11 +79,11 @@ fun FirClassLikeSymbol<*>.getAllowedAnnotationTargets(): Set { } } -fun FirAnnotatedDeclaration.getRetentionAnnotation(): FirAnnotation? { +fun FirDeclaration.getRetentionAnnotation(): FirAnnotation? { return getAnnotationByClassId(StandardClassIds.Annotations.Retention) } -fun FirAnnotatedDeclaration.getTargetAnnotation(): FirAnnotation? { +fun FirDeclaration.getTargetAnnotation(): FirAnnotation? { return getAnnotationByClassId(StandardClassIds.Annotations.Target) } 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 67d6e169a38..178f6e1da4a 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 @@ -5,18 +5,20 @@ package org.jetbrains.kotlin.fir.analysis.checkers -import org.jetbrains.kotlin.builtins.StandardNames.HASHCODE_NAME import org.jetbrains.kotlin.KtFakeSourceElementKind import org.jetbrains.kotlin.KtSourceElement +import org.jetbrains.kotlin.builtins.StandardNames.HASHCODE_NAME import org.jetbrains.kotlin.descriptors.ClassKind import org.jetbrains.kotlin.descriptors.Modality import org.jetbrains.kotlin.descriptors.Visibilities import org.jetbrains.kotlin.descriptors.annotations.KotlinTarget import org.jetbrains.kotlin.diagnostics.* -import org.jetbrains.kotlin.fir.* +import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext -import org.jetbrains.kotlin.fir.analysis.diagnostics.* +import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors import org.jetbrains.kotlin.fir.analysis.getChild +import org.jetbrains.kotlin.fir.containingClass +import org.jetbrains.kotlin.fir.containingClassForLocalAttr import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.utils.* import org.jetbrains.kotlin.fir.expressions.FirExpression @@ -38,6 +40,7 @@ import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol import org.jetbrains.kotlin.fir.symbols.SymbolInternals import org.jetbrains.kotlin.fir.symbols.impl.* import org.jetbrains.kotlin.fir.types.* +import org.jetbrains.kotlin.fir.unwrapFakeOverrides import org.jetbrains.kotlin.lexer.KtTokens import org.jetbrains.kotlin.name.* import org.jetbrains.kotlin.psi.KtParameter.VAL_VAR_TOKEN_SET @@ -370,7 +373,7 @@ private fun lowerThanBound(context: ConeInferenceContext, argument: ConeKotlinTy } fun FirMemberDeclaration.isInlineOnly(): Boolean = - isInline && (this as FirAnnotatedDeclaration).hasAnnotation(INLINE_ONLY_ANNOTATION_CLASS_ID) + isInline && hasAnnotation(INLINE_ONLY_ANNOTATION_CLASS_ID) 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 3b744ecd4f7..81836cc9efe 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 @@ -40,7 +40,7 @@ private data class FirSinceKotlinValue( val wasExperimentalMarkerClasses: List ) -fun FirAnnotatedDeclaration.checkSinceKotlinVersionAccessibility(context: CheckerContext): FirSinceKotlinAccessibility { +fun FirDeclaration.checkSinceKotlinVersionAccessibility(context: CheckerContext): FirSinceKotlinAccessibility { val value = getOwnSinceKotlinVersion(context.session) val version = value?.apiVersion val languageVersionSettings = context.session.languageVersionSettings @@ -59,11 +59,11 @@ fun FirAnnotatedDeclaration.checkSinceKotlinVersionAccessibility(context: Checke return FirSinceKotlinAccessibility.NotAccessible(version) } -private fun FirAnnotatedDeclaration.getOwnSinceKotlinVersion(session: FirSession): FirSinceKotlinValue? { +private fun FirDeclaration.getOwnSinceKotlinVersion(session: FirSession): FirSinceKotlinValue? { var result: FirSinceKotlinValue? = null // TODO: use-site targeted annotations - fun FirAnnotatedDeclaration.consider() { + fun FirDeclaration.consider() { val sinceKotlinSingleArgument = getAnnotationByClassId(StandardClassIds.Annotations.SinceKotlin)?.findArgumentByName(StandardClassIds.Annotations.ParameterNames.sinceKotlinVersion) val apiVersion = ((sinceKotlinSingleArgument as? FirConstExpression<*>)?.value as? String)?.let(ApiVersion.Companion::parse) if (apiVersion != null) { @@ -96,7 +96,7 @@ private fun FirAnnotatedDeclaration.getOwnSinceKotlinVersion(session: FirSession return result } -private fun FirAnnotatedDeclaration.loadWasExperimentalMarkerClasses(): List { +private fun FirDeclaration.loadWasExperimentalMarkerClasses(): List { val wasExperimental = getAnnotationByClassId(OptInNames.WAS_EXPERIMENTAL_CLASS_ID) ?: return emptyList() val annotationClasses = wasExperimental.findArgumentByName(OptInNames.WAS_EXPERIMENTAL_ANNOTATION_CLASS) ?: return emptyList() return annotationClasses.extractClassesFromArgument() diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirAnnotationChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirAnnotationChecker.kt index 2d7a3f632cd..af198a6e990 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirAnnotationChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirAnnotationChecker.kt @@ -16,7 +16,8 @@ import org.jetbrains.kotlin.fir.FirAnnotationContainer import org.jetbrains.kotlin.fir.analysis.checkers.* import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext import org.jetbrains.kotlin.fir.analysis.checkers.context.findClosest -import org.jetbrains.kotlin.fir.analysis.diagnostics.* +import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors +import org.jetbrains.kotlin.fir.analysis.diagnostics.withSuppressedDiagnostics import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.utils.hasBackingField import org.jetbrains.kotlin.fir.expressions.FirAnnotation @@ -31,12 +32,12 @@ import org.jetbrains.kotlin.fir.types.customAnnotations import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.StandardClassIds -object FirAnnotationChecker : FirAnnotatedDeclarationChecker() { +object FirAnnotationChecker : FirBasicDeclarationChecker() { private val deprecatedClassId = FqName("kotlin.Deprecated") private val deprecatedSinceKotlinClassId = FqName("kotlin.DeprecatedSinceKotlin") override fun check( - declaration: FirAnnotatedDeclaration, + declaration: FirDeclaration, context: CheckerContext, reporter: DiagnosticReporter ) { @@ -75,7 +76,7 @@ object FirAnnotationChecker : FirAnnotatedDeclarationChecker() { } private fun checkAnnotationTarget( - declaration: FirAnnotatedDeclaration, + declaration: FirDeclaration, annotation: FirAnnotation, context: CheckerContext, reporter: DiagnosticReporter @@ -124,7 +125,7 @@ object FirAnnotationChecker : FirAnnotatedDeclarationChecker() { } private fun checkAnnotationUseSiteTarget( - annotated: FirAnnotatedDeclaration, + annotated: FirDeclaration, annotation: FirAnnotation, target: AnnotationUseSiteTarget, context: CheckerContext, 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 75bf44adf11..7deb515360a 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 @@ -14,13 +14,13 @@ import org.jetbrains.kotlin.fir.analysis.checkers.getAllowedAnnotationTargets import org.jetbrains.kotlin.fir.analysis.checkers.getAnnotationClassForOptInMarker import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors import org.jetbrains.kotlin.fir.analysis.diagnostics.withSuppressedDiagnostics -import org.jetbrains.kotlin.fir.declarations.FirAnnotatedDeclaration +import org.jetbrains.kotlin.fir.declarations.FirDeclaration import org.jetbrains.kotlin.fir.declarations.FirProperty import org.jetbrains.kotlin.fir.declarations.FirPropertyAccessor import org.jetbrains.kotlin.fir.declarations.FirValueParameter -object FirOptInMarkedDeclarationChecker : FirAnnotatedDeclarationChecker() { - override fun check(declaration: FirAnnotatedDeclaration, context: CheckerContext, reporter: DiagnosticReporter) { +object FirOptInMarkedDeclarationChecker : FirBasicDeclarationChecker() { + override fun check(declaration: FirDeclaration, context: CheckerContext, reporter: DiagnosticReporter) { for (annotation in declaration.annotations) { val annotationClass = annotation.getAnnotationClassForOptInMarker(context.session) ?: continue withSuppressedDiagnostics(annotation, context) { @@ -43,4 +43,4 @@ object FirOptInMarkedDeclarationChecker : FirAnnotatedDeclarationChecker() { } } } -} \ No newline at end of file +} 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 4b64d2fbb4a..a03315a8372 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 @@ -6,19 +6,19 @@ package org.jetbrains.kotlin.fir.analysis.checkers.declaration import org.jetbrains.kotlin.descriptors.Visibilities -import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext import org.jetbrains.kotlin.diagnostics.DiagnosticReporter -import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors import org.jetbrains.kotlin.diagnostics.reportOn -import org.jetbrains.kotlin.fir.declarations.FirAnnotatedDeclaration +import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext +import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors +import org.jetbrains.kotlin.fir.declarations.FirDeclaration import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration import org.jetbrains.kotlin.fir.declarations.FirValueParameter import org.jetbrains.kotlin.fir.declarations.getAnnotationByClassId import org.jetbrains.kotlin.fir.declarations.utils.visibility import org.jetbrains.kotlin.name.StandardClassIds -object FirPublishedApiChecker : FirAnnotatedDeclarationChecker() { - override fun check(declaration: FirAnnotatedDeclaration, context: CheckerContext, reporter: DiagnosticReporter) { +object FirPublishedApiChecker : FirBasicDeclarationChecker() { + override fun check(declaration: FirDeclaration, context: CheckerContext, reporter: DiagnosticReporter) { if (declaration !is FirMemberDeclaration) return if (declaration is FirValueParameter) return if (declaration.visibility == Visibilities.Internal) return 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 60986734c3c..b8bd2495730 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 @@ -6,17 +6,14 @@ package org.jetbrains.kotlin.fir.analysis.checkers.expression import org.jetbrains.kotlin.config.AnalysisFlags +import org.jetbrains.kotlin.diagnostics.DiagnosticReporter +import org.jetbrains.kotlin.diagnostics.reportOn import org.jetbrains.kotlin.fir.* import org.jetbrains.kotlin.fir.analysis.checkers.* import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext -import org.jetbrains.kotlin.diagnostics.DiagnosticReporter import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors -import org.jetbrains.kotlin.diagnostics.reportOn import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.utils.isLocal -import org.jetbrains.kotlin.fir.declarations.FirRegularClass -import org.jetbrains.kotlin.fir.declarations.findArgumentByName -import org.jetbrains.kotlin.fir.declarations.FirResolvePhase import org.jetbrains.kotlin.fir.expressions.FirConstExpression import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessExpression import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference @@ -27,14 +24,14 @@ import org.jetbrains.kotlin.fir.scopes.ProcessorAction import org.jetbrains.kotlin.fir.scopes.processDirectlyOverriddenFunctions import org.jetbrains.kotlin.fir.scopes.processDirectlyOverriddenProperties import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol -import org.jetbrains.kotlin.fir.types.* -import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.fir.symbols.SymbolInternals import org.jetbrains.kotlin.fir.symbols.ensureResolved import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol +import org.jetbrains.kotlin.fir.types.* +import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.resolve.checkers.OptInNames import org.jetbrains.kotlin.utils.SmartSet @@ -57,10 +54,10 @@ object FirOptInUsageBaseChecker { fun FirBasedSymbol<*>.loadExperimentalitiesFromAnnotationTo(session: FirSession, result: MutableCollection) { ensureResolved(FirResolvePhase.STATUS) @OptIn(SymbolInternals::class) - (fir as? FirAnnotatedDeclaration)?.loadExperimentalitiesFromAnnotationTo(session, result) + fir.loadExperimentalitiesFromAnnotationTo(session, result) } - private fun FirAnnotatedDeclaration.loadExperimentalitiesFromAnnotationTo( + private fun FirDeclaration.loadExperimentalitiesFromAnnotationTo( session: FirSession, result: MutableCollection ) { @@ -104,12 +101,12 @@ object FirOptInUsageBaseChecker { private fun FirBasedSymbol<*>.loadExperimentalities( context: CheckerContext, knownExperimentalities: SmartSet?, - visited: MutableSet, + visited: MutableSet, fromSetter: Boolean, dispatchReceiverType: ConeKotlinType?, ): Set { ensureResolved(FirResolvePhase.STATUS) - val fir = this.fir as? FirAnnotatedDeclaration ?: return emptySet() + val fir = this.fir if (!visited.add(fir)) return emptySet() val result = knownExperimentalities ?: SmartSet.create() val session = context.session @@ -176,7 +173,7 @@ object FirOptInUsageBaseChecker { private fun ConeKotlinType?.addExperimentalities( context: CheckerContext, result: SmartSet, - visited: MutableSet = mutableSetOf() + visited: MutableSet = mutableSetOf() ) { if (this !is ConeClassLikeType) return lookupTag.toSymbol(context.session)?.loadExperimentalities( 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 70bdec17e26..6efae1b479b 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 @@ -87,7 +87,7 @@ class FirSignatureEnhancement( return enhancements.getOrPut(property) { enhance(property, name) } as FirVariableSymbol<*> } - private fun FirAnnotatedDeclaration.computeDefaultQualifiers() = + private fun FirDeclaration.computeDefaultQualifiers() = typeQualifierResolver.extractAndMergeDefaultQualifiers(contextQualifiers, annotations) private fun enhance( 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 d145be478ca..7d6f3521a32 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 @@ -97,7 +97,7 @@ 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 FirAnnotatedDeclaration.hasAnnotation(classId: ClassId): Boolean { +fun FirDeclaration.hasAnnotation(classId: ClassId): Boolean { return annotations.any { it.toAnnotationClassId() == classId } } diff --git a/compiler/fir/providers/src/org/jetbrains/kotlin/fir/resolve/providers/FirProvider.kt b/compiler/fir/providers/src/org/jetbrains/kotlin/fir/resolve/providers/FirProvider.kt index a8587774726..644565ee2c0 100644 --- a/compiler/fir/providers/src/org/jetbrains/kotlin/fir/resolve/providers/FirProvider.kt +++ b/compiler/fir/providers/src/org/jetbrains/kotlin/fir/resolve/providers/FirProvider.kt @@ -7,7 +7,10 @@ package org.jetbrains.kotlin.fir.resolve.providers import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.FirSessionComponent -import org.jetbrains.kotlin.fir.declarations.* +import org.jetbrains.kotlin.fir.declarations.FirClassLikeDeclaration +import org.jetbrains.kotlin.fir.declarations.FirDeclaration +import org.jetbrains.kotlin.fir.declarations.FirFile +import org.jetbrains.kotlin.fir.declarations.FirRegularClass import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol import org.jetbrains.kotlin.name.ClassId @@ -42,10 +45,10 @@ abstract class FirProvider : FirSessionComponent { abstract fun getFirFilesByPackage(fqName: FqName): List @FirProviderInternals - abstract fun recordGeneratedClass(owner: FirAnnotatedDeclaration, klass: FirRegularClass) + abstract fun recordGeneratedClass(owner: FirDeclaration, klass: FirRegularClass) @FirProviderInternals - abstract fun recordGeneratedMember(owner: FirAnnotatedDeclaration, klass: FirDeclaration) + abstract fun recordGeneratedMember(owner: FirDeclaration, klass: FirDeclaration) abstract fun getClassNamesInPackage(fqName: FqName): Set } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/extensions/FirPredicateBasedProvider.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/extensions/FirPredicateBasedProvider.kt index 901bf4eabb8..523ba3ce8df 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/extensions/FirPredicateBasedProvider.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/extensions/FirPredicateBasedProvider.kt @@ -11,7 +11,7 @@ import kotlinx.collections.immutable.PersistentList import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.FirSessionComponent import org.jetbrains.kotlin.fir.NoMutableState -import org.jetbrains.kotlin.fir.declarations.FirAnnotatedDeclaration +import org.jetbrains.kotlin.fir.declarations.FirDeclaration import org.jetbrains.kotlin.fir.declarations.FirFile import org.jetbrains.kotlin.fir.extensions.predicate.* import org.jetbrains.kotlin.fir.resolve.fqName @@ -25,11 +25,11 @@ abstract class FirPredicateBasedProvider : FirSessionComponent { } abstract fun getSymbolsByPredicate(predicate: DeclarationPredicate): List> - abstract fun getOwnersOfDeclaration(declaration: FirAnnotatedDeclaration): List>? + abstract fun getOwnersOfDeclaration(declaration: FirDeclaration): List>? abstract fun fileHasPluginAnnotations(file: FirFile): Boolean - abstract fun matches(predicate: DeclarationPredicate, declaration: FirAnnotatedDeclaration): Boolean + abstract fun matches(predicate: DeclarationPredicate, declaration: FirDeclaration): Boolean - fun matches(predicates: List, declaration: FirAnnotatedDeclaration): Boolean { + fun matches(predicates: List, declaration: FirDeclaration): Boolean { return predicates.any { matches(it, declaration) } } } @@ -52,7 +52,7 @@ class FirPredicateBasedProviderImpl(private val session: FirSession) : FirPredic return file in cache.filesWithPluginAnnotations } - fun registerAnnotatedDeclaration(declaration: FirAnnotatedDeclaration, owners: PersistentList) { + fun registerAnnotatedDeclaration(declaration: FirDeclaration, owners: PersistentList) { cache.ownersForDeclaration[declaration] = owners registerOwnersDeclarations(declaration, owners) @@ -66,11 +66,11 @@ class FirPredicateBasedProviderImpl(private val session: FirSession) : FirPredic cache.filesWithPluginAnnotations += file } - override fun getOwnersOfDeclaration(declaration: FirAnnotatedDeclaration): List>? { + override fun getOwnersOfDeclaration(declaration: FirDeclaration): List>? { return cache.ownersForDeclaration[declaration]?.map { it.symbol } } - private fun registerOwnersDeclarations(declaration: FirAnnotatedDeclaration, owners: PersistentList) { + private fun registerOwnersDeclarations(declaration: FirDeclaration, owners: PersistentList) { val lastOwner = owners.lastOrNull() ?: return val annotationsFromLastOwner = cache.annotationsOfDeclaration[lastOwner] val annotationsFromPreviousOwners = cache.parentAnnotationsOfDeclaration[lastOwner] @@ -82,53 +82,53 @@ class FirPredicateBasedProviderImpl(private val session: FirSession) : FirPredic // ---------------------------------- Matching ---------------------------------- - override fun matches(predicate: DeclarationPredicate, declaration: FirAnnotatedDeclaration): Boolean { + override fun matches(predicate: DeclarationPredicate, declaration: FirDeclaration): Boolean { return predicate.accept(matcher, declaration) } private val matcher = Matcher() - private inner class Matcher : DeclarationPredicateVisitor() { - override fun visitPredicate(predicate: DeclarationPredicate, data: FirAnnotatedDeclaration): Boolean { + private inner class Matcher : DeclarationPredicateVisitor() { + override fun visitPredicate(predicate: DeclarationPredicate, data: FirDeclaration): Boolean { throw IllegalStateException("Should not be there") } - override fun visitAny(predicate: DeclarationPredicate.Any, data: FirAnnotatedDeclaration): Boolean { + override fun visitAny(predicate: DeclarationPredicate.Any, data: FirDeclaration): Boolean { return true } - override fun visitAnd(predicate: DeclarationPredicate.And, data: FirAnnotatedDeclaration): Boolean { + override fun visitAnd(predicate: DeclarationPredicate.And, data: FirDeclaration): Boolean { return predicate.a.accept(this, data) && predicate.b.accept(this, data) } - override fun visitOr(predicate: DeclarationPredicate.Or, data: FirAnnotatedDeclaration): Boolean { + override fun visitOr(predicate: DeclarationPredicate.Or, data: FirDeclaration): Boolean { return predicate.a.accept(this, data) || predicate.b.accept(this, data) } - override fun visitAnnotatedWith(predicate: AnnotatedWith, data: FirAnnotatedDeclaration): Boolean { + override fun visitAnnotatedWith(predicate: AnnotatedWith, data: FirDeclaration): Boolean { return matchWith(data, predicate.annotations) } - override fun visitUnderAnnotatedWith(predicate: UnderAnnotatedWith, data: FirAnnotatedDeclaration): Boolean { + override fun visitUnderAnnotatedWith(predicate: UnderAnnotatedWith, data: FirDeclaration): Boolean { return matchUnder(data, predicate.annotations) } - override fun visitAnnotatedWithMeta(predicate: AnnotatedWithMeta, data: FirAnnotatedDeclaration): Boolean { + override fun visitAnnotatedWithMeta(predicate: AnnotatedWithMeta, data: FirDeclaration): Boolean { return matchWith(data, predicate.userDefinedAnnotations) } - override fun visitUnderMetaAnnotated(predicate: UnderMetaAnnotated, data: FirAnnotatedDeclaration): Boolean { + override fun visitUnderMetaAnnotated(predicate: UnderMetaAnnotated, data: FirDeclaration): Boolean { return matchUnder(data, predicate.userDefinedAnnotations) } private val MetaAnnotated.userDefinedAnnotations: Set get() = metaAnnotations.flatMapTo(mutableSetOf()) { registeredPluginAnnotations.getAnnotationsWithMetaAnnotation(it) } - private fun matchWith(declaration: FirAnnotatedDeclaration, annotations: Set): Boolean { + private fun matchWith(declaration: FirDeclaration, annotations: Set): Boolean { return cache.annotationsOfDeclaration[declaration].any { it in annotations } } - private fun matchUnder(declaration: FirAnnotatedDeclaration, annotations: Set): Boolean { + private fun matchUnder(declaration: FirDeclaration, annotations: Set): Boolean { return cache.parentAnnotationsOfDeclaration[declaration].any { it in annotations } } } @@ -136,13 +136,13 @@ class FirPredicateBasedProviderImpl(private val session: FirSession) : FirPredic // ---------------------------------- Cache ---------------------------------- private class Cache { - val declarationByAnnotation: Multimap = LinkedHashMultimap.create() - val annotationsOfDeclaration: LinkedHashMultimap = LinkedHashMultimap.create() + val declarationByAnnotation: Multimap = LinkedHashMultimap.create() + val annotationsOfDeclaration: LinkedHashMultimap = LinkedHashMultimap.create() - val declarationsUnderAnnotated: Multimap = LinkedHashMultimap.create() - val parentAnnotationsOfDeclaration: LinkedHashMultimap = LinkedHashMultimap.create() + val declarationsUnderAnnotated: Multimap = LinkedHashMultimap.create() + val parentAnnotationsOfDeclaration: LinkedHashMultimap = LinkedHashMultimap.create() - val ownersForDeclaration: MutableMap> = mutableMapOf() + val ownersForDeclaration: MutableMap> = mutableMapOf() val filesWithPluginAnnotations: MutableSet = mutableSetOf() } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/extensions/FirStatusTransformerExtension.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/extensions/FirStatusTransformerExtension.kt index 3db2b30d795..9d988e1342a 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/extensions/FirStatusTransformerExtension.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/extensions/FirStatusTransformerExtension.kt @@ -22,11 +22,11 @@ abstract class FirStatusTransformerExtension(session: FirSession) : FirPredicate final override val extensionType: KClass = FirStatusTransformerExtension::class - abstract fun needTransformStatus(declaration: FirAnnotatedDeclaration): Boolean + abstract fun needTransformStatus(declaration: FirDeclaration): Boolean protected open fun transformStatus( status: FirDeclarationStatus, - declaration: FirAnnotatedDeclaration + declaration: FirDeclaration ): FirDeclarationStatus { return status } 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 06831c4d277..b5ae28772b6 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,8 +6,8 @@ package org.jetbrains.kotlin.fir.resolve.inference import org.jetbrains.kotlin.fir.FirElement -import org.jetbrains.kotlin.fir.declarations.FirAnnotatedDeclaration import org.jetbrains.kotlin.fir.declarations.FirAnonymousFunction +import org.jetbrains.kotlin.fir.declarations.FirDeclaration import org.jetbrains.kotlin.fir.declarations.hasAnnotation import org.jetbrains.kotlin.fir.expressions.FirArgumentList import org.jetbrains.kotlin.fir.expressions.FirResolvable @@ -272,4 +272,4 @@ class FirStubTypeTransformer( private val BUILDER_INFERENCE_ANNOTATION_CLASS_ID = ClassId.topLevel(BUILDER_INFERENCE_ANNOTATION_FQ_NAME) fun FirElement.hasBuilderInferenceAnnotation(): Boolean = - (this as? FirAnnotatedDeclaration)?.hasAnnotation(BUILDER_INFERENCE_ANNOTATION_CLASS_ID) == true + (this as? FirDeclaration)?.hasAnnotation(BUILDER_INFERENCE_ANNOTATION_CLASS_ID) == true diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/providers/impl/FirLibrarySessionProvider.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/providers/impl/FirLibrarySessionProvider.kt index 2a882aaf62c..4abfcaf515e 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/providers/impl/FirLibrarySessionProvider.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/providers/impl/FirLibrarySessionProvider.kt @@ -5,7 +5,10 @@ package org.jetbrains.kotlin.fir.resolve.providers.impl -import org.jetbrains.kotlin.fir.declarations.* +import org.jetbrains.kotlin.fir.declarations.FirClassLikeDeclaration +import org.jetbrains.kotlin.fir.declarations.FirDeclaration +import org.jetbrains.kotlin.fir.declarations.FirFile +import org.jetbrains.kotlin.fir.declarations.FirRegularClass import org.jetbrains.kotlin.fir.resolve.providers.FirProvider import org.jetbrains.kotlin.fir.resolve.providers.FirProviderInternals import org.jetbrains.kotlin.fir.resolve.providers.FirSymbolProvider @@ -27,10 +30,10 @@ class FirLibrarySessionProvider( override fun getFirFilesByPackage(fqName: FqName): List = emptyList() @FirProviderInternals - override fun recordGeneratedClass(owner: FirAnnotatedDeclaration, klass: FirRegularClass) = shouldNotBeCalled() + override fun recordGeneratedClass(owner: FirDeclaration, klass: FirRegularClass) = shouldNotBeCalled() @FirProviderInternals - override fun recordGeneratedMember(owner: FirAnnotatedDeclaration, klass: FirDeclaration) = shouldNotBeCalled() + override fun recordGeneratedMember(owner: FirDeclaration, klass: FirDeclaration) = shouldNotBeCalled() override fun getClassNamesInPackage(fqName: FqName): Set = shouldNotBeCalled() diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/providers/impl/FirProviderImpl.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/providers/impl/FirProviderImpl.kt index efe6917f498..fc4ca5408cd 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/providers/impl/FirProviderImpl.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/providers/impl/FirProviderImpl.kt @@ -78,16 +78,16 @@ class FirProviderImpl(val session: FirSession, val kotlinScopeProvider: FirKotli } @FirProviderInternals - override fun recordGeneratedClass(owner: FirAnnotatedDeclaration, klass: FirRegularClass) { + override fun recordGeneratedClass(owner: FirDeclaration, klass: FirRegularClass) { klass.accept(FirRecorder, FirRecorderData(state, owner.file, session.nameConflictsTracker)) } @FirProviderInternals - override fun recordGeneratedMember(owner: FirAnnotatedDeclaration, klass: FirDeclaration) { + override fun recordGeneratedMember(owner: FirDeclaration, klass: FirDeclaration) { klass.accept(FirRecorder, FirRecorderData(state, owner.file, session.nameConflictsTracker)) } - private val FirAnnotatedDeclaration.file: FirFile + private val FirDeclaration.file: FirFile get() = when (this) { is FirFile -> this is FirRegularClass -> getFirClassifierContainerFile(this.symbol.classId) diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirStatusResolver.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirStatusResolver.kt index 8ced58f7fca..a262f8c303a 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirStatusResolver.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirStatusResolver.kt @@ -220,7 +220,7 @@ class FirStatusResolver( containingClass?.symbol?.toLookupTag(), forClass = declaration is FirClass ) val effectiveVisibility = parentEffectiveVisibility.lowerBound(selfEffectiveVisibility, session.typeContext) - val annotations = ((containingProperty ?: declaration) as? FirAnnotatedDeclaration)?.annotations ?: emptyList() + val annotations = (containingProperty ?: declaration).annotations val hasPublishedApiAnnotation = annotations.any { it.typeRef.coneTypeSafe()?.lookupTag?.classId == StandardClassIds.Annotations.PublishedApi diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirAbstractAnnotationResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirAbstractAnnotationResolveTransformer.kt index 4943da9cf61..c03e38ea981 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirAbstractAnnotationResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirAbstractAnnotationResolveTransformer.kt @@ -12,7 +12,6 @@ import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.expressions.FirAnnotation import org.jetbrains.kotlin.fir.expressions.FirStatement import org.jetbrains.kotlin.fir.resolve.ScopeSession -import org.jetbrains.kotlin.fir.scopes.FirCompositeScope import org.jetbrains.kotlin.fir.scopes.FirScope import org.jetbrains.kotlin.fir.scopes.createImportingScopes import org.jetbrains.kotlin.fir.types.FirTypeRef @@ -31,18 +30,18 @@ internal abstract class FirAbstractAnnotationResolveTransformer( val state = beforeChildren(file) file.transformDeclarations(this, data) afterChildren(state) - return transformAnnotatedDeclaration(file, data) as FirFile + return transformDeclaration(file, data) as FirFile } override fun transformProperty(property: FirProperty, data: D): FirProperty { - return transformAnnotatedDeclaration(property, data) as FirProperty + return transformDeclaration(property, data) as FirProperty } override fun transformRegularClass( regularClass: FirRegularClass, data: D ): FirStatement { - return transformAnnotatedDeclaration(regularClass, data).also { + return transformDeclaration(regularClass, data).also { val state = beforeChildren(regularClass) regularClass.transformDeclarations(this, data) regularClass.transformCompanionObject(this, data) @@ -55,7 +54,7 @@ internal abstract class FirAbstractAnnotationResolveTransformer( simpleFunction: FirSimpleFunction, data: D ): FirSimpleFunction { - return transformAnnotatedDeclaration(simpleFunction, data).also { + return transformDeclaration(simpleFunction, data).also { val state = beforeChildren(simpleFunction) simpleFunction.transformValueParameters(this, data) afterChildren(state) @@ -66,7 +65,7 @@ internal abstract class FirAbstractAnnotationResolveTransformer( constructor: FirConstructor, data: D ): FirConstructor { - return transformAnnotatedDeclaration(constructor, data).also { + return transformDeclaration(constructor, data).also { val state = beforeChildren(constructor) constructor.transformValueParameters(this, data) afterChildren(state) @@ -77,22 +76,19 @@ internal abstract class FirAbstractAnnotationResolveTransformer( valueParameter: FirValueParameter, data: D ): FirStatement { - return transformAnnotatedDeclaration(valueParameter, data) as FirStatement + return transformDeclaration(valueParameter, data) as FirStatement } override fun transformTypeAlias(typeAlias: FirTypeAlias, data: D): FirTypeAlias { - return transformAnnotatedDeclaration(typeAlias, data) as FirTypeAlias + return transformDeclaration(typeAlias, data) as FirTypeAlias } override fun transformTypeRef(typeRef: FirTypeRef, data: D): FirTypeRef { return transformAnnotationContainer(typeRef, data) as FirTypeRef } - override fun transformAnnotatedDeclaration( - annotatedDeclaration: FirAnnotatedDeclaration, - data: D - ): FirAnnotatedDeclaration { - return transformAnnotationContainer(annotatedDeclaration, data) as FirAnnotatedDeclaration + override fun transformDeclaration(declaration: FirDeclaration, data: D): FirDeclaration { + return transformAnnotationContainer(declaration, data) as FirDeclaration } override fun transformAnnotationContainer( @@ -106,7 +102,7 @@ internal abstract class FirAbstractAnnotationResolveTransformer( return element } - protected open fun beforeChildren(declaration: FirAnnotatedDeclaration): S? { + protected open fun beforeChildren(declaration: FirDeclaration): S? { return null } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirPluginAnnotationsResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirPluginAnnotationsResolveTransformer.kt index 883ba93ee69..84ab3459029 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirPluginAnnotationsResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirPluginAnnotationsResolveTransformer.kt @@ -12,7 +12,7 @@ import kotlinx.collections.immutable.persistentListOf import org.jetbrains.kotlin.descriptors.ClassKind import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.FirSession -import org.jetbrains.kotlin.fir.declarations.FirAnnotatedDeclaration +import org.jetbrains.kotlin.fir.declarations.FirDeclaration import org.jetbrains.kotlin.fir.declarations.FirFile import org.jetbrains.kotlin.fir.declarations.FirRegularClass import org.jetbrains.kotlin.fir.declarations.FirResolvePhase @@ -82,7 +82,7 @@ private class FirPartialImportResolveTransformer( private class FirAnnotationResolveTransformer( session: FirSession, scopeSession: ScopeSession -) : FirAbstractAnnotationResolveTransformer, PersistentList>(session, scopeSession) { +) : FirAbstractAnnotationResolveTransformer, PersistentList>(session, scopeSession) { private val predicateBasedProvider = session.predicateBasedProvider as FirPredicateBasedProviderImpl var metaAnnotations: Set = emptySet() @@ -91,16 +91,16 @@ private class FirAnnotationResolveTransformer( errorTypeAsResolved = false ) - private var owners: PersistentList = persistentListOf() + private var owners: PersistentList = persistentListOf() private val classDeclarationsStack = ArrayDeque() - override fun beforeChildren(declaration: FirAnnotatedDeclaration): PersistentList { + override fun beforeChildren(declaration: FirDeclaration): PersistentList { val current = owners owners = owners.add(declaration) return current } - override fun afterChildren(state: PersistentList?) { + override fun afterChildren(state: PersistentList?) { requireNotNull(state) owners = state } @@ -135,12 +135,9 @@ private class FirAnnotationResolveTransformer( } } - override fun transformAnnotatedDeclaration( - annotatedDeclaration: FirAnnotatedDeclaration, - data: Multimap - ): FirAnnotatedDeclaration { - return super.transformAnnotatedDeclaration(annotatedDeclaration, data).also { - predicateBasedProvider.registerAnnotatedDeclaration(annotatedDeclaration, owners) + override fun transformDeclaration(declaration: FirDeclaration, data: Multimap): FirDeclaration { + return super.transformDeclaration(declaration, data).also { + predicateBasedProvider.registerAnnotatedDeclaration(declaration, owners) } } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/GeneratedClassIndex.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/GeneratedClassIndex.kt index 5079609b074..8b2bc92d25e 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/GeneratedClassIndex.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/GeneratedClassIndex.kt @@ -9,12 +9,12 @@ import com.google.common.collect.ArrayListMultimap import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.FirSessionComponent import org.jetbrains.kotlin.fir.ThreadSafeMutableState -import org.jetbrains.kotlin.fir.declarations.FirAnnotatedDeclaration +import org.jetbrains.kotlin.fir.declarations.FirDeclaration import org.jetbrains.kotlin.fir.declarations.FirDeclarationOrigin import org.jetbrains.kotlin.fir.declarations.FirPluginKey import org.jetbrains.kotlin.fir.declarations.FirRegularClass -data class GeneratedClass(val klass: FirRegularClass, val owner: FirAnnotatedDeclaration) +data class GeneratedClass(val klass: FirRegularClass, val owner: FirDeclaration) abstract class GeneratedClassIndex : FirSessionComponent { companion object { @@ -23,7 +23,7 @@ abstract class GeneratedClassIndex : FirSessionComponent { } } - abstract fun registerClass(klass: FirRegularClass, owner: FirAnnotatedDeclaration) + abstract fun registerClass(klass: FirRegularClass, owner: FirDeclaration) abstract operator fun get(key: FirPluginKey): List } @@ -33,7 +33,7 @@ val FirSession.generatedClassIndex: GeneratedClassIndex by FirSession.sessionCom private class GeneratedClassIndexImpl : GeneratedClassIndex() { private val index: ArrayListMultimap = ArrayListMultimap.create() - override fun registerClass(klass: FirRegularClass, owner: FirAnnotatedDeclaration) { + override fun registerClass(klass: FirRegularClass, owner: FirDeclaration) { val key = (klass.origin as FirDeclarationOrigin.Plugin).key index.put(key, GeneratedClass(klass, owner)) } diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirAnnotatedDeclaration.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirAnnotatedDeclaration.kt deleted file mode 100644 index 3dcc84ce241..00000000000 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirAnnotatedDeclaration.kt +++ /dev/null @@ -1,39 +0,0 @@ -/* - * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors. - * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. - */ - -package org.jetbrains.kotlin.fir.declarations - -import org.jetbrains.kotlin.KtSourceElement -import org.jetbrains.kotlin.fir.FirAnnotationContainer -import org.jetbrains.kotlin.fir.FirElement -import org.jetbrains.kotlin.fir.FirModuleData -import org.jetbrains.kotlin.fir.expressions.FirAnnotation -import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol -import org.jetbrains.kotlin.fir.visitors.* - -/* - * This file was generated automatically - * DO NOT MODIFY IT MANUALLY - */ - -sealed class FirAnnotatedDeclaration : FirDeclaration(), FirAnnotationContainer { - abstract override val source: KtSourceElement? - abstract override val symbol: FirBasedSymbol - abstract override val moduleData: FirModuleData - abstract override val resolvePhase: FirResolvePhase - abstract override val origin: FirDeclarationOrigin - abstract override val attributes: FirDeclarationAttributes - abstract override val annotations: List - - override fun accept(visitor: FirVisitor, data: D): R = visitor.visitAnnotatedDeclaration(this, data) - - @Suppress("UNCHECKED_CAST") - override fun transform(transformer: FirTransformer, data: D): E = - transformer.transformAnnotatedDeclaration(this, data) as E - - abstract override fun replaceResolvePhase(newResolvePhase: FirResolvePhase) - - abstract override fun transformAnnotations(transformer: FirTransformer, data: D): FirAnnotatedDeclaration -} diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirAnonymousFunction.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirAnonymousFunction.kt index 4745e4da00f..a7d8d923227 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirAnonymousFunction.kt +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirAnonymousFunction.kt @@ -26,11 +26,11 @@ import org.jetbrains.kotlin.fir.visitors.* abstract class FirAnonymousFunction : FirFunction(), FirTypeParametersOwner { abstract override val source: KtSourceElement? + abstract override val annotations: List abstract override val moduleData: FirModuleData abstract override val resolvePhase: FirResolvePhase abstract override val origin: FirDeclarationOrigin abstract override val attributes: FirDeclarationAttributes - abstract override val annotations: List abstract override val status: FirDeclarationStatus abstract override val returnTypeRef: FirTypeRef abstract override val receiverTypeRef: FirTypeRef? diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirAnonymousInitializer.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirAnonymousInitializer.kt index ea56c68db8c..958b6af416c 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirAnonymousInitializer.kt +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirAnonymousInitializer.kt @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.fir.declarations import org.jetbrains.kotlin.KtSourceElement import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.FirModuleData +import org.jetbrains.kotlin.fir.expressions.FirAnnotation import org.jetbrains.kotlin.fir.expressions.FirBlock import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference import org.jetbrains.kotlin.fir.symbols.impl.FirAnonymousInitializerSymbol @@ -20,6 +21,7 @@ import org.jetbrains.kotlin.fir.visitors.* abstract class FirAnonymousInitializer : FirDeclaration(), FirControlFlowGraphOwner { abstract override val source: KtSourceElement? + abstract override val annotations: List abstract override val moduleData: FirModuleData abstract override val resolvePhase: FirResolvePhase abstract override val origin: FirDeclarationOrigin @@ -37,4 +39,6 @@ abstract class FirAnonymousInitializer : FirDeclaration(), FirControlFlowGraphOw abstract override fun replaceResolvePhase(newResolvePhase: FirResolvePhase) abstract override fun replaceControlFlowGraphReference(newControlFlowGraphReference: FirControlFlowGraphReference?) + + abstract override fun transformAnnotations(transformer: FirTransformer, data: D): FirAnonymousInitializer } diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirCallableDeclaration.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirCallableDeclaration.kt index 3f783bce3fa..190b3ce3f71 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirCallableDeclaration.kt +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirCallableDeclaration.kt @@ -22,11 +22,11 @@ import org.jetbrains.kotlin.fir.visitors.* sealed class FirCallableDeclaration : FirTypedDeclaration() { abstract override val source: KtSourceElement? + abstract override val annotations: List abstract override val moduleData: FirModuleData abstract override val resolvePhase: FirResolvePhase abstract override val origin: FirDeclarationOrigin abstract override val attributes: FirDeclarationAttributes - abstract override val annotations: List abstract override val typeParameters: List abstract override val status: FirDeclarationStatus abstract override val returnTypeRef: FirTypeRef diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirClassLikeDeclaration.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirClassLikeDeclaration.kt index 45ea0766471..7d92ba90556 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirClassLikeDeclaration.kt +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirClassLikeDeclaration.kt @@ -20,11 +20,11 @@ import org.jetbrains.kotlin.fir.visitors.* sealed class FirClassLikeDeclaration : FirMemberDeclaration(), FirStatement { abstract override val source: KtSourceElement? + abstract override val annotations: List abstract override val moduleData: FirModuleData abstract override val resolvePhase: FirResolvePhase abstract override val origin: FirDeclarationOrigin abstract override val attributes: FirDeclarationAttributes - abstract override val annotations: List abstract override val typeParameters: List abstract override val status: FirDeclarationStatus abstract override val symbol: FirClassLikeSymbol diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirDeclaration.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirDeclaration.kt index ecbb5ad4e48..f98eb3e3b83 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirDeclaration.kt +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirDeclaration.kt @@ -6,9 +6,11 @@ package org.jetbrains.kotlin.fir.declarations import org.jetbrains.kotlin.KtSourceElement +import org.jetbrains.kotlin.fir.FirAnnotationContainer import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.FirModuleData import org.jetbrains.kotlin.fir.FirPureAbstractElement +import org.jetbrains.kotlin.fir.expressions.FirAnnotation import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol import org.jetbrains.kotlin.fir.visitors.* @@ -17,8 +19,9 @@ import org.jetbrains.kotlin.fir.visitors.* * DO NOT MODIFY IT MANUALLY */ -sealed class FirDeclaration : FirPureAbstractElement(), FirElement { +sealed class FirDeclaration : FirPureAbstractElement(), FirAnnotationContainer { abstract override val source: KtSourceElement? + abstract override val annotations: List abstract val symbol: FirBasedSymbol abstract val moduleData: FirModuleData abstract val resolvePhase: FirResolvePhase @@ -32,4 +35,6 @@ sealed class FirDeclaration : FirPureAbstractElement(), FirElement { transformer.transformDeclaration(this, data) as E abstract fun replaceResolvePhase(newResolvePhase: FirResolvePhase) + + abstract override fun transformAnnotations(transformer: FirTransformer, data: D): FirDeclaration } diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirErrorFunction.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirErrorFunction.kt index 637fccac234..c7db0df86eb 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirErrorFunction.kt +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirErrorFunction.kt @@ -26,11 +26,11 @@ import org.jetbrains.kotlin.fir.visitors.* abstract class FirErrorFunction : FirFunction(), FirDiagnosticHolder { abstract override val source: KtSourceElement? + abstract override val annotations: List abstract override val moduleData: FirModuleData abstract override val resolvePhase: FirResolvePhase abstract override val origin: FirDeclarationOrigin abstract override val attributes: FirDeclarationAttributes - abstract override val annotations: List abstract override val status: FirDeclarationStatus abstract override val returnTypeRef: FirTypeRef abstract override val receiverTypeRef: FirTypeRef? diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirFile.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirFile.kt index 4b11a03838b..55c66a3fe3e 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirFile.kt +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirFile.kt @@ -18,13 +18,13 @@ import org.jetbrains.kotlin.fir.visitors.* * DO NOT MODIFY IT MANUALLY */ -abstract class FirFile : FirAnnotatedDeclaration() { +abstract class FirFile : FirDeclaration() { abstract override val source: KtSourceElement? + abstract override val annotations: List abstract override val moduleData: FirModuleData abstract override val resolvePhase: FirResolvePhase abstract override val origin: FirDeclarationOrigin abstract override val attributes: FirDeclarationAttributes - abstract override val annotations: List abstract val packageDirective: FirPackageDirective abstract val imports: List abstract val declarations: List diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirFunction.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirFunction.kt index 31d02d920d8..37ebed3e06a 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirFunction.kt +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirFunction.kt @@ -26,11 +26,11 @@ import org.jetbrains.kotlin.fir.visitors.* sealed class FirFunction : FirCallableDeclaration(), FirTargetElement, FirControlFlowGraphOwner, FirStatement { abstract override val source: KtSourceElement? + abstract override val annotations: List abstract override val moduleData: FirModuleData abstract override val resolvePhase: FirResolvePhase abstract override val origin: FirDeclarationOrigin abstract override val attributes: FirDeclarationAttributes - abstract override val annotations: List abstract override val typeParameters: List abstract override val status: FirDeclarationStatus abstract override val returnTypeRef: FirTypeRef diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirMemberDeclaration.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirMemberDeclaration.kt index 4e0273ab226..d907f9d7127 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirMemberDeclaration.kt +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirMemberDeclaration.kt @@ -17,14 +17,14 @@ import org.jetbrains.kotlin.fir.visitors.* * DO NOT MODIFY IT MANUALLY */ -sealed class FirMemberDeclaration : FirAnnotatedDeclaration(), FirTypeParameterRefsOwner { +sealed class FirMemberDeclaration : FirDeclaration(), FirTypeParameterRefsOwner { abstract override val source: KtSourceElement? + abstract override val annotations: List abstract override val symbol: FirBasedSymbol abstract override val moduleData: FirModuleData abstract override val resolvePhase: FirResolvePhase abstract override val origin: FirDeclarationOrigin abstract override val attributes: FirDeclarationAttributes - abstract override val annotations: List abstract override val typeParameters: List abstract val status: FirDeclarationStatus diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirTypeParameter.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirTypeParameter.kt index fb483ea60cb..45b0d31e509 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirTypeParameter.kt +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirTypeParameter.kt @@ -21,7 +21,7 @@ import org.jetbrains.kotlin.fir.visitors.* * DO NOT MODIFY IT MANUALLY */ -abstract class FirTypeParameter : FirTypeParameterRef, FirAnnotatedDeclaration() { +abstract class FirTypeParameter : FirTypeParameterRef, FirDeclaration() { abstract override val source: KtSourceElement? abstract override val moduleData: FirModuleData abstract override val resolvePhase: FirResolvePhase diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirTypedDeclaration.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirTypedDeclaration.kt index a9aa8a261b5..3b3c6faa059 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirTypedDeclaration.kt +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirTypedDeclaration.kt @@ -20,12 +20,12 @@ import org.jetbrains.kotlin.fir.visitors.* sealed class FirTypedDeclaration : FirMemberDeclaration() { abstract override val source: KtSourceElement? + abstract override val annotations: List abstract override val symbol: FirBasedSymbol abstract override val moduleData: FirModuleData abstract override val resolvePhase: FirResolvePhase abstract override val origin: FirDeclarationOrigin abstract override val attributes: FirDeclarationAttributes - abstract override val annotations: List abstract override val typeParameters: List abstract override val status: FirDeclarationStatus abstract val returnTypeRef: FirTypeRef diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/builder/FirAbstractConstructorBuilder.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/builder/FirAbstractConstructorBuilder.kt index 13aae3b2e3a..b9520203516 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/builder/FirAbstractConstructorBuilder.kt +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/builder/FirAbstractConstructorBuilder.kt @@ -35,11 +35,11 @@ import org.jetbrains.kotlin.serialization.deserialization.descriptors.Deserializ @FirBuilderDsl interface FirAbstractConstructorBuilder : FirFunctionBuilder { abstract override var source: KtSourceElement? + abstract override val annotations: MutableList abstract override var moduleData: FirModuleData abstract override var resolvePhase: FirResolvePhase abstract override var origin: FirDeclarationOrigin abstract override var attributes: FirDeclarationAttributes - abstract override val annotations: MutableList abstract override var status: FirDeclarationStatus abstract override var returnTypeRef: FirTypeRef abstract override var deprecation: DeprecationsPerUseSite? diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/builder/FirAnonymousFunctionBuilder.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/builder/FirAnonymousFunctionBuilder.kt index eca78b6c2c3..c0ae3a401da 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/builder/FirAnonymousFunctionBuilder.kt +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/builder/FirAnonymousFunctionBuilder.kt @@ -42,10 +42,10 @@ import org.jetbrains.kotlin.serialization.deserialization.descriptors.Deserializ @FirBuilderDsl class FirAnonymousFunctionBuilder : FirFunctionBuilder, FirAnnotationContainerBuilder { override var source: KtSourceElement? = null + override val annotations: MutableList = mutableListOf() override lateinit var moduleData: FirModuleData override lateinit var origin: FirDeclarationOrigin override var attributes: FirDeclarationAttributes = FirDeclarationAttributes() - override val annotations: MutableList = mutableListOf() override lateinit var returnTypeRef: FirTypeRef var receiverTypeRef: FirTypeRef? = null override var deprecation: DeprecationsPerUseSite? = null @@ -66,10 +66,10 @@ class FirAnonymousFunctionBuilder : FirFunctionBuilder, FirAnnotationContainerBu override fun build(): FirAnonymousFunction { return FirAnonymousFunctionImpl( source, + annotations, moduleData, origin, attributes, - annotations, returnTypeRef, receiverTypeRef, deprecation, diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/builder/FirAnonymousInitializerBuilder.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/builder/FirAnonymousInitializerBuilder.kt index 3f35dc1e422..4b72a557c75 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/builder/FirAnonymousInitializerBuilder.kt +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/builder/FirAnonymousInitializerBuilder.kt @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.fir.declarations.builder import kotlin.contracts.* import org.jetbrains.kotlin.KtSourceElement import org.jetbrains.kotlin.fir.FirModuleData +import org.jetbrains.kotlin.fir.builder.FirAnnotationContainerBuilder import org.jetbrains.kotlin.fir.builder.FirBuilderDsl import org.jetbrains.kotlin.fir.declarations.FirAnonymousInitializer import org.jetbrains.kotlin.fir.declarations.FirDeclarationAttributes @@ -15,6 +16,7 @@ import org.jetbrains.kotlin.fir.declarations.FirDeclarationOrigin import org.jetbrains.kotlin.fir.declarations.FirResolvePhase import org.jetbrains.kotlin.fir.declarations.builder.FirDeclarationBuilder import org.jetbrains.kotlin.fir.declarations.impl.FirAnonymousInitializerImpl +import org.jetbrains.kotlin.fir.expressions.FirAnnotation import org.jetbrains.kotlin.fir.expressions.FirBlock import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference import org.jetbrains.kotlin.fir.symbols.impl.FirAnonymousInitializerSymbol @@ -26,7 +28,7 @@ import org.jetbrains.kotlin.fir.visitors.* */ @FirBuilderDsl -class FirAnonymousInitializerBuilder : FirDeclarationBuilder { +class FirAnonymousInitializerBuilder : FirDeclarationBuilder, FirAnnotationContainerBuilder { override var source: KtSourceElement? = null override lateinit var moduleData: FirModuleData override var resolvePhase: FirResolvePhase = FirResolvePhase.RAW_FIR @@ -47,6 +49,9 @@ class FirAnonymousInitializerBuilder : FirDeclarationBuilder { ) } + + @Deprecated("Modification of 'annotations' has no impact for FirAnonymousInitializerBuilder", level = DeprecationLevel.HIDDEN) + override val annotations: MutableList = mutableListOf() } @OptIn(ExperimentalContracts::class) diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/builder/FirClassBuilder.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/builder/FirClassBuilder.kt index 37ae2eb3bd1..7f3b9b4216e 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/builder/FirClassBuilder.kt +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/builder/FirClassBuilder.kt @@ -32,11 +32,11 @@ import org.jetbrains.kotlin.fir.visitors.* @FirBuilderDsl interface FirClassBuilder : FirDeclarationBuilder, FirAnnotationContainerBuilder { abstract override var source: KtSourceElement? + abstract override val annotations: MutableList abstract override var moduleData: FirModuleData abstract override var resolvePhase: FirResolvePhase abstract override var origin: FirDeclarationOrigin abstract override var attributes: FirDeclarationAttributes - abstract override val annotations: MutableList abstract val typeParameters: MutableList abstract var status: FirDeclarationStatus abstract var deprecation: DeprecationsPerUseSite? diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/builder/FirDeclarationBuilder.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/builder/FirDeclarationBuilder.kt index 39b36f33e99..18d5b3bd083 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/builder/FirDeclarationBuilder.kt +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/builder/FirDeclarationBuilder.kt @@ -12,6 +12,7 @@ import org.jetbrains.kotlin.fir.declarations.FirDeclaration import org.jetbrains.kotlin.fir.declarations.FirDeclarationAttributes import org.jetbrains.kotlin.fir.declarations.FirDeclarationOrigin import org.jetbrains.kotlin.fir.declarations.FirResolvePhase +import org.jetbrains.kotlin.fir.expressions.FirAnnotation import org.jetbrains.kotlin.fir.visitors.* /* @@ -22,6 +23,7 @@ import org.jetbrains.kotlin.fir.visitors.* @FirBuilderDsl interface FirDeclarationBuilder { abstract var source: KtSourceElement? + abstract val annotations: MutableList abstract var moduleData: FirModuleData abstract var resolvePhase: FirResolvePhase abstract var origin: FirDeclarationOrigin diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/builder/FirErrorFunctionBuilder.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/builder/FirErrorFunctionBuilder.kt index 5b5c139545f..e1dc5cb3c51 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/builder/FirErrorFunctionBuilder.kt +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/builder/FirErrorFunctionBuilder.kt @@ -39,11 +39,11 @@ import org.jetbrains.kotlin.serialization.deserialization.descriptors.Deserializ @FirBuilderDsl class FirErrorFunctionBuilder : FirAnnotationContainerBuilder { override var source: KtSourceElement? = null + override val annotations: MutableList = mutableListOf() lateinit var moduleData: FirModuleData var resolvePhase: FirResolvePhase = FirResolvePhase.RAW_FIR lateinit var origin: FirDeclarationOrigin var attributes: FirDeclarationAttributes = FirDeclarationAttributes() - override val annotations: MutableList = mutableListOf() var deprecation: DeprecationsPerUseSite? = null var containerSource: DeserializedContainerSource? = null var dispatchReceiverType: ConeKotlinType? = null @@ -54,11 +54,11 @@ class FirErrorFunctionBuilder : FirAnnotationContainerBuilder { override fun build(): FirErrorFunction { return FirErrorFunctionImpl( source, + annotations, moduleData, resolvePhase, origin, attributes, - annotations, deprecation, containerSource, dispatchReceiverType, diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/builder/FirFileBuilder.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/builder/FirFileBuilder.kt index 12d9094fb84..05ebe41fb65 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/builder/FirFileBuilder.kt +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/builder/FirFileBuilder.kt @@ -30,11 +30,11 @@ import org.jetbrains.kotlin.fir.visitors.* @FirBuilderDsl class FirFileBuilder : FirAnnotationContainerBuilder { override var source: KtSourceElement? = null + override val annotations: MutableList = mutableListOf() lateinit var moduleData: FirModuleData var resolvePhase: FirResolvePhase = FirResolvePhase.RAW_FIR lateinit var origin: FirDeclarationOrigin var attributes: FirDeclarationAttributes = FirDeclarationAttributes() - override val annotations: MutableList = mutableListOf() lateinit var packageDirective: FirPackageDirective val imports: MutableList = mutableListOf() val declarations: MutableList = mutableListOf() @@ -44,11 +44,11 @@ class FirFileBuilder : FirAnnotationContainerBuilder { override fun build(): FirFile { return FirFileImpl( source, + annotations, moduleData, resolvePhase, origin, attributes, - annotations, packageDirective, imports, declarations, diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/builder/FirFunctionBuilder.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/builder/FirFunctionBuilder.kt index 1ea8b6ad8e1..6f4c4714e51 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/builder/FirFunctionBuilder.kt +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/builder/FirFunctionBuilder.kt @@ -32,11 +32,11 @@ import org.jetbrains.kotlin.serialization.deserialization.descriptors.Deserializ @FirBuilderDsl interface FirFunctionBuilder : FirDeclarationBuilder, FirAnnotationContainerBuilder { abstract override var source: KtSourceElement? + abstract override val annotations: MutableList abstract override var moduleData: FirModuleData abstract override var resolvePhase: FirResolvePhase abstract override var origin: FirDeclarationOrigin abstract override var attributes: FirDeclarationAttributes - abstract override val annotations: MutableList abstract var status: FirDeclarationStatus abstract var returnTypeRef: FirTypeRef abstract var deprecation: DeprecationsPerUseSite? diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/impl/FirAnonymousFunctionImpl.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/impl/FirAnonymousFunctionImpl.kt index ec576a5b364..b9936d5c1d0 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/impl/FirAnonymousFunctionImpl.kt +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/impl/FirAnonymousFunctionImpl.kt @@ -35,10 +35,10 @@ import org.jetbrains.kotlin.fir.visitors.* internal class FirAnonymousFunctionImpl( override val source: KtSourceElement?, + override val annotations: MutableList, override val moduleData: FirModuleData, override val origin: FirDeclarationOrigin, override val attributes: FirDeclarationAttributes, - override val annotations: MutableList, override var returnTypeRef: FirTypeRef, override var receiverTypeRef: FirTypeRef?, override var deprecation: DeprecationsPerUseSite?, diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/impl/FirAnonymousInitializerImpl.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/impl/FirAnonymousInitializerImpl.kt index eb6de3aba1d..8aa8ade62cf 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/impl/FirAnonymousInitializerImpl.kt +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/impl/FirAnonymousInitializerImpl.kt @@ -11,6 +11,7 @@ import org.jetbrains.kotlin.fir.declarations.FirAnonymousInitializer import org.jetbrains.kotlin.fir.declarations.FirDeclarationAttributes import org.jetbrains.kotlin.fir.declarations.FirDeclarationOrigin import org.jetbrains.kotlin.fir.declarations.FirResolvePhase +import org.jetbrains.kotlin.fir.expressions.FirAnnotation import org.jetbrains.kotlin.fir.expressions.FirBlock import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference import org.jetbrains.kotlin.fir.symbols.impl.FirAnonymousInitializerSymbol @@ -31,6 +32,7 @@ internal class FirAnonymousInitializerImpl( override var body: FirBlock?, override val symbol: FirAnonymousInitializerSymbol, ) : FirAnonymousInitializer() { + override val annotations: List get() = emptyList() override var controlFlowGraphReference: FirControlFlowGraphReference? = null init { @@ -48,6 +50,10 @@ internal class FirAnonymousInitializerImpl( return this } + override fun transformAnnotations(transformer: FirTransformer, data: D): FirAnonymousInitializerImpl { + return this + } + override fun replaceResolvePhase(newResolvePhase: FirResolvePhase) { resolvePhase = newResolvePhase } diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/impl/FirErrorFunctionImpl.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/impl/FirErrorFunctionImpl.kt index ef4d64fe625..720b01ac4d8 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/impl/FirErrorFunctionImpl.kt +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/impl/FirErrorFunctionImpl.kt @@ -34,12 +34,12 @@ import org.jetbrains.kotlin.fir.visitors.* internal class FirErrorFunctionImpl( override val source: KtSourceElement?, + override val annotations: MutableList, override val moduleData: FirModuleData, @Volatile override var resolvePhase: FirResolvePhase, override val origin: FirDeclarationOrigin, override val attributes: FirDeclarationAttributes, - override val annotations: MutableList, override var deprecation: DeprecationsPerUseSite?, override val containerSource: DeserializedContainerSource?, override val dispatchReceiverType: ConeKotlinType?, diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/impl/FirFileImpl.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/impl/FirFileImpl.kt index 998733b7e60..a638f5daedb 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/impl/FirFileImpl.kt +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/impl/FirFileImpl.kt @@ -25,12 +25,12 @@ import org.jetbrains.kotlin.fir.visitors.* internal class FirFileImpl( override val source: KtSourceElement?, + override val annotations: MutableList, override val moduleData: FirModuleData, @Volatile override var resolvePhase: FirResolvePhase, override val origin: FirDeclarationOrigin, override val attributes: FirDeclarationAttributes, - override val annotations: MutableList, override var packageDirective: FirPackageDirective, override val imports: MutableList, override val declarations: MutableList, diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirDefaultVisitor.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirDefaultVisitor.kt index b646d0c851b..92b93e92532 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirDefaultVisitor.kt +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirDefaultVisitor.kt @@ -20,7 +20,6 @@ import org.jetbrains.kotlin.fir.expressions.FirExpression import org.jetbrains.kotlin.fir.declarations.FirDeclaration import org.jetbrains.kotlin.fir.declarations.FirTypeParameterRefsOwner import org.jetbrains.kotlin.fir.declarations.FirTypeParametersOwner -import org.jetbrains.kotlin.fir.declarations.FirAnnotatedDeclaration import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration import org.jetbrains.kotlin.fir.declarations.FirAnonymousInitializer import org.jetbrains.kotlin.fir.declarations.FirTypedDeclaration @@ -152,6 +151,8 @@ abstract class FirDefaultVisitor : FirVisitor() { override fun visitExpression(expression: FirExpression, data: D): R = visitStatement(expression, data) + override fun visitDeclaration(declaration: FirDeclaration, data: D): R = visitAnnotationContainer(declaration, data) + override fun visitTypeParametersOwner(typeParametersOwner: FirTypeParametersOwner, data: D): R = visitTypeParameterRefsOwner(typeParametersOwner, data) override fun visitTypedDeclaration(typedDeclaration: FirTypedDeclaration, data: D): R = visitMemberDeclaration(typedDeclaration, data) @@ -162,7 +163,7 @@ abstract class FirDefaultVisitor : FirVisitor() { override fun visitEnumEntry(enumEntry: FirEnumEntry, data: D): R = visitVariable(enumEntry, data) - override fun visitFile(file: FirFile, data: D): R = visitAnnotatedDeclaration(file, data) + override fun visitFile(file: FirFile, data: D): R = visitDeclaration(file, data) override fun visitAnonymousFunctionExpression(anonymousFunctionExpression: FirAnonymousFunctionExpression, data: D): R = visitExpression(anonymousFunctionExpression, data) diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirDefaultVisitorVoid.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirDefaultVisitorVoid.kt index 75c7c4768b5..743fac567e6 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirDefaultVisitorVoid.kt +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirDefaultVisitorVoid.kt @@ -20,7 +20,6 @@ import org.jetbrains.kotlin.fir.expressions.FirExpression import org.jetbrains.kotlin.fir.declarations.FirDeclaration import org.jetbrains.kotlin.fir.declarations.FirTypeParameterRefsOwner import org.jetbrains.kotlin.fir.declarations.FirTypeParametersOwner -import org.jetbrains.kotlin.fir.declarations.FirAnnotatedDeclaration import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration import org.jetbrains.kotlin.fir.declarations.FirAnonymousInitializer import org.jetbrains.kotlin.fir.declarations.FirTypedDeclaration @@ -152,6 +151,8 @@ abstract class FirDefaultVisitorVoid : FirVisitorVoid() { override fun visitExpression(expression: FirExpression) = visitStatement(expression) + override fun visitDeclaration(declaration: FirDeclaration) = visitAnnotationContainer(declaration) + override fun visitTypeParametersOwner(typeParametersOwner: FirTypeParametersOwner) = visitTypeParameterRefsOwner(typeParametersOwner) override fun visitTypedDeclaration(typedDeclaration: FirTypedDeclaration) = visitMemberDeclaration(typedDeclaration) @@ -162,7 +163,7 @@ abstract class FirDefaultVisitorVoid : FirVisitorVoid() { override fun visitEnumEntry(enumEntry: FirEnumEntry) = visitVariable(enumEntry) - override fun visitFile(file: FirFile) = visitAnnotatedDeclaration(file) + override fun visitFile(file: FirFile) = visitDeclaration(file) override fun visitAnonymousFunctionExpression(anonymousFunctionExpression: FirAnonymousFunctionExpression) = visitExpression(anonymousFunctionExpression) diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirTransformer.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirTransformer.kt index 72ebcc5dca7..d3567035d4a 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirTransformer.kt +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirTransformer.kt @@ -20,7 +20,6 @@ import org.jetbrains.kotlin.fir.expressions.FirExpression import org.jetbrains.kotlin.fir.declarations.FirDeclaration import org.jetbrains.kotlin.fir.declarations.FirTypeParameterRefsOwner import org.jetbrains.kotlin.fir.declarations.FirTypeParametersOwner -import org.jetbrains.kotlin.fir.declarations.FirAnnotatedDeclaration import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration import org.jetbrains.kotlin.fir.declarations.FirAnonymousInitializer import org.jetbrains.kotlin.fir.declarations.FirTypedDeclaration @@ -203,10 +202,6 @@ abstract class FirTransformer : FirVisitor() { return transformElement(typeParametersOwner, data) } - open fun transformAnnotatedDeclaration(annotatedDeclaration: FirAnnotatedDeclaration, data: D): FirAnnotatedDeclaration { - return transformElement(annotatedDeclaration, data) - } - open fun transformMemberDeclaration(memberDeclaration: FirMemberDeclaration, data: D): FirMemberDeclaration { return transformElement(memberDeclaration, data) } @@ -731,10 +726,6 @@ abstract class FirTransformer : FirVisitor() { return transformTypeParametersOwner(typeParametersOwner, data) } - final override fun visitAnnotatedDeclaration(annotatedDeclaration: FirAnnotatedDeclaration, data: D): FirAnnotatedDeclaration { - return transformAnnotatedDeclaration(annotatedDeclaration, data) - } - final override fun visitMemberDeclaration(memberDeclaration: FirMemberDeclaration, data: D): FirMemberDeclaration { return transformMemberDeclaration(memberDeclaration, data) } diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirVisitor.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirVisitor.kt index 98ab9b99d26..d7056dbf314 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirVisitor.kt +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirVisitor.kt @@ -20,7 +20,6 @@ import org.jetbrains.kotlin.fir.expressions.FirExpression import org.jetbrains.kotlin.fir.declarations.FirDeclaration import org.jetbrains.kotlin.fir.declarations.FirTypeParameterRefsOwner import org.jetbrains.kotlin.fir.declarations.FirTypeParametersOwner -import org.jetbrains.kotlin.fir.declarations.FirAnnotatedDeclaration import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration import org.jetbrains.kotlin.fir.declarations.FirAnonymousInitializer import org.jetbrains.kotlin.fir.declarations.FirTypedDeclaration @@ -174,8 +173,6 @@ abstract class FirVisitor { open fun visitTypeParametersOwner(typeParametersOwner: FirTypeParametersOwner, data: D): R = visitElement(typeParametersOwner, data) - open fun visitAnnotatedDeclaration(annotatedDeclaration: FirAnnotatedDeclaration, data: D): R = visitElement(annotatedDeclaration, data) - open fun visitMemberDeclaration(memberDeclaration: FirMemberDeclaration, data: D): R = visitElement(memberDeclaration, data) open fun visitAnonymousInitializer(anonymousInitializer: FirAnonymousInitializer, data: D): R = visitElement(anonymousInitializer, data) diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirVisitorVoid.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirVisitorVoid.kt index 51a9dcd919d..a26e5d7d801 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirVisitorVoid.kt +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirVisitorVoid.kt @@ -20,7 +20,6 @@ import org.jetbrains.kotlin.fir.expressions.FirExpression import org.jetbrains.kotlin.fir.declarations.FirDeclaration import org.jetbrains.kotlin.fir.declarations.FirTypeParameterRefsOwner import org.jetbrains.kotlin.fir.declarations.FirTypeParametersOwner -import org.jetbrains.kotlin.fir.declarations.FirAnnotatedDeclaration import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration import org.jetbrains.kotlin.fir.declarations.FirAnonymousInitializer import org.jetbrains.kotlin.fir.declarations.FirTypedDeclaration @@ -202,10 +201,6 @@ abstract class FirVisitorVoid : FirVisitor() { visitElement(typeParametersOwner) } - open fun visitAnnotatedDeclaration(annotatedDeclaration: FirAnnotatedDeclaration) { - visitElement(annotatedDeclaration) - } - open fun visitMemberDeclaration(memberDeclaration: FirMemberDeclaration) { visitElement(memberDeclaration) } @@ -730,10 +725,6 @@ abstract class FirVisitorVoid : FirVisitor() { visitTypeParametersOwner(typeParametersOwner) } - final override fun visitAnnotatedDeclaration(annotatedDeclaration: FirAnnotatedDeclaration, data: Nothing?) { - visitAnnotatedDeclaration(annotatedDeclaration) - } - final override fun visitMemberDeclaration(memberDeclaration: FirMemberDeclaration, data: Nothing?) { visitMemberDeclaration(memberDeclaration) } diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/FirBasedSymbol.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/FirBasedSymbol.kt index c17d8cf290b..76371b16a81 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/FirBasedSymbol.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/FirBasedSymbol.kt @@ -7,7 +7,6 @@ package org.jetbrains.kotlin.fir.symbols import org.jetbrains.kotlin.KtSourceElement import org.jetbrains.kotlin.fir.FirModuleData -import org.jetbrains.kotlin.fir.declarations.FirAnnotatedDeclaration import org.jetbrains.kotlin.fir.declarations.FirDeclaration import org.jetbrains.kotlin.fir.declarations.FirDeclarationOrigin import org.jetbrains.kotlin.fir.expressions.FirAnnotation @@ -34,7 +33,7 @@ abstract class FirBasedSymbol { get() = fir.moduleData val annotations: List - get() = (fir as? FirAnnotatedDeclaration)?.annotations ?: emptyList() + get() = fir.annotations } @RequiresOptIn diff --git a/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/FirTreeBuilder.kt b/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/FirTreeBuilder.kt index 1612809353d..6daea0bedf9 100644 --- a/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/FirTreeBuilder.kt +++ b/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/FirTreeBuilder.kt @@ -26,16 +26,15 @@ object FirTreeBuilder : AbstractFirTreeBuilder() { val statement by element(Expression, annotationContainer) val expression by element(Expression, statement) - val declaration by sealedElement(Declaration) + val declaration by sealedElement(Declaration, annotationContainer) val typeParameterRefsOwner by sealedElement(Declaration) val typeParametersOwner by sealedElement(Declaration, typeParameterRefsOwner) - val annotatedDeclaration by sealedElement(Declaration, declaration, annotationContainer) - val memberDeclaration by sealedElement(Declaration, annotatedDeclaration, typeParameterRefsOwner) + val memberDeclaration by sealedElement(Declaration, declaration, typeParameterRefsOwner) val anonymousInitializer by element(Declaration, declaration, controlFlowGraphOwner) val typedDeclaration by sealedElement(Declaration, memberDeclaration) val callableDeclaration by sealedElement(Declaration, typedDeclaration) val typeParameterRef by element(Declaration) - val typeParameter by element(Declaration, typeParameterRef, annotatedDeclaration) + val typeParameter by element(Declaration, typeParameterRef, declaration) val variable by sealedElement(Declaration, callableDeclaration, statement) val valueParameter by element(Declaration, variable, controlFlowGraphOwner) @@ -55,7 +54,7 @@ object FirTreeBuilder : AbstractFirTreeBuilder() { val propertyAccessor by element(Declaration, function, contractDescriptionOwner, typeParametersOwner) val backingField by element(Declaration, variable, typeParametersOwner, statement) val constructor by element(Declaration, function, typeParameterRefsOwner) - val file by element(Declaration, annotatedDeclaration) + val file by element(Declaration, declaration) val packageDirective by element(Other) val anonymousFunction by element(Declaration, function, typeParametersOwner) diff --git a/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/ImplementationConfigurator.kt b/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/ImplementationConfigurator.kt index a72e920b233..f16ca484c8a 100644 --- a/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/ImplementationConfigurator.kt +++ b/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/ImplementationConfigurator.kt @@ -38,6 +38,10 @@ object ImplementationConfigurator : AbstractFirTreeImplementationConfigurator() defaultFalse("hasLazyNestedClassifiers", withGetter = true) } + impl(anonymousInitializer) { + defaultEmptyList("annotations") + } + impl(anonymousObject) noImpl(anonymousObjectExpression) @@ -73,7 +77,7 @@ object ImplementationConfigurator : AbstractFirTreeImplementationConfigurator() delegateFields(listOf("aliasName", "importedFqName", "isAllUnder", "source"), "delegate") } - fun ImplementationContext.commonAnnotationConfig(): Unit { + fun ImplementationContext.commonAnnotationConfig() { defaultEmptyList("annotations") default("typeRef") { value = "annotationTypeRef" diff --git a/plugins/fir/fir-plugin-prototype/src/org/jetbrains/kotlin/fir/plugin/AllOpenStatusTransformer.kt b/plugins/fir/fir-plugin-prototype/src/org/jetbrains/kotlin/fir/plugin/AllOpenStatusTransformer.kt index 7d6f01583ca..26baa1a845d 100644 --- a/plugins/fir/fir-plugin-prototype/src/org/jetbrains/kotlin/fir/plugin/AllOpenStatusTransformer.kt +++ b/plugins/fir/fir-plugin-prototype/src/org/jetbrains/kotlin/fir/plugin/AllOpenStatusTransformer.kt @@ -7,7 +7,7 @@ package org.jetbrains.kotlin.fir.plugin import org.jetbrains.kotlin.descriptors.Modality import org.jetbrains.kotlin.fir.FirSession -import org.jetbrains.kotlin.fir.declarations.FirAnnotatedDeclaration +import org.jetbrains.kotlin.fir.declarations.FirDeclaration import org.jetbrains.kotlin.fir.declarations.FirDeclarationStatus import org.jetbrains.kotlin.fir.declarations.FirPluginKey import org.jetbrains.kotlin.fir.extensions.FirDeclarationPredicateRegistrar @@ -26,12 +26,12 @@ class AllOpenStatusTransformer(session: FirSession) : FirStatusTransformerExtens private val PREDICATE: DeclarationPredicate = hasOrUnder(ALL_OPEN) or metaHasOrUnder(ALL_OPEN) } - override fun transformStatus(status: FirDeclarationStatus, declaration: FirAnnotatedDeclaration): FirDeclarationStatus { + override fun transformStatus(status: FirDeclarationStatus, declaration: FirDeclaration): FirDeclarationStatus { if (status.modality != null) return status return status.transform(modality = Modality.OPEN) } - override fun needTransformStatus(declaration: FirAnnotatedDeclaration): Boolean { + override fun needTransformStatus(declaration: FirDeclaration): Boolean { return session.predicateBasedProvider.matches(PREDICATE, declaration) } diff --git a/plugins/fir/fir-plugin-prototype/src/org/jetbrains/kotlin/fir/plugin/AllPublicVisibilityTransformer.kt b/plugins/fir/fir-plugin-prototype/src/org/jetbrains/kotlin/fir/plugin/AllPublicVisibilityTransformer.kt index 59ff28927d3..3a58b95182f 100644 --- a/plugins/fir/fir-plugin-prototype/src/org/jetbrains/kotlin/fir/plugin/AllPublicVisibilityTransformer.kt +++ b/plugins/fir/fir-plugin-prototype/src/org/jetbrains/kotlin/fir/plugin/AllPublicVisibilityTransformer.kt @@ -8,7 +8,6 @@ package org.jetbrains.kotlin.fir.plugin import org.jetbrains.kotlin.descriptors.Visibilities import org.jetbrains.kotlin.descriptors.Visibility import org.jetbrains.kotlin.fir.FirSession -import org.jetbrains.kotlin.fir.declarations.FirAnnotatedDeclaration import org.jetbrains.kotlin.fir.declarations.FirDeclaration import org.jetbrains.kotlin.fir.declarations.FirDeclarationStatus import org.jetbrains.kotlin.fir.declarations.FirPluginKey @@ -42,7 +41,7 @@ class AllPublicVisibilityTransformer(session: FirSession) : FirStatusTransformer private val PREDICATE: DeclarationPredicate = hasOrUnder(AllPublicClassId.asSingleFqName()) } - override fun transformStatus(status: FirDeclarationStatus, declaration: FirAnnotatedDeclaration): FirDeclarationStatus { + override fun transformStatus(status: FirDeclarationStatus, declaration: FirDeclaration): FirDeclarationStatus { val owners = session.predicateBasedProvider.getOwnersOfDeclaration(declaration) ?: emptyList() val visibility = findVisibility(declaration, owners) ?: return status if (visibility == status.visibility) return status @@ -72,7 +71,7 @@ class AllPublicVisibilityTransformer(session: FirSession) : FirStatusTransformer } } - override fun needTransformStatus(declaration: FirAnnotatedDeclaration): Boolean { + override fun needTransformStatus(declaration: FirDeclaration): Boolean { return session.predicateBasedProvider.matches(PREDICATE, declaration) }