azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[FIR] Rename FirAnnotationCall to FirAnnotation

Browse Source
This commit is contained in:
Dmitriy Novozhilov
2021-09-03 14:54:01 +03:00
committed by teamcityserver
parent a7353d5a02
commit 4b662a42a1
365 changed files with 890 additions and 886 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/Main.kt
+1 -1
View File
@@ -39,7 +39,7 @@ fun main(args: Array<String>) {
alias<FirBinaryLogicExpression>("LogicExpressionChecker") alias<FirBinaryLogicExpression>("LogicExpressionChecker")
alias<FirReturnExpression>("ReturnExpressionChecker") alias<FirReturnExpression>("ReturnExpressionChecker")
alias<FirBlock>("BlockChecker") alias<FirBlock>("BlockChecker")
alias<FirAnnotationCall>("AnnotationCallChecker") alias<FirAnnotation>("AnnotationCallChecker")
alias<FirCheckNotNullCall>("CheckNotNullCallChecker") alias<FirCheckNotNullCall>("CheckNotNullCallChecker")
alias<FirElvisExpression>("ElvisExpressionChecker") alias<FirElvisExpression>("ElvisExpressionChecker")
alias<FirGetClassCall>("GetClassCallChecker") alias<FirGetClassCall>("GetClassCallChecker")
compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirJvmDefaultChecker.kt
+4 -4
View File
@@ -20,7 +20,7 @@ import org.jetbrains.kotlin.fir.containingClass
import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.*
import org.jetbrains.kotlin.fir.declarations.utils.isInterface import org.jetbrains.kotlin.fir.declarations.utils.isInterface
import org.jetbrains.kotlin.fir.declarations.utils.modality import org.jetbrains.kotlin.fir.declarations.utils.modality
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.java.jvmDefaultModeState import org.jetbrains.kotlin.fir.java.jvmDefaultModeState
import org.jetbrains.kotlin.fir.resolve.toSymbol import org.jetbrains.kotlin.fir.resolve.toSymbol
import org.jetbrains.kotlin.fir.scopes.getDirectOverriddenFunctions import org.jetbrains.kotlin.fir.scopes.getDirectOverriddenFunctions
@@ -34,7 +34,7 @@ import org.jetbrains.kotlin.name.JvmNames.JVM_DEFAULT_NO_COMPATIBILITY_CLASS_ID
object FirJvmDefaultChecker : FirBasicDeclarationChecker() { object FirJvmDefaultChecker : FirBasicDeclarationChecker() {
override fun check(declaration: FirDeclaration, context: CheckerContext, reporter: DiagnosticReporter) { override fun check(declaration: FirDeclaration, context: CheckerContext, reporter: DiagnosticReporter) {
val jvmDefaultMode = context.session.jvmDefaultModeState val jvmDefaultMode = context.session.jvmDefaultModeState
var defaultAnnotation: FirAnnotationCall? = null var defaultAnnotation: FirAnnotation? = null
val containingDeclaration = context.findClosest<FirClassLikeDeclaration>() val containingDeclaration = context.findClosest<FirClassLikeDeclaration>()
if (declaration is FirAnnotatedDeclaration) { if (declaration is FirAnnotatedDeclaration) {
@@ -121,7 +121,7 @@ object FirJvmDefaultChecker : FirBasicDeclarationChecker() {
} }
private fun checkNonJvmDefaultOverridesJavaDefault( private fun checkNonJvmDefaultOverridesJavaDefault(
defaultAnnotation: FirAnnotationCall?, defaultAnnotation: FirAnnotation?,
jvmDefaultMode: JvmDefaultMode, jvmDefaultMode: JvmDefaultMode,
declaration: FirDeclaration, declaration: FirDeclaration,
containingDeclaration: FirClassLikeDeclaration?, containingDeclaration: FirClassLikeDeclaration?,
@@ -175,4 +175,4 @@ object FirJvmDefaultChecker : FirBasicDeclarationChecker() {
// TODO: Fix support for all cases // TODO: Fix support for all cases
return isCompiledToJvmDefault(jvmDefaultMode) return isCompiledToJvmDefault(jvmDefaultMode)
} }
} }
compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirJvmNameChecker.kt
+2 -2
View File
@@ -15,7 +15,7 @@ import org.jetbrains.kotlin.fir.declarations.*
import org.jetbrains.kotlin.fir.declarations.utils.isInline import org.jetbrains.kotlin.fir.declarations.utils.isInline
import org.jetbrains.kotlin.fir.declarations.utils.isOpen import org.jetbrains.kotlin.fir.declarations.utils.isOpen
import org.jetbrains.kotlin.fir.declarations.utils.isOverride import org.jetbrains.kotlin.fir.declarations.utils.isOverride
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.expressions.FirConstExpression import org.jetbrains.kotlin.fir.expressions.FirConstExpression
import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
import org.jetbrains.kotlin.fir.resolve.getContainingClass import org.jetbrains.kotlin.fir.resolve.getContainingClass
@@ -60,7 +60,7 @@ object FirJvmNameChecker : FirBasicDeclarationChecker() {
} }
} }
private fun FirAnnotatedDeclaration.findJvmNameAnnotation(): FirAnnotationCall? { private fun FirAnnotatedDeclaration.findJvmNameAnnotation(): FirAnnotation? {
return annotations.firstOrNull { return annotations.firstOrNull {
it.calleeReference.safeAs<FirResolvedNamedReference>()?.name == StandardClassIds.JvmName.shortClassName it.calleeReference.safeAs<FirResolvedNamedReference>()?.name == StandardClassIds.JvmName.shortClassName
} }
compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirJvmStaticChecker.kt
+2 -2
View File
@@ -19,7 +19,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.jvm.FirJvmErrors
import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn
import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.*
import org.jetbrains.kotlin.fir.declarations.utils.* import org.jetbrains.kotlin.fir.declarations.utils.*
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.languageVersionSettings import org.jetbrains.kotlin.fir.languageVersionSettings
import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
import org.jetbrains.kotlin.fir.symbols.SymbolInternals import org.jetbrains.kotlin.fir.symbols.SymbolInternals
@@ -242,7 +242,7 @@ object FirJvmStaticChecker : FirAnnotatedDeclarationChecker() {
return findAnnotation(classId) != null return findAnnotation(classId) != null
} }
private fun FirAnnotatedDeclaration.findAnnotation(classId: ClassId): FirAnnotationCall? { private fun FirAnnotatedDeclaration.findAnnotation(classId: ClassId): FirAnnotation? {
return annotations.firstOrNull { return annotations.firstOrNull {
it.calleeReference.safeAs<FirResolvedNamedReference>()?.name == classId.shortClassName it.calleeReference.safeAs<FirResolvedNamedReference>()?.name == classId.shortClassName
} }
compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirRepeatableAnnotationChecker.kt
+4 -4
View File
@@ -106,7 +106,7 @@ object FirRepeatableAnnotationChecker : FirAnnotatedDeclarationChecker() {
return repeatableAnnotation.resolveContainerAnnotation() return repeatableAnnotation.resolveContainerAnnotation()
} }
private fun FirAnnotationCall.resolveContainerAnnotation(): ClassId? { private fun FirAnnotation.resolveContainerAnnotation(): ClassId? {
val value = findArgumentByName(REPEATABLE_PARAMETER_NAME) ?: return null val value = findArgumentByName(REPEATABLE_PARAMETER_NAME) ?: return null
val classCallArgument = (value as? FirGetClassCall)?.argument ?: return null val classCallArgument = (value as? FirGetClassCall)?.argument ?: return null
if (classCallArgument is FirResolvedQualifier) { if (classCallArgument is FirResolvedQualifier) {
@@ -119,7 +119,7 @@ object FirRepeatableAnnotationChecker : FirAnnotatedDeclarationChecker() {
} }
private fun checkJavaRepeatableAnnotationDeclaration( private fun checkJavaRepeatableAnnotationDeclaration(
javaRepeatable: FirAnnotationCall, javaRepeatable: FirAnnotation,
annotationClass: FirRegularClass, annotationClass: FirRegularClass,
context: CheckerContext, context: CheckerContext,
reporter: DiagnosticReporter reporter: DiagnosticReporter
@@ -131,7 +131,7 @@ object FirRepeatableAnnotationChecker : FirAnnotatedDeclarationChecker() {
} }
private fun checkKotlinRepeatableAnnotationDeclaration( private fun checkKotlinRepeatableAnnotationDeclaration(
kotlinRepeatable: FirAnnotationCall, kotlinRepeatable: FirAnnotation,
declaration: FirRegularClass, declaration: FirRegularClass,
context: CheckerContext, context: CheckerContext,
reporter: DiagnosticReporter reporter: DiagnosticReporter
@@ -253,4 +253,4 @@ object FirRepeatableAnnotationChecker : FirAnnotatedDeclarationChecker() {
} }
} }
} }
} }
compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/expression/FirDeprecatedJavaAnnotationsChecker.kt
+3 -3
View File
@@ -12,7 +12,7 @@ import org.jetbrains.kotlin.fir.analysis.checkers.expression.FirAnnotationCallCh
import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
import org.jetbrains.kotlin.fir.analysis.diagnostics.jvm.FirJvmErrors import org.jetbrains.kotlin.fir.analysis.diagnostics.jvm.FirJvmErrors
import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.types.ConeClassLikeType import org.jetbrains.kotlin.fir.types.ConeClassLikeType
import org.jetbrains.kotlin.fir.types.coneTypeSafe import org.jetbrains.kotlin.fir.types.coneTypeSafe
import org.jetbrains.kotlin.load.java.JvmAnnotationNames import org.jetbrains.kotlin.load.java.JvmAnnotationNames
@@ -29,7 +29,7 @@ object FirDeprecatedJavaAnnotationsChecker : FirAnnotationCallChecker() {
ClassId.topLevel(JvmAnnotationNames.DOCUMENTED_ANNOTATION) to StandardNames.FqNames.mustBeDocumented ClassId.topLevel(JvmAnnotationNames.DOCUMENTED_ANNOTATION) to StandardNames.FqNames.mustBeDocumented
) )
override fun check(expression: FirAnnotationCall, context: CheckerContext, reporter: DiagnosticReporter) { override fun check(expression: FirAnnotation, context: CheckerContext, reporter: DiagnosticReporter) {
if (context.containingDeclarations.lastOrNull()?.source?.kind != FirRealSourceElementKind) return if (context.containingDeclarations.lastOrNull()?.source?.kind != FirRealSourceElementKind) return
val lookupTag = expression.annotationTypeRef.coneTypeSafe<ConeClassLikeType>()?.lookupTag ?: return val lookupTag = expression.annotationTypeRef.coneTypeSafe<ConeClassLikeType>()?.lookupTag ?: return
@@ -37,4 +37,4 @@ object FirDeprecatedJavaAnnotationsChecker : FirAnnotationCallChecker() {
reporter.reportOn(expression.source, FirJvmErrors.DEPRECATED_JAVA_ANNOTATION, betterName, context) reporter.reportOn(expression.source, FirJvmErrors.DEPRECATED_JAVA_ANNOTATION, betterName, context)
} }
} }
} }
compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/expression/FirJvmPackageNameAnnotationsChecker.kt
+3 -3
View File
@@ -13,7 +13,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn
import org.jetbrains.kotlin.fir.declarations.FirClass import org.jetbrains.kotlin.fir.declarations.FirClass
import org.jetbrains.kotlin.fir.declarations.FirFile import org.jetbrains.kotlin.fir.declarations.FirFile
import org.jetbrains.kotlin.fir.declarations.getStringArgument import org.jetbrains.kotlin.fir.declarations.getStringArgument
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.types.ConeClassLikeType import org.jetbrains.kotlin.fir.types.ConeClassLikeType
import org.jetbrains.kotlin.fir.types.coneTypeSafe import org.jetbrains.kotlin.fir.types.coneTypeSafe
import org.jetbrains.kotlin.name.* import org.jetbrains.kotlin.name.*
@@ -23,7 +23,7 @@ object FirJvmPackageNameAnnotationsChecker : FirAnnotationCallChecker() {
private val jvmPackageNameClassId = ClassId.topLevel(FqName("kotlin.jvm.JvmPackageName")) private val jvmPackageNameClassId = ClassId.topLevel(FqName("kotlin.jvm.JvmPackageName"))
private val stringParameterName = Name.identifier("name") private val stringParameterName = Name.identifier("name")
override fun check(expression: FirAnnotationCall, context: CheckerContext, reporter: DiagnosticReporter) { override fun check(expression: FirAnnotation, context: CheckerContext, reporter: DiagnosticReporter) {
val lookupTag = expression.annotationTypeRef.coneTypeSafe<ConeClassLikeType>()?.lookupTag ?: return val lookupTag = expression.annotationTypeRef.coneTypeSafe<ConeClassLikeType>()?.lookupTag ?: return
if (lookupTag.classId != jvmPackageNameClassId) return if (lookupTag.classId != jvmPackageNameClassId) return
@@ -39,4 +39,4 @@ object FirJvmPackageNameAnnotationsChecker : FirAnnotationCallChecker() {
reporter.reportOn(expression.source, FirJvmErrors.JVM_PACKAGE_NAME_NOT_SUPPORTED_IN_FILES_WITH_CLASSES, context) reporter.reportOn(expression.source, FirJvmErrors.JVM_PACKAGE_NAME_NOT_SUPPORTED_IN_FILES_WITH_CLASSES, context)
} }
} }
} }
compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirExpressionCheckerAliases.kt
+2 -2
View File
@@ -10,7 +10,7 @@ package org.jetbrains.kotlin.fir.analysis.checkers.expression
* DO NOT MODIFY IT MANUALLY * DO NOT MODIFY IT MANUALLY
*/ */
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.expressions.FirArrayOfCall import org.jetbrains.kotlin.fir.expressions.FirArrayOfCall
import org.jetbrains.kotlin.fir.expressions.FirBinaryLogicExpression import org.jetbrains.kotlin.fir.expressions.FirBinaryLogicExpression
import org.jetbrains.kotlin.fir.expressions.FirBlock import org.jetbrains.kotlin.fir.expressions.FirBlock
@@ -53,7 +53,7 @@ typealias FirLoopJumpChecker = FirExpressionChecker<FirLoopJump>
typealias FirLogicExpressionChecker = FirExpressionChecker<FirBinaryLogicExpression> typealias FirLogicExpressionChecker = FirExpressionChecker<FirBinaryLogicExpression>
typealias FirReturnExpressionChecker = FirExpressionChecker<FirReturnExpression> typealias FirReturnExpressionChecker = FirExpressionChecker<FirReturnExpression>
typealias FirBlockChecker = FirExpressionChecker<FirBlock> typealias FirBlockChecker = FirExpressionChecker<FirBlock>
typealias FirAnnotationCallChecker = FirExpressionChecker<FirAnnotationCall> typealias FirAnnotationCallChecker = FirExpressionChecker<FirAnnotation>
typealias FirCheckNotNullCallChecker = FirExpressionChecker<FirCheckNotNullCall> typealias FirCheckNotNullCallChecker = FirExpressionChecker<FirCheckNotNullCall>
typealias FirElvisExpressionChecker = FirExpressionChecker<FirElvisExpression> typealias FirElvisExpressionChecker = FirExpressionChecker<FirElvisExpression>
typealias FirGetClassCallChecker = FirExpressionChecker<FirGetClassCall> typealias FirGetClassCallChecker = FirExpressionChecker<FirGetClassCall>
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirAnnotationHelpers.kt
+19 -8
View File
@@ -25,6 +25,7 @@ import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
import org.jetbrains.kotlin.fir.resolve.fullyExpandedType import org.jetbrains.kotlin.fir.resolve.fullyExpandedType
import org.jetbrains.kotlin.fir.resolve.symbolProvider import org.jetbrains.kotlin.fir.resolve.symbolProvider
import org.jetbrains.kotlin.fir.resolve.toSymbol import org.jetbrains.kotlin.fir.resolve.toSymbol
import org.jetbrains.kotlin.fir.symbols.SymbolInternals
import org.jetbrains.kotlin.fir.symbols.ensureResolved import org.jetbrains.kotlin.fir.symbols.ensureResolved
import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
@@ -42,11 +43,21 @@ private val JAVA_REPEATABLE_ANNOTATION = FqName("java.lang.annotation.Repeatable
private val JAVA_REPEATABLE_ANNOTATION_CLASS_ID = ClassId.topLevel(JAVA_REPEATABLE_ANNOTATION) private val JAVA_REPEATABLE_ANNOTATION_CLASS_ID = ClassId.topLevel(JAVA_REPEATABLE_ANNOTATION)
private val JVM_REPEATABLE_ANNOTATION_CLASS_ID = ClassId.fromString("kotlin/jvm/JvmRepeatable") private val JVM_REPEATABLE_ANNOTATION_CLASS_ID = ClassId.fromString("kotlin/jvm/JvmRepeatable")
@OptIn(SymbolInternals::class)
fun FirAnnotation.getRetention(session: FirSession): AnnotationRetention {
val annotationClassSymbol =
(this.annotationTypeRef.coneType as? ConeClassLikeType)?.lookupTag?.toSymbol(session) as? FirRegularClassSymbol
?: return AnnotationRetention.RUNTIME
annotationClassSymbol.ensureResolved(FirResolvePhase.BODY_RESOLVE)
val annotationClass = annotationClassSymbol.fir
return annotationClass.getRetention()
}
fun FirRegularClass.getRetention(): AnnotationRetention { fun FirRegularClass.getRetention(): AnnotationRetention {
return getRetentionAnnotation()?.getRetention() ?: AnnotationRetention.RUNTIME return getRetentionAnnotation()?.getRetention() ?: AnnotationRetention.RUNTIME
} }
fun FirAnnotationCall.getRetention(): AnnotationRetention { fun FirAnnotation.getRetention(): AnnotationRetention {
val retentionArgument = findArgumentByName(RETENTION_PARAMETER_NAME) as? FirQualifiedAccessExpression val retentionArgument = findArgumentByName(RETENTION_PARAMETER_NAME) as? FirQualifiedAccessExpression
?: return AnnotationRetention.RUNTIME ?: return AnnotationRetention.RUNTIME
val retentionName = (retentionArgument.calleeReference as? FirResolvedNamedReference)?.name?.asString() val retentionName = (retentionArgument.calleeReference as? FirResolvedNamedReference)?.name?.asString()
@@ -56,7 +67,7 @@ fun FirAnnotationCall.getRetention(): AnnotationRetention {
private val defaultAnnotationTargets = KotlinTarget.DEFAULT_TARGET_SET private val defaultAnnotationTargets = KotlinTarget.DEFAULT_TARGET_SET
fun FirAnnotationCall.getAllowedAnnotationTargets(session: FirSession): Set<KotlinTarget> { fun FirAnnotation.getAllowedAnnotationTargets(session: FirSession): Set<KotlinTarget> {
if (annotationTypeRef is FirErrorTypeRef) return KotlinTarget.values().toSet() if (annotationTypeRef is FirErrorTypeRef) return KotlinTarget.values().toSet()
val annotationClassSymbol = (this.annotationTypeRef.coneType as? ConeClassLikeType) val annotationClassSymbol = (this.annotationTypeRef.coneType as? ConeClassLikeType)
?.fullyExpandedType(session)?.lookupTag?.toSymbol(session) ?: return defaultAnnotationTargets ?.fullyExpandedType(session)?.lookupTag?.toSymbol(session) ?: return defaultAnnotationTargets
@@ -80,15 +91,15 @@ fun FirClassLikeSymbol<*>.getAllowedAnnotationTargets(): Set<KotlinTarget> {
} }
} }
fun FirAnnotatedDeclaration.getRetentionAnnotation(): FirAnnotationCall? { fun FirAnnotatedDeclaration.getRetentionAnnotation(): FirAnnotation? {
return getAnnotationByClassId(StandardNames.FqNames.retentionClassId) return getAnnotationByClassId(StandardNames.FqNames.retentionClassId)
} }
fun FirAnnotatedDeclaration.getTargetAnnotation(): FirAnnotationCall? { fun FirAnnotatedDeclaration.getTargetAnnotation(): FirAnnotation? {
return getAnnotationByClassId(StandardNames.FqNames.targetClassId) return getAnnotationByClassId(StandardNames.FqNames.targetClassId)
} }
fun FirClassLikeSymbol<*>.getTargetAnnotation(): FirAnnotationCall? { fun FirClassLikeSymbol<*>.getTargetAnnotation(): FirAnnotation? {
return getAnnotationByClassId(StandardNames.FqNames.targetClassId) return getAnnotationByClassId(StandardNames.FqNames.targetClassId)
} }
@@ -103,7 +114,7 @@ fun FirExpression.extractClassesFromArgument(): List<FirRegularClassSymbol> {
fun checkRepeatedAnnotation( fun checkRepeatedAnnotation(
useSiteTarget: AnnotationUseSiteTarget?, useSiteTarget: AnnotationUseSiteTarget?,
existingTargetsForAnnotation: MutableList<AnnotationUseSiteTarget?>, existingTargetsForAnnotation: MutableList<AnnotationUseSiteTarget?>,
annotation: FirAnnotationCall, annotation: FirAnnotation,
context: CheckerContext, context: CheckerContext,
reporter: DiagnosticReporter, reporter: DiagnosticReporter,
) { ) {
@@ -114,7 +125,7 @@ fun checkRepeatedAnnotation(
} }
} }
fun FirAnnotationCall.isRepeatable(session: FirSession): Boolean { fun FirAnnotation.isRepeatable(session: FirSession): Boolean {
val annotationClassId = this.toAnnotationClassId() ?: return false val annotationClassId = this.toAnnotationClassId() ?: return false
if (annotationClassId.isLocal) return false if (annotationClassId.isLocal) return false
val annotationClass = session.symbolProvider.getClassLikeSymbolByClassId(annotationClassId) ?: return false val annotationClass = session.symbolProvider.getClassLikeSymbolByClassId(annotationClassId) ?: return false
@@ -138,7 +149,7 @@ fun FirClassLikeSymbol<*>.getAnnotationRetention(): AnnotationRetention {
} }
fun FirAnnotationContainer.getDefaultUseSiteTarget( fun FirAnnotationContainer.getDefaultUseSiteTarget(
annotation: FirAnnotationCall, annotation: FirAnnotation,
context: CheckerContext context: CheckerContext
): AnnotationUseSiteTarget? { ): AnnotationUseSiteTarget? {
return getImplicitUseSiteTargetList(context).firstOrNull { return getImplicitUseSiteTargetList(context).firstOrNull {
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirAnnotationChecker.kt
+18 -17
View File
@@ -5,6 +5,7 @@
package org.jetbrains.kotlin.fir.analysis.checkers.declaration package org.jetbrains.kotlin.fir.analysis.checkers.declaration
import org.jetbrains.kotlin.descriptors.ClassKind
import org.jetbrains.kotlin.config.LanguageFeature import org.jetbrains.kotlin.config.LanguageFeature
import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
import org.jetbrains.kotlin.descriptors.annotations.KotlinTarget import org.jetbrains.kotlin.descriptors.annotations.KotlinTarget
@@ -16,7 +17,7 @@ import org.jetbrains.kotlin.fir.analysis.checkers.context.findClosest
import org.jetbrains.kotlin.fir.analysis.diagnostics.* import org.jetbrains.kotlin.fir.analysis.diagnostics.*
import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.*
import org.jetbrains.kotlin.fir.declarations.utils.hasBackingField import org.jetbrains.kotlin.fir.declarations.utils.hasBackingField
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.expressions.argumentMapping import org.jetbrains.kotlin.fir.expressions.argumentMapping
import org.jetbrains.kotlin.fir.languageVersionSettings import org.jetbrains.kotlin.fir.languageVersionSettings
import org.jetbrains.kotlin.fir.packageFqName import org.jetbrains.kotlin.fir.packageFqName
@@ -35,24 +36,24 @@ object FirAnnotationChecker : FirAnnotatedDeclarationChecker() {
context: CheckerContext, context: CheckerContext,
reporter: DiagnosticReporter reporter: DiagnosticReporter
) { ) {
var deprecatedCall: FirAnnotationCall? = null var deprecated: FirAnnotation? = null
var deprecatedSinceKotlinCall: FirAnnotationCall? = null var deprecatedSinceKotlin: FirAnnotation? = null
for (annotation in declaration.annotations) { for (annotation in declaration.annotations) {
val fqName = annotation.fqName(context.session) ?: continue val fqName = annotation.fqName(context.session) ?: continue
if (fqName == deprecatedClassId) { if (fqName == deprecatedClassId) {
deprecatedCall = annotation deprecated = annotation
} else if (fqName == deprecatedSinceKotlinClassId) { } else if (fqName == deprecatedSinceKotlinClassId) {
deprecatedSinceKotlinCall = annotation deprecatedSinceKotlin = annotation
} }
withSuppressedDiagnostics(annotation, context) { withSuppressedDiagnostics(annotation, context) {
checkAnnotationTarget(declaration, annotation, context, reporter) checkAnnotationTarget(declaration, annotation, context, reporter)
} }
} }
if (deprecatedSinceKotlinCall != null) { if (deprecatedSinceKotlin != null) {
withSuppressedDiagnostics(deprecatedSinceKotlinCall, context) { withSuppressedDiagnostics(deprecatedSinceKotlin, context) {
checkDeprecatedCalls(deprecatedSinceKotlinCall, deprecatedCall, context, reporter) checkDeprecatedCalls(deprecatedSinceKotlin, deprecated, context, reporter)
} }
} }
@@ -67,7 +68,7 @@ object FirAnnotationChecker : FirAnnotatedDeclarationChecker() {
private fun checkAnnotationTarget( private fun checkAnnotationTarget(
declaration: FirAnnotatedDeclaration, declaration: FirAnnotatedDeclaration,
annotation: FirAnnotationCall, annotation: FirAnnotation,
context: CheckerContext, context: CheckerContext,
reporter: DiagnosticReporter reporter: DiagnosticReporter
) { ) {
@@ -119,7 +120,7 @@ object FirAnnotationChecker : FirAnnotatedDeclarationChecker() {
private fun checkAnnotationUseSiteTarget( private fun checkAnnotationUseSiteTarget(
annotated: FirAnnotatedDeclaration, annotated: FirAnnotatedDeclaration,
annotation: FirAnnotationCall, annotation: FirAnnotation,
target: AnnotationUseSiteTarget, target: AnnotationUseSiteTarget,
context: CheckerContext, context: CheckerContext,
reporter: DiagnosticReporter reporter: DiagnosticReporter
@@ -176,28 +177,28 @@ object FirAnnotationChecker : FirAnnotatedDeclarationChecker() {
} }
private fun checkDeprecatedCalls( private fun checkDeprecatedCalls(
deprecatedSinceKotlinCall: FirAnnotationCall, deprecatedSinceKotlin: FirAnnotation,
deprecatedCall: FirAnnotationCall?, deprecated: FirAnnotation?,
context: CheckerContext, context: CheckerContext,
reporter: DiagnosticReporter reporter: DiagnosticReporter
) { ) {
val closestFirFile = context.findClosest<FirFile>() val closestFirFile = context.findClosest<FirFile>()
if (closestFirFile != null && !closestFirFile.packageFqName.startsWith(StandardClassIds.BASE_KOTLIN_PACKAGE.shortName())) { if (closestFirFile != null && !closestFirFile.packageFqName.startsWith(StandardClassIds.BASE_KOTLIN_PACKAGE.shortName())) {
reporter.reportOn( reporter.reportOn(
deprecatedSinceKotlinCall.source, deprecatedSinceKotlin.source,
FirErrors.DEPRECATED_SINCE_KOTLIN_OUTSIDE_KOTLIN_SUBPACKAGE, FirErrors.DEPRECATED_SINCE_KOTLIN_OUTSIDE_KOTLIN_SUBPACKAGE,
context context
) )
} }
if (deprecatedCall == null) { if (deprecated == null) {
reporter.reportOn(deprecatedSinceKotlinCall.source, FirErrors.DEPRECATED_SINCE_KOTLIN_WITHOUT_DEPRECATED, context) reporter.reportOn(deprecatedSinceKotlin.source, FirErrors.DEPRECATED_SINCE_KOTLIN_WITHOUT_DEPRECATED, context)
} else { } else {
val argumentMapping = deprecatedCall.argumentMapping ?: return val argumentMapping = deprecated.argumentMapping ?: return
for (value in argumentMapping.values) { for (value in argumentMapping.values) {
if (value.name.identifier == "level") { if (value.name.identifier == "level") {
reporter.reportOn( reporter.reportOn(
deprecatedSinceKotlinCall.source, deprecatedSinceKotlin.source,
FirErrors.DEPRECATED_SINCE_KOTLIN_WITH_DEPRECATED_LEVEL, FirErrors.DEPRECATED_SINCE_KOTLIN_WITH_DEPRECATED_LEVEL,
context context
) )
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirAnnotationArgumentChecker.kt
+3 -3
View File
@@ -34,7 +34,7 @@ object FirAnnotationArgumentChecker : FirAnnotationCallChecker() {
sinceKotlinFqName, sinceKotlinFqName,
) )
override fun check(expression: FirAnnotationCall, context: CheckerContext, reporter: DiagnosticReporter) { override fun check(expression: FirAnnotation, context: CheckerContext, reporter: DiagnosticReporter) {
val argumentMapping = expression.argumentMapping ?: return val argumentMapping = expression.argumentMapping ?: return
val fqName = expression.fqName(context.session) val fqName = expression.fqName(context.session)
for ((arg, _) in argumentMapping) { for ((arg, _) in argumentMapping) {
@@ -130,12 +130,12 @@ object FirAnnotationArgumentChecker : FirAnnotationCallChecker() {
private fun checkAnnotationsWithVersion( private fun checkAnnotationsWithVersion(
fqName: FqName?, fqName: FqName?,
annotationCall: FirAnnotationCall, annotation: FirAnnotation,
context: CheckerContext, context: CheckerContext,
reporter: DiagnosticReporter reporter: DiagnosticReporter
) { ) {
if (!annotationFqNamesWithVersion.contains(fqName)) return if (!annotationFqNamesWithVersion.contains(fqName)) return
val versionExpression = annotationCall.findArgumentByName(versionArgumentName) ?: return val versionExpression = annotation.findArgumentByName(versionArgumentName) ?: return
val version = parseVersionExpressionOrReport(versionExpression, context, reporter) ?: return val version = parseVersionExpressionOrReport(versionExpression, context, reporter) ?: return
if (fqName == sinceKotlinFqName) { if (fqName == sinceKotlinFqName) {
val specified = context.session.languageVersionSettings.apiVersion val specified = context.session.languageVersionSettings.apiVersion
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirConstructorCallChecker.kt
+2 -2
View File
@@ -13,7 +13,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn
import org.jetbrains.kotlin.fir.declarations.FirRegularClass import org.jetbrains.kotlin.fir.declarations.FirRegularClass
import org.jetbrains.kotlin.fir.declarations.utils.isAbstract import org.jetbrains.kotlin.fir.declarations.utils.isAbstract
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.expressions.FirFunctionCall import org.jetbrains.kotlin.fir.expressions.FirFunctionCall
import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
import org.jetbrains.kotlin.fir.symbols.impl.FirConstructorSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirConstructorSymbol
@@ -31,7 +31,7 @@ object FirConstructorCallChecker : FirFunctionCallChecker() {
} }
if (declarationClass.classKind == ClassKind.ANNOTATION_CLASS && if (declarationClass.classKind == ClassKind.ANNOTATION_CLASS &&
context.qualifiedAccessOrAnnotationCalls.all { call -> context.qualifiedAccessOrAnnotationCalls.all { call ->
call !is FirAnnotationCall call !is FirAnnotation
} && } &&
context.containingDeclarations.all { klass -> context.containingDeclarations.all { klass ->
klass !is FirRegularClass || klass.classKind != ClassKind.ANNOTATION_CLASS klass !is FirRegularClass || klass.classKind != ClassKind.ANNOTATION_CLASS
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirDeprecationChecker.kt
+1 -1
View File
@@ -32,7 +32,7 @@ object FirDeprecationChecker : FirBasicExpressionChecker() {
override fun check(expression: FirStatement, context: CheckerContext, reporter: DiagnosticReporter) { override fun check(expression: FirStatement, context: CheckerContext, reporter: DiagnosticReporter) {
if (!allowedSourceKinds.contains(expression.source?.kind)) return if (!allowedSourceKinds.contains(expression.source?.kind)) return
if (expression is FirAnnotationCall || expression is FirDelegatedConstructorCall) return //checked by FirDeprecatedTypeChecker if (expression is FirAnnotation || expression is FirDelegatedConstructorCall) return //checked by FirDeprecatedTypeChecker
val resolvable = expression as? FirResolvable ?: return val resolvable = expression as? FirResolvable ?: return
val reference = resolvable.calleeReference as? FirResolvedNamedReference ?: return val reference = resolvable.calleeReference as? FirResolvedNamedReference ?: return
val referencedSymbol = reference.resolvedSymbol val referencedSymbol = reference.resolvedSymbol
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirNamedVarargChecker.kt
+3 -3
View File
@@ -22,8 +22,8 @@ import org.jetbrains.kotlin.fir.types.isArrayType
object FirNamedVarargChecker : FirCallChecker() { object FirNamedVarargChecker : FirCallChecker() {
override fun check(expression: FirCall, context: CheckerContext, reporter: DiagnosticReporter) { override fun check(expression: FirCall, context: CheckerContext, reporter: DiagnosticReporter) {
if (expression !is FirFunctionCall && expression !is FirAnnotationCall && expression !is FirDelegatedConstructorCall) return if (expression !is FirFunctionCall && expression !is FirAnnotation && expression !is FirDelegatedConstructorCall) return
val isAnnotation = expression is FirAnnotationCall val isAnnotation = expression is FirAnnotation
val errorFactory = val errorFactory =
if (isAnnotation) FirErrors.ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_ANNOTATION if (isAnnotation) FirErrors.ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_ANNOTATION
else FirErrors.ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION else FirErrors.ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION
@@ -56,4 +56,4 @@ object FirNamedVarargChecker : FirCallChecker() {
} }
} }
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirOptInAnnotationCallChecker.kt
+1 -1
View File
@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.fir.types.coneTypeSafe
import org.jetbrains.kotlin.resolve.checkers.OptInNames import org.jetbrains.kotlin.resolve.checkers.OptInNames
object FirOptInAnnotationCallChecker : FirAnnotationCallChecker() { object FirOptInAnnotationCallChecker : FirAnnotationCallChecker() {
override fun check(expression: FirAnnotationCall, context: CheckerContext, reporter: DiagnosticReporter) { override fun check(expression: FirAnnotation, context: CheckerContext, reporter: DiagnosticReporter) {
val lookupTag = expression.annotationTypeRef.coneTypeSafe<ConeClassLikeType>()?.lookupTag ?: return val lookupTag = expression.annotationTypeRef.coneTypeSafe<ConeClassLikeType>()?.lookupTag ?: return
val classId = lookupTag.classId val classId = lookupTag.classId
val isMarker = classId == OptInNames.REQUIRES_OPT_IN_CLASS_ID val isMarker = classId == OptInNames.REQUIRES_OPT_IN_CLASS_ID
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/extended/UnusedChecker.kt
+2 -2
View File
@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn
import org.jetbrains.kotlin.fir.declarations.FirResolvePhase import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
import org.jetbrains.kotlin.fir.declarations.utils.isLocal import org.jetbrains.kotlin.fir.declarations.utils.isLocal
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.expressions.FirFunctionCall import org.jetbrains.kotlin.fir.expressions.FirFunctionCall
import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccess import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccess
import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
@@ -251,7 +251,7 @@ object UnusedChecker : FirControlFlowChecker() {
private fun visitAnnotation( private fun visitAnnotation(
dataForNode: PathAwareVariableStatusInfo, dataForNode: PathAwareVariableStatusInfo,
annotation: FirAnnotationCall, annotation: FirAnnotation,
): PathAwareVariableStatusInfo { ): PathAwareVariableStatusInfo {
val qualifiedAccesses = annotation.argumentList.arguments.mapNotNull { it as? FirQualifiedAccess }.toTypedArray() val qualifiedAccesses = annotation.argumentList.arguments.mapNotNull { it as? FirQualifiedAccess }.toTypedArray()
return visitQualifiedAccesses(dataForNode, *qualifiedAccesses) return visitQualifiedAccesses(dataForNode, *qualifiedAccesses)
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/type/FirOptInUsageTypeRefChecker.kt
+3 -3
View File
@@ -14,7 +14,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.OPT_IN_MARKER_CAN
import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn
import org.jetbrains.kotlin.fir.declarations.FirResolvePhase import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
import org.jetbrains.kotlin.fir.declarations.getAnnotationByClassId import org.jetbrains.kotlin.fir.declarations.getAnnotationByClassId
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.resolve.toSymbol import org.jetbrains.kotlin.fir.resolve.toSymbol
import org.jetbrains.kotlin.fir.symbols.SymbolInternals import org.jetbrains.kotlin.fir.symbols.SymbolInternals
import org.jetbrains.kotlin.fir.symbols.ensureResolved import org.jetbrains.kotlin.fir.symbols.ensureResolved
@@ -33,7 +33,7 @@ object FirOptInUsageTypeRefChecker : FirTypeRefChecker() {
val symbol = coneType.lookupTag.toSymbol(context.session) ?: return val symbol = coneType.lookupTag.toSymbol(context.session) ?: return
symbol.ensureResolved(FirResolvePhase.STATUS) symbol.ensureResolved(FirResolvePhase.STATUS)
val classId = symbol.classId val classId = symbol.classId
val lastAnnotationCall = context.qualifiedAccessOrAnnotationCalls.lastOrNull() as? FirAnnotationCall val lastAnnotationCall = context.qualifiedAccessOrAnnotationCalls.lastOrNull() as? FirAnnotation
if (lastAnnotationCall == null || lastAnnotationCall.annotationTypeRef !== typeRef) { if (lastAnnotationCall == null || lastAnnotationCall.annotationTypeRef !== typeRef) {
if (classId == OptInNames.REQUIRES_OPT_IN_CLASS_ID || classId == OptInNames.OPT_IN_CLASS_ID) { if (classId == OptInNames.REQUIRES_OPT_IN_CLASS_ID || classId == OptInNames.OPT_IN_CLASS_ID) {
reporter.reportOn(source, OPT_IN_CAN_ONLY_BE_USED_AS_ANNOTATION, context) reporter.reportOn(source, OPT_IN_CAN_ONLY_BE_USED_AS_ANNOTATION, context)
@@ -48,4 +48,4 @@ object FirOptInUsageTypeRefChecker : FirTypeRefChecker() {
reportNotAcceptedExperimentalities(experimentalities, typeRef, context, reporter) reportNotAcceptedExperimentalities(experimentalities, typeRef, context, reporter)
} }
} }
} }
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/AbstractDiagnosticCollectorVisitor.kt
+2 -2
View File
@@ -204,8 +204,8 @@ abstract class AbstractDiagnosticCollectorVisitor(
visitWithQualifiedAccessOrAnnotationCall(propertyAccessExpression) visitWithQualifiedAccessOrAnnotationCall(propertyAccessExpression)
} }
override fun visitAnnotationCall(annotationCall: FirAnnotationCall, data: Nothing?) { override fun visitAnnotation(annotation: FirAnnotation, data: Nothing?) {
visitWithQualifiedAccessOrAnnotationCall(annotationCall) visitWithQualifiedAccessOrAnnotationCall(annotation)
} }
override fun visitVariableAssignment(variableAssignment: FirVariableAssignment, data: Nothing?) { override fun visitVariableAssignment(variableAssignment: FirVariableAssignment, data: Nothing?) {
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/components/ErrorNodeDiagnosticCollectorComponent.kt
+1 -1
View File
@@ -51,7 +51,7 @@ class ErrorNodeDiagnosticCollectorComponent(
// Use the source of the enclosing FirQualifiedAccess if it is exactly the call to the erroneous callee. // Use the source of the enclosing FirQualifiedAccess if it is exactly the call to the erroneous callee.
when (it) { when (it) {
is FirQualifiedAccess -> it.calleeReference == errorNamedReference is FirQualifiedAccess -> it.calleeReference == errorNamedReference
is FirAnnotationCall -> it.calleeReference == errorNamedReference is FirAnnotation -> it.calleeReference == errorNamedReference
else -> false else -> false
} }
} }
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/components/ExpressionCheckersDiagnosticComponent.kt
+2 -2
View File
@@ -28,8 +28,8 @@ class ExpressionCheckersDiagnosticComponent(
checkers.allConstExpressionCheckers.check(constExpression, data, reporter) checkers.allConstExpressionCheckers.check(constExpression, data, reporter)
} }
override fun visitAnnotationCall(annotationCall: FirAnnotationCall, data: CheckerContext) { override fun visitAnnotation(annotation: FirAnnotation, data: CheckerContext) {
checkers.allAnnotationCallCheckers.check(annotationCall, data, reporter) checkers.allAnnotationCallCheckers.check(annotation, data, reporter)
} }
override fun visitQualifiedAccessExpression(qualifiedAccessExpression: FirQualifiedAccessExpression, data: CheckerContext) { override fun visitQualifiedAccessExpression(qualifiedAccessExpression: FirQualifiedAccessExpression, data: CheckerContext) {
compiler/fir/fir-deserialization/src/org/jetbrains/kotlin/fir/deserialization/AbstractAnnotationDeserializer.kt
+15 -15
View File
@@ -12,7 +12,7 @@ import org.jetbrains.kotlin.fir.declarations.FirValueParameter
import org.jetbrains.kotlin.fir.declarations.utils.collectEnumEntries import org.jetbrains.kotlin.fir.declarations.utils.collectEnumEntries
import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnostic import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnostic
import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.expressions.FirConstExpression import org.jetbrains.kotlin.fir.expressions.FirConstExpression
import org.jetbrains.kotlin.fir.expressions.FirExpression import org.jetbrains.kotlin.fir.expressions.FirExpression
import org.jetbrains.kotlin.fir.expressions.buildUnaryArgumentList import org.jetbrains.kotlin.fir.expressions.buildUnaryArgumentList
@@ -58,13 +58,13 @@ abstract class AbstractAnnotationDeserializer(
OTHERS OTHERS
} }
fun loadClassAnnotations(classProto: ProtoBuf.Class, nameResolver: NameResolver): List<FirAnnotationCall> { fun loadClassAnnotations(classProto: ProtoBuf.Class, nameResolver: NameResolver): List<FirAnnotation> {
if (!Flags.HAS_ANNOTATIONS.get(classProto.flags)) return emptyList() if (!Flags.HAS_ANNOTATIONS.get(classProto.flags)) return emptyList()
val annotations = classProto.getExtension(protocol.classAnnotation).orEmpty() val annotations = classProto.getExtension(protocol.classAnnotation).orEmpty()
return annotations.map { deserializeAnnotation(it, nameResolver) } return annotations.map { deserializeAnnotation(it, nameResolver) }
} }
fun loadTypeAliasAnnotations(aliasProto: ProtoBuf.TypeAlias, nameResolver: NameResolver): List<FirAnnotationCall> { fun loadTypeAliasAnnotations(aliasProto: ProtoBuf.TypeAlias, nameResolver: NameResolver): List<FirAnnotation> {
if (!Flags.HAS_ANNOTATIONS.get(aliasProto.flags)) return emptyList() if (!Flags.HAS_ANNOTATIONS.get(aliasProto.flags)) return emptyList()
return aliasProto.annotationList.map { deserializeAnnotation(it, nameResolver) } return aliasProto.annotationList.map { deserializeAnnotation(it, nameResolver) }
} }
@@ -74,7 +74,7 @@ abstract class AbstractAnnotationDeserializer(
functionProto: ProtoBuf.Function, functionProto: ProtoBuf.Function,
nameResolver: NameResolver, nameResolver: NameResolver,
typeTable: TypeTable typeTable: TypeTable
): List<FirAnnotationCall> { ): List<FirAnnotation> {
if (!Flags.HAS_ANNOTATIONS.get(functionProto.flags)) return emptyList() if (!Flags.HAS_ANNOTATIONS.get(functionProto.flags)) return emptyList()
val annotations = functionProto.getExtension(protocol.functionAnnotation).orEmpty() val annotations = functionProto.getExtension(protocol.functionAnnotation).orEmpty()
return annotations.map { deserializeAnnotation(it, nameResolver) } return annotations.map { deserializeAnnotation(it, nameResolver) }
@@ -86,7 +86,7 @@ abstract class AbstractAnnotationDeserializer(
containingClassProto: ProtoBuf.Class?, containingClassProto: ProtoBuf.Class?,
nameResolver: NameResolver, nameResolver: NameResolver,
typeTable: TypeTable typeTable: TypeTable
): List<FirAnnotationCall> { ): List<FirAnnotation> {
if (!Flags.HAS_ANNOTATIONS.get(propertyProto.flags)) return emptyList() if (!Flags.HAS_ANNOTATIONS.get(propertyProto.flags)) return emptyList()
val annotations = propertyProto.getExtension(protocol.propertyAnnotation).orEmpty() val annotations = propertyProto.getExtension(protocol.propertyAnnotation).orEmpty()
return annotations.map { deserializeAnnotation(it, nameResolver, AnnotationUseSiteTarget.PROPERTY) } return annotations.map { deserializeAnnotation(it, nameResolver, AnnotationUseSiteTarget.PROPERTY) }
@@ -97,7 +97,7 @@ abstract class AbstractAnnotationDeserializer(
propertyProto: ProtoBuf.Property, propertyProto: ProtoBuf.Property,
nameResolver: NameResolver, nameResolver: NameResolver,
typeTable: TypeTable typeTable: TypeTable
): List<FirAnnotationCall> { ): List<FirAnnotation> {
return emptyList() return emptyList()
} }
@@ -106,7 +106,7 @@ abstract class AbstractAnnotationDeserializer(
propertyProto: ProtoBuf.Property, propertyProto: ProtoBuf.Property,
nameResolver: NameResolver, nameResolver: NameResolver,
typeTable: TypeTable typeTable: TypeTable
): List<FirAnnotationCall> { ): List<FirAnnotation> {
return emptyList() return emptyList()
} }
@@ -116,7 +116,7 @@ abstract class AbstractAnnotationDeserializer(
nameResolver: NameResolver, nameResolver: NameResolver,
typeTable: TypeTable, typeTable: TypeTable,
getterFlags: Int getterFlags: Int
): List<FirAnnotationCall> { ): List<FirAnnotation> {
if (!Flags.HAS_ANNOTATIONS.get(getterFlags)) return emptyList() if (!Flags.HAS_ANNOTATIONS.get(getterFlags)) return emptyList()
val annotations = propertyProto.getExtension(protocol.propertyGetterAnnotation).orEmpty() val annotations = propertyProto.getExtension(protocol.propertyGetterAnnotation).orEmpty()
return annotations.map { deserializeAnnotation(it, nameResolver, AnnotationUseSiteTarget.PROPERTY_GETTER) } return annotations.map { deserializeAnnotation(it, nameResolver, AnnotationUseSiteTarget.PROPERTY_GETTER) }
@@ -128,7 +128,7 @@ abstract class AbstractAnnotationDeserializer(
nameResolver: NameResolver, nameResolver: NameResolver,
typeTable: TypeTable, typeTable: TypeTable,
setterFlags: Int setterFlags: Int
): List<FirAnnotationCall> { ): List<FirAnnotation> {
if (!Flags.HAS_ANNOTATIONS.get(setterFlags)) return emptyList() if (!Flags.HAS_ANNOTATIONS.get(setterFlags)) return emptyList()
val annotations = propertyProto.getExtension(protocol.propertySetterAnnotation).orEmpty() val annotations = propertyProto.getExtension(protocol.propertySetterAnnotation).orEmpty()
return annotations.map { deserializeAnnotation(it, nameResolver, AnnotationUseSiteTarget.PROPERTY_SETTER) } return annotations.map { deserializeAnnotation(it, nameResolver, AnnotationUseSiteTarget.PROPERTY_SETTER) }
@@ -139,7 +139,7 @@ abstract class AbstractAnnotationDeserializer(
constructorProto: ProtoBuf.Constructor, constructorProto: ProtoBuf.Constructor,
nameResolver: NameResolver, nameResolver: NameResolver,
typeTable: TypeTable typeTable: TypeTable
): List<FirAnnotationCall> { ): List<FirAnnotation> {
if (!Flags.HAS_ANNOTATIONS.get(constructorProto.flags)) return emptyList() if (!Flags.HAS_ANNOTATIONS.get(constructorProto.flags)) return emptyList()
val annotations = constructorProto.getExtension(protocol.constructorAnnotation).orEmpty() val annotations = constructorProto.getExtension(protocol.constructorAnnotation).orEmpty()
return annotations.map { deserializeAnnotation(it, nameResolver) } return annotations.map { deserializeAnnotation(it, nameResolver) }
@@ -154,7 +154,7 @@ abstract class AbstractAnnotationDeserializer(
typeTable: TypeTable, typeTable: TypeTable,
kind: CallableKind, kind: CallableKind,
parameterIndex: Int parameterIndex: Int
): List<FirAnnotationCall> { ): List<FirAnnotation> {
if (!Flags.HAS_ANNOTATIONS.get(valueParameterProto.flags)) return emptyList() if (!Flags.HAS_ANNOTATIONS.get(valueParameterProto.flags)) return emptyList()
val annotations = valueParameterProto.getExtension(protocol.parameterAnnotation).orEmpty() val annotations = valueParameterProto.getExtension(protocol.parameterAnnotation).orEmpty()
return annotations.map { deserializeAnnotation(it, nameResolver) } return annotations.map { deserializeAnnotation(it, nameResolver) }
@@ -166,17 +166,17 @@ abstract class AbstractAnnotationDeserializer(
nameResolver: NameResolver, nameResolver: NameResolver,
typeTable: TypeTable, typeTable: TypeTable,
kind: CallableKind kind: CallableKind
): List<FirAnnotationCall> { ): List<FirAnnotation> {
return emptyList() return emptyList()
} }
abstract fun loadTypeAnnotations(typeProto: ProtoBuf.Type, nameResolver: NameResolver): List<FirAnnotationCall> abstract fun loadTypeAnnotations(typeProto: ProtoBuf.Type, nameResolver: NameResolver): List<FirAnnotation>
fun deserializeAnnotation( fun deserializeAnnotation(
proto: ProtoBuf.Annotation, proto: ProtoBuf.Annotation,
nameResolver: NameResolver, nameResolver: NameResolver,
useSiteTarget: AnnotationUseSiteTarget? = null useSiteTarget: AnnotationUseSiteTarget? = null
): FirAnnotationCall { ): FirAnnotation {
val classId = nameResolver.getClassId(proto.id) val classId = nameResolver.getClassId(proto.id)
var arguments = emptyList<FirExpression>() var arguments = emptyList<FirExpression>()
@@ -208,7 +208,7 @@ abstract class AbstractAnnotationDeserializer(
} }
} }
return buildAnnotationCall { return buildAnnotation {
annotationTypeRef = buildResolvedTypeRef { annotationTypeRef = buildResolvedTypeRef {
type = ConeClassLikeLookupTagImpl(classId).constructClassType(emptyArray(), isNullable = false) type = ConeClassLikeLookupTagImpl(classId).constructClassType(emptyArray(), isNullable = false)
} }
compiler/fir/fir-deserialization/src/org/jetbrains/kotlin/fir/deserialization/ClassDeserialization.kt
+2 -2
View File
@@ -19,7 +19,7 @@ import org.jetbrains.kotlin.fir.declarations.impl.FirResolvedDeclarationStatusIm
import org.jetbrains.kotlin.fir.declarations.utils.addDeclarations import org.jetbrains.kotlin.fir.declarations.utils.addDeclarations
import org.jetbrains.kotlin.fir.declarations.utils.moduleName import org.jetbrains.kotlin.fir.declarations.utils.moduleName
import org.jetbrains.kotlin.fir.declarations.utils.sourceElement import org.jetbrains.kotlin.fir.declarations.utils.sourceElement
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.resolve.providers.impl.FirCloneableSymbolProvider.Companion.CLONE import org.jetbrains.kotlin.fir.resolve.providers.impl.FirCloneableSymbolProvider.Companion.CLONE
import org.jetbrains.kotlin.fir.resolve.providers.impl.FirCloneableSymbolProvider.Companion.CLONEABLE_CLASS_ID import org.jetbrains.kotlin.fir.resolve.providers.impl.FirCloneableSymbolProvider.Companion.CLONEABLE_CLASS_ID
import org.jetbrains.kotlin.fir.scopes.FirScopeProvider import org.jetbrains.kotlin.fir.scopes.FirScopeProvider
@@ -212,7 +212,7 @@ fun deserializeClassToSymbol(
} }
it.setSealedClassInheritors(inheritors) it.setSealedClassInheritors(inheritors)
} }
(it.annotations as MutableList<FirAnnotationCall>) += (it.annotations as MutableList<FirAnnotation>) +=
context.annotationDeserializer.loadClassAnnotations(classProto, context.nameResolver) context.annotationDeserializer.loadClassAnnotations(classProto, context.nameResolver)
it.versionRequirementsTable = context.versionRequirementTable it.versionRequirementsTable = context.versionRequirementTable
compiler/fir/fir-deserialization/src/org/jetbrains/kotlin/fir/deserialization/FirBuiltinAnnotationDeserializer.kt
+2 -2
View File
@@ -6,7 +6,7 @@
package org.jetbrains.kotlin.fir.deserialization package org.jetbrains.kotlin.fir.deserialization
import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.metadata.ProtoBuf import org.jetbrains.kotlin.metadata.ProtoBuf
import org.jetbrains.kotlin.metadata.deserialization.Flags import org.jetbrains.kotlin.metadata.deserialization.Flags
import org.jetbrains.kotlin.metadata.deserialization.NameResolver import org.jetbrains.kotlin.metadata.deserialization.NameResolver
@@ -15,7 +15,7 @@ class FirBuiltinAnnotationDeserializer(
session: FirSession session: FirSession
) : AbstractAnnotationDeserializer(session) { ) : AbstractAnnotationDeserializer(session) {
override fun loadTypeAnnotations(typeProto: ProtoBuf.Type, nameResolver: NameResolver): List<FirAnnotationCall> { override fun loadTypeAnnotations(typeProto: ProtoBuf.Type, nameResolver: NameResolver): List<FirAnnotation> {
if (!Flags.HAS_ANNOTATIONS.get(typeProto.flags)) return emptyList() if (!Flags.HAS_ANNOTATIONS.get(typeProto.flags)) return emptyList()
val annotations = typeProto.getExtension(protocol.typeAnnotation).orEmpty() val annotations = typeProto.getExtension(protocol.typeAnnotation).orEmpty()
return annotations.map { deserializeAnnotation(it, nameResolver) } return annotations.map { deserializeAnnotation(it, nameResolver) }
compiler/fir/fir-deserialization/src/org/jetbrains/kotlin/fir/deserialization/FirMemberDeserializer.kt
+3 -3
View File
@@ -13,7 +13,7 @@ import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyGetter
import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertySetter import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertySetter
import org.jetbrains.kotlin.fir.declarations.impl.FirResolvedDeclarationStatusImpl import org.jetbrains.kotlin.fir.declarations.impl.FirResolvedDeclarationStatusImpl
import org.jetbrains.kotlin.fir.declarations.utils.sourceElement import org.jetbrains.kotlin.fir.declarations.utils.sourceElement
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.expressions.FirExpression import org.jetbrains.kotlin.fir.expressions.FirExpression
import org.jetbrains.kotlin.fir.expressions.builder.buildExpressionStub import org.jetbrains.kotlin.fir.expressions.builder.buildExpressionStub
import org.jetbrains.kotlin.fir.resolve.defaultType import org.jetbrains.kotlin.fir.resolve.defaultType
@@ -261,7 +261,7 @@ class FirMemberDeserializer(private val c: FirDeserializationContext) {
effectiveVisibility effectiveVisibility
) )
}.apply { }.apply {
(annotations as MutableList<FirAnnotationCall>) += (annotations as MutableList<FirAnnotation>) +=
c.annotationDeserializer.loadPropertyGetterAnnotations( c.annotationDeserializer.loadPropertyGetterAnnotations(
c.containerSource, proto, local.nameResolver, local.typeTable, getterFlags c.containerSource, proto, local.nameResolver, local.typeTable, getterFlags
) )
@@ -317,7 +317,7 @@ class FirMemberDeserializer(private val c: FirDeserializationContext) {
effectiveVisibility effectiveVisibility
) )
}.apply { }.apply {
(annotations as MutableList<FirAnnotationCall>) += (annotations as MutableList<FirAnnotation>) +=
c.annotationDeserializer.loadPropertySetterAnnotations( c.annotationDeserializer.loadPropertySetterAnnotations(
c.containerSource, proto, local.nameResolver, local.typeTable, setterFlags c.containerSource, proto, local.nameResolver, local.typeTable, setterFlags
) )
compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/FirAnnotationSerializer.kt
+1 -1
View File
@@ -16,7 +16,7 @@ import org.jetbrains.kotlin.metadata.ProtoBuf
import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.name.Name
class FirAnnotationSerializer(private val session: FirSession, internal val stringTable: FirElementAwareStringTable) { class FirAnnotationSerializer(private val session: FirSession, internal val stringTable: FirElementAwareStringTable) {
fun serializeAnnotation(annotation: FirAnnotationCall): ProtoBuf.Annotation = ProtoBuf.Annotation.newBuilder().apply { fun serializeAnnotation(annotation: FirAnnotation): ProtoBuf.Annotation = ProtoBuf.Annotation.newBuilder().apply {
val lookupTag = annotation.typeRef.coneTypeSafe<ConeClassLikeType>()?.lookupTag val lookupTag = annotation.typeRef.coneTypeSafe<ConeClassLikeType>()?.lookupTag
?: error { "Annotation without proper lookup tag: ${annotation.annotationTypeRef.coneType}" } ?: error { "Annotation without proper lookup tag: ${annotation.annotationTypeRef.coneType}" }
compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/FirElementSerializer.kt
+8 -8
View File
@@ -18,11 +18,11 @@ import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyAccessor
import org.jetbrains.kotlin.fir.declarations.utils.* import org.jetbrains.kotlin.fir.declarations.utils.*
import org.jetbrains.kotlin.fir.deserialization.CONTINUATION_INTERFACE_CLASS_ID import org.jetbrains.kotlin.fir.deserialization.CONTINUATION_INTERFACE_CLASS_ID
import org.jetbrains.kotlin.fir.deserialization.projection import org.jetbrains.kotlin.fir.deserialization.projection
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.expressions.FirArgumentList import org.jetbrains.kotlin.fir.expressions.FirArgumentList
import org.jetbrains.kotlin.fir.expressions.FirExpression import org.jetbrains.kotlin.fir.expressions.FirExpression
import org.jetbrains.kotlin.fir.expressions.FirNamedArgumentExpression import org.jetbrains.kotlin.fir.expressions.FirNamedArgumentExpression
import org.jetbrains.kotlin.fir.expressions.builder.buildAnnotationCall import org.jetbrains.kotlin.fir.expressions.builder.buildAnnotation
import org.jetbrains.kotlin.fir.references.impl.FirReferencePlaceholderForResolvedAnnotations import org.jetbrains.kotlin.fir.references.impl.FirReferencePlaceholderForResolvedAnnotations
import org.jetbrains.kotlin.fir.resolve.* import org.jetbrains.kotlin.fir.resolve.*
import org.jetbrains.kotlin.fir.resolve.calls.varargElementType import org.jetbrains.kotlin.fir.resolve.calls.varargElementType
@@ -240,7 +240,7 @@ class FirElementSerializer private constructor(
} }
} }
private fun FirPropertyAccessor.nonSourceAnnotations(session: FirSession, property: FirProperty): List<FirAnnotationCall> = private fun FirPropertyAccessor.nonSourceAnnotations(session: FirSession, property: FirProperty): List<FirAnnotation> =
(this as FirAnnotationContainer).nonSourceAnnotations(session) + property.nonSourceAnnotations(session).filter { (this as FirAnnotationContainer).nonSourceAnnotations(session) + property.nonSourceAnnotations(session).filter {
val useSiteTarget = it.useSiteTarget val useSiteTarget = it.useSiteTarget
useSiteTarget == AnnotationUseSiteTarget.PROPERTY_GETTER && isGetter || useSiteTarget == AnnotationUseSiteTarget.PROPERTY_GETTER && isGetter ||
@@ -529,7 +529,7 @@ class FirElementSerializer private constructor(
private fun valueParameterProto( private fun valueParameterProto(
parameter: FirValueParameter, parameter: FirValueParameter,
additionalAnnotations: List<FirAnnotationCall> = emptyList() additionalAnnotations: List<FirAnnotation> = emptyList()
): ProtoBuf.ValueParameter.Builder { ): ProtoBuf.ValueParameter.Builder {
val builder = ProtoBuf.ValueParameter.newBuilder() val builder = ProtoBuf.ValueParameter.newBuilder()
@@ -708,13 +708,13 @@ class FirElementSerializer private constructor(
} }
private fun serializeAnnotationFromAttribute( private fun serializeAnnotationFromAttribute(
existingAnnotations: List<FirAnnotationCall>?, existingAnnotations: List<FirAnnotation>?,
classId: ClassId, classId: ClassId,
builder: ProtoBuf.Type.Builder builder: ProtoBuf.Type.Builder
) { ) {
if (existingAnnotations?.any { it.annotationTypeRef.coneTypeSafe<ConeClassLikeType>()?.classId == classId } != true) { if (existingAnnotations?.any { it.annotationTypeRef.coneTypeSafe<ConeClassLikeType>()?.classId == classId } != true) {
extension.serializeTypeAnnotation( extension.serializeTypeAnnotation(
buildAnnotationCall { buildAnnotation {
calleeReference = FirReferencePlaceholderForResolvedAnnotations calleeReference = FirReferencePlaceholderForResolvedAnnotations
annotationTypeRef = buildResolvedTypeRef { annotationTypeRef = buildResolvedTypeRef {
this.type = CompilerConeAttributes.ExtensionFunctionType.ANNOTATION_CLASS_ID.constructClassLikeType( this.type = CompilerConeAttributes.ExtensionFunctionType.ANNOTATION_CLASS_ID.constructClassLikeType(
@@ -834,7 +834,7 @@ class FirElementSerializer private constructor(
private fun MutableVersionRequirementTable.serializeVersionRequirements(container: FirAnnotationContainer): List<Int> = private fun MutableVersionRequirementTable.serializeVersionRequirements(container: FirAnnotationContainer): List<Int> =
serializeVersionRequirements(container.annotations) serializeVersionRequirements(container.annotations)
private fun MutableVersionRequirementTable.serializeVersionRequirements(annotations: List<FirAnnotationCall>): List<Int> = private fun MutableVersionRequirementTable.serializeVersionRequirements(annotations: List<FirAnnotation>): List<Int> =
annotations annotations
.filter { .filter {
it.toAnnotationClassId()?.asSingleFqName() == RequireKotlinConstants.FQ_NAME it.toAnnotationClassId()?.asSingleFqName() == RequireKotlinConstants.FQ_NAME
@@ -849,7 +849,7 @@ class FirElementSerializer private constructor(
private fun MutableVersionRequirementTable.writeVersionRequirementDependingOnCoroutinesVersion(): Int = private fun MutableVersionRequirementTable.writeVersionRequirementDependingOnCoroutinesVersion(): Int =
writeVersionRequirement(LanguageFeature.ReleaseCoroutines) writeVersionRequirement(LanguageFeature.ReleaseCoroutines)
private fun serializeVersionRequirementFromRequireKotlin(annotation: FirAnnotationCall): ProtoBuf.VersionRequirement.Builder? { private fun serializeVersionRequirementFromRequireKotlin(annotation: FirAnnotation): ProtoBuf.VersionRequirement.Builder? {
val args = annotation.argumentList val args = annotation.argumentList
val versionString = (args[RequireKotlinConstants.VERSION]?.toConstantValue() as? StringValue)?.value ?: return null val versionString = (args[RequireKotlinConstants.VERSION]?.toConstantValue() as? StringValue)?.value ?: return null
compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/FirSerializerExtension.kt
+2 -2
View File
@@ -7,7 +7,7 @@ package org.jetbrains.kotlin.fir.serialization
import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.*
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.types.ConeFlexibleType import org.jetbrains.kotlin.fir.types.ConeFlexibleType
import org.jetbrains.kotlin.fir.types.ConeKotlinErrorType import org.jetbrains.kotlin.fir.types.ConeKotlinErrorType
import org.jetbrains.kotlin.metadata.ProtoBuf import org.jetbrains.kotlin.metadata.ProtoBuf
@@ -74,7 +74,7 @@ abstract class FirSerializerExtension {
open fun serializeFlexibleType(type: ConeFlexibleType, lowerProto: ProtoBuf.Type.Builder, upperProto: ProtoBuf.Type.Builder) { open fun serializeFlexibleType(type: ConeFlexibleType, lowerProto: ProtoBuf.Type.Builder, upperProto: ProtoBuf.Type.Builder) {
} }
open fun serializeTypeAnnotation(annotation: FirAnnotationCall, proto: ProtoBuf.Type.Builder) { open fun serializeTypeAnnotation(annotation: FirAnnotation, proto: ProtoBuf.Type.Builder) {
} }
open fun serializeTypeParameter(typeParameter: FirTypeParameter, proto: ProtoBuf.TypeParameter.Builder) { open fun serializeTypeParameter(typeParameter: FirTypeParameter, proto: ProtoBuf.TypeParameter.Builder) {
compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/constant/ConstantValue.kt
+2 -2
View File
@@ -7,7 +7,7 @@ package org.jetbrains.kotlin.fir.serialization.constant
import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.declarations.FirRegularClass import org.jetbrains.kotlin.fir.declarations.FirRegularClass
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.resolve.defaultType import org.jetbrains.kotlin.fir.resolve.defaultType
import org.jetbrains.kotlin.fir.resolve.symbolProvider import org.jetbrains.kotlin.fir.resolve.symbolProvider
import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.fir.types.*
@@ -30,7 +30,7 @@ internal sealed class ConstantValue<out T>(open val value: T) {
internal abstract class IntegerValueConstant<out T> protected constructor(value: T) : ConstantValue<T>(value) internal abstract class IntegerValueConstant<out T> protected constructor(value: T) : ConstantValue<T>(value)
internal abstract class UnsignedValueConstant<out T> protected constructor(value: T) : ConstantValue<T>(value) internal abstract class UnsignedValueConstant<out T> protected constructor(value: T) : ConstantValue<T>(value)
internal class AnnotationValue(value: FirAnnotationCall) : ConstantValue<FirAnnotationCall>(value) { internal class AnnotationValue(value: FirAnnotation) : ConstantValue<FirAnnotation>(value) {
override fun <R, D> accept(visitor: AnnotationArgumentVisitor<R, D>, data: D): R = visitor.visitAnnotationValue(this, data) override fun <R, D> accept(visitor: AnnotationArgumentVisitor<R, D>, data: D): R = visitor.visitAnnotationValue(this, data)
} }
compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/constant/FirToConstantValueTransformer.kt
+3 -3
View File
@@ -55,11 +55,11 @@ internal object FirToConstantValueTransformer : FirDefaultVisitor<ConstantValue<
return ArrayValue(arrayOfCall.argumentList.arguments.mapNotNull { it.accept(this, null) }) return ArrayValue(arrayOfCall.argumentList.arguments.mapNotNull { it.accept(this, null) })
} }
override fun visitAnnotationCall( override fun visitAnnotation(
annotationCall: FirAnnotationCall, annotation: FirAnnotation,
data: Nothing? data: Nothing?
): ConstantValue<*> { ): ConstantValue<*> {
return AnnotationValue(annotationCall) return AnnotationValue(annotation)
} }
override fun visitGetClassCall( override fun visitGetClassCall(
compiler/fir/fir2ir/jvm-backend/src/org/jetbrains/kotlin/fir/backend/jvm/FirJvmSerializerExtension.kt
+2 -2
View File
@@ -17,7 +17,7 @@ import org.jetbrains.kotlin.fir.backend.Fir2IrComponents
import org.jetbrains.kotlin.fir.backend.FirMetadataSource import org.jetbrains.kotlin.fir.backend.FirMetadataSource
import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.*
import org.jetbrains.kotlin.fir.declarations.utils.* import org.jetbrains.kotlin.fir.declarations.utils.*
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.render import org.jetbrains.kotlin.fir.render
import org.jetbrains.kotlin.fir.resolve.firProvider import org.jetbrains.kotlin.fir.resolve.firProvider
import org.jetbrains.kotlin.fir.resolve.inference.isBuiltinFunctionalType import org.jetbrains.kotlin.fir.resolve.inference.isBuiltinFunctionalType
@@ -160,7 +160,7 @@ class FirJvmSerializerExtension(
} }
} }
override fun serializeTypeAnnotation(annotation: FirAnnotationCall, proto: ProtoBuf.Type.Builder) { override fun serializeTypeAnnotation(annotation: FirAnnotation, proto: ProtoBuf.Type.Builder) {
proto.addExtension(JvmProtoBuf.typeAnnotation, annotationSerializer.serializeAnnotation(annotation)) proto.addExtension(JvmProtoBuf.typeAnnotation, annotationSerializer.serializeAnnotation(annotation))
} }
compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/ConversionUtils.kt
+2 -2
View File
@@ -18,7 +18,7 @@ import org.jetbrains.kotlin.fir.declarations.synthetic.FirSyntheticProperty
import org.jetbrains.kotlin.fir.declarations.utils.isInline import org.jetbrains.kotlin.fir.declarations.utils.isInline
import org.jetbrains.kotlin.fir.declarations.utils.isJava import org.jetbrains.kotlin.fir.declarations.utils.isJava
import org.jetbrains.kotlin.fir.declarations.utils.visibility import org.jetbrains.kotlin.fir.declarations.utils.visibility
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.expressions.FirConstExpression import org.jetbrains.kotlin.fir.expressions.FirConstExpression
import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccess import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccess
import org.jetbrains.kotlin.fir.references.FirErrorNamedReference import org.jetbrains.kotlin.fir.references.FirErrorNamedReference
@@ -126,7 +126,7 @@ fun FirClassifierSymbol<*>.toSymbol(
session: FirSession, session: FirSession,
classifierStorage: Fir2IrClassifierStorage, classifierStorage: Fir2IrClassifierStorage,
typeContext: ConversionTypeContext = ConversionTypeContext.DEFAULT, typeContext: ConversionTypeContext = ConversionTypeContext.DEFAULT,
handleAnnotations: ((List<FirAnnotationCall>) -> Unit)? = null handleAnnotations: ((List<FirAnnotation>) -> Unit)? = null
): IrClassifierSymbol { ): IrClassifierSymbol {
return when (this) { return when (this) {
is FirTypeParameterSymbol -> { is FirTypeParameterSymbol -> {
compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrImplicitCastInserter.kt
+1 -1
View File
@@ -38,7 +38,7 @@ class Fir2IrImplicitCastInserter(
TODO("Should not be here: ${element::class}: ${element.render()}") TODO("Should not be here: ${element::class}: ${element.render()}")
} }
override fun visitAnnotationCall(annotationCall: FirAnnotationCall, data: IrElement): IrElement = data override fun visitAnnotation(annotation: FirAnnotation, data: IrElement): IrElement = data
override fun visitAnonymousObjectExpression(anonymousObjectExpression: FirAnonymousObjectExpression, data: IrElement): IrElement = data override fun visitAnonymousObjectExpression(anonymousObjectExpression: FirAnonymousObjectExpression, data: IrElement): IrElement = data
compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrTypeConverter.kt
+2 -2
View File
@@ -5,7 +5,7 @@
package org.jetbrains.kotlin.fir.backend package org.jetbrains.kotlin.fir.backend
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.expressions.classId import org.jetbrains.kotlin.fir.expressions.classId
import org.jetbrains.kotlin.fir.languageVersionSettings import org.jetbrains.kotlin.fir.languageVersionSettings
import org.jetbrains.kotlin.fir.resolve.fullyExpandedType import org.jetbrains.kotlin.fir.resolve.fullyExpandedType
@@ -94,7 +94,7 @@ class Fir2IrTypeConverter(
fun ConeKotlinType.toIrType( fun ConeKotlinType.toIrType(
typeContext: ConversionTypeContext = ConversionTypeContext.DEFAULT, typeContext: ConversionTypeContext = ConversionTypeContext.DEFAULT,
annotations: List<FirAnnotationCall> = emptyList(), annotations: List<FirAnnotation> = emptyList(),
hasFlexibleNullability: Boolean = false hasFlexibleNullability: Boolean = false
): IrType { ): IrType {
return when (this) { return when (this) {
compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrVisitor.kt
+2 -2
View File
@@ -372,8 +372,8 @@ class Fir2IrVisitor(
return calleeReference.resolvedSymbol as? FirNamedFunctionSymbol return calleeReference.resolvedSymbol as? FirNamedFunctionSymbol
} }
override fun visitAnnotationCall(annotationCall: FirAnnotationCall, data: Any?): IrElement { override fun visitAnnotation(annotation: FirAnnotation, data: Any?): IrElement {
return callGenerator.convertToIrConstructorCall(annotationCall) return callGenerator.convertToIrConstructorCall(annotation)
} }
override fun visitQualifiedAccessExpression(qualifiedAccessExpression: FirQualifiedAccessExpression, data: Any?): IrElement { override fun visitQualifiedAccessExpression(qualifiedAccessExpression: FirQualifiedAccessExpression, data: Any?): IrElement {
compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/AnnotationGenerator.kt
+3 -3
View File
@@ -12,7 +12,7 @@ import org.jetbrains.kotlin.fir.backend.Fir2IrComponents
import org.jetbrains.kotlin.fir.declarations.FirProperty import org.jetbrains.kotlin.fir.declarations.FirProperty
import org.jetbrains.kotlin.fir.declarations.FirValueParameter import org.jetbrains.kotlin.fir.declarations.FirValueParameter
import org.jetbrains.kotlin.fir.declarations.useSiteTargetsFromMetaAnnotation import org.jetbrains.kotlin.fir.declarations.useSiteTargetsFromMetaAnnotation
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.ir.declarations.* import org.jetbrains.kotlin.ir.declarations.*
import org.jetbrains.kotlin.ir.expressions.IrConstructorCall import org.jetbrains.kotlin.ir.expressions.IrConstructorCall
import org.jetbrains.kotlin.ir.util.isSetter import org.jetbrains.kotlin.ir.util.isSetter
@@ -27,7 +27,7 @@ import org.jetbrains.kotlin.ir.util.isSetter
*/ */
class AnnotationGenerator(private val components: Fir2IrComponents) : Fir2IrComponents by components { class AnnotationGenerator(private val components: Fir2IrComponents) : Fir2IrComponents by components {
fun List<FirAnnotationCall>.toIrAnnotations(): List<IrConstructorCall> = fun List<FirAnnotation>.toIrAnnotations(): List<IrConstructorCall> =
mapNotNull { mapNotNull {
callGenerator.convertToIrConstructorCall(it) as? IrConstructorCall callGenerator.convertToIrConstructorCall(it) as? IrConstructorCall
} }
@@ -36,7 +36,7 @@ class AnnotationGenerator(private val components: Fir2IrComponents) : Fir2IrComp
irContainer.annotations = firContainer.annotations.toIrAnnotations() irContainer.annotations = firContainer.annotations.toIrAnnotations()
} }
private fun FirAnnotationCall.target(applicable: List<AnnotationUseSiteTarget>): AnnotationUseSiteTarget? = private fun FirAnnotation.target(applicable: List<AnnotationUseSiteTarget>): AnnotationUseSiteTarget? =
useSiteTarget ?: applicable.firstOrNull(useSiteTargetsFromMetaAnnotation(session)::contains) useSiteTarget ?: applicable.firstOrNull(useSiteTargetsFromMetaAnnotation(session)::contains)
companion object { companion object {
compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/CallAndReferenceGenerator.kt
+8 -8
View File
@@ -379,15 +379,15 @@ class CallAndReferenceGenerator(
} }
} }
fun convertToIrConstructorCall(annotationCall: FirAnnotationCall): IrExpression { fun convertToIrConstructorCall(annotation: FirAnnotation): IrExpression {
val coneType = annotationCall.annotationTypeRef.coneTypeSafe<ConeLookupTagBasedType>() val coneType = annotation.annotationTypeRef.coneTypeSafe<ConeLookupTagBasedType>()
val type = coneType?.toIrType() val type = coneType?.toIrType()
val symbol = type?.classifierOrNull val symbol = type?.classifierOrNull
return annotationCall.convertWithOffsets { startOffset, endOffset -> return annotation.convertWithOffsets { startOffset, endOffset ->
when (symbol) { when (symbol) {
is IrClassSymbol -> { is IrClassSymbol -> {
val irClass = symbol.owner val irClass = symbol.owner
val irConstructor = (annotationCall.toResolvedCallableSymbol() as? FirConstructorSymbol)?.let { val irConstructor = (annotation.toResolvedCallableSymbol() as? FirConstructorSymbol)?.let {
this.declarationStorage.getIrConstructorSymbol(it) this.declarationStorage.getIrConstructorSymbol(it)
} ?: run { } ?: run {
// Fallback for FirReferencePlaceholderForResolvedAnnotations from jar // Fallback for FirReferencePlaceholderForResolvedAnnotations from jar
@@ -419,11 +419,11 @@ class CallAndReferenceGenerator(
startOffset, startOffset,
endOffset, endOffset,
type ?: createErrorType(), type ?: createErrorType(),
"Unresolved reference: ${annotationCall.render()}" "Unresolved reference: ${annotation.render()}"
) )
} }
} }
}.applyCallArguments(annotationCall, annotationMode = true) }.applyCallArguments(annotation, annotationMode = true)
} }
internal fun convertToGetObject(qualifier: FirResolvedQualifier): IrExpression { internal fun convertToGetObject(qualifier: FirResolvedQualifier): IrExpression {
@@ -487,11 +487,11 @@ class CallAndReferenceGenerator(
val calleeReference = when (call) { val calleeReference = when (call) {
is FirFunctionCall -> call.calleeReference is FirFunctionCall -> call.calleeReference
is FirDelegatedConstructorCall -> call.calleeReference is FirDelegatedConstructorCall -> call.calleeReference
is FirAnnotationCall -> call.calleeReference is FirAnnotation -> call.calleeReference
else -> null else -> null
} }
val function = if (calleeReference == FirReferencePlaceholderForResolvedAnnotations) { val function = if (calleeReference == FirReferencePlaceholderForResolvedAnnotations) {
val coneClassLikeType = (call as FirAnnotationCall).annotationTypeRef.coneTypeSafe<ConeClassLikeType>() val coneClassLikeType = (call as FirAnnotation).annotationTypeRef.coneTypeSafe<ConeClassLikeType>()
val firClass = (coneClassLikeType?.lookupTag?.toSymbol(session) as? FirRegularClassSymbol)?.fir val firClass = (coneClassLikeType?.lookupTag?.toSymbol(session) as? FirRegularClassSymbol)?.fir
firClass?.declarations?.filterIsInstance<FirConstructor>()?.firstOrNull() firClass?.declarations?.filterIsInstance<FirConstructor>()?.firstOrNull()
} else { } else {
compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaUtils.kt
+5 -5
View File
@@ -149,13 +149,13 @@ private fun buildArgumentMapping(
internal fun Iterable<JavaAnnotation>.convertAnnotationsToFir( internal fun Iterable<JavaAnnotation>.convertAnnotationsToFir(
session: FirSession, javaTypeParameterStack: JavaTypeParameterStack session: FirSession, javaTypeParameterStack: JavaTypeParameterStack
): List<FirAnnotationCall> = map { it.toFirAnnotationCall(session, javaTypeParameterStack) } ): List<FirAnnotation> = map { it.toFirAnnotationCall(session, javaTypeParameterStack) }
internal fun JavaAnnotationOwner.convertAnnotationsToFir( internal fun JavaAnnotationOwner.convertAnnotationsToFir(
session: FirSession, javaTypeParameterStack: JavaTypeParameterStack session: FirSession, javaTypeParameterStack: JavaTypeParameterStack
): List<FirAnnotationCall> = annotations.convertAnnotationsToFir(session, javaTypeParameterStack) ): List<FirAnnotation> = annotations.convertAnnotationsToFir(session, javaTypeParameterStack)
internal fun MutableList<FirAnnotationCall>.addFromJava( internal fun MutableList<FirAnnotation>.addFromJava(
session: FirSession, session: FirSession,
javaAnnotationOwner: JavaAnnotationOwner, javaAnnotationOwner: JavaAnnotationOwner,
javaTypeParameterStack: JavaTypeParameterStack javaTypeParameterStack: JavaTypeParameterStack
@@ -165,8 +165,8 @@ internal fun MutableList<FirAnnotationCall>.addFromJava(
private fun JavaAnnotation.toFirAnnotationCall( private fun JavaAnnotation.toFirAnnotationCall(
session: FirSession, javaTypeParameterStack: JavaTypeParameterStack session: FirSession, javaTypeParameterStack: JavaTypeParameterStack
): FirAnnotationCall { ): FirAnnotation {
return buildAnnotationCall { return buildAnnotation {
val lookupTag = when (classId) { val lookupTag = when (classId) {
JAVA_TARGET_CLASS_ID -> ClassId.topLevel(StandardNames.FqNames.target) JAVA_TARGET_CLASS_ID -> ClassId.topLevel(StandardNames.FqNames.target)
JAVA_RETENTION_CLASS_ID -> ClassId.topLevel(StandardNames.FqNames.retention) JAVA_RETENTION_CLASS_ID -> ClassId.topLevel(StandardNames.FqNames.retention)
compiler/fir/java/src/org/jetbrains/kotlin/fir/java/declarations/FirJavaClass.kt
+3 -3
View File
@@ -15,7 +15,7 @@ import org.jetbrains.kotlin.fir.builder.FirAnnotationContainerBuilder
import org.jetbrains.kotlin.fir.builder.FirBuilderDsl import org.jetbrains.kotlin.fir.builder.FirBuilderDsl
import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.*
import org.jetbrains.kotlin.fir.declarations.builder.FirRegularClassBuilder import org.jetbrains.kotlin.fir.declarations.builder.FirRegularClassBuilder
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.java.JavaTypeParameterStack import org.jetbrains.kotlin.fir.java.JavaTypeParameterStack
import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference
import org.jetbrains.kotlin.fir.scopes.FirScopeProvider import org.jetbrains.kotlin.fir.scopes.FirScopeProvider
@@ -36,7 +36,7 @@ class FirJavaClass @FirImplementationDetail internal constructor(
@Volatile @Volatile
override var resolvePhase: FirResolvePhase, override var resolvePhase: FirResolvePhase,
override val name: Name, override val name: Name,
override val annotations: MutableList<FirAnnotationCall>, override val annotations: MutableList<FirAnnotation>,
override var status: FirDeclarationStatus, override var status: FirDeclarationStatus,
override val classKind: ClassKind, override val classKind: ClassKind,
override val declarations: MutableList<FirDeclaration>, override val declarations: MutableList<FirDeclaration>,
@@ -139,7 +139,7 @@ internal class FirJavaClassBuilder : FirRegularClassBuilder(), FirAnnotationCont
override var source: FirSourceElement? = null override var source: FirSourceElement? = null
override var resolvePhase: FirResolvePhase = FirResolvePhase.RAW_FIR override var resolvePhase: FirResolvePhase = FirResolvePhase.RAW_FIR
override val annotations: MutableList<FirAnnotationCall> = mutableListOf() override val annotations: MutableList<FirAnnotation> = mutableListOf()
override val typeParameters: MutableList<FirTypeParameterRef> = mutableListOf() override val typeParameters: MutableList<FirTypeParameterRef> = mutableListOf()
override val declarations: MutableList<FirDeclaration> = mutableListOf() override val declarations: MutableList<FirDeclaration> = mutableListOf()
compiler/fir/java/src/org/jetbrains/kotlin/fir/java/declarations/FirJavaConstructor.kt
+4 -4
View File
@@ -12,7 +12,7 @@ import org.jetbrains.kotlin.fir.FirSourceElement
import org.jetbrains.kotlin.fir.builder.FirBuilderDsl import org.jetbrains.kotlin.fir.builder.FirBuilderDsl
import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.*
import org.jetbrains.kotlin.fir.declarations.builder.FirConstructorBuilder import org.jetbrains.kotlin.fir.declarations.builder.FirConstructorBuilder
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.expressions.FirBlock import org.jetbrains.kotlin.fir.expressions.FirBlock
import org.jetbrains.kotlin.fir.expressions.FirDelegatedConstructorCall import org.jetbrains.kotlin.fir.expressions.FirDelegatedConstructorCall
import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference
@@ -35,7 +35,7 @@ class FirJavaConstructor @FirImplementationDetail constructor(
override var returnTypeRef: FirTypeRef, override var returnTypeRef: FirTypeRef,
override val valueParameters: MutableList<FirValueParameter>, override val valueParameters: MutableList<FirValueParameter>,
override val typeParameters: MutableList<FirTypeParameterRef>, override val typeParameters: MutableList<FirTypeParameterRef>,
annotationBuilder: () -> List<FirAnnotationCall>, annotationBuilder: () -> List<FirAnnotation>,
override var status: FirDeclarationStatus, override var status: FirDeclarationStatus,
@Volatile @Volatile
override var resolvePhase: FirResolvePhase, override var resolvePhase: FirResolvePhase,
@@ -61,7 +61,7 @@ class FirJavaConstructor @FirImplementationDetail constructor(
override val controlFlowGraphReference: FirControlFlowGraphReference? get() = null override val controlFlowGraphReference: FirControlFlowGraphReference? get() = null
override val annotations: List<FirAnnotationCall> by lazy { annotationBuilder() } override val annotations: List<FirAnnotation> by lazy { annotationBuilder() }
override fun <D> transformValueParameters(transformer: FirTransformer<D>, data: D): FirJavaConstructor { override fun <D> transformValueParameters(transformer: FirTransformer<D>, data: D): FirJavaConstructor {
@@ -150,7 +150,7 @@ class FirJavaConstructorBuilder : FirConstructorBuilder() {
lateinit var visibility: Visibility lateinit var visibility: Visibility
var isInner: Boolean by Delegates.notNull() var isInner: Boolean by Delegates.notNull()
var isPrimary: Boolean by Delegates.notNull() var isPrimary: Boolean by Delegates.notNull()
lateinit var annotationBuilder: () -> List<FirAnnotationCall> lateinit var annotationBuilder: () -> List<FirAnnotation>
@OptIn(FirImplementationDetail::class) @OptIn(FirImplementationDetail::class)
override fun build(): FirJavaConstructor { override fun build(): FirJavaConstructor {
compiler/fir/java/src/org/jetbrains/kotlin/fir/java/declarations/FirJavaField.kt
+4 -4
View File
@@ -13,7 +13,7 @@ import org.jetbrains.kotlin.fir.FirSourceElement
import org.jetbrains.kotlin.fir.builder.FirBuilderDsl import org.jetbrains.kotlin.fir.builder.FirBuilderDsl
import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.*
import org.jetbrains.kotlin.fir.declarations.builder.FirFieldBuilder import org.jetbrains.kotlin.fir.declarations.builder.FirFieldBuilder
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.expressions.FirExpression import org.jetbrains.kotlin.fir.expressions.FirExpression
import org.jetbrains.kotlin.fir.languageVersionSettings import org.jetbrains.kotlin.fir.languageVersionSettings
import org.jetbrains.kotlin.fir.symbols.impl.FirFieldSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirFieldSymbol
@@ -41,7 +41,7 @@ class FirJavaField @FirImplementationDetail constructor(
override var returnTypeRef: FirTypeRef, override var returnTypeRef: FirTypeRef,
override var status: FirDeclarationStatus, override var status: FirDeclarationStatus,
override val isVar: Boolean, override val isVar: Boolean,
annotationBuilder: () -> List<FirAnnotationCall>, annotationBuilder: () -> List<FirAnnotation>,
override val typeParameters: MutableList<FirTypeParameterRef>, override val typeParameters: MutableList<FirTypeParameterRef>,
override var initializer: FirExpression?, override var initializer: FirExpression?,
override val dispatchReceiverType: ConeKotlinType?, override val dispatchReceiverType: ConeKotlinType?,
@@ -60,7 +60,7 @@ class FirJavaField @FirImplementationDetail constructor(
override val origin: FirDeclarationOrigin override val origin: FirDeclarationOrigin
get() = FirDeclarationOrigin.Java get() = FirDeclarationOrigin.Java
override val annotations: List<FirAnnotationCall> by lazy { annotationBuilder() } override val annotations: List<FirAnnotation> by lazy { annotationBuilder() }
override val deprecation: DeprecationsPerUseSite by lazy { override val deprecation: DeprecationsPerUseSite by lazy {
annotations.getDeprecationInfosFromAnnotations(moduleData.session.languageVersionSettings.apiVersion, fromJava = true) annotations.getDeprecationInfosFromAnnotations(moduleData.session.languageVersionSettings.apiVersion, fromJava = true)
@@ -160,7 +160,7 @@ internal class FirJavaFieldBuilder : FirFieldBuilder() {
var modality: Modality? = null var modality: Modality? = null
lateinit var visibility: Visibility lateinit var visibility: Visibility
var isStatic: Boolean by Delegates.notNull() var isStatic: Boolean by Delegates.notNull()
lateinit var annotationBuilder: () -> List<FirAnnotationCall> lateinit var annotationBuilder: () -> List<FirAnnotation>
override var resolvePhase: FirResolvePhase = FirResolvePhase.ANALYZED_DEPENDENCIES override var resolvePhase: FirResolvePhase = FirResolvePhase.ANALYZED_DEPENDENCIES
compiler/fir/java/src/org/jetbrains/kotlin/fir/java/declarations/FirJavaMethod.kt
+5 -5
View File
@@ -15,7 +15,7 @@ import org.jetbrains.kotlin.fir.contracts.impl.FirEmptyContractDescription
import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.*
import org.jetbrains.kotlin.fir.declarations.builder.FirFunctionBuilder import org.jetbrains.kotlin.fir.declarations.builder.FirFunctionBuilder
import org.jetbrains.kotlin.fir.declarations.builder.FirTypeParametersOwnerBuilder import org.jetbrains.kotlin.fir.declarations.builder.FirTypeParametersOwnerBuilder
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.expressions.FirBlock import org.jetbrains.kotlin.fir.expressions.FirBlock
import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference
import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
@@ -59,7 +59,7 @@ class FirJavaMethod @FirImplementationDetail constructor(
override val name: Name, override val name: Name,
override var status: FirDeclarationStatus, override var status: FirDeclarationStatus,
override val symbol: FirNamedFunctionSymbol, override val symbol: FirNamedFunctionSymbol,
annotationBuilder: () -> List<FirAnnotationCall>, annotationBuilder: () -> List<FirAnnotation>,
override val dispatchReceiverType: ConeKotlinType?, override val dispatchReceiverType: ConeKotlinType?,
) : FirSimpleFunction() { ) : FirSimpleFunction() {
init { init {
@@ -83,7 +83,7 @@ class FirJavaMethod @FirImplementationDetail constructor(
override var controlFlowGraphReference: FirControlFlowGraphReference? = null override var controlFlowGraphReference: FirControlFlowGraphReference? = null
override val annotations: List<FirAnnotationCall> by lazy { annotationBuilder() } override val annotations: List<FirAnnotation> by lazy { annotationBuilder() }
//not used actually, because get 'enhanced' into regular FirSimpleFunction //not used actually, because get 'enhanced' into regular FirSimpleFunction
override var deprecation: DeprecationsPerUseSite? = null override var deprecation: DeprecationsPerUseSite? = null
@@ -196,11 +196,11 @@ class FirJavaMethodBuilder : FirFunctionBuilder, FirTypeParametersOwnerBuilder,
override var dispatchReceiverType: ConeKotlinType? = null override var dispatchReceiverType: ConeKotlinType? = null
lateinit var name: Name lateinit var name: Name
lateinit var symbol: FirNamedFunctionSymbol lateinit var symbol: FirNamedFunctionSymbol
override val annotations: MutableList<FirAnnotationCall> = mutableListOf() override val annotations: MutableList<FirAnnotation> = mutableListOf()
override val typeParameters: MutableList<FirTypeParameter> = mutableListOf() override val typeParameters: MutableList<FirTypeParameter> = mutableListOf()
var isStatic: Boolean by Delegates.notNull() var isStatic: Boolean by Delegates.notNull()
override var resolvePhase: FirResolvePhase = FirResolvePhase.ANALYZED_DEPENDENCIES override var resolvePhase: FirResolvePhase = FirResolvePhase.ANALYZED_DEPENDENCIES
lateinit var annotationBuilder: () -> List<FirAnnotationCall> lateinit var annotationBuilder: () -> List<FirAnnotation>
@Deprecated("Modification of 'deprecation' has no impact for FirJavaFunctionBuilder", level = DeprecationLevel.HIDDEN) @Deprecated("Modification of 'deprecation' has no impact for FirJavaFunctionBuilder", level = DeprecationLevel.HIDDEN)
override var deprecation: DeprecationsPerUseSite? override var deprecation: DeprecationsPerUseSite?
compiler/fir/java/src/org/jetbrains/kotlin/fir/java/declarations/FirJavaValueParameter.kt
+4 -4
View File
@@ -11,7 +11,7 @@ import org.jetbrains.kotlin.fir.FirSourceElement
import org.jetbrains.kotlin.fir.builder.FirBuilderDsl import org.jetbrains.kotlin.fir.builder.FirBuilderDsl
import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.*
import org.jetbrains.kotlin.fir.declarations.impl.FirResolvedDeclarationStatusImpl import org.jetbrains.kotlin.fir.declarations.impl.FirResolvedDeclarationStatusImpl
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.expressions.FirExpression import org.jetbrains.kotlin.fir.expressions.FirExpression
import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference
import org.jetbrains.kotlin.fir.symbols.impl.FirValueParameterSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirValueParameterSymbol
@@ -36,7 +36,7 @@ class FirJavaValueParameter @FirImplementationDetail constructor(
override var returnTypeRef: FirTypeRef, override var returnTypeRef: FirTypeRef,
override val name: Name, override val name: Name,
override val symbol: FirValueParameterSymbol, override val symbol: FirValueParameterSymbol,
annotationBuilder: () -> List<FirAnnotationCall>, annotationBuilder: () -> List<FirAnnotation>,
override var defaultValue: FirExpression?, override var defaultValue: FirExpression?,
override val isVararg: Boolean, override val isVararg: Boolean,
) : FirValueParameter() { ) : FirValueParameter() {
@@ -56,7 +56,7 @@ class FirJavaValueParameter @FirImplementationDetail constructor(
override val isVar: Boolean override val isVar: Boolean
get() = false get() = false
override val annotations: List<FirAnnotationCall> by lazy { annotationBuilder() } override val annotations: List<FirAnnotation> by lazy { annotationBuilder() }
override val origin: FirDeclarationOrigin override val origin: FirDeclarationOrigin
get() = FirDeclarationOrigin.Java get() = FirDeclarationOrigin.Java
@@ -190,7 +190,7 @@ class FirJavaValueParameterBuilder {
var attributes: FirDeclarationAttributes = FirDeclarationAttributes() var attributes: FirDeclarationAttributes = FirDeclarationAttributes()
lateinit var returnTypeRef: FirTypeRef lateinit var returnTypeRef: FirTypeRef
lateinit var name: Name lateinit var name: Name
lateinit var annotationBuilder: () -> List<FirAnnotationCall> lateinit var annotationBuilder: () -> List<FirAnnotation>
var defaultValue: FirExpression? = null var defaultValue: FirExpression? = null
var isVararg: Boolean by kotlin.properties.Delegates.notNull() var isVararg: Boolean by kotlin.properties.Delegates.notNull()
compiler/fir/java/src/org/jetbrains/kotlin/fir/java/deserialization/AnnotationsLoader.kt
+5 -5
View File
@@ -34,7 +34,7 @@ import org.jetbrains.kotlin.resolve.constants.ClassLiteralValue
internal class AnnotationsLoader(private val session: FirSession, private val kotlinClassFinder: KotlinClassFinder) { internal class AnnotationsLoader(private val session: FirSession, private val kotlinClassFinder: KotlinClassFinder) {
private fun loadAnnotation( private fun loadAnnotation(
annotationClassId: ClassId, result: MutableList<FirAnnotationCall>, annotationClassId: ClassId, result: MutableList<FirAnnotation>,
): KotlinJvmBinaryClass.AnnotationArgumentVisitor { ): KotlinJvmBinaryClass.AnnotationArgumentVisitor {
val lookupTag = ConeClassLikeLookupTagImpl(annotationClassId) val lookupTag = ConeClassLikeLookupTagImpl(annotationClassId)
@@ -111,7 +111,7 @@ internal class AnnotationsLoader(private val session: FirSession, private val ko
} }
override fun visitAnnotation(classId: ClassId): KotlinJvmBinaryClass.AnnotationArgumentVisitor? { override fun visitAnnotation(classId: ClassId): KotlinJvmBinaryClass.AnnotationArgumentVisitor? {
val list = mutableListOf<FirAnnotationCall>() val list = mutableListOf<FirAnnotation>()
val visitor = loadAnnotation(classId, list) val visitor = loadAnnotation(classId, list)
return object : KotlinJvmBinaryClass.AnnotationArgumentVisitor by visitor { return object : KotlinJvmBinaryClass.AnnotationArgumentVisitor by visitor {
override fun visitEnd() { override fun visitEnd() {
@@ -132,7 +132,7 @@ internal class AnnotationsLoader(private val session: FirSession, private val ko
} }
override fun visitAnnotation(name: Name, classId: ClassId): KotlinJvmBinaryClass.AnnotationArgumentVisitor { override fun visitAnnotation(name: Name, classId: ClassId): KotlinJvmBinaryClass.AnnotationArgumentVisitor {
val list = mutableListOf<FirAnnotationCall>() val list = mutableListOf<FirAnnotation>()
val visitor = loadAnnotation(classId, list) val visitor = loadAnnotation(classId, list)
return object : KotlinJvmBinaryClass.AnnotationArgumentVisitor by visitor { return object : KotlinJvmBinaryClass.AnnotationArgumentVisitor by visitor {
override fun visitEnd() { override fun visitEnd() {
@@ -148,7 +148,7 @@ internal class AnnotationsLoader(private val session: FirSession, private val ko
// resolved, since that class is only generated in the backend, and is not visible to the frontend. // resolved, since that class is only generated in the backend, and is not visible to the frontend.
if (isRepeatableWithImplicitContainer(lookupTag, argumentMap)) return if (isRepeatableWithImplicitContainer(lookupTag, argumentMap)) return
result += buildAnnotationCall { result += buildAnnotation {
annotationTypeRef = lookupTag.toDefaultResolvedTypeRef() annotationTypeRef = lookupTag.toDefaultResolvedTypeRef()
argumentList = buildArgumentList { argumentList = buildArgumentList {
for ((name, expression) in argumentMap) { for ((name, expression) in argumentMap) {
@@ -185,7 +185,7 @@ internal class AnnotationsLoader(private val session: FirSession, private val ko
} }
internal fun loadAnnotationIfNotSpecial( internal fun loadAnnotationIfNotSpecial(
annotationClassId: ClassId, result: MutableList<FirAnnotationCall>, annotationClassId: ClassId, result: MutableList<FirAnnotation>,
): KotlinJvmBinaryClass.AnnotationArgumentVisitor? { ): KotlinJvmBinaryClass.AnnotationArgumentVisitor? {
if (annotationClassId in SpecialJvmAnnotations.SPECIAL_ANNOTATIONS) return null if (annotationClassId in SpecialJvmAnnotations.SPECIAL_ANNOTATIONS) return null
return loadAnnotation(annotationClassId, result) return loadAnnotation(annotationClassId, result)
compiler/fir/java/src/org/jetbrains/kotlin/fir/java/deserialization/JvmBinaryAnnotationDeserializer.kt
+19 -19
View File
@@ -9,8 +9,8 @@ import org.jetbrains.kotlin.descriptors.SourceElement
import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.deserialization.AbstractAnnotationDeserializer import org.jetbrains.kotlin.fir.deserialization.AbstractAnnotationDeserializer
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.expressions.builder.buildAnnotationCall import org.jetbrains.kotlin.fir.expressions.builder.buildAnnotation
import org.jetbrains.kotlin.load.java.JvmAbi import org.jetbrains.kotlin.load.java.JvmAbi
import org.jetbrains.kotlin.load.kotlin.KotlinClassFinder import org.jetbrains.kotlin.load.kotlin.KotlinClassFinder
import org.jetbrains.kotlin.load.kotlin.KotlinJvmBinaryClass import org.jetbrains.kotlin.load.kotlin.KotlinJvmBinaryClass
@@ -49,7 +49,7 @@ class JvmBinaryAnnotationDeserializer(
} }
} }
override fun loadTypeAnnotations(typeProto: ProtoBuf.Type, nameResolver: NameResolver): List<FirAnnotationCall> { override fun loadTypeAnnotations(typeProto: ProtoBuf.Type, nameResolver: NameResolver): List<FirAnnotation> {
val annotations = typeProto.getExtension(JvmProtoBuf.typeAnnotation).orEmpty() val annotations = typeProto.getExtension(JvmProtoBuf.typeAnnotation).orEmpty()
return annotations.map { deserializeAnnotation(it, nameResolver) } return annotations.map { deserializeAnnotation(it, nameResolver) }
} }
@@ -59,7 +59,7 @@ class JvmBinaryAnnotationDeserializer(
constructorProto: ProtoBuf.Constructor, constructorProto: ProtoBuf.Constructor,
nameResolver: NameResolver, nameResolver: NameResolver,
typeTable: TypeTable typeTable: TypeTable
): List<FirAnnotationCall> { ): List<FirAnnotation> {
val signature = getCallableSignature(constructorProto, nameResolver, typeTable) ?: return emptyList() val signature = getCallableSignature(constructorProto, nameResolver, typeTable) ?: return emptyList()
return findJvmBinaryClassAndLoadMemberAnnotations(signature) return findJvmBinaryClassAndLoadMemberAnnotations(signature)
} }
@@ -69,7 +69,7 @@ class JvmBinaryAnnotationDeserializer(
functionProto: ProtoBuf.Function, functionProto: ProtoBuf.Function,
nameResolver: NameResolver, nameResolver: NameResolver,
typeTable: TypeTable typeTable: TypeTable
): List<FirAnnotationCall> { ): List<FirAnnotation> {
val signature = getCallableSignature(functionProto, nameResolver, typeTable) ?: return emptyList() val signature = getCallableSignature(functionProto, nameResolver, typeTable) ?: return emptyList()
return findJvmBinaryClassAndLoadMemberAnnotations(signature) return findJvmBinaryClassAndLoadMemberAnnotations(signature)
} }
@@ -80,7 +80,7 @@ class JvmBinaryAnnotationDeserializer(
containingClassProto: ProtoBuf.Class?, containingClassProto: ProtoBuf.Class?,
nameResolver: NameResolver, nameResolver: NameResolver,
typeTable: TypeTable typeTable: TypeTable
): List<FirAnnotationCall> { ): List<FirAnnotation> {
val signature = getPropertySignature(propertyProto, nameResolver, typeTable, synthetic = true) ?: return emptyList() val signature = getPropertySignature(propertyProto, nameResolver, typeTable, synthetic = true) ?: return emptyList()
val classIsInterface = containingClassProto?.let { Flags.CLASS_KIND.get(it.flags) == ProtoBuf.Class.Kind.INTERFACE } ?: false val classIsInterface = containingClassProto?.let { Flags.CLASS_KIND.get(it.flags) == ProtoBuf.Class.Kind.INTERFACE } ?: false
val jvmClassFlags = runIf(containingClassProto?.hasExtension(JvmProtoBuf.jvmClassFlags) == true) { val jvmClassFlags = runIf(containingClassProto?.hasExtension(JvmProtoBuf.jvmClassFlags) == true) {
@@ -91,7 +91,7 @@ class JvmBinaryAnnotationDeserializer(
signature, signature,
searchInDefaultImpls = classIsInterface && allCompatibilityModeIsEnabled searchInDefaultImpls = classIsInterface && allCompatibilityModeIsEnabled
).map { ).map {
buildAnnotationCall { buildAnnotation {
annotationTypeRef = it.annotationTypeRef annotationTypeRef = it.annotationTypeRef
argumentList = it.argumentList argumentList = it.argumentList
useSiteTarget = AnnotationUseSiteTarget.PROPERTY useSiteTarget = AnnotationUseSiteTarget.PROPERTY
@@ -108,13 +108,13 @@ class JvmBinaryAnnotationDeserializer(
propertyProto: ProtoBuf.Property, propertyProto: ProtoBuf.Property,
nameResolver: NameResolver, nameResolver: NameResolver,
typeTable: TypeTable typeTable: TypeTable
): List<FirAnnotationCall> { ): List<FirAnnotation> {
val signature = getPropertySignature(propertyProto, nameResolver, typeTable, field = true) ?: return emptyList() val signature = getPropertySignature(propertyProto, nameResolver, typeTable, field = true) ?: return emptyList()
if (signature.isDelegated) { if (signature.isDelegated) {
return emptyList() return emptyList()
} }
return findJvmBinaryClassAndLoadMemberAnnotations(signature).map { return findJvmBinaryClassAndLoadMemberAnnotations(signature).map {
buildAnnotationCall { buildAnnotation {
annotationTypeRef = it.annotationTypeRef annotationTypeRef = it.annotationTypeRef
argumentList = it.argumentList argumentList = it.argumentList
useSiteTarget = AnnotationUseSiteTarget.FIELD useSiteTarget = AnnotationUseSiteTarget.FIELD
@@ -128,13 +128,13 @@ class JvmBinaryAnnotationDeserializer(
propertyProto: ProtoBuf.Property, propertyProto: ProtoBuf.Property,
nameResolver: NameResolver, nameResolver: NameResolver,
typeTable: TypeTable typeTable: TypeTable
): List<FirAnnotationCall> { ): List<FirAnnotation> {
val signature = getPropertySignature(propertyProto, nameResolver, typeTable, field = true) ?: return emptyList() val signature = getPropertySignature(propertyProto, nameResolver, typeTable, field = true) ?: return emptyList()
if (!signature.isDelegated) { if (!signature.isDelegated) {
return emptyList() return emptyList()
} }
return findJvmBinaryClassAndLoadMemberAnnotations(signature).map { return findJvmBinaryClassAndLoadMemberAnnotations(signature).map {
buildAnnotationCall { buildAnnotation {
annotationTypeRef = it.annotationTypeRef annotationTypeRef = it.annotationTypeRef
argumentList = it.argumentList argumentList = it.argumentList
useSiteTarget = AnnotationUseSiteTarget.PROPERTY_DELEGATE_FIELD useSiteTarget = AnnotationUseSiteTarget.PROPERTY_DELEGATE_FIELD
@@ -149,7 +149,7 @@ class JvmBinaryAnnotationDeserializer(
nameResolver: NameResolver, nameResolver: NameResolver,
typeTable: TypeTable, typeTable: TypeTable,
getterFlags: Int getterFlags: Int
): List<FirAnnotationCall> { ): List<FirAnnotation> {
val signature = getCallableSignature(propertyProto, nameResolver, typeTable, CallableKind.PROPERTY_GETTER) ?: return emptyList() val signature = getCallableSignature(propertyProto, nameResolver, typeTable, CallableKind.PROPERTY_GETTER) ?: return emptyList()
return findJvmBinaryClassAndLoadMemberAnnotations(signature) return findJvmBinaryClassAndLoadMemberAnnotations(signature)
} }
@@ -160,7 +160,7 @@ class JvmBinaryAnnotationDeserializer(
nameResolver: NameResolver, nameResolver: NameResolver,
typeTable: TypeTable, typeTable: TypeTable,
setterFlags: Int setterFlags: Int
): List<FirAnnotationCall> { ): List<FirAnnotation> {
val signature = getCallableSignature(propertyProto, nameResolver, typeTable, CallableKind.PROPERTY_SETTER) ?: return emptyList() val signature = getCallableSignature(propertyProto, nameResolver, typeTable, CallableKind.PROPERTY_SETTER) ?: return emptyList()
return findJvmBinaryClassAndLoadMemberAnnotations(signature) return findJvmBinaryClassAndLoadMemberAnnotations(signature)
} }
@@ -174,7 +174,7 @@ class JvmBinaryAnnotationDeserializer(
typeTable: TypeTable, typeTable: TypeTable,
kind: CallableKind, kind: CallableKind,
parameterIndex: Int, parameterIndex: Int,
): List<FirAnnotationCall> { ): List<FirAnnotation> {
val methodSignature = getCallableSignature(callableProto, nameResolver, typeTable, kind) ?: return emptyList() val methodSignature = getCallableSignature(callableProto, nameResolver, typeTable, kind) ?: return emptyList()
val index = parameterIndex + computeJvmParameterIndexShift(classProto, callableProto) val index = parameterIndex + computeJvmParameterIndexShift(classProto, callableProto)
val paramSignature = MemberSignature.fromMethodSignatureAndParameterIndex(methodSignature, index) val paramSignature = MemberSignature.fromMethodSignatureAndParameterIndex(methodSignature, index)
@@ -187,7 +187,7 @@ class JvmBinaryAnnotationDeserializer(
nameResolver: NameResolver, nameResolver: NameResolver,
typeTable: TypeTable, typeTable: TypeTable,
kind: CallableKind kind: CallableKind
): List<FirAnnotationCall> { ): List<FirAnnotation> {
val methodSignature = getCallableSignature(callableProto, nameResolver, typeTable, kind) ?: return emptyList() val methodSignature = getCallableSignature(callableProto, nameResolver, typeTable, kind) ?: return emptyList()
val paramSignature = MemberSignature.fromMethodSignatureAndParameterIndex(methodSignature, 0) val paramSignature = MemberSignature.fromMethodSignatureAndParameterIndex(methodSignature, 0)
return findJvmBinaryClassAndLoadMemberAnnotations(paramSignature) return findJvmBinaryClassAndLoadMemberAnnotations(paramSignature)
@@ -274,7 +274,7 @@ class JvmBinaryAnnotationDeserializer(
private fun findJvmBinaryClassAndLoadMemberAnnotations( private fun findJvmBinaryClassAndLoadMemberAnnotations(
memberSignature: MemberSignature, searchInDefaultImpls: Boolean = false memberSignature: MemberSignature, searchInDefaultImpls: Boolean = false
): List<FirAnnotationCall> { ): List<FirAnnotation> {
val info = if (searchInDefaultImpls) { val info = if (searchInDefaultImpls) {
annotationInfoForDefaultImpls ?: return emptyList() annotationInfoForDefaultImpls ?: return emptyList()
} else { } else {
@@ -285,7 +285,7 @@ class JvmBinaryAnnotationDeserializer(
} }
// TODO: Rename this once property constants are recorded as well // TODO: Rename this once property constants are recorded as well
private data class MemberAnnotations(val memberAnnotations: MutableMap<MemberSignature, MutableList<FirAnnotationCall>>) private data class MemberAnnotations(val memberAnnotations: MutableMap<MemberSignature, MutableList<FirAnnotation>>)
// TODO: better to be in KotlinDeserializedJvmSymbolsProvider? // TODO: better to be in KotlinDeserializedJvmSymbolsProvider?
private fun FirSession.loadMemberAnnotations( private fun FirSession.loadMemberAnnotations(
@@ -293,7 +293,7 @@ private fun FirSession.loadMemberAnnotations(
byteContent: ByteArray?, byteContent: ByteArray?,
kotlinClassFinder: KotlinClassFinder, kotlinClassFinder: KotlinClassFinder,
): MemberAnnotations { ): MemberAnnotations {
val memberAnnotations = hashMapOf<MemberSignature, MutableList<FirAnnotationCall>>() val memberAnnotations = hashMapOf<MemberSignature, MutableList<FirAnnotation>>()
val annotationsLoader = AnnotationsLoader(this, kotlinClassFinder) val annotationsLoader = AnnotationsLoader(this, kotlinClassFinder)
kotlinBinaryClass.visitMembers(object : KotlinJvmBinaryClass.MemberVisitor { kotlinBinaryClass.visitMembers(object : KotlinJvmBinaryClass.MemberVisitor {
@@ -328,7 +328,7 @@ private fun FirSession.loadMemberAnnotations(
} }
open inner class MemberAnnotationVisitor(protected val signature: MemberSignature) : KotlinJvmBinaryClass.AnnotationVisitor { open inner class MemberAnnotationVisitor(protected val signature: MemberSignature) : KotlinJvmBinaryClass.AnnotationVisitor {
private val result = arrayListOf<FirAnnotationCall>() private val result = arrayListOf<FirAnnotation>()
override fun visitAnnotation(classId: ClassId, source: SourceElement): KotlinJvmBinaryClass.AnnotationArgumentVisitor? { override fun visitAnnotation(classId: ClassId, source: SourceElement): KotlinJvmBinaryClass.AnnotationArgumentVisitor? {
return annotationsLoader.loadAnnotationIfNotSpecial(classId, result) return annotationsLoader.loadAnnotationIfNotSpecial(classId, result)
compiler/fir/java/src/org/jetbrains/kotlin/fir/java/deserialization/KotlinDeserializedJvmSymbolsProvider.kt
+3 -3
View File
@@ -14,7 +14,7 @@ import org.jetbrains.kotlin.fir.caches.firCachesFactory
import org.jetbrains.kotlin.fir.caches.getValue import org.jetbrains.kotlin.fir.caches.getValue
import org.jetbrains.kotlin.fir.declarations.getDeprecationInfos import org.jetbrains.kotlin.fir.declarations.getDeprecationInfos
import org.jetbrains.kotlin.fir.deserialization.* import org.jetbrains.kotlin.fir.deserialization.*
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.java.JavaSymbolProvider import org.jetbrains.kotlin.fir.java.JavaSymbolProvider
import org.jetbrains.kotlin.fir.java.topLevelName import org.jetbrains.kotlin.fir.java.topLevelName
import org.jetbrains.kotlin.fir.languageVersionSettings import org.jetbrains.kotlin.fir.languageVersionSettings
@@ -125,7 +125,7 @@ open class KotlinDeserializedJvmSymbolsProvider(
kotlinClass: KotlinClassFinder.Result.KotlinClass, kotlinClass: KotlinClassFinder.Result.KotlinClass,
symbol: FirRegularClassSymbol symbol: FirRegularClassSymbol
) { ) {
val annotations = mutableListOf<FirAnnotationCall>() val annotations = mutableListOf<FirAnnotation>()
kotlinClass.kotlinJvmBinaryClass.loadClassAnnotations( kotlinClass.kotlinJvmBinaryClass.loadClassAnnotations(
object : KotlinJvmBinaryClass.AnnotationVisitor { object : KotlinJvmBinaryClass.AnnotationVisitor {
override fun visitAnnotation(classId: ClassId, source: SourceElement): KotlinJvmBinaryClass.AnnotationArgumentVisitor? { override fun visitAnnotation(classId: ClassId, source: SourceElement): KotlinJvmBinaryClass.AnnotationArgumentVisitor? {
@@ -137,7 +137,7 @@ open class KotlinDeserializedJvmSymbolsProvider(
}, },
kotlinClass.byteContent, kotlinClass.byteContent,
) )
(symbol.fir.annotations as MutableList<FirAnnotationCall>) += annotations (symbol.fir.annotations as MutableList<FirAnnotation>) += annotations
symbol.fir.replaceDeprecation(symbol.fir.getDeprecationInfos(session.languageVersionSettings.apiVersion)) symbol.fir.replaceDeprecation(symbol.fir.getDeprecationInfos(session.languageVersionSettings.apiVersion))
} }
compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/FirAnnotationTypeQualifierResolver.kt
+5 -5
View File
@@ -25,18 +25,18 @@ class FirAnnotationTypeQualifierResolver(
private val session: FirSession, private val session: FirSession,
javaTypeEnhancementState: JavaTypeEnhancementState, javaTypeEnhancementState: JavaTypeEnhancementState,
private val javaModuleAnnotationsProvider: JavaModuleAnnotationsProvider, private val javaModuleAnnotationsProvider: JavaModuleAnnotationsProvider,
) : AbstractAnnotationTypeQualifierResolver<FirAnnotationCall>(javaTypeEnhancementState), FirSessionComponent { ) : AbstractAnnotationTypeQualifierResolver<FirAnnotation>(javaTypeEnhancementState), FirSessionComponent {
override val FirAnnotationCall.metaAnnotations: Iterable<FirAnnotationCall> override val FirAnnotation.metaAnnotations: Iterable<FirAnnotation>
get() = coneClassLikeType?.lookupTag?.toSymbol(session)?.fir?.annotations.orEmpty() get() = coneClassLikeType?.lookupTag?.toSymbol(session)?.fir?.annotations.orEmpty()
override val FirAnnotationCall.key: Any override val FirAnnotation.key: Any
get() = coneClassLikeType!!.lookupTag get() = coneClassLikeType!!.lookupTag
override val FirAnnotationCall.fqName: FqName? override val FirAnnotation.fqName: FqName?
get() = coneClassLikeType?.lookupTag?.classId?.asSingleFqName() get() = coneClassLikeType?.lookupTag?.classId?.asSingleFqName()
override fun FirAnnotationCall.enumArguments(onlyValue: Boolean): Iterable<String> = override fun FirAnnotation.enumArguments(onlyValue: Boolean): Iterable<String> =
arguments.flatMap { argument -> arguments.flatMap { argument ->
if (!onlyValue || argument !is FirNamedArgumentExpression || argument.name == DEFAULT_ANNOTATION_MEMBER_NAME) if (!onlyValue || argument !is FirNamedArgumentExpression || argument.name == DEFAULT_ANNOTATION_MEMBER_NAME)
argument.toEnumNames() argument.toEnumNames()
compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/SignatureEnhancement.kt
+5 -5
View File
@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.fir.declarations.utils.isInner
import org.jetbrains.kotlin.fir.declarations.utils.isStatic import org.jetbrains.kotlin.fir.declarations.utils.isStatic
import org.jetbrains.kotlin.fir.declarations.utils.modality import org.jetbrains.kotlin.fir.declarations.utils.modality
import org.jetbrains.kotlin.fir.declarations.utils.visibility import org.jetbrains.kotlin.fir.declarations.utils.visibility
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.java.FirJavaTypeConversionMode import org.jetbrains.kotlin.fir.java.FirJavaTypeConversionMode
import org.jetbrains.kotlin.fir.java.JavaTypeParameterStack import org.jetbrains.kotlin.fir.java.JavaTypeParameterStack
import org.jetbrains.kotlin.fir.java.declarations.* import org.jetbrains.kotlin.fir.java.declarations.*
@@ -504,14 +504,14 @@ private class EnhancementSignatureParts(
override val forceOnlyHeadTypeConstructor: Boolean, override val forceOnlyHeadTypeConstructor: Boolean,
override val containerApplicabilityType: AnnotationQualifierApplicabilityType, override val containerApplicabilityType: AnnotationQualifierApplicabilityType,
override val containerDefaultTypeQualifiers: JavaTypeQualifiersByElementType? override val containerDefaultTypeQualifiers: JavaTypeQualifiersByElementType?
) : AbstractSignatureParts<FirAnnotationCall>() { ) : AbstractSignatureParts<FirAnnotation>() {
override val enableImprovementsInStrictMode: Boolean override val enableImprovementsInStrictMode: Boolean
get() = true get() = true
override val skipRawTypeArguments: Boolean override val skipRawTypeArguments: Boolean
get() = false get() = false
override val containerAnnotations: Iterable<FirAnnotationCall> override val containerAnnotations: Iterable<FirAnnotation>
get() = typeContainer?.annotations ?: emptyList() get() = typeContainer?.annotations ?: emptyList()
override val containerIsVarargParameter: Boolean override val containerIsVarargParameter: Boolean
@@ -520,10 +520,10 @@ private class EnhancementSignatureParts(
override val typeSystem: TypeSystemContext override val typeSystem: TypeSystemContext
get() = session.typeContext get() = session.typeContext
override val FirAnnotationCall.forceWarning: Boolean override val FirAnnotation.forceWarning: Boolean
get() = false // TODO: force warnings on IDEA external annotations get() = false // TODO: force warnings on IDEA external annotations
override val KotlinTypeMarker.annotations: Iterable<FirAnnotationCall> override val KotlinTypeMarker.annotations: Iterable<FirAnnotation>
get() = (this as ConeKotlinType).attributes.customAnnotations get() = (this as ConeKotlinType).attributes.customAnnotations
override val KotlinTypeMarker.fqNameUnsafe: FqNameUnsafe? override val KotlinTypeMarker.fqNameUnsafe: FqNameUnsafe?
compiler/fir/java/src/org/jetbrains/kotlin/fir/types/jvm/FirJavaTypeRef.kt
+4 -4
View File
@@ -7,7 +7,7 @@ package org.jetbrains.kotlin.fir.types.jvm
import org.jetbrains.kotlin.fir.FirSourceElement import org.jetbrains.kotlin.fir.FirSourceElement
import org.jetbrains.kotlin.fir.builder.FirBuilderDsl import org.jetbrains.kotlin.fir.builder.FirBuilderDsl
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.types.FirQualifierPart import org.jetbrains.kotlin.fir.types.FirQualifierPart
import org.jetbrains.kotlin.fir.types.FirTypeProjection import org.jetbrains.kotlin.fir.types.FirTypeProjection
import org.jetbrains.kotlin.fir.types.FirUserTypeRef import org.jetbrains.kotlin.fir.types.FirUserTypeRef
@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.load.java.structure.JavaType
class FirJavaTypeRef( class FirJavaTypeRef(
val type: JavaType, val type: JavaType,
annotationBuilder: () -> List<FirAnnotationCall>, annotationBuilder: () -> List<FirAnnotation>,
override val qualifier: MutableList<FirQualifierPart> override val qualifier: MutableList<FirQualifierPart>
) : FirUserTypeRef() { ) : FirUserTypeRef() {
override val customRenderer: Boolean override val customRenderer: Boolean
@@ -33,7 +33,7 @@ class FirJavaTypeRef(
override val source: FirSourceElement? override val source: FirSourceElement?
get() = null get() = null
override val annotations: List<FirAnnotationCall> by lazy { annotationBuilder() } override val annotations: List<FirAnnotation> by lazy { annotationBuilder() }
override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) { override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
for (part in qualifier) { for (part in qualifier) {
@@ -60,7 +60,7 @@ class FirJavaTypeRef(
@FirBuilderDsl @FirBuilderDsl
class FirJavaTypeRefBuilder { class FirJavaTypeRefBuilder {
lateinit var annotationBuilder: () -> List<FirAnnotationCall> lateinit var annotationBuilder: () -> List<FirAnnotation>
lateinit var type: JavaType lateinit var type: JavaType
val qualifier: MutableList<FirQualifierPart> = mutableListOf() val qualifier: MutableList<FirQualifierPart> = mutableListOf()
compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/converter/DeclarationsConverter.kt
+8 -8
View File
@@ -85,7 +85,7 @@ class DeclarationsConverter(
throw Exception() throw Exception()
} }
val fileAnnotationList = mutableListOf<FirAnnotationCall>() val fileAnnotationList = mutableListOf<FirAnnotation>()
val importList = mutableListOf<FirImport>() val importList = mutableListOf<FirImport>()
val firDeclarationList = mutableListOf<FirDeclaration>() val firDeclarationList = mutableListOf<FirDeclaration>()
context.packageFqName = FqName.ROOT context.packageFqName = FqName.ROOT
@@ -287,7 +287,7 @@ class DeclarationsConverter(
/** /**
* [org.jetbrains.kotlin.parsing.KotlinParsing.parseFileAnnotationList] * [org.jetbrains.kotlin.parsing.KotlinParsing.parseFileAnnotationList]
*/ */
private fun convertFileAnnotationList(fileAnnotationList: LighterASTNode): List<FirAnnotationCall> { private fun convertFileAnnotationList(fileAnnotationList: LighterASTNode): List<FirAnnotation> {
return fileAnnotationList.forEachChildrenReturnList { node, container -> return fileAnnotationList.forEachChildrenReturnList { node, container ->
when (node.tokenType) { when (node.tokenType) {
ANNOTATION -> container += convertAnnotation(node) ANNOTATION -> container += convertAnnotation(node)
@@ -299,7 +299,7 @@ class DeclarationsConverter(
/** /**
* @see org.jetbrains.kotlin.parsing.KotlinParsing.parseAnnotationOrList * @see org.jetbrains.kotlin.parsing.KotlinParsing.parseAnnotationOrList
*/ */
fun convertAnnotation(annotationNode: LighterASTNode): List<FirAnnotationCall> { fun convertAnnotation(annotationNode: LighterASTNode): List<FirAnnotation> {
var annotationTarget: AnnotationUseSiteTarget? = null var annotationTarget: AnnotationUseSiteTarget? = null
return annotationNode.forEachChildrenReturnList { node, container -> return annotationNode.forEachChildrenReturnList { node, container ->
when (node.tokenType) { when (node.tokenType) {
@@ -338,7 +338,7 @@ class DeclarationsConverter(
fun convertAnnotationEntry( fun convertAnnotationEntry(
unescapedAnnotation: LighterASTNode, unescapedAnnotation: LighterASTNode,
defaultAnnotationUseSiteTarget: AnnotationUseSiteTarget? = null defaultAnnotationUseSiteTarget: AnnotationUseSiteTarget? = null
): FirAnnotationCall { ): FirAnnotation {
var annotationUseSiteTarget: AnnotationUseSiteTarget? = null var annotationUseSiteTarget: AnnotationUseSiteTarget? = null
lateinit var constructorCalleePair: Pair<FirTypeRef, List<FirExpression>> lateinit var constructorCalleePair: Pair<FirTypeRef, List<FirExpression>>
unescapedAnnotation.forEachChildren { unescapedAnnotation.forEachChildren {
@@ -348,7 +348,7 @@ class DeclarationsConverter(
} }
} }
val name = (constructorCalleePair.first as? FirUserTypeRef)?.qualifier?.last()?.name ?: Name.special("<no-annotation-name>") val name = (constructorCalleePair.first as? FirUserTypeRef)?.qualifier?.last()?.name ?: Name.special("<no-annotation-name>")
return buildAnnotationCall { return buildAnnotation {
source = unescapedAnnotation.toFirSourceElement() source = unescapedAnnotation.toFirSourceElement()
useSiteTarget = annotationUseSiteTarget ?: defaultAnnotationUseSiteTarget useSiteTarget = annotationUseSiteTarget ?: defaultAnnotationUseSiteTarget
annotationTypeRef = constructorCalleePair.first annotationTypeRef = constructorCalleePair.first
@@ -1775,7 +1775,7 @@ class DeclarationsConverter(
lateinit var identifier: String lateinit var identifier: String
lateinit var firType: FirTypeRef lateinit var firType: FirTypeRef
lateinit var referenceExpression: LighterASTNode lateinit var referenceExpression: LighterASTNode
val annotations = mutableListOf<FirAnnotationCall>() val annotations = mutableListOf<FirAnnotation>()
typeConstraint.forEachChildren { typeConstraint.forEachChildren {
when (it.tokenType) { when (it.tokenType) {
//annotations will be saved later, on mapping stage with type parameters //annotations will be saved later, on mapping stage with type parameters
@@ -1890,7 +1890,7 @@ class DeclarationsConverter(
} }
for (modifierList in allTypeModifiers) { for (modifierList in allTypeModifiers) {
(calculatedFirType.annotations as MutableList<FirAnnotationCall>) += modifierList.annotations (calculatedFirType.annotations as MutableList<FirAnnotation>) += modifierList.annotations
} }
return calculatedFirType return calculatedFirType
} }
@@ -2116,7 +2116,7 @@ class DeclarationsConverter(
return ValueParameter(isVal, isVar, modifiers, firValueParameter, destructuringDeclaration) return ValueParameter(isVal, isVar, modifiers, firValueParameter, destructuringDeclaration)
} }
private val extensionFunctionAnnotation = buildAnnotationCall { private val extensionFunctionAnnotation = buildAnnotation {
annotationTypeRef = buildResolvedTypeRef { annotationTypeRef = buildResolvedTypeRef {
type = ConeClassLikeTypeImpl( type = ConeClassLikeTypeImpl(
ConeClassLikeLookupTagImpl(EXTENSION_FUNCTION_ANNOTATION), ConeClassLikeLookupTagImpl(EXTENSION_FUNCTION_ANNOTATION),
compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/converter/ExpressionsConverter.kt
+2 -2
View File
@@ -421,7 +421,7 @@ class ExpressionsConverter(
*/ */
private fun convertAnnotatedExpression(annotatedExpression: LighterASTNode): FirElement { private fun convertAnnotatedExpression(annotatedExpression: LighterASTNode): FirElement {
var firExpression: FirElement? = null var firExpression: FirElement? = null
val firAnnotationList = mutableListOf<FirAnnotationCall>() val firAnnotationList = mutableListOf<FirAnnotation>()
annotatedExpression.forEachChildren { annotatedExpression.forEachChildren {
when (it.tokenType) { when (it.tokenType) {
ANNOTATION -> firAnnotationList += declarationsConverter.convertAnnotation(it) ANNOTATION -> firAnnotationList += declarationsConverter.convertAnnotation(it)
@@ -432,7 +432,7 @@ class ExpressionsConverter(
val result = firExpression ?: buildErrorExpression(null, ConeNotAnnotationContainer(firExpression?.render() ?: "???")) val result = firExpression ?: buildErrorExpression(null, ConeNotAnnotationContainer(firExpression?.render() ?: "???"))
require(result is FirAnnotationContainer) require(result is FirAnnotationContainer)
(result.annotations as MutableList<FirAnnotationCall>) += firAnnotationList (result.annotations as MutableList<FirAnnotation>) += firAnnotationList
return result return result
} }
compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/fir/TypeConstraint.kt
+2 -2
View File
@@ -6,11 +6,11 @@
package org.jetbrains.kotlin.fir.lightTree.fir package org.jetbrains.kotlin.fir.lightTree.fir
import org.jetbrains.kotlin.fir.FirSourceElement import org.jetbrains.kotlin.fir.FirSourceElement
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.fir.types.FirTypeRef
class TypeConstraint( class TypeConstraint(
val annotations: List<FirAnnotationCall>, val annotations: List<FirAnnotation>,
val identifier: String, val identifier: String,
val firTypeRef: FirTypeRef, val firTypeRef: FirTypeRef,
val source: FirSourceElement val source: FirSourceElement
compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/fir/modifier/Modifier.kt
+2 -2
View File
@@ -9,12 +9,12 @@ import com.intellij.lang.LighterASTNode
import org.jetbrains.kotlin.descriptors.Modality import org.jetbrains.kotlin.descriptors.Modality
import org.jetbrains.kotlin.descriptors.Visibilities import org.jetbrains.kotlin.descriptors.Visibilities
import org.jetbrains.kotlin.descriptors.Visibility import org.jetbrains.kotlin.descriptors.Visibility
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.lexer.KtTokens import org.jetbrains.kotlin.lexer.KtTokens
import org.jetbrains.kotlin.types.Variance import org.jetbrains.kotlin.types.Variance
open class Modifier(var modifiers: Long = ModifierFlag.NONE.value) { open class Modifier(var modifiers: Long = ModifierFlag.NONE.value) {
val annotations: MutableList<FirAnnotationCall> = mutableListOf() val annotations: MutableList<FirAnnotation> = mutableListOf()
fun addModifier(modifier: LighterASTNode, isInClass: Boolean = false) { fun addModifier(modifier: LighterASTNode, isInClass: Boolean = false) {
when (val tokenType = modifier.tokenType) { when (val tokenType = modifier.tokenType) {
compiler/fir/raw-fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/RawFirBuilder.kt
+7 -7
View File
@@ -594,9 +594,9 @@ open class RawFirBuilder(
annotated.extractAnnotationsTo(this.annotations) annotated.extractAnnotationsTo(this.annotations)
} }
private fun KtAnnotated.extractAnnotationsTo(container: MutableList<FirAnnotationCall>) { private fun KtAnnotated.extractAnnotationsTo(container: MutableList<FirAnnotation>) {
for (annotationEntry in annotationEntries) { for (annotationEntry in annotationEntries) {
container += annotationEntry.convert<FirAnnotationCall>() container += annotationEntry.convert<FirAnnotation>()
} }
} }
@@ -864,7 +864,7 @@ open class RawFirBuilder(
source = file.packageDirective?.toFirPsiSourceElement() source = file.packageDirective?.toFirPsiSourceElement()
} }
for (annotationEntry in file.annotationEntries) { for (annotationEntry in file.annotationEntries) {
annotations += annotationEntry.convert<FirAnnotationCall>() annotations += annotationEntry.convert<FirAnnotation>()
} }
for (importDirective in file.importDirectives) { for (importDirective in file.importDirectives) {
imports += buildImport { imports += buildImport {
@@ -1682,14 +1682,14 @@ open class RawFirBuilder(
for (modifierList in allModifierLists) { for (modifierList in allModifierLists) {
for (annotationEntry in modifierList.annotationEntries) { for (annotationEntry in modifierList.annotationEntries) {
firTypeBuilder.annotations += annotationEntry.convert<FirAnnotationCall>() firTypeBuilder.annotations += annotationEntry.convert<FirAnnotation>()
} }
} }
return firTypeBuilder.build() return firTypeBuilder.build()
} }
override fun visitAnnotationEntry(annotationEntry: KtAnnotationEntry, data: Unit): FirElement { override fun visitAnnotationEntry(annotationEntry: KtAnnotationEntry, data: Unit): FirElement {
return buildAnnotationCall { return buildAnnotation {
source = annotationEntry.toFirSourceElement() source = annotationEntry.toFirSourceElement()
useSiteTarget = annotationEntry.useSiteTarget?.getAnnotationUseSiteTarget() useSiteTarget = annotationEntry.useSiteTarget?.getAnnotationUseSiteTarget()
annotationTypeRef = annotationEntry.typeReference.toFirOrErrorType() annotationTypeRef = annotationEntry.typeReference.toFirOrErrorType()
@@ -2354,7 +2354,7 @@ open class RawFirBuilder(
expression.toFirSourceElement(), expression.toFirSourceElement(),
ConeNotAnnotationContainer(rawResult?.render() ?: "???") ConeNotAnnotationContainer(rawResult?.render() ?: "???")
) )
expression.extractAnnotationsTo(result.annotations as MutableList<FirAnnotationCall>) expression.extractAnnotationsTo(result.annotations as MutableList<FirAnnotation>)
return result return result
} }
@@ -2418,7 +2418,7 @@ open class RawFirBuilder(
} }
} }
private val extensionFunctionAnnotation = buildAnnotationCall { private val extensionFunctionAnnotation = buildAnnotation {
annotationTypeRef = buildResolvedTypeRef { annotationTypeRef = buildResolvedTypeRef {
type = ConeClassLikeTypeImpl( type = ConeClassLikeTypeImpl(
ConeClassLikeLookupTagImpl(EXTENSION_FUNCTION_ANNOTATION), ConeClassLikeLookupTagImpl(EXTENSION_FUNCTION_ANNOTATION),
compiler/fir/raw-fir/psi2fir/tests/org/jetbrains/kotlin/fir/builder/AbstractRawFirBuilderTestCase.kt
+3 -3
View File
@@ -20,7 +20,7 @@ import org.jetbrains.kotlin.fir.declarations.FirFile
import org.jetbrains.kotlin.fir.declarations.FirTypeParameter import org.jetbrains.kotlin.fir.declarations.FirTypeParameter
import org.jetbrains.kotlin.fir.declarations.FirValueParameter import org.jetbrains.kotlin.fir.declarations.FirValueParameter
import org.jetbrains.kotlin.fir.declarations.impl.FirResolvedDeclarationStatusImpl import org.jetbrains.kotlin.fir.declarations.impl.FirResolvedDeclarationStatusImpl
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.expressions.FirEmptyArgumentList import org.jetbrains.kotlin.fir.expressions.FirEmptyArgumentList
import org.jetbrains.kotlin.fir.expressions.impl.FirNoReceiverExpression import org.jetbrains.kotlin.fir.expressions.impl.FirNoReceiverExpression
import org.jetbrains.kotlin.fir.expressions.impl.FirStubStatement import org.jetbrains.kotlin.fir.expressions.impl.FirStubStatement
@@ -183,7 +183,7 @@ abstract class AbstractRawFirBuilderTestCase : KtParsingTestCase(
private fun throwTwiceVisitingError(element: FirElement) { private fun throwTwiceVisitingError(element: FirElement) {
if (element is FirTypeRef || element is FirNoReceiverExpression || element is FirTypeParameter || if (element is FirTypeRef || element is FirNoReceiverExpression || element is FirTypeParameter ||
element is FirTypeProjection || element is FirValueParameter || element is FirAnnotationCall || element is FirTypeProjection || element is FirValueParameter || element is FirAnnotation ||
element is FirEmptyContractDescription || element is FirEmptyContractDescription ||
element is FirStubReference || element.isExtensionFunctionAnnotation || element is FirEmptyArgumentList || element is FirStubReference || element.isExtensionFunctionAnnotation || element is FirEmptyArgumentList ||
element is FirStubStatement || element === FirResolvedDeclarationStatusImpl.DEFAULT_STATUS_FOR_STATUSLESS_DECLARATIONS element is FirStubStatement || element === FirResolvedDeclarationStatusImpl.DEFAULT_STATUS_FOR_STATUSLESS_DECLARATIONS
@@ -196,4 +196,4 @@ private fun throwTwiceVisitingError(element: FirElement) {
private val FirElement.isExtensionFunctionAnnotation: Boolean private val FirElement.isExtensionFunctionAnnotation: Boolean
get() = (this as? FirAnnotationCall)?.isExtensionFunctionAnnotationCall == true get() = (this as? FirAnnotation)?.isExtensionFunctionAnnotationCall == true
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/CopyUtils.kt
+6 -6
View File
@@ -26,7 +26,7 @@ import org.jetbrains.kotlin.fir.types.builder.buildErrorTypeRef
import org.jetbrains.kotlin.fir.types.builder.buildResolvedTypeRef import org.jetbrains.kotlin.fir.types.builder.buildResolvedTypeRef
fun FirFunctionCall.copy( fun FirFunctionCall.copy(
annotations: List<FirAnnotationCall> = this.annotations, annotations: List<FirAnnotation> = this.annotations,
argumentList: FirArgumentList = this.argumentList, argumentList: FirArgumentList = this.argumentList,
calleeReference: FirNamedReference = this.calleeReference, calleeReference: FirNamedReference = this.calleeReference,
explicitReceiver: FirExpression? = this.explicitReceiver, explicitReceiver: FirExpression? = this.explicitReceiver,
@@ -85,7 +85,7 @@ fun FirAnonymousFunction.copy(
returnTypeRef: FirTypeRef = this.returnTypeRef, returnTypeRef: FirTypeRef = this.returnTypeRef,
valueParameters: List<FirValueParameter> = this.valueParameters, valueParameters: List<FirValueParameter> = this.valueParameters,
body: FirBlock? = this.body, body: FirBlock? = this.body,
annotations: List<FirAnnotationCall> = this.annotations, annotations: List<FirAnnotation> = this.annotations,
typeRef: FirTypeRef = this.typeRef, typeRef: FirTypeRef = this.typeRef,
label: FirLabel? = this.label, label: FirLabel? = this.label,
controlFlowGraphReference: FirControlFlowGraphReference? = this.controlFlowGraphReference, controlFlowGraphReference: FirControlFlowGraphReference? = this.controlFlowGraphReference,
@@ -137,7 +137,7 @@ fun FirTypeRef.errorTypeFromPrototype(
fun FirTypeParameter.copy( fun FirTypeParameter.copy(
bounds: List<FirTypeRef> = this.bounds, bounds: List<FirTypeRef> = this.bounds,
annotations: List<FirAnnotationCall> = this.annotations annotations: List<FirAnnotation> = this.annotations
): FirTypeParameter { ): FirTypeParameter {
return buildTypeParameter { return buildTypeParameter {
source = this@copy.source source = this@copy.source
@@ -155,7 +155,7 @@ fun FirTypeParameter.copy(
fun FirWhenExpression.copy( fun FirWhenExpression.copy(
resultType: FirTypeRef = this.typeRef, resultType: FirTypeRef = this.typeRef,
calleeReference: FirReference = this.calleeReference, calleeReference: FirReference = this.calleeReference,
annotations: List<FirAnnotationCall> = this.annotations annotations: List<FirAnnotation> = this.annotations
): FirWhenExpression = buildWhenExpression { ): FirWhenExpression = buildWhenExpression {
source = this@copy.source source = this@copy.source
subject = this@copy.subject subject = this@copy.subject
@@ -171,7 +171,7 @@ fun FirWhenExpression.copy(
fun FirTryExpression.copy( fun FirTryExpression.copy(
resultType: FirTypeRef = this.typeRef, resultType: FirTypeRef = this.typeRef,
calleeReference: FirReference = this.calleeReference, calleeReference: FirReference = this.calleeReference,
annotations: List<FirAnnotationCall> = this.annotations annotations: List<FirAnnotation> = this.annotations
): FirTryExpression = buildTryExpression { ): FirTryExpression = buildTryExpression {
source = this@copy.source source = this@copy.source
tryBlock = this@copy.tryBlock tryBlock = this@copy.tryBlock
@@ -185,7 +185,7 @@ fun FirTryExpression.copy(
fun FirCheckNotNullCall.copy( fun FirCheckNotNullCall.copy(
resultType: FirTypeRef = this.typeRef, resultType: FirTypeRef = this.typeRef,
calleeReference: FirReference = this.calleeReference, calleeReference: FirReference = this.calleeReference,
annotations: List<FirAnnotationCall> = this.annotations annotations: List<FirAnnotation> = this.annotations
): FirCheckNotNullCall = buildCheckNotNullCall { ): FirCheckNotNullCall = buildCheckNotNullCall {
source = this@copy.source source = this@copy.source
this.calleeReference = calleeReference this.calleeReference = calleeReference
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirCallResolver.kt
+7 -7
View File
@@ -489,16 +489,16 @@ class FirCallResolver(
} }
} }
fun resolveAnnotationCall(annotationCall: FirAnnotationCall): FirAnnotationCall? { fun resolveAnnotationCall(annotation: FirAnnotation): FirAnnotation? {
val reference = annotationCall.calleeReference as? FirSimpleNamedReference ?: return null val reference = annotation.calleeReference as? FirSimpleNamedReference ?: return null
annotationCall.argumentList.transformArguments(transformer, ResolutionMode.ContextDependent) annotation.argumentList.transformArguments(transformer, ResolutionMode.ContextDependent)
val callInfo = CallInfo( val callInfo = CallInfo(
annotationCall, annotation,
CallKind.Function, CallKind.Function,
name = reference.name, name = reference.name,
explicitReceiver = null, explicitReceiver = null,
annotationCall.argumentList, annotation.argumentList,
isPotentialQualifierPart = false, isPotentialQualifierPart = false,
isImplicitInvoke = false, isImplicitInvoke = false,
typeArguments = emptyList(), typeArguments = emptyList(),
@@ -507,7 +507,7 @@ class FirCallResolver(
components.containingDeclarations components.containingDeclarations
) )
val annotationClassSymbol = annotationCall.getCorrespondingClassSymbolOrNull(session) val annotationClassSymbol = annotation.getCorrespondingClassSymbolOrNull(session)
val resolvedReference = if (annotationClassSymbol != null && annotationClassSymbol.fir.classKind == ClassKind.ANNOTATION_CLASS) { val resolvedReference = if (annotationClassSymbol != null && annotationClassSymbol.fir.classKind == ClassKind.ANNOTATION_CLASS) {
val resolutionResult = createCandidateForAnnotationCall(annotationClassSymbol, callInfo) val resolutionResult = createCandidateForAnnotationCall(annotationClassSymbol, callInfo)
?: ResolutionResult(callInfo, CandidateApplicability.HIDDEN, emptyList()) ?: ResolutionResult(callInfo, CandidateApplicability.HIDDEN, emptyList())
@@ -529,7 +529,7 @@ class FirCallResolver(
) )
} }
return annotationCall.transformCalleeReference(StoreNameReference, resolvedReference) return annotation.transformCalleeReference(StoreNameReference, resolvedReference)
} }
private fun createCandidateForAnnotationCall( private fun createCandidateForAnnotationCall(
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/declarations/FirAnnotationUtils.kt
+15 -15
View File
@@ -26,14 +26,14 @@ private val RETENTION_CLASS_ID = ClassId.fromString("kotlin/annotation/Retention
private val TARGET_CLASS_ID = ClassId.fromString("kotlin/annotation/Target") private val TARGET_CLASS_ID = ClassId.fromString("kotlin/annotation/Target")
private val JVM_FIELD_CLASS_ID = ClassId.fromString("kotlin/jvm/JvmField") private val JVM_FIELD_CLASS_ID = ClassId.fromString("kotlin/jvm/JvmField")
private fun FirAnnotationCall.toAnnotationLookupTag(): ConeClassLikeLookupTag? = private fun FirAnnotation.toAnnotationLookupTag(): ConeClassLikeLookupTag? =
// this cast fails when we have generic-typed annotations @T // this cast fails when we have generic-typed annotations @T
(annotationTypeRef.coneType as? ConeClassLikeType)?.lookupTag (annotationTypeRef.coneType as? ConeClassLikeType)?.lookupTag
fun FirAnnotationCall.toAnnotationClassId(): ClassId? = fun FirAnnotation.toAnnotationClassId(): ClassId? =
toAnnotationLookupTag()?.classId toAnnotationLookupTag()?.classId
private fun FirAnnotationCall.toAnnotationClass(session: FirSession): FirRegularClass? = private fun FirAnnotation.toAnnotationClass(session: FirSession): FirRegularClass? =
toAnnotationLookupTag()?.toSymbol(session)?.fir as? FirRegularClass toAnnotationLookupTag()?.toSymbol(session)?.fir as? FirRegularClass
// TODO: this is temporary solution, we need something better // TODO: this is temporary solution, we need something better
@@ -44,7 +44,7 @@ private val FirExpression.callableNameOfMetaAnnotationArgument: Name?
callableSymbol?.callableId?.callableName callableSymbol?.callableId?.callableName
} }
fun FirAnnotationContainer.nonSourceAnnotations(session: FirSession): List<FirAnnotationCall> = fun FirAnnotationContainer.nonSourceAnnotations(session: FirSession): List<FirAnnotation> =
annotations.filter { annotation -> annotations.filter { annotation ->
val firAnnotationClass = annotation.toAnnotationClass(session) val firAnnotationClass = annotation.toAnnotationClass(session)
firAnnotationClass != null && firAnnotationClass.annotations.none { meta -> firAnnotationClass != null && firAnnotationClass.annotations.none { meta ->
@@ -56,10 +56,10 @@ fun FirAnnotationContainer.nonSourceAnnotations(session: FirSession): List<FirAn
inline val FirProperty.hasJvmFieldAnnotation: Boolean inline val FirProperty.hasJvmFieldAnnotation: Boolean
get() = annotations.any { it.isJvmFieldAnnotation } get() = annotations.any { it.isJvmFieldAnnotation }
val FirAnnotationCall.isJvmFieldAnnotation: Boolean val FirAnnotation.isJvmFieldAnnotation: Boolean
get() = toAnnotationClassId() == JVM_FIELD_CLASS_ID get() = toAnnotationClassId() == JVM_FIELD_CLASS_ID
fun FirAnnotationCall.useSiteTargetsFromMetaAnnotation(session: FirSession): Set<AnnotationUseSiteTarget> = fun FirAnnotation.useSiteTargetsFromMetaAnnotation(session: FirSession): Set<AnnotationUseSiteTarget> =
toAnnotationClass(session)?.annotations?.find { it.toAnnotationClassId() == TARGET_CLASS_ID }?.argumentList?.arguments toAnnotationClass(session)?.annotations?.find { it.toAnnotationClassId() == TARGET_CLASS_ID }?.argumentList?.arguments
?.toAnnotationUseSiteTargets() ?: DEFAULT_USE_SITE_TARGETS ?.toAnnotationUseSiteTargets() ?: DEFAULT_USE_SITE_TARGETS
@@ -94,35 +94,35 @@ fun FirAnnotatedDeclaration.hasAnnotation(classId: ClassId): Boolean {
return annotations.any { it.toAnnotationClassId() == classId } return annotations.any { it.toAnnotationClassId() == classId }
} }
fun <D> FirBasedSymbol<out D>.getAnnotationByFqName(fqName: FqName): FirAnnotationCall? where D : FirAnnotationContainer, D : FirDeclaration { fun <D> FirBasedSymbol<out D>.getAnnotationByFqName(fqName: FqName): FirAnnotation? where D : FirAnnotationContainer, D : FirDeclaration {
return fir.getAnnotationByFqName(fqName) return fir.getAnnotationByFqName(fqName)
} }
fun <D> FirBasedSymbol<out D>.getAnnotationByClassId(classId: ClassId): FirAnnotationCall? where D : FirAnnotationContainer, D : FirDeclaration { fun <D> FirBasedSymbol<out D>.getAnnotationByClassId(classId: ClassId): FirAnnotation? where D : FirAnnotationContainer, D : FirDeclaration {
return fir.getAnnotationByClassId(classId) return fir.getAnnotationByClassId(classId)
} }
fun FirAnnotationContainer.getAnnotationByFqName(fqName: FqName): FirAnnotationCall? { fun FirAnnotationContainer.getAnnotationByFqName(fqName: FqName): FirAnnotation? {
return annotations.find { return annotations.find {
it.annotationTypeRef.coneTypeSafe<ConeClassLikeType>()?.lookupTag?.classId?.asSingleFqName() == fqName it.annotationTypeRef.coneTypeSafe<ConeClassLikeType>()?.lookupTag?.classId?.asSingleFqName() == fqName
} }
} }
fun FirAnnotationContainer.getAnnotationByClassId(classId: ClassId): FirAnnotationCall? { fun FirAnnotationContainer.getAnnotationByClassId(classId: ClassId): FirAnnotation? {
return annotations.find { return annotations.find {
it.annotationTypeRef.coneTypeSafe<ConeClassLikeType>()?.lookupTag?.classId == classId it.annotationTypeRef.coneTypeSafe<ConeClassLikeType>()?.lookupTag?.classId == classId
} }
} }
fun FirAnnotationContainer.getAnnotationsByFqName(fqName: FqName): List<FirAnnotationCall> = annotations.getAnnotationsByFqName(fqName) fun FirAnnotationContainer.getAnnotationsByFqName(fqName: FqName): List<FirAnnotation> = annotations.getAnnotationsByFqName(fqName)
fun List<FirAnnotationCall>.getAnnotationsByFqName(fqName: FqName): List<FirAnnotationCall> { fun List<FirAnnotation>.getAnnotationsByFqName(fqName: FqName): List<FirAnnotation> {
return filter { return filter {
it.annotationTypeRef.coneTypeSafe<ConeClassLikeType>()?.lookupTag?.classId?.asSingleFqName() == fqName it.annotationTypeRef.coneTypeSafe<ConeClassLikeType>()?.lookupTag?.classId?.asSingleFqName() == fqName
} }
} }
fun FirAnnotationCall.findArgumentByName(name: Name): FirExpression? { fun FirAnnotation.findArgumentByName(name: Name): FirExpression? {
val argumentMapping = argumentMapping val argumentMapping = argumentMapping
if (argumentMapping != null) { if (argumentMapping != null) {
return argumentMapping.keys.find { argumentMapping[it]?.name == name }?.unwrapArgument() return argumentMapping.keys.find { argumentMapping[it]?.name == name }?.unwrapArgument()
@@ -138,7 +138,7 @@ fun FirAnnotationCall.findArgumentByName(name: Name): FirExpression? {
return arguments.singleOrNull() return arguments.singleOrNull()
} }
fun FirAnnotationCall.getStringArgument(name: Name): String? = fun FirAnnotation.getStringArgument(name: Name): String? =
findArgumentByName(name)?.let { expression -> findArgumentByName(name)?.let { expression ->
expression.safeAs<FirConstExpression<*>>()?.value as? String expression.safeAs<FirConstExpression<*>>()?.value as? String
} }
@@ -151,4 +151,4 @@ fun FirAnnotationContainer.getJvmNameFromAnnotation(target: AnnotationUseSiteTar
return annotationCalls.firstNotNullOfOrNull { call -> return annotationCalls.firstNotNullOfOrNull { call ->
call.getStringArgument(name)?.takeIf { target == null || call.useSiteTarget == target } call.getStringArgument(name)?.takeIf { target == null || call.useSiteTarget == target }
} }
} }
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/declarations/GeneratedDeclarationValidation.kt
+4 -4
View File
@@ -6,7 +6,7 @@
package org.jetbrains.kotlin.fir.declarations package org.jetbrains.kotlin.fir.declarations
import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.FirElement
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.expressions.FirAnnotationResolveStatus import org.jetbrains.kotlin.fir.expressions.FirAnnotationResolveStatus
import org.jetbrains.kotlin.fir.expressions.FirArgumentList import org.jetbrains.kotlin.fir.expressions.FirArgumentList
import org.jetbrains.kotlin.fir.expressions.impl.FirResolvedArgumentList import org.jetbrains.kotlin.fir.expressions.impl.FirResolvedArgumentList
@@ -30,9 +30,9 @@ object FirGeneratedElementsValidator : FirDefaultVisitor<Unit, Any?>() {
element.acceptChildren(this, null) element.acceptChildren(this, null)
} }
override fun visitAnnotationCall(annotationCall: FirAnnotationCall, data: Any?) { override fun visitAnnotation(annotation: FirAnnotation, data: Any?) {
require(annotationCall.resolveStatus == FirAnnotationResolveStatus.Resolved) require(annotation.resolveStatus == FirAnnotationResolveStatus.Resolved)
annotationCall.acceptChildren(this, null) annotation.acceptChildren(this, null)
} }
override fun visitRegularClass(regularClass: FirRegularClass, data: Any?) { override fun visitRegularClass(regularClass: FirRegularClass, data: Any?) {
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/declarations/deprecationUtils.kt
+4 -4
View File
@@ -77,7 +77,7 @@ fun getDeprecationsFromAccessors(
return if (perUseSite.isEmpty()) EmptyDeprecationsPerUseSite else DeprecationsPerUseSite(null, perUseSite) return if (perUseSite.isEmpty()) EmptyDeprecationsPerUseSite else DeprecationsPerUseSite(null, perUseSite)
} }
fun List<FirAnnotationCall>.getDeprecationInfosFromAnnotations(currentVersion: ApiVersion, fromJava: Boolean): DeprecationsPerUseSite { fun List<FirAnnotation>.getDeprecationInfosFromAnnotations(currentVersion: ApiVersion, fromJava: Boolean): DeprecationsPerUseSite {
val deprecationByUseSite = extractDeprecationInfoPerUseSite(currentVersion, fromJava).toMap() val deprecationByUseSite = extractDeprecationInfoPerUseSite(currentVersion, fromJava).toMap()
return DeprecationsPerUseSite.fromMap(deprecationByUseSite) return DeprecationsPerUseSite.fromMap(deprecationByUseSite)
} }
@@ -93,10 +93,10 @@ fun FirBasedSymbol<*>.getDeprecationForCallSite(
return (deprecations ?: EmptyDeprecationsPerUseSite).forUseSite(*sites) return (deprecations ?: EmptyDeprecationsPerUseSite).forUseSite(*sites)
} }
private fun FirAnnotationCall.getVersionFromArgument(name: Name): ApiVersion? = private fun FirAnnotation.getVersionFromArgument(name: Name): ApiVersion? =
getStringArgument(name)?.let { ApiVersion.parse(it) } getStringArgument(name)?.let { ApiVersion.parse(it) }
private fun FirAnnotationCall.getDeprecationLevel(): DeprecationLevelValue? { private fun FirAnnotation.getDeprecationLevel(): DeprecationLevelValue? {
//take last because Annotation might be not resolved yet and arguments passed without explicit names //take last because Annotation might be not resolved yet and arguments passed without explicit names
val arg = findArgumentByName(LEVEL_NAME) ?: arguments.lastOrNull() val arg = findArgumentByName(LEVEL_NAME) ?: arguments.lastOrNull()
return arg?.let { argument -> return arg?.let { argument ->
@@ -106,7 +106,7 @@ private fun FirAnnotationCall.getDeprecationLevel(): DeprecationLevelValue? {
} }
} }
private fun List<FirAnnotationCall>.extractDeprecationInfoPerUseSite( private fun List<FirAnnotation>.extractDeprecationInfoPerUseSite(
currentVersion: ApiVersion, currentVersion: ApiVersion,
fromJava: Boolean fromJava: Boolean
): List<Pair<AnnotationUseSiteTarget?, DeprecationInfo>> { ): List<Pair<AnnotationUseSiteTarget?, DeprecationInfo>> {
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ResolveUtils.kt
+2 -2
View File
@@ -366,7 +366,7 @@ fun CallableId.isIteratorHasNext(): Boolean =
fun CallableId.isIterator(): Boolean = fun CallableId.isIterator(): Boolean =
callableName.asString() == "iterator" && packageName.asString() in arrayOf("kotlin.collections", "kotlin.ranges") callableName.asString() == "iterator" && packageName.asString() in arrayOf("kotlin.collections", "kotlin.ranges")
fun FirAnnotationCall.fqName(session: FirSession): FqName? { fun FirAnnotation.fqName(session: FirSession): FqName? {
val symbol = session.symbolProvider.getSymbolByTypeRef<FirRegularClassSymbol>(annotationTypeRef) ?: return null val symbol = session.symbolProvider.getSymbolByTypeRef<FirRegularClassSymbol>(annotationTypeRef) ?: return null
return symbol.classId.asSingleFqName() return symbol.classId.asSingleFqName()
} }
@@ -419,7 +419,7 @@ private fun FirQualifiedAccess.expressionTypeOrUnitForAssignment(): ConeKotlinTy
return StandardClassIds.Unit.constructClassLikeType(emptyArray(), isNullable = false) return StandardClassIds.Unit.constructClassLikeType(emptyArray(), isNullable = false)
} }
fun FirAnnotationCall.getCorrespondingClassSymbolOrNull(session: FirSession): FirRegularClassSymbol? { fun FirAnnotation.getCorrespondingClassSymbolOrNull(session: FirSession): FirRegularClassSymbol? {
return annotationTypeRef.coneType.fullyExpandedType(session).classId?.let { return annotationTypeRef.coneType.fullyExpandedType(session).classId?.let {
if (it.isLocal) { if (it.isLocal) {
// TODO: How to retrieve local annotaiton's constructor? // TODO: How to retrieve local annotaiton's constructor?
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/CallableReferenceResolution.kt
+2 -2
View File
@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.fir.resolve.calls
import org.jetbrains.kotlin.fir.* import org.jetbrains.kotlin.fir.*
import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.*
import org.jetbrains.kotlin.fir.declarations.utils.isSuspend import org.jetbrains.kotlin.fir.declarations.utils.isSuspend
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.expressions.FirExpression import org.jetbrains.kotlin.fir.expressions.FirExpression
import org.jetbrains.kotlin.fir.expressions.FirNamedArgumentExpression import org.jetbrains.kotlin.fir.expressions.FirNamedArgumentExpression
import org.jetbrains.kotlin.fir.expressions.FirResolvedQualifier import org.jetbrains.kotlin.fir.expressions.FirResolvedQualifier
@@ -365,7 +365,7 @@ class FirFakeArgumentForCallableReference(
override val typeRef: FirTypeRef override val typeRef: FirTypeRef
get() = error("should not be called") get() = error("should not be called")
override val annotations: List<FirAnnotationCall> override val annotations: List<FirAnnotation>
get() = error("should not be called") get() = error("should not be called")
override fun replaceTypeRef(newTypeRef: FirTypeRef) { override fun replaceTypeRef(newTypeRef: FirTypeRef) {
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/FirDataFlowAnalyzer.kt
+4 -4
View File
@@ -1267,12 +1267,12 @@ abstract class FirDataFlowAnalyzer<FLOW : Flow>(
// ----------------------------------- Annotations ----------------------------------- // ----------------------------------- Annotations -----------------------------------
fun enterAnnotationCall(annotationCall: FirAnnotationCall) { fun enterAnnotationCall(annotation: FirAnnotation) {
graphBuilder.enterAnnotationCall(annotationCall).mergeIncomingFlow() graphBuilder.enterAnnotationCall(annotation).mergeIncomingFlow()
} }
fun exitAnnotationCall(annotationCall: FirAnnotationCall) { fun exitAnnotationCall(annotation: FirAnnotation) {
graphBuilder.exitAnnotationCall(annotationCall).mergeIncomingFlow() graphBuilder.exitAnnotationCall(annotation).mergeIncomingFlow()
} }
// ----------------------------------- Init block ----------------------------------- // ----------------------------------- Init block -----------------------------------
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/cfg/CFGNode.kt
+2 -2
View File
@@ -734,7 +734,7 @@ class ElvisExitNode(owner: ControlFlowGraph, override val fir: FirElvisExpressio
// ----------------------------------- Other ----------------------------------- // ----------------------------------- Other -----------------------------------
class AnnotationEnterNode(owner: ControlFlowGraph, override val fir: FirAnnotationCall, level: Int, id: Int) : CFGNode<FirAnnotationCall>(owner, level, id), EnterNodeMarker { class AnnotationEnterNode(owner: ControlFlowGraph, override val fir: FirAnnotation, level: Int, id: Int) : CFGNode<FirAnnotation>(owner, level, id), EnterNodeMarker {
init { init {
owner.enterNode = this owner.enterNode = this
} }
@@ -743,7 +743,7 @@ class AnnotationEnterNode(owner: ControlFlowGraph, override val fir: FirAnnotati
return visitor.visitAnnotationEnterNode(this, data) return visitor.visitAnnotationEnterNode(this, data)
} }
} }
class AnnotationExitNode(owner: ControlFlowGraph, override val fir: FirAnnotationCall, level: Int, id: Int) : CFGNode<FirAnnotationCall>(owner, level, id), ExitNodeMarker { class AnnotationExitNode(owner: ControlFlowGraph, override val fir: FirAnnotation, level: Int, id: Int) : CFGNode<FirAnnotation>(owner, level, id), ExitNodeMarker {
init { init {
owner.exitNode = this owner.exitNode = this
} }
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/cfg/ControlFlowGraphBuilder.kt
+4 -4
View File
@@ -1177,16 +1177,16 @@ class ControlFlowGraphBuilder {
// ----------------------------------- Annotations ----------------------------------- // ----------------------------------- Annotations -----------------------------------
fun enterAnnotationCall(annotationCall: FirAnnotationCall): AnnotationEnterNode { fun enterAnnotationCall(annotation: FirAnnotation): AnnotationEnterNode {
val graph = ControlFlowGraph(null, "STUB_GRAPH_FOR_ANNOTATION_CALL", ControlFlowGraph.Kind.AnnotationCall) val graph = ControlFlowGraph(null, "STUB_GRAPH_FOR_ANNOTATION_CALL", ControlFlowGraph.Kind.AnnotationCall)
pushGraph(graph, Mode.Body) pushGraph(graph, Mode.Body)
return createAnnotationEnterNode(annotationCall).also { return createAnnotationEnterNode(annotation).also {
lastNodes.push(it) lastNodes.push(it)
} }
} }
fun exitAnnotationCall(annotationCall: FirAnnotationCall): AnnotationExitNode { fun exitAnnotationCall(annotation: FirAnnotation): AnnotationExitNode {
val node = createAnnotationExitNode(annotationCall) val node = createAnnotationExitNode(annotation)
popAndAddEdge(node) popAndAddEdge(node)
popGraph() popGraph()
return node return node
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/cfg/ControlFlowGraphNodeBuilder.kt
+2 -2
View File
@@ -140,10 +140,10 @@ fun ControlFlowGraphBuilder.createStringConcatenationCallNode(fir: FirStringConc
fun ControlFlowGraphBuilder.createVariableAssignmentNode(fir: FirVariableAssignment): VariableAssignmentNode = fun ControlFlowGraphBuilder.createVariableAssignmentNode(fir: FirVariableAssignment): VariableAssignmentNode =
VariableAssignmentNode(currentGraph, fir, levelCounter, createId()) VariableAssignmentNode(currentGraph, fir, levelCounter, createId())
fun ControlFlowGraphBuilder.createAnnotationExitNode(fir: FirAnnotationCall): AnnotationExitNode = fun ControlFlowGraphBuilder.createAnnotationExitNode(fir: FirAnnotation): AnnotationExitNode =
AnnotationExitNode(currentGraph, fir, levelCounter, createId()) AnnotationExitNode(currentGraph, fir, levelCounter, createId())
fun ControlFlowGraphBuilder.createAnnotationEnterNode(fir: FirAnnotationCall): AnnotationEnterNode = fun ControlFlowGraphBuilder.createAnnotationEnterNode(fir: FirAnnotation): AnnotationEnterNode =
AnnotationEnterNode(currentGraph, fir, levelCounter, createId()) AnnotationEnterNode(currentGraph, fir, levelCounter, createId())
fun ControlFlowGraphBuilder.createElvisLhsIsNotNullNode(fir: FirElvisExpression): ElvisLhsIsNotNullNode = fun ControlFlowGraphBuilder.createElvisLhsIsNotNullNode(fir: FirElvisExpression): ElvisLhsIsNotNullNode =
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/ConstraintSystemCompleter.kt
+1 -1
View File
@@ -467,7 +467,7 @@ fun FirStatement.processAllContainingCallCandidates(processBlocks: Boolean, proc
rhs.processAllContainingCallCandidates(processBlocks, processor) rhs.processAllContainingCallCandidates(processBlocks, processor)
} }
is FirAnnotationCall -> { is FirAnnotation -> {
processCandidateIfApplicable(processor, processBlocks) processCandidateIfApplicable(processor, processBlocks)
arguments.forEach { it.processAllContainingCallCandidates(processBlocks, processor) } arguments.forEach { it.processAllContainingCallCandidates(processBlocks, processor) }
} }
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirCallCompletionResultsWriterTransformer.kt
+10 -10
View File
@@ -257,40 +257,40 @@ class FirCallCompletionResultsWriterTransformer(
return constructor.returnTypeRef.coneType.isArrayOrPrimitiveArray return constructor.returnTypeRef.coneType.isArrayOrPrimitiveArray
} }
override fun transformAnnotationCall( override fun transformAnnotation(
annotationCall: FirAnnotationCall, annotation: FirAnnotation,
data: ExpectedArgumentType? data: ExpectedArgumentType?
): FirStatement { ): FirStatement {
val calleeReference = annotationCall.calleeReference as? FirNamedReferenceWithCandidate val calleeReference = annotation.calleeReference as? FirNamedReferenceWithCandidate
?: return annotationCall ?: return annotation
annotationCall.transformCalleeReference( annotation.transformCalleeReference(
StoreCalleeReference, StoreCalleeReference,
calleeReference.toResolvedReference(), calleeReference.toResolvedReference(),
) )
val subCandidate = calleeReference.candidate val subCandidate = calleeReference.candidate
val expectedArgumentsTypeMapping = runIf(!calleeReference.isError) { subCandidate.createArgumentsMapping() } val expectedArgumentsTypeMapping = runIf(!calleeReference.isError) { subCandidate.createArgumentsMapping() }
withFirArrayOfCallTransformer { withFirArrayOfCallTransformer {
annotationCall.argumentList.transformArguments(this, expectedArgumentsTypeMapping) annotation.argumentList.transformArguments(this, expectedArgumentsTypeMapping)
var index = 0 var index = 0
subCandidate.argumentMapping = subCandidate.argumentMapping?.let { subCandidate.argumentMapping = subCandidate.argumentMapping?.let {
LinkedHashMap<FirExpression, FirValueParameter>(it.size).let { newMapping -> LinkedHashMap<FirExpression, FirValueParameter>(it.size).let { newMapping ->
subCandidate.argumentMapping?.mapKeysTo(newMapping) { (_, _) -> subCandidate.argumentMapping?.mapKeysTo(newMapping) { (_, _) ->
annotationCall.argumentList.arguments[index++] annotation.argumentList.arguments[index++]
} }
} }
} }
} }
if (calleeReference.isError) { if (calleeReference.isError) {
subCandidate.argumentMapping?.let { subCandidate.argumentMapping?.let {
annotationCall.replaceArgumentList(buildArgumentListForErrorCall(annotationCall.argumentList, it)) annotation.replaceArgumentList(buildArgumentListForErrorCall(annotation.argumentList, it))
} }
} else { } else {
subCandidate.handleVarargs() subCandidate.handleVarargs()
subCandidate.argumentMapping?.let { subCandidate.argumentMapping?.let {
annotationCall.replaceArgumentList(buildResolvedArgumentList(it, annotationCall.argumentList.source)) annotation.replaceArgumentList(buildResolvedArgumentList(it, annotation.argumentList.source))
} }
} }
return annotationCall return annotation
} }
private fun Candidate.handleVarargs() { private fun Candidate.handleVarargs() {
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirTypeResolveTransformer.kt
+4 -5
View File
@@ -9,7 +9,7 @@ import kotlinx.collections.immutable.toImmutableList
import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.*
import org.jetbrains.kotlin.fir.declarations.utils.isFromVararg import org.jetbrains.kotlin.fir.declarations.utils.isFromVararg
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.expressions.FirBlock import org.jetbrains.kotlin.fir.expressions.FirBlock
import org.jetbrains.kotlin.fir.expressions.FirDelegatedConstructorCall import org.jetbrains.kotlin.fir.expressions.FirDelegatedConstructorCall
import org.jetbrains.kotlin.fir.expressions.FirStatement import org.jetbrains.kotlin.fir.expressions.FirStatement
@@ -19,7 +19,6 @@ import org.jetbrains.kotlin.fir.scopes.FirScope
import org.jetbrains.kotlin.fir.scopes.createImportingScopes import org.jetbrains.kotlin.fir.scopes.createImportingScopes
import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.fir.types.*
import org.jetbrains.kotlin.fir.types.builder.buildErrorTypeRef import org.jetbrains.kotlin.fir.types.builder.buildErrorTypeRef
import org.jetbrains.kotlin.fir.types.impl.FirImplicitBuiltinTypeRef
class FirTypeResolveProcessor( class FirTypeResolveProcessor(
session: FirSession, session: FirSession,
@@ -204,8 +203,8 @@ open class FirTypeResolveTransformer(
return delegatedConstructorCall return delegatedConstructorCall
} }
override fun transformAnnotationCall(annotationCall: FirAnnotationCall, data: Any?): FirStatement { override fun transformAnnotation(annotation: FirAnnotation, data: Any?): FirStatement {
annotationCall.transformAnnotationTypeRef(this, data) annotation.transformAnnotationTypeRef(this, data)
return annotationCall return annotation
} }
} }
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirArrayOfCallTransformer.kt
+1 -1
View File
@@ -18,7 +18,7 @@ import org.jetbrains.kotlin.fir.types.isArrayType
/** /**
* A transformer that converts resolved arrayOf() call to [FirArrayOfCall]. * A transformer that converts resolved arrayOf() call to [FirArrayOfCall].
* *
* Note that arrayOf() calls only in [FirAnnotationCall] or the default value of annotation constructor are transformed. * Note that arrayOf() calls only in [FirAnnotation] or the default value of annotation constructor are transformed.
*/ */
internal class FirArrayOfCallTransformer { internal class FirArrayOfCallTransformer {
private val FirFunctionCall.isArrayOfCall: Boolean private val FirFunctionCall.isArrayOfCall: Boolean
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirBodyResolveTransformer.kt
+2 -2
View File
@@ -203,8 +203,8 @@ open class FirBodyResolveTransformer(
return expressionsTransformer.transformConstExpression(constExpression, data) return expressionsTransformer.transformConstExpression(constExpression, data)
} }
override fun transformAnnotationCall(annotationCall: FirAnnotationCall, data: ResolutionMode): FirStatement { override fun transformAnnotation(annotation: FirAnnotation, data: ResolutionMode): FirStatement {
return expressionsTransformer.transformAnnotationCall(annotationCall, data) return expressionsTransformer.transformAnnotation(annotation, data)
} }
override fun transformDelegatedConstructorCall( override fun transformDelegatedConstructorCall(
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt
+12 -12
View File
@@ -892,25 +892,25 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform
return constExpression return constExpression
} }
override fun transformAnnotationCall(annotationCall: FirAnnotationCall, data: ResolutionMode): FirStatement { override fun transformAnnotation(annotation: FirAnnotation, data: ResolutionMode): FirStatement {
if (annotationCall.resolveStatus == FirAnnotationResolveStatus.Resolved) return annotationCall if (annotation.resolveStatus == FirAnnotationResolveStatus.Resolved) return annotation
return resolveAnnotationCall(annotationCall, FirAnnotationResolveStatus.Resolved) return resolveAnnotationCall(annotation, FirAnnotationResolveStatus.Resolved)
} }
protected fun resolveAnnotationCall( protected fun resolveAnnotationCall(
annotationCall: FirAnnotationCall, annotation: FirAnnotation,
status: FirAnnotationResolveStatus status: FirAnnotationResolveStatus
): FirAnnotationCall { ): FirAnnotation {
return withFirArrayOfCallTransformer { return withFirArrayOfCallTransformer {
annotationCall.transformAnnotationTypeRef(transformer, ResolutionMode.ContextIndependent) annotation.transformAnnotationTypeRef(transformer, ResolutionMode.ContextIndependent)
if (status == FirAnnotationResolveStatus.PartiallyResolved) return annotationCall if (status == FirAnnotationResolveStatus.PartiallyResolved) return annotation
dataFlowAnalyzer.enterAnnotationCall(annotationCall) dataFlowAnalyzer.enterAnnotationCall(annotation)
val result = callResolver.resolveAnnotationCall(annotationCall) val result = callResolver.resolveAnnotationCall(annotation)
dataFlowAnalyzer.exitAnnotationCall(result ?: annotationCall) dataFlowAnalyzer.exitAnnotationCall(result ?: annotation)
if (result == null) return annotationCall if (result == null) return annotation
callCompleter.completeCall(result, noExpectedType) callCompleter.completeCall(result, noExpectedType)
result.replaceResolveStatus(status) result.replaceResolveStatus(status)
annotationCall annotation
} }
} }
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/contracts/FirContractResolveTransformer.kt
+2 -2
View File
@@ -45,8 +45,8 @@ open class FirContractResolveTransformer(
) { ) {
override val declarationsTransformer: FirDeclarationsResolveTransformer = FirDeclarationsContractResolveTransformer(this) override val declarationsTransformer: FirDeclarationsResolveTransformer = FirDeclarationsContractResolveTransformer(this)
override fun transformAnnotationCall(annotationCall: FirAnnotationCall, data: ResolutionMode): FirStatement { override fun transformAnnotation(annotation: FirAnnotation, data: ResolutionMode): FirStatement {
return annotationCall return annotation
} }
protected open class FirDeclarationsContractResolveTransformer(transformer: FirBodyResolveTransformer) : FirDeclarationsResolveTransformer(transformer) { protected open class FirDeclarationsContractResolveTransformer(transformer: FirBodyResolveTransformer) : FirDeclarationsResolveTransformer(transformer) {
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirAbstractAnnotationResolveTransformer.kt
+2 -2
View File
@@ -9,7 +9,7 @@ import org.jetbrains.kotlin.fir.FirAnnotationContainer
import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.FirElement
import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.*
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.expressions.FirStatement import org.jetbrains.kotlin.fir.expressions.FirStatement
import org.jetbrains.kotlin.fir.resolve.ScopeSession import org.jetbrains.kotlin.fir.resolve.ScopeSession
import org.jetbrains.kotlin.fir.scopes.FirCompositeScope import org.jetbrains.kotlin.fir.scopes.FirCompositeScope
@@ -22,7 +22,7 @@ internal abstract class FirAbstractAnnotationResolveTransformer<D, S>(
protected val session: FirSession, protected val session: FirSession,
protected val scopeSession: ScopeSession protected val scopeSession: ScopeSession
) : FirDefaultTransformer<D>() { ) : FirDefaultTransformer<D>() {
abstract override fun transformAnnotationCall(annotationCall: FirAnnotationCall, data: D): FirStatement abstract override fun transformAnnotation(annotation: FirAnnotation, data: D): FirStatement
protected lateinit var scope: FirScope protected lateinit var scope: FirScope
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirAnnotationArgumentsResolveTransformer.kt
+7 -7
View File
@@ -137,13 +137,13 @@ private class FirExpressionsResolveTransformerForSpecificAnnotations(
transformer: FirBodyResolveTransformer transformer: FirBodyResolveTransformer
) : FirExpressionsResolveTransformer(transformer) { ) : FirExpressionsResolveTransformer(transformer) {
override fun transformAnnotationCall(annotationCall: FirAnnotationCall, data: ResolutionMode): FirStatement { override fun transformAnnotation(annotation: FirAnnotation, data: ResolutionMode): FirStatement {
if (annotationCall.resolveStatus >= FirAnnotationResolveStatus.PartiallyResolved) return annotationCall if (annotation.resolveStatus >= FirAnnotationResolveStatus.PartiallyResolved) return annotation
dataFlowAnalyzer.enterAnnotationCall(annotationCall) dataFlowAnalyzer.enterAnnotationCall(annotation)
annotationCall.transformChildren(transformer, ResolutionMode.ContextDependent) annotation.transformChildren(transformer, ResolutionMode.ContextDependent)
dataFlowAnalyzer.exitAnnotationCall(annotationCall) dataFlowAnalyzer.exitAnnotationCall(annotation)
annotationCall.replaceResolveStatus(FirAnnotationResolveStatus.PartiallyResolved) annotation.replaceResolveStatus(FirAnnotationResolveStatus.PartiallyResolved)
return annotationCall return annotation
} }
override fun transformExpression(expression: FirExpression, data: ResolutionMode): FirStatement { override fun transformExpression(expression: FirExpression, data: ResolutionMode): FirStatement {
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirPluginAnnotationsResolveTransformer.kt
+4 -4
View File
@@ -16,7 +16,7 @@ import org.jetbrains.kotlin.fir.declarations.FirAnnotatedDeclaration
import org.jetbrains.kotlin.fir.declarations.FirFile import org.jetbrains.kotlin.fir.declarations.FirFile
import org.jetbrains.kotlin.fir.declarations.FirRegularClass import org.jetbrains.kotlin.fir.declarations.FirRegularClass
import org.jetbrains.kotlin.fir.declarations.FirResolvePhase import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.expressions.FirStatement import org.jetbrains.kotlin.fir.expressions.FirStatement
import org.jetbrains.kotlin.fir.extensions.* import org.jetbrains.kotlin.fir.extensions.*
import org.jetbrains.kotlin.fir.resolve.ScopeSession import org.jetbrains.kotlin.fir.resolve.ScopeSession
@@ -102,11 +102,11 @@ private class FirAnnotationResolveTransformer(
owners = state owners = state
} }
override fun transformAnnotationCall( override fun transformAnnotation(
annotationCall: FirAnnotationCall, annotation: FirAnnotation,
data: Multimap<AnnotationFqn, FirRegularClass> data: Multimap<AnnotationFqn, FirRegularClass>
): FirStatement { ): FirStatement {
return annotationCall.transformAnnotationTypeRef( return annotation.transformAnnotationTypeRef(
typeResolverTransformer, typeResolverTransformer,
ScopeClassDeclaration(scope, classDeclarationsStack.lastOrNull()) ScopeClassDeclaration(scope, classDeclarationsStack.lastOrNull())
) )
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirIntegerOperatorCall.kt
+4 -5
View File
@@ -9,8 +9,7 @@ import org.jetbrains.kotlin.fir.FirImplementationDetail
import org.jetbrains.kotlin.fir.FirSourceElement import org.jetbrains.kotlin.fir.FirSourceElement
import org.jetbrains.kotlin.fir.builder.FirAnnotationContainerBuilder import org.jetbrains.kotlin.fir.builder.FirAnnotationContainerBuilder
import org.jetbrains.kotlin.fir.builder.FirBuilderDsl import org.jetbrains.kotlin.fir.builder.FirBuilderDsl
import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnostic import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
import org.jetbrains.kotlin.fir.expressions.FirArgumentList import org.jetbrains.kotlin.fir.expressions.FirArgumentList
import org.jetbrains.kotlin.fir.expressions.FirExpression import org.jetbrains.kotlin.fir.expressions.FirExpression
import org.jetbrains.kotlin.fir.expressions.FirFunctionCallOrigin import org.jetbrains.kotlin.fir.expressions.FirFunctionCallOrigin
@@ -28,7 +27,7 @@ import org.jetbrains.kotlin.fir.types.builder.buildImplicitTypeRef
class FirIntegerOperatorCall @FirImplementationDetail constructor( class FirIntegerOperatorCall @FirImplementationDetail constructor(
source: FirSourceElement?, source: FirSourceElement?,
typeRef: FirTypeRef, typeRef: FirTypeRef,
annotations: MutableList<FirAnnotationCall>, annotations: MutableList<FirAnnotation>,
typeArguments: MutableList<FirTypeProjection>, typeArguments: MutableList<FirTypeProjection>,
explicitReceiver: FirExpression?, explicitReceiver: FirExpression?,
dispatchReceiver: FirExpression, dispatchReceiver: FirExpression,
@@ -52,7 +51,7 @@ class FirIntegerOperatorCall @FirImplementationDetail constructor(
class FirIntegerOperatorCallBuilder : FirQualifiedAccessBuilder, FirCallBuilder, FirAnnotationContainerBuilder, FirExpressionBuilder { class FirIntegerOperatorCallBuilder : FirQualifiedAccessBuilder, FirCallBuilder, FirAnnotationContainerBuilder, FirExpressionBuilder {
override var source: FirSourceElement? = null override var source: FirSourceElement? = null
override var typeRef: FirTypeRef = buildImplicitTypeRef() override var typeRef: FirTypeRef = buildImplicitTypeRef()
override val annotations: MutableList<FirAnnotationCall> = mutableListOf() override val annotations: MutableList<FirAnnotation> = mutableListOf()
override val typeArguments: MutableList<FirTypeProjection> = mutableListOf() override val typeArguments: MutableList<FirTypeProjection> = mutableListOf()
override var explicitReceiver: FirExpression? = null override var explicitReceiver: FirExpression? = null
override var dispatchReceiver: FirExpression = FirNoReceiverExpression override var dispatchReceiver: FirExpression = FirNoReceiverExpression
@@ -79,4 +78,4 @@ class FirIntegerOperatorCallBuilder : FirQualifiedAccessBuilder, FirCallBuilder,
inline fun buildIntegerOperatorFunctionCall(init: FirIntegerOperatorCallBuilder.() -> Unit): FirIntegerOperatorCall { inline fun buildIntegerOperatorFunctionCall(init: FirIntegerOperatorCallBuilder.() -> Unit): FirIntegerOperatorCall {
return FirIntegerOperatorCallBuilder().apply(init).build() return FirIntegerOperatorCallBuilder().apply(init).build()
} }
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/FirAnnotationContainer.kt
+2 -2
View File
@@ -5,7 +5,7 @@
package org.jetbrains.kotlin.fir package org.jetbrains.kotlin.fir
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.visitors.* import org.jetbrains.kotlin.fir.visitors.*
/* /*
@@ -15,7 +15,7 @@ import org.jetbrains.kotlin.fir.visitors.*
interface FirAnnotationContainer : FirElement { interface FirAnnotationContainer : FirElement {
override val source: FirSourceElement? override val source: FirSourceElement?
val annotations: List<FirAnnotationCall> val annotations: List<FirAnnotation>
override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitAnnotationContainer(this, data) override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitAnnotationContainer(this, data)
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/builder/FirAnnotationContainerBuilder.kt
+2 -2
View File
@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.fir.builder
import org.jetbrains.kotlin.fir.FirAnnotationContainer import org.jetbrains.kotlin.fir.FirAnnotationContainer
import org.jetbrains.kotlin.fir.FirSourceElement import org.jetbrains.kotlin.fir.FirSourceElement
import org.jetbrains.kotlin.fir.builder.FirBuilderDsl import org.jetbrains.kotlin.fir.builder.FirBuilderDsl
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.visitors.* import org.jetbrains.kotlin.fir.visitors.*
/* /*
@@ -19,7 +19,7 @@ import org.jetbrains.kotlin.fir.visitors.*
@FirBuilderDsl @FirBuilderDsl
interface FirAnnotationContainerBuilder { interface FirAnnotationContainerBuilder {
abstract var source: FirSourceElement? abstract var source: FirSourceElement?
abstract val annotations: MutableList<FirAnnotationCall> abstract val annotations: MutableList<FirAnnotation>
fun build(): FirAnnotationContainer fun build(): FirAnnotationContainer
} }
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirAnnotatedDeclaration.kt
+2 -2
View File
@@ -9,7 +9,7 @@ import org.jetbrains.kotlin.fir.FirAnnotationContainer
import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.FirElement
import org.jetbrains.kotlin.fir.FirModuleData import org.jetbrains.kotlin.fir.FirModuleData
import org.jetbrains.kotlin.fir.FirSourceElement import org.jetbrains.kotlin.fir.FirSourceElement
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
import org.jetbrains.kotlin.fir.visitors.* import org.jetbrains.kotlin.fir.visitors.*
@@ -25,7 +25,7 @@ sealed class FirAnnotatedDeclaration : FirDeclaration(), FirAnnotationContainer
abstract override val resolvePhase: FirResolvePhase abstract override val resolvePhase: FirResolvePhase
abstract override val origin: FirDeclarationOrigin abstract override val origin: FirDeclarationOrigin
abstract override val attributes: FirDeclarationAttributes abstract override val attributes: FirDeclarationAttributes
abstract override val annotations: List<FirAnnotationCall> abstract override val annotations: List<FirAnnotation>
override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitAnnotatedDeclaration(this, data) override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitAnnotatedDeclaration(this, data)
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirAnonymousFunction.kt
+2 -2
View File
@@ -10,7 +10,7 @@ import org.jetbrains.kotlin.fir.FirElement
import org.jetbrains.kotlin.fir.FirLabel import org.jetbrains.kotlin.fir.FirLabel
import org.jetbrains.kotlin.fir.FirModuleData import org.jetbrains.kotlin.fir.FirModuleData
import org.jetbrains.kotlin.fir.FirSourceElement import org.jetbrains.kotlin.fir.FirSourceElement
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.expressions.FirBlock import org.jetbrains.kotlin.fir.expressions.FirBlock
import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference
import org.jetbrains.kotlin.fir.symbols.impl.FirAnonymousFunctionSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirAnonymousFunctionSymbol
@@ -30,7 +30,7 @@ abstract class FirAnonymousFunction : FirFunction(), FirTypeParametersOwner {
abstract override val resolvePhase: FirResolvePhase abstract override val resolvePhase: FirResolvePhase
abstract override val origin: FirDeclarationOrigin abstract override val origin: FirDeclarationOrigin
abstract override val attributes: FirDeclarationAttributes abstract override val attributes: FirDeclarationAttributes
abstract override val annotations: List<FirAnnotationCall> abstract override val annotations: List<FirAnnotation>
abstract override val returnTypeRef: FirTypeRef abstract override val returnTypeRef: FirTypeRef
abstract override val status: FirDeclarationStatus abstract override val status: FirDeclarationStatus
abstract override val receiverTypeRef: FirTypeRef? abstract override val receiverTypeRef: FirTypeRef?
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirAnonymousObject.kt
+2 -2
View File
@@ -9,7 +9,7 @@ import org.jetbrains.kotlin.descriptors.ClassKind
import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.FirElement
import org.jetbrains.kotlin.fir.FirModuleData import org.jetbrains.kotlin.fir.FirModuleData
import org.jetbrains.kotlin.fir.FirSourceElement import org.jetbrains.kotlin.fir.FirSourceElement
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference
import org.jetbrains.kotlin.fir.scopes.FirScopeProvider import org.jetbrains.kotlin.fir.scopes.FirScopeProvider
import org.jetbrains.kotlin.fir.symbols.impl.FirAnonymousObjectSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirAnonymousObjectSymbol
@@ -32,7 +32,7 @@ abstract class FirAnonymousObject : FirClass(), FirControlFlowGraphOwner {
abstract override val classKind: ClassKind abstract override val classKind: ClassKind
abstract override val superTypeRefs: List<FirTypeRef> abstract override val superTypeRefs: List<FirTypeRef>
abstract override val declarations: List<FirDeclaration> abstract override val declarations: List<FirDeclaration>
abstract override val annotations: List<FirAnnotationCall> abstract override val annotations: List<FirAnnotation>
abstract override val scopeProvider: FirScopeProvider abstract override val scopeProvider: FirScopeProvider
abstract override val controlFlowGraphReference: FirControlFlowGraphReference? abstract override val controlFlowGraphReference: FirControlFlowGraphReference?
abstract override val symbol: FirAnonymousObjectSymbol abstract override val symbol: FirAnonymousObjectSymbol
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirBackingField.kt
+2 -2
View File
@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.fir.declarations
import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.FirElement
import org.jetbrains.kotlin.fir.FirModuleData import org.jetbrains.kotlin.fir.FirModuleData
import org.jetbrains.kotlin.fir.FirSourceElement import org.jetbrains.kotlin.fir.FirSourceElement
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.expressions.FirExpression import org.jetbrains.kotlin.fir.expressions.FirExpression
import org.jetbrains.kotlin.fir.expressions.FirStatement import org.jetbrains.kotlin.fir.expressions.FirStatement
import org.jetbrains.kotlin.fir.symbols.impl.FirBackingFieldSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirBackingFieldSymbol
@@ -45,7 +45,7 @@ abstract class FirBackingField : FirVariable(), FirTypeParametersOwner, FirState
abstract override val symbol: FirBackingFieldSymbol abstract override val symbol: FirBackingFieldSymbol
abstract val propertySymbol: FirPropertySymbol abstract val propertySymbol: FirPropertySymbol
abstract override val initializer: FirExpression? abstract override val initializer: FirExpression?
abstract override val annotations: List<FirAnnotationCall> abstract override val annotations: List<FirAnnotation>
abstract override val typeParameters: List<FirTypeParameter> abstract override val typeParameters: List<FirTypeParameter>
abstract override val status: FirDeclarationStatus abstract override val status: FirDeclarationStatus
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirCallableDeclaration.kt
+2 -2
View File
@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.fir.declarations
import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.FirElement
import org.jetbrains.kotlin.fir.FirModuleData import org.jetbrains.kotlin.fir.FirModuleData
import org.jetbrains.kotlin.fir.FirSourceElement import org.jetbrains.kotlin.fir.FirSourceElement
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
import org.jetbrains.kotlin.fir.types.ConeKotlinType import org.jetbrains.kotlin.fir.types.ConeKotlinType
import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.fir.types.FirTypeRef
@@ -26,7 +26,7 @@ sealed class FirCallableDeclaration : FirTypedDeclaration(), FirMemberDeclaratio
abstract override val resolvePhase: FirResolvePhase abstract override val resolvePhase: FirResolvePhase
abstract override val origin: FirDeclarationOrigin abstract override val origin: FirDeclarationOrigin
abstract override val attributes: FirDeclarationAttributes abstract override val attributes: FirDeclarationAttributes
abstract override val annotations: List<FirAnnotationCall> abstract override val annotations: List<FirAnnotation>
abstract override val returnTypeRef: FirTypeRef abstract override val returnTypeRef: FirTypeRef
abstract override val typeParameters: List<FirTypeParameterRef> abstract override val typeParameters: List<FirTypeParameterRef>
abstract override val status: FirDeclarationStatus abstract override val status: FirDeclarationStatus
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirClass.kt
+2 -2
View File
@@ -9,7 +9,7 @@ import org.jetbrains.kotlin.descriptors.ClassKind
import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.FirElement
import org.jetbrains.kotlin.fir.FirModuleData import org.jetbrains.kotlin.fir.FirModuleData
import org.jetbrains.kotlin.fir.FirSourceElement import org.jetbrains.kotlin.fir.FirSourceElement
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.expressions.FirStatement import org.jetbrains.kotlin.fir.expressions.FirStatement
import org.jetbrains.kotlin.fir.scopes.FirScopeProvider import org.jetbrains.kotlin.fir.scopes.FirScopeProvider
import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
@@ -33,7 +33,7 @@ sealed class FirClass : FirClassLikeDeclaration(), FirStatement, FirTypeParamete
abstract val classKind: ClassKind abstract val classKind: ClassKind
abstract val superTypeRefs: List<FirTypeRef> abstract val superTypeRefs: List<FirTypeRef>
abstract val declarations: List<FirDeclaration> abstract val declarations: List<FirDeclaration>
abstract override val annotations: List<FirAnnotationCall> abstract override val annotations: List<FirAnnotation>
abstract val scopeProvider: FirScopeProvider abstract val scopeProvider: FirScopeProvider
override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitClass(this, data) override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitClass(this, data)
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirClassLikeDeclaration.kt
+2 -2
View File
@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.fir.declarations
import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.FirElement
import org.jetbrains.kotlin.fir.FirModuleData import org.jetbrains.kotlin.fir.FirModuleData
import org.jetbrains.kotlin.fir.FirSourceElement import org.jetbrains.kotlin.fir.FirSourceElement
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.expressions.FirStatement import org.jetbrains.kotlin.fir.expressions.FirStatement
import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
import org.jetbrains.kotlin.fir.visitors.* import org.jetbrains.kotlin.fir.visitors.*
@@ -24,7 +24,7 @@ sealed class FirClassLikeDeclaration : FirAnnotatedDeclaration(), FirStatement {
abstract override val resolvePhase: FirResolvePhase abstract override val resolvePhase: FirResolvePhase
abstract override val origin: FirDeclarationOrigin abstract override val origin: FirDeclarationOrigin
abstract override val attributes: FirDeclarationAttributes abstract override val attributes: FirDeclarationAttributes
abstract override val annotations: List<FirAnnotationCall> abstract override val annotations: List<FirAnnotation>
abstract override val symbol: FirClassLikeSymbol<out FirClassLikeDeclaration> abstract override val symbol: FirClassLikeSymbol<out FirClassLikeDeclaration>
abstract val deprecation: DeprecationsPerUseSite? abstract val deprecation: DeprecationsPerUseSite?
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirConstructor.kt
+2 -2
View File
@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.fir.declarations
import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.FirElement
import org.jetbrains.kotlin.fir.FirModuleData import org.jetbrains.kotlin.fir.FirModuleData
import org.jetbrains.kotlin.fir.FirSourceElement import org.jetbrains.kotlin.fir.FirSourceElement
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.expressions.FirBlock import org.jetbrains.kotlin.fir.expressions.FirBlock
import org.jetbrains.kotlin.fir.expressions.FirDelegatedConstructorCall import org.jetbrains.kotlin.fir.expressions.FirDelegatedConstructorCall
import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference
@@ -38,7 +38,7 @@ abstract class FirConstructor : FirFunction(), FirTypeParameterRefsOwner {
abstract override val dispatchReceiverType: ConeKotlinType? abstract override val dispatchReceiverType: ConeKotlinType?
abstract override val controlFlowGraphReference: FirControlFlowGraphReference? abstract override val controlFlowGraphReference: FirControlFlowGraphReference?
abstract override val valueParameters: List<FirValueParameter> abstract override val valueParameters: List<FirValueParameter>
abstract override val annotations: List<FirAnnotationCall> abstract override val annotations: List<FirAnnotation>
abstract override val symbol: FirConstructorSymbol abstract override val symbol: FirConstructorSymbol
abstract val delegatedConstructor: FirDelegatedConstructorCall? abstract val delegatedConstructor: FirDelegatedConstructorCall?
abstract override val body: FirBlock? abstract override val body: FirBlock?
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirEnumEntry.kt
+2 -2
View File
@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.fir.declarations
import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.FirElement
import org.jetbrains.kotlin.fir.FirModuleData import org.jetbrains.kotlin.fir.FirModuleData
import org.jetbrains.kotlin.fir.FirSourceElement import org.jetbrains.kotlin.fir.FirSourceElement
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.expressions.FirExpression import org.jetbrains.kotlin.fir.expressions.FirExpression
import org.jetbrains.kotlin.fir.symbols.impl.FirEnumEntrySymbol import org.jetbrains.kotlin.fir.symbols.impl.FirEnumEntrySymbol
import org.jetbrains.kotlin.fir.types.ConeKotlinType import org.jetbrains.kotlin.fir.types.ConeKotlinType
@@ -43,7 +43,7 @@ abstract class FirEnumEntry : FirVariable() {
abstract override val getter: FirPropertyAccessor? abstract override val getter: FirPropertyAccessor?
abstract override val setter: FirPropertyAccessor? abstract override val setter: FirPropertyAccessor?
abstract override val backingField: FirBackingField? abstract override val backingField: FirBackingField?
abstract override val annotations: List<FirAnnotationCall> abstract override val annotations: List<FirAnnotation>
abstract override val symbol: FirEnumEntrySymbol abstract override val symbol: FirEnumEntrySymbol
override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitEnumEntry(this, data) override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitEnumEntry(this, data)
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirErrorFunction.kt
+2 -2
View File
@@ -10,7 +10,7 @@ import org.jetbrains.kotlin.fir.FirModuleData
import org.jetbrains.kotlin.fir.FirSourceElement import org.jetbrains.kotlin.fir.FirSourceElement
import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnostic import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnostic
import org.jetbrains.kotlin.fir.diagnostics.FirDiagnosticHolder import org.jetbrains.kotlin.fir.diagnostics.FirDiagnosticHolder
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.expressions.FirBlock import org.jetbrains.kotlin.fir.expressions.FirBlock
import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference
import org.jetbrains.kotlin.fir.symbols.impl.FirErrorFunctionSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirErrorFunctionSymbol
@@ -30,7 +30,7 @@ abstract class FirErrorFunction : FirFunction(), FirDiagnosticHolder {
abstract override val resolvePhase: FirResolvePhase abstract override val resolvePhase: FirResolvePhase
abstract override val origin: FirDeclarationOrigin abstract override val origin: FirDeclarationOrigin
abstract override val attributes: FirDeclarationAttributes abstract override val attributes: FirDeclarationAttributes
abstract override val annotations: List<FirAnnotationCall> abstract override val annotations: List<FirAnnotation>
abstract override val returnTypeRef: FirTypeRef abstract override val returnTypeRef: FirTypeRef
abstract override val status: FirDeclarationStatus abstract override val status: FirDeclarationStatus
abstract override val receiverTypeRef: FirTypeRef? abstract override val receiverTypeRef: FirTypeRef?
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirErrorProperty.kt
+2 -2
View File
@@ -10,7 +10,7 @@ import org.jetbrains.kotlin.fir.FirModuleData
import org.jetbrains.kotlin.fir.FirSourceElement import org.jetbrains.kotlin.fir.FirSourceElement
import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnostic import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnostic
import org.jetbrains.kotlin.fir.diagnostics.FirDiagnosticHolder import org.jetbrains.kotlin.fir.diagnostics.FirDiagnosticHolder
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.expressions.FirExpression import org.jetbrains.kotlin.fir.expressions.FirExpression
import org.jetbrains.kotlin.fir.symbols.impl.FirErrorPropertySymbol import org.jetbrains.kotlin.fir.symbols.impl.FirErrorPropertySymbol
import org.jetbrains.kotlin.fir.types.ConeKotlinType import org.jetbrains.kotlin.fir.types.ConeKotlinType
@@ -45,7 +45,7 @@ abstract class FirErrorProperty : FirVariable(), FirDiagnosticHolder {
abstract override val getter: FirPropertyAccessor? abstract override val getter: FirPropertyAccessor?
abstract override val setter: FirPropertyAccessor? abstract override val setter: FirPropertyAccessor?
abstract override val backingField: FirBackingField? abstract override val backingField: FirBackingField?
abstract override val annotations: List<FirAnnotationCall> abstract override val annotations: List<FirAnnotation>
abstract override val diagnostic: ConeDiagnostic abstract override val diagnostic: ConeDiagnostic
abstract override val symbol: FirErrorPropertySymbol abstract override val symbol: FirErrorPropertySymbol
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirField.kt
+2 -2
View File
@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.fir.declarations
import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.FirElement
import org.jetbrains.kotlin.fir.FirModuleData import org.jetbrains.kotlin.fir.FirModuleData
import org.jetbrains.kotlin.fir.FirSourceElement import org.jetbrains.kotlin.fir.FirSourceElement
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.expressions.FirExpression import org.jetbrains.kotlin.fir.expressions.FirExpression
import org.jetbrains.kotlin.fir.symbols.impl.FirFieldSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirFieldSymbol
import org.jetbrains.kotlin.fir.types.ConeKotlinType import org.jetbrains.kotlin.fir.types.ConeKotlinType
@@ -43,7 +43,7 @@ abstract class FirField : FirVariable() {
abstract override val getter: FirPropertyAccessor? abstract override val getter: FirPropertyAccessor?
abstract override val setter: FirPropertyAccessor? abstract override val setter: FirPropertyAccessor?
abstract override val backingField: FirBackingField? abstract override val backingField: FirBackingField?
abstract override val annotations: List<FirAnnotationCall> abstract override val annotations: List<FirAnnotation>
abstract override val symbol: FirFieldSymbol abstract override val symbol: FirFieldSymbol
override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitField(this, data) override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitField(this, data)
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirFile.kt
+2 -2
View File
@@ -9,7 +9,7 @@ import org.jetbrains.kotlin.fir.FirElement
import org.jetbrains.kotlin.fir.FirModuleData import org.jetbrains.kotlin.fir.FirModuleData
import org.jetbrains.kotlin.fir.FirPackageDirective import org.jetbrains.kotlin.fir.FirPackageDirective
import org.jetbrains.kotlin.fir.FirSourceElement import org.jetbrains.kotlin.fir.FirSourceElement
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.symbols.impl.FirFileSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirFileSymbol
import org.jetbrains.kotlin.fir.visitors.* import org.jetbrains.kotlin.fir.visitors.*
@@ -24,7 +24,7 @@ abstract class FirFile : FirAnnotatedDeclaration() {
abstract override val resolvePhase: FirResolvePhase abstract override val resolvePhase: FirResolvePhase
abstract override val origin: FirDeclarationOrigin abstract override val origin: FirDeclarationOrigin
abstract override val attributes: FirDeclarationAttributes abstract override val attributes: FirDeclarationAttributes
abstract override val annotations: List<FirAnnotationCall> abstract override val annotations: List<FirAnnotation>
abstract val packageDirective: FirPackageDirective abstract val packageDirective: FirPackageDirective
abstract val imports: List<FirImport> abstract val imports: List<FirImport>
abstract val declarations: List<FirDeclaration> abstract val declarations: List<FirDeclaration>
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirFunction.kt
+2 -2
View File
@@ -9,7 +9,7 @@ import org.jetbrains.kotlin.fir.FirElement
import org.jetbrains.kotlin.fir.FirModuleData import org.jetbrains.kotlin.fir.FirModuleData
import org.jetbrains.kotlin.fir.FirSourceElement import org.jetbrains.kotlin.fir.FirSourceElement
import org.jetbrains.kotlin.fir.FirTargetElement import org.jetbrains.kotlin.fir.FirTargetElement
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.expressions.FirBlock import org.jetbrains.kotlin.fir.expressions.FirBlock
import org.jetbrains.kotlin.fir.expressions.FirStatement import org.jetbrains.kotlin.fir.expressions.FirStatement
import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference
@@ -30,7 +30,7 @@ sealed class FirFunction : FirCallableDeclaration(), FirTargetElement, FirContro
abstract override val resolvePhase: FirResolvePhase abstract override val resolvePhase: FirResolvePhase
abstract override val origin: FirDeclarationOrigin abstract override val origin: FirDeclarationOrigin
abstract override val attributes: FirDeclarationAttributes abstract override val attributes: FirDeclarationAttributes
abstract override val annotations: List<FirAnnotationCall> abstract override val annotations: List<FirAnnotation>
abstract override val returnTypeRef: FirTypeRef abstract override val returnTypeRef: FirTypeRef
abstract override val typeParameters: List<FirTypeParameterRef> abstract override val typeParameters: List<FirTypeParameterRef>
abstract override val status: FirDeclarationStatus abstract override val status: FirDeclarationStatus
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirProperty.kt
+2 -2
View File
@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.fir.declarations
import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.FirElement
import org.jetbrains.kotlin.fir.FirModuleData import org.jetbrains.kotlin.fir.FirModuleData
import org.jetbrains.kotlin.fir.FirSourceElement import org.jetbrains.kotlin.fir.FirSourceElement
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.expressions.FirExpression import org.jetbrains.kotlin.fir.expressions.FirExpression
import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference
import org.jetbrains.kotlin.fir.symbols.impl.FirDelegateFieldSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirDelegateFieldSymbol
@@ -44,7 +44,7 @@ abstract class FirProperty : FirVariable(), FirTypeParametersOwner, FirControlFl
abstract override val getter: FirPropertyAccessor? abstract override val getter: FirPropertyAccessor?
abstract override val setter: FirPropertyAccessor? abstract override val setter: FirPropertyAccessor?
abstract override val backingField: FirBackingField? abstract override val backingField: FirBackingField?
abstract override val annotations: List<FirAnnotationCall> abstract override val annotations: List<FirAnnotation>
abstract override val controlFlowGraphReference: FirControlFlowGraphReference? abstract override val controlFlowGraphReference: FirControlFlowGraphReference?
abstract override val symbol: FirPropertySymbol abstract override val symbol: FirPropertySymbol
abstract val delegateFieldSymbol: FirDelegateFieldSymbol? abstract val delegateFieldSymbol: FirDelegateFieldSymbol?
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirPropertyAccessor.kt
+2 -2
View File
@@ -9,7 +9,7 @@ import org.jetbrains.kotlin.fir.FirElement
import org.jetbrains.kotlin.fir.FirModuleData import org.jetbrains.kotlin.fir.FirModuleData
import org.jetbrains.kotlin.fir.FirSourceElement import org.jetbrains.kotlin.fir.FirSourceElement
import org.jetbrains.kotlin.fir.contracts.FirContractDescription import org.jetbrains.kotlin.fir.contracts.FirContractDescription
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.expressions.FirBlock import org.jetbrains.kotlin.fir.expressions.FirBlock
import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference
import org.jetbrains.kotlin.fir.symbols.impl.FirPropertyAccessorSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirPropertyAccessorSymbol
@@ -44,7 +44,7 @@ abstract class FirPropertyAccessor : FirFunction(), FirContractDescriptionOwner,
abstract val propertySymbol: FirPropertySymbol? abstract val propertySymbol: FirPropertySymbol?
abstract val isGetter: Boolean abstract val isGetter: Boolean
abstract val isSetter: Boolean abstract val isSetter: Boolean
abstract override val annotations: List<FirAnnotationCall> abstract override val annotations: List<FirAnnotation>
abstract override val typeParameters: List<FirTypeParameter> abstract override val typeParameters: List<FirTypeParameter>
override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitPropertyAccessor(this, data) override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitPropertyAccessor(this, data)
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirRegularClass.kt
+2 -2
View File
@@ -9,7 +9,7 @@ import org.jetbrains.kotlin.descriptors.ClassKind
import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.FirElement
import org.jetbrains.kotlin.fir.FirModuleData import org.jetbrains.kotlin.fir.FirModuleData
import org.jetbrains.kotlin.fir.FirSourceElement import org.jetbrains.kotlin.fir.FirSourceElement
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference
import org.jetbrains.kotlin.fir.scopes.FirScopeProvider import org.jetbrains.kotlin.fir.scopes.FirScopeProvider
import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
@@ -32,7 +32,7 @@ abstract class FirRegularClass : FirClass(), FirMemberDeclaration, FirControlFlo
abstract override val typeParameters: List<FirTypeParameterRef> abstract override val typeParameters: List<FirTypeParameterRef>
abstract override val classKind: ClassKind abstract override val classKind: ClassKind
abstract override val declarations: List<FirDeclaration> abstract override val declarations: List<FirDeclaration>
abstract override val annotations: List<FirAnnotationCall> abstract override val annotations: List<FirAnnotation>
abstract override val scopeProvider: FirScopeProvider abstract override val scopeProvider: FirScopeProvider
abstract override val status: FirDeclarationStatus abstract override val status: FirDeclarationStatus
abstract override val controlFlowGraphReference: FirControlFlowGraphReference? abstract override val controlFlowGraphReference: FirControlFlowGraphReference?
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirSimpleFunction.kt
+2 -2
View File
@@ -9,7 +9,7 @@ import org.jetbrains.kotlin.fir.FirElement
import org.jetbrains.kotlin.fir.FirModuleData import org.jetbrains.kotlin.fir.FirModuleData
import org.jetbrains.kotlin.fir.FirSourceElement import org.jetbrains.kotlin.fir.FirSourceElement
import org.jetbrains.kotlin.fir.contracts.FirContractDescription import org.jetbrains.kotlin.fir.contracts.FirContractDescription
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.expressions.FirBlock import org.jetbrains.kotlin.fir.expressions.FirBlock
import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference
import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
@@ -42,7 +42,7 @@ abstract class FirSimpleFunction : FirFunction(), FirContractDescriptionOwner, F
abstract override val contractDescription: FirContractDescription abstract override val contractDescription: FirContractDescription
abstract val name: Name abstract val name: Name
abstract override val symbol: FirNamedFunctionSymbol abstract override val symbol: FirNamedFunctionSymbol
abstract override val annotations: List<FirAnnotationCall> abstract override val annotations: List<FirAnnotation>
abstract override val typeParameters: List<FirTypeParameter> abstract override val typeParameters: List<FirTypeParameter>
override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitSimpleFunction(this, data) override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitSimpleFunction(this, data)
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirTypeAlias.kt
+2 -2
View File
@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.fir.declarations
import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.FirElement
import org.jetbrains.kotlin.fir.FirModuleData import org.jetbrains.kotlin.fir.FirModuleData
import org.jetbrains.kotlin.fir.FirSourceElement import org.jetbrains.kotlin.fir.FirSourceElement
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.symbols.impl.FirTypeAliasSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirTypeAliasSymbol
import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.fir.types.FirTypeRef
import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.name.Name
@@ -31,7 +31,7 @@ abstract class FirTypeAlias : FirClassLikeDeclaration(), FirMemberDeclaration, F
abstract val name: Name abstract val name: Name
abstract override val symbol: FirTypeAliasSymbol abstract override val symbol: FirTypeAliasSymbol
abstract val expandedTypeRef: FirTypeRef abstract val expandedTypeRef: FirTypeRef
abstract override val annotations: List<FirAnnotationCall> abstract override val annotations: List<FirAnnotation>
override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitTypeAlias(this, data) override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitTypeAlias(this, data)
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirTypeParameter.kt
+2 -2
View File
@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.fir.declarations
import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.FirElement
import org.jetbrains.kotlin.fir.FirModuleData import org.jetbrains.kotlin.fir.FirModuleData
import org.jetbrains.kotlin.fir.FirSourceElement import org.jetbrains.kotlin.fir.FirSourceElement
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol
import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.fir.types.FirTypeRef
@@ -33,7 +33,7 @@ abstract class FirTypeParameter : FirTypeParameterRef, FirAnnotatedDeclaration()
abstract val variance: Variance abstract val variance: Variance
abstract val isReified: Boolean abstract val isReified: Boolean
abstract val bounds: List<FirTypeRef> abstract val bounds: List<FirTypeRef>
abstract override val annotations: List<FirAnnotationCall> abstract override val annotations: List<FirAnnotation>
override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitTypeParameter(this, data) override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitTypeParameter(this, data)
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirTypedDeclaration.kt
+2 -2
View File
@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.fir.declarations
import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.FirElement
import org.jetbrains.kotlin.fir.FirModuleData import org.jetbrains.kotlin.fir.FirModuleData
import org.jetbrains.kotlin.fir.FirSourceElement import org.jetbrains.kotlin.fir.FirSourceElement
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.fir.types.FirTypeRef
import org.jetbrains.kotlin.fir.visitors.* import org.jetbrains.kotlin.fir.visitors.*
@@ -25,7 +25,7 @@ sealed class FirTypedDeclaration : FirAnnotatedDeclaration() {
abstract override val resolvePhase: FirResolvePhase abstract override val resolvePhase: FirResolvePhase
abstract override val origin: FirDeclarationOrigin abstract override val origin: FirDeclarationOrigin
abstract override val attributes: FirDeclarationAttributes abstract override val attributes: FirDeclarationAttributes
abstract override val annotations: List<FirAnnotationCall> abstract override val annotations: List<FirAnnotation>
abstract val returnTypeRef: FirTypeRef abstract val returnTypeRef: FirTypeRef
override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitTypedDeclaration(this, data) override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitTypedDeclaration(this, data)
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirValueParameter.kt
+2 -2
View File
@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.fir.declarations
import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.FirElement
import org.jetbrains.kotlin.fir.FirModuleData import org.jetbrains.kotlin.fir.FirModuleData
import org.jetbrains.kotlin.fir.FirSourceElement import org.jetbrains.kotlin.fir.FirSourceElement
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.expressions.FirExpression import org.jetbrains.kotlin.fir.expressions.FirExpression
import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference
import org.jetbrains.kotlin.fir.symbols.impl.FirValueParameterSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirValueParameterSymbol
@@ -44,7 +44,7 @@ abstract class FirValueParameter : FirVariable(), FirControlFlowGraphOwner {
abstract override val getter: FirPropertyAccessor? abstract override val getter: FirPropertyAccessor?
abstract override val setter: FirPropertyAccessor? abstract override val setter: FirPropertyAccessor?
abstract override val backingField: FirBackingField? abstract override val backingField: FirBackingField?
abstract override val annotations: List<FirAnnotationCall> abstract override val annotations: List<FirAnnotation>
abstract override val controlFlowGraphReference: FirControlFlowGraphReference? abstract override val controlFlowGraphReference: FirControlFlowGraphReference?
abstract override val symbol: FirValueParameterSymbol abstract override val symbol: FirValueParameterSymbol
abstract val defaultValue: FirExpression? abstract val defaultValue: FirExpression?

Some files were not shown because too many files have changed in this diff Show More