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<FirReturnExpression>("ReturnExpressionChecker")
alias<FirBlock>("BlockChecker")
alias<FirAnnotationCall>("AnnotationCallChecker")
alias<FirAnnotation>("AnnotationCallChecker")
alias<FirCheckNotNullCall>("CheckNotNullCallChecker")
alias<FirElvisExpression>("ElvisExpressionChecker")
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.utils.isInterface
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.resolve.toSymbol
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() {
override fun check(declaration: FirDeclaration, context: CheckerContext, reporter: DiagnosticReporter) {
val jvmDefaultMode = context.session.jvmDefaultModeState
var defaultAnnotation: FirAnnotationCall? = null
var defaultAnnotation: FirAnnotation? = null
val containingDeclaration = context.findClosest<FirClassLikeDeclaration>()
if (declaration is FirAnnotatedDeclaration) {
@@ -121,7 +121,7 @@ object FirJvmDefaultChecker : FirBasicDeclarationChecker() {
}
private fun checkNonJvmDefaultOverridesJavaDefault(
defaultAnnotation: FirAnnotationCall?,
defaultAnnotation: FirAnnotation?,
jvmDefaultMode: JvmDefaultMode,
declaration: FirDeclaration,
containingDeclaration: FirClassLikeDeclaration?,
@@ -175,4 +175,4 @@ object FirJvmDefaultChecker : FirBasicDeclarationChecker() {
// TODO: Fix support for all cases
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.isOpen
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.references.FirResolvedNamedReference
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 {
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.declarations.*
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.references.FirResolvedNamedReference
import org.jetbrains.kotlin.fir.symbols.SymbolInternals
@@ -242,7 +242,7 @@ object FirJvmStaticChecker : FirAnnotatedDeclarationChecker() {
return findAnnotation(classId) != null
}
private fun FirAnnotatedDeclaration.findAnnotation(classId: ClassId): FirAnnotationCall? {
private fun FirAnnotatedDeclaration.findAnnotation(classId: ClassId): FirAnnotation? {
return annotations.firstOrNull {
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()
}
private fun FirAnnotationCall.resolveContainerAnnotation(): ClassId? {
private fun FirAnnotation.resolveContainerAnnotation(): ClassId? {
val value = findArgumentByName(REPEATABLE_PARAMETER_NAME) ?: return null
val classCallArgument = (value as? FirGetClassCall)?.argument ?: return null
if (classCallArgument is FirResolvedQualifier) {
@@ -119,7 +119,7 @@ object FirRepeatableAnnotationChecker : FirAnnotatedDeclarationChecker() {
}
private fun checkJavaRepeatableAnnotationDeclaration(
javaRepeatable: FirAnnotationCall,
javaRepeatable: FirAnnotation,
annotationClass: FirRegularClass,
context: CheckerContext,
reporter: DiagnosticReporter
@@ -131,7 +131,7 @@ object FirRepeatableAnnotationChecker : FirAnnotatedDeclarationChecker() {
}
private fun checkKotlinRepeatableAnnotationDeclaration(
kotlinRepeatable: FirAnnotationCall,
kotlinRepeatable: FirAnnotation,
declaration: FirRegularClass,
context: CheckerContext,
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.jvm.FirJvmErrors
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.coneTypeSafe
import org.jetbrains.kotlin.load.java.JvmAnnotationNames
@@ -29,7 +29,7 @@ object FirDeprecatedJavaAnnotationsChecker : FirAnnotationCallChecker() {
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
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)
}
}
}
}
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.FirFile
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.coneTypeSafe
import org.jetbrains.kotlin.name.*
@@ -23,7 +23,7 @@ object FirJvmPackageNameAnnotationsChecker : FirAnnotationCallChecker() {
private val jvmPackageNameClassId = ClassId.topLevel(FqName("kotlin.jvm.JvmPackageName"))
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
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)
}
}
}
}
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
*/
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.FirBinaryLogicExpression
import org.jetbrains.kotlin.fir.expressions.FirBlock
@@ -53,7 +53,7 @@ typealias FirLoopJumpChecker = FirExpressionChecker<FirLoopJump>
typealias FirLogicExpressionChecker = FirExpressionChecker<FirBinaryLogicExpression>
typealias FirReturnExpressionChecker = FirExpressionChecker<FirReturnExpression>
typealias FirBlockChecker = FirExpressionChecker<FirBlock>
typealias FirAnnotationCallChecker = FirExpressionChecker<FirAnnotationCall>
typealias FirAnnotationCallChecker = FirExpressionChecker<FirAnnotation>
typealias FirCheckNotNullCallChecker = FirExpressionChecker<FirCheckNotNullCall>
typealias FirElvisExpressionChecker = FirExpressionChecker<FirElvisExpression>
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.symbolProvider
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.impl.FirClassLikeSymbol
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 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 {
return getRetentionAnnotation()?.getRetention() ?: AnnotationRetention.RUNTIME
}
fun FirAnnotationCall.getRetention(): AnnotationRetention {
fun FirAnnotation.getRetention(): AnnotationRetention {
val retentionArgument = findArgumentByName(RETENTION_PARAMETER_NAME) as? FirQualifiedAccessExpression
?: return AnnotationRetention.RUNTIME
val retentionName = (retentionArgument.calleeReference as? FirResolvedNamedReference)?.name?.asString()
@@ -56,7 +67,7 @@ fun FirAnnotationCall.getRetention(): AnnotationRetention {
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()
val annotationClassSymbol = (this.annotationTypeRef.coneType as? ConeClassLikeType)
?.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)
}
fun FirAnnotatedDeclaration.getTargetAnnotation(): FirAnnotationCall? {
fun FirAnnotatedDeclaration.getTargetAnnotation(): FirAnnotation? {
return getAnnotationByClassId(StandardNames.FqNames.targetClassId)
}
fun FirClassLikeSymbol<*>.getTargetAnnotation(): FirAnnotationCall? {
fun FirClassLikeSymbol<*>.getTargetAnnotation(): FirAnnotation? {
return getAnnotationByClassId(StandardNames.FqNames.targetClassId)
}
@@ -103,7 +114,7 @@ fun FirExpression.extractClassesFromArgument(): List<FirRegularClassSymbol> {
fun checkRepeatedAnnotation(
useSiteTarget: AnnotationUseSiteTarget?,
existingTargetsForAnnotation: MutableList<AnnotationUseSiteTarget?>,
annotation: FirAnnotationCall,
annotation: FirAnnotation,
context: CheckerContext,
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
if (annotationClassId.isLocal) return false
val annotationClass = session.symbolProvider.getClassLikeSymbolByClassId(annotationClassId) ?: return false
@@ -138,7 +149,7 @@ fun FirClassLikeSymbol<*>.getAnnotationRetention(): AnnotationRetention {
}
fun FirAnnotationContainer.getDefaultUseSiteTarget(
annotation: FirAnnotationCall,
annotation: FirAnnotation,
context: CheckerContext
): AnnotationUseSiteTarget? {
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
import org.jetbrains.kotlin.descriptors.ClassKind
import org.jetbrains.kotlin.config.LanguageFeature
import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
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.declarations.*
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.languageVersionSettings
import org.jetbrains.kotlin.fir.packageFqName
@@ -35,24 +36,24 @@ object FirAnnotationChecker : FirAnnotatedDeclarationChecker() {
context: CheckerContext,
reporter: DiagnosticReporter
) {
var deprecatedCall: FirAnnotationCall? = null
var deprecatedSinceKotlinCall: FirAnnotationCall? = null
var deprecated: FirAnnotation? = null
var deprecatedSinceKotlin: FirAnnotation? = null
for (annotation in declaration.annotations) {
val fqName = annotation.fqName(context.session) ?: continue
if (fqName == deprecatedClassId) {
deprecatedCall = annotation
deprecated = annotation
} else if (fqName == deprecatedSinceKotlinClassId) {
deprecatedSinceKotlinCall = annotation
deprecatedSinceKotlin = annotation
}
withSuppressedDiagnostics(annotation, context) {
checkAnnotationTarget(declaration, annotation, context, reporter)
}
}
if (deprecatedSinceKotlinCall != null) {
withSuppressedDiagnostics(deprecatedSinceKotlinCall, context) {
checkDeprecatedCalls(deprecatedSinceKotlinCall, deprecatedCall, context, reporter)
if (deprecatedSinceKotlin != null) {
withSuppressedDiagnostics(deprecatedSinceKotlin, context) {
checkDeprecatedCalls(deprecatedSinceKotlin, deprecated, context, reporter)
}
}
@@ -67,7 +68,7 @@ object FirAnnotationChecker : FirAnnotatedDeclarationChecker() {
private fun checkAnnotationTarget(
declaration: FirAnnotatedDeclaration,
annotation: FirAnnotationCall,
annotation: FirAnnotation,
context: CheckerContext,
reporter: DiagnosticReporter
) {
@@ -119,7 +120,7 @@ object FirAnnotationChecker : FirAnnotatedDeclarationChecker() {
private fun checkAnnotationUseSiteTarget(
annotated: FirAnnotatedDeclaration,
annotation: FirAnnotationCall,
annotation: FirAnnotation,
target: AnnotationUseSiteTarget,
context: CheckerContext,
reporter: DiagnosticReporter
@@ -176,28 +177,28 @@ object FirAnnotationChecker : FirAnnotatedDeclarationChecker() {
}
private fun checkDeprecatedCalls(
deprecatedSinceKotlinCall: FirAnnotationCall,
deprecatedCall: FirAnnotationCall?,
deprecatedSinceKotlin: FirAnnotation,
deprecated: FirAnnotation?,
context: CheckerContext,
reporter: DiagnosticReporter
) {
val closestFirFile = context.findClosest<FirFile>()
if (closestFirFile != null && !closestFirFile.packageFqName.startsWith(StandardClassIds.BASE_KOTLIN_PACKAGE.shortName())) {
reporter.reportOn(
deprecatedSinceKotlinCall.source,
deprecatedSinceKotlin.source,
FirErrors.DEPRECATED_SINCE_KOTLIN_OUTSIDE_KOTLIN_SUBPACKAGE,
context
)
}
if (deprecatedCall == null) {
reporter.reportOn(deprecatedSinceKotlinCall.source, FirErrors.DEPRECATED_SINCE_KOTLIN_WITHOUT_DEPRECATED, context)
if (deprecated == null) {
reporter.reportOn(deprecatedSinceKotlin.source, FirErrors.DEPRECATED_SINCE_KOTLIN_WITHOUT_DEPRECATED, context)
} else {
val argumentMapping = deprecatedCall.argumentMapping ?: return
val argumentMapping = deprecated.argumentMapping ?: return
for (value in argumentMapping.values) {
if (value.name.identifier == "level") {
reporter.reportOn(
deprecatedSinceKotlinCall.source,
deprecatedSinceKotlin.source,
FirErrors.DEPRECATED_SINCE_KOTLIN_WITH_DEPRECATED_LEVEL,
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,
)
override fun check(expression: FirAnnotationCall, context: CheckerContext, reporter: DiagnosticReporter) {
override fun check(expression: FirAnnotation, context: CheckerContext, reporter: DiagnosticReporter) {
val argumentMapping = expression.argumentMapping ?: return
val fqName = expression.fqName(context.session)
for ((arg, _) in argumentMapping) {
@@ -130,12 +130,12 @@ object FirAnnotationArgumentChecker : FirAnnotationCallChecker() {
private fun checkAnnotationsWithVersion(
fqName: FqName?,
annotationCall: FirAnnotationCall,
annotation: FirAnnotation,
context: CheckerContext,
reporter: DiagnosticReporter
) {
if (!annotationFqNamesWithVersion.contains(fqName)) return
val versionExpression = annotationCall.findArgumentByName(versionArgumentName) ?: return
val versionExpression = annotation.findArgumentByName(versionArgumentName) ?: return
val version = parseVersionExpressionOrReport(versionExpression, context, reporter) ?: return
if (fqName == sinceKotlinFqName) {
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.declarations.FirRegularClass
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.references.FirResolvedNamedReference
import org.jetbrains.kotlin.fir.symbols.impl.FirConstructorSymbol
@@ -31,7 +31,7 @@ object FirConstructorCallChecker : FirFunctionCallChecker() {
}
if (declarationClass.classKind == ClassKind.ANNOTATION_CLASS &&
context.qualifiedAccessOrAnnotationCalls.all { call ->
call !is FirAnnotationCall
call !is FirAnnotation
} &&
context.containingDeclarations.all { klass ->
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) {
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 reference = resolvable.calleeReference as? FirResolvedNamedReference ?: return
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() {
override fun check(expression: FirCall, context: CheckerContext, reporter: DiagnosticReporter) {
if (expression !is FirFunctionCall && expression !is FirAnnotationCall && expression !is FirDelegatedConstructorCall) return
val isAnnotation = expression is FirAnnotationCall
if (expression !is FirFunctionCall && expression !is FirAnnotation && expression !is FirDelegatedConstructorCall) return
val isAnnotation = expression is FirAnnotation
val errorFactory =
if (isAnnotation) FirErrors.ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_ANNOTATION
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
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 classId = lookupTag.classId
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.declarations.FirResolvePhase
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.FirQualifiedAccess
import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
@@ -251,7 +251,7 @@ object UnusedChecker : FirControlFlowChecker() {
private fun visitAnnotation(
dataForNode: PathAwareVariableStatusInfo,
annotation: FirAnnotationCall,
annotation: FirAnnotation,
): PathAwareVariableStatusInfo {
val qualifiedAccesses = annotation.argumentList.arguments.mapNotNull { it as? FirQualifiedAccess }.toTypedArray()
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.declarations.FirResolvePhase
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.symbols.SymbolInternals
import org.jetbrains.kotlin.fir.symbols.ensureResolved
@@ -33,7 +33,7 @@ object FirOptInUsageTypeRefChecker : FirTypeRefChecker() {
val symbol = coneType.lookupTag.toSymbol(context.session) ?: return
symbol.ensureResolved(FirResolvePhase.STATUS)
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 (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)
@@ -48,4 +48,4 @@ object FirOptInUsageTypeRefChecker : FirTypeRefChecker() {
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)
}
override fun visitAnnotationCall(annotationCall: FirAnnotationCall, data: Nothing?) {
visitWithQualifiedAccessOrAnnotationCall(annotationCall)
override fun visitAnnotation(annotation: FirAnnotation, data: Nothing?) {
visitWithQualifiedAccessOrAnnotationCall(annotation)
}
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.
when (it) {
is FirQualifiedAccess -> it.calleeReference == errorNamedReference
is FirAnnotationCall -> it.calleeReference == errorNamedReference
is FirAnnotation -> it.calleeReference == errorNamedReference
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)
}
override fun visitAnnotationCall(annotationCall: FirAnnotationCall, data: CheckerContext) {
checkers.allAnnotationCallCheckers.check(annotationCall, data, reporter)
override fun visitAnnotation(annotation: FirAnnotation, data: CheckerContext) {
checkers.allAnnotationCallCheckers.check(annotation, data, reporter)
}
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.diagnostics.ConeSimpleDiagnostic
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.FirExpression
import org.jetbrains.kotlin.fir.expressions.buildUnaryArgumentList
@@ -58,13 +58,13 @@ abstract class AbstractAnnotationDeserializer(
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()
val annotations = classProto.getExtension(protocol.classAnnotation).orEmpty()
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()
return aliasProto.annotationList.map { deserializeAnnotation(it, nameResolver) }
}
@@ -74,7 +74,7 @@ abstract class AbstractAnnotationDeserializer(
functionProto: ProtoBuf.Function,
nameResolver: NameResolver,
typeTable: TypeTable
): List<FirAnnotationCall> {
): List<FirAnnotation> {
if (!Flags.HAS_ANNOTATIONS.get(functionProto.flags)) return emptyList()
val annotations = functionProto.getExtension(protocol.functionAnnotation).orEmpty()
return annotations.map { deserializeAnnotation(it, nameResolver) }
@@ -86,7 +86,7 @@ abstract class AbstractAnnotationDeserializer(
containingClassProto: ProtoBuf.Class?,
nameResolver: NameResolver,
typeTable: TypeTable
): List<FirAnnotationCall> {
): List<FirAnnotation> {
if (!Flags.HAS_ANNOTATIONS.get(propertyProto.flags)) return emptyList()
val annotations = propertyProto.getExtension(protocol.propertyAnnotation).orEmpty()
return annotations.map { deserializeAnnotation(it, nameResolver, AnnotationUseSiteTarget.PROPERTY) }
@@ -97,7 +97,7 @@ abstract class AbstractAnnotationDeserializer(
propertyProto: ProtoBuf.Property,
nameResolver: NameResolver,
typeTable: TypeTable
): List<FirAnnotationCall> {
): List<FirAnnotation> {
return emptyList()
}
@@ -106,7 +106,7 @@ abstract class AbstractAnnotationDeserializer(
propertyProto: ProtoBuf.Property,
nameResolver: NameResolver,
typeTable: TypeTable
): List<FirAnnotationCall> {
): List<FirAnnotation> {
return emptyList()
}
@@ -116,7 +116,7 @@ abstract class AbstractAnnotationDeserializer(
nameResolver: NameResolver,
typeTable: TypeTable,
getterFlags: Int
): List<FirAnnotationCall> {
): List<FirAnnotation> {
if (!Flags.HAS_ANNOTATIONS.get(getterFlags)) return emptyList()
val annotations = propertyProto.getExtension(protocol.propertyGetterAnnotation).orEmpty()
return annotations.map { deserializeAnnotation(it, nameResolver, AnnotationUseSiteTarget.PROPERTY_GETTER) }
@@ -128,7 +128,7 @@ abstract class AbstractAnnotationDeserializer(
nameResolver: NameResolver,
typeTable: TypeTable,
setterFlags: Int
): List<FirAnnotationCall> {
): List<FirAnnotation> {
if (!Flags.HAS_ANNOTATIONS.get(setterFlags)) return emptyList()
val annotations = propertyProto.getExtension(protocol.propertySetterAnnotation).orEmpty()
return annotations.map { deserializeAnnotation(it, nameResolver, AnnotationUseSiteTarget.PROPERTY_SETTER) }
@@ -139,7 +139,7 @@ abstract class AbstractAnnotationDeserializer(
constructorProto: ProtoBuf.Constructor,
nameResolver: NameResolver,
typeTable: TypeTable
): List<FirAnnotationCall> {
): List<FirAnnotation> {
if (!Flags.HAS_ANNOTATIONS.get(constructorProto.flags)) return emptyList()
val annotations = constructorProto.getExtension(protocol.constructorAnnotation).orEmpty()
return annotations.map { deserializeAnnotation(it, nameResolver) }
@@ -154,7 +154,7 @@ abstract class AbstractAnnotationDeserializer(
typeTable: TypeTable,
kind: CallableKind,
parameterIndex: Int
): List<FirAnnotationCall> {
): List<FirAnnotation> {
if (!Flags.HAS_ANNOTATIONS.get(valueParameterProto.flags)) return emptyList()
val annotations = valueParameterProto.getExtension(protocol.parameterAnnotation).orEmpty()
return annotations.map { deserializeAnnotation(it, nameResolver) }
@@ -166,17 +166,17 @@ abstract class AbstractAnnotationDeserializer(
nameResolver: NameResolver,
typeTable: TypeTable,
kind: CallableKind
): List<FirAnnotationCall> {
): List<FirAnnotation> {
return emptyList()
}
abstract fun loadTypeAnnotations(typeProto: ProtoBuf.Type, nameResolver: NameResolver): List<FirAnnotationCall>
abstract fun loadTypeAnnotations(typeProto: ProtoBuf.Type, nameResolver: NameResolver): List<FirAnnotation>
fun deserializeAnnotation(
proto: ProtoBuf.Annotation,
nameResolver: NameResolver,
useSiteTarget: AnnotationUseSiteTarget? = null
): FirAnnotationCall {
): FirAnnotation {
val classId = nameResolver.getClassId(proto.id)
var arguments = emptyList<FirExpression>()
@@ -208,7 +208,7 @@ abstract class AbstractAnnotationDeserializer(
}
}
return buildAnnotationCall {
return buildAnnotation {
annotationTypeRef = buildResolvedTypeRef {
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.moduleName
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.CLONEABLE_CLASS_ID
import org.jetbrains.kotlin.fir.scopes.FirScopeProvider
@@ -212,7 +212,7 @@ fun deserializeClassToSymbol(
}
it.setSealedClassInheritors(inheritors)
}
(it.annotations as MutableList<FirAnnotationCall>) +=
(it.annotations as MutableList<FirAnnotation>) +=
context.annotationDeserializer.loadClassAnnotations(classProto, context.nameResolver)
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
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.deserialization.Flags
import org.jetbrains.kotlin.metadata.deserialization.NameResolver
@@ -15,7 +15,7 @@ class FirBuiltinAnnotationDeserializer(
session: FirSession
) : 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()
val annotations = typeProto.getExtension(protocol.typeAnnotation).orEmpty()
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.FirResolvedDeclarationStatusImpl
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.builder.buildExpressionStub
import org.jetbrains.kotlin.fir.resolve.defaultType
@@ -261,7 +261,7 @@ class FirMemberDeserializer(private val c: FirDeserializationContext) {
effectiveVisibility
)
}.apply {
(annotations as MutableList<FirAnnotationCall>) +=
(annotations as MutableList<FirAnnotation>) +=
c.annotationDeserializer.loadPropertyGetterAnnotations(
c.containerSource, proto, local.nameResolver, local.typeTable, getterFlags
)
@@ -317,7 +317,7 @@ class FirMemberDeserializer(private val c: FirDeserializationContext) {
effectiveVisibility
)
}.apply {
(annotations as MutableList<FirAnnotationCall>) +=
(annotations as MutableList<FirAnnotation>) +=
c.annotationDeserializer.loadPropertySetterAnnotations(
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
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
?: 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.deserialization.CONTINUATION_INTERFACE_CLASS_ID
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.FirExpression
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.resolve.*
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 {
val useSiteTarget = it.useSiteTarget
useSiteTarget == AnnotationUseSiteTarget.PROPERTY_GETTER && isGetter ||
@@ -529,7 +529,7 @@ class FirElementSerializer private constructor(
private fun valueParameterProto(
parameter: FirValueParameter,
additionalAnnotations: List<FirAnnotationCall> = emptyList()
additionalAnnotations: List<FirAnnotation> = emptyList()
): ProtoBuf.ValueParameter.Builder {
val builder = ProtoBuf.ValueParameter.newBuilder()
@@ -708,13 +708,13 @@ class FirElementSerializer private constructor(
}
private fun serializeAnnotationFromAttribute(
existingAnnotations: List<FirAnnotationCall>?,
existingAnnotations: List<FirAnnotation>?,
classId: ClassId,
builder: ProtoBuf.Type.Builder
) {
if (existingAnnotations?.any { it.annotationTypeRef.coneTypeSafe<ConeClassLikeType>()?.classId == classId } != true) {
extension.serializeTypeAnnotation(
buildAnnotationCall {
buildAnnotation {
calleeReference = FirReferencePlaceholderForResolvedAnnotations
annotationTypeRef = buildResolvedTypeRef {
this.type = CompilerConeAttributes.ExtensionFunctionType.ANNOTATION_CLASS_ID.constructClassLikeType(
@@ -834,7 +834,7 @@ class FirElementSerializer private constructor(
private fun MutableVersionRequirementTable.serializeVersionRequirements(container: FirAnnotationContainer): List<Int> =
serializeVersionRequirements(container.annotations)
private fun MutableVersionRequirementTable.serializeVersionRequirements(annotations: List<FirAnnotationCall>): List<Int> =
private fun MutableVersionRequirementTable.serializeVersionRequirements(annotations: List<FirAnnotation>): List<Int> =
annotations
.filter {
it.toAnnotationClassId()?.asSingleFqName() == RequireKotlinConstants.FQ_NAME
@@ -849,7 +849,7 @@ class FirElementSerializer private constructor(
private fun MutableVersionRequirementTable.writeVersionRequirementDependingOnCoroutinesVersion(): Int =
writeVersionRequirement(LanguageFeature.ReleaseCoroutines)
private fun serializeVersionRequirementFromRequireKotlin(annotation: FirAnnotationCall): ProtoBuf.VersionRequirement.Builder? {
private fun serializeVersionRequirementFromRequireKotlin(annotation: FirAnnotation): ProtoBuf.VersionRequirement.Builder? {
val args = annotation.argumentList
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.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.ConeKotlinErrorType
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 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) {
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.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.symbolProvider
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 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)
}
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) })
}
override fun visitAnnotationCall(
annotationCall: FirAnnotationCall,
override fun visitAnnotation(
annotation: FirAnnotation,
data: Nothing?
): ConstantValue<*> {
return AnnotationValue(annotationCall)
return AnnotationValue(annotation)
}
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.declarations.*
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.resolve.firProvider
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))
}
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.isJava
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.FirQualifiedAccess
import org.jetbrains.kotlin.fir.references.FirErrorNamedReference
@@ -126,7 +126,7 @@ fun FirClassifierSymbol<*>.toSymbol(
session: FirSession,
classifierStorage: Fir2IrClassifierStorage,
typeContext: ConversionTypeContext = ConversionTypeContext.DEFAULT,
handleAnnotations: ((List<FirAnnotationCall>) -> Unit)? = null
handleAnnotations: ((List<FirAnnotation>) -> Unit)? = null
): IrClassifierSymbol {
return when (this) {
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()}")
}
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
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
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.languageVersionSettings
import org.jetbrains.kotlin.fir.resolve.fullyExpandedType
@@ -94,7 +94,7 @@ class Fir2IrTypeConverter(
fun ConeKotlinType.toIrType(
typeContext: ConversionTypeContext = ConversionTypeContext.DEFAULT,
annotations: List<FirAnnotationCall> = emptyList(),
annotations: List<FirAnnotation> = emptyList(),
hasFlexibleNullability: Boolean = false
): IrType {
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
}
override fun visitAnnotationCall(annotationCall: FirAnnotationCall, data: Any?): IrElement {
return callGenerator.convertToIrConstructorCall(annotationCall)
override fun visitAnnotation(annotation: FirAnnotation, data: Any?): IrElement {
return callGenerator.convertToIrConstructorCall(annotation)
}
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.FirValueParameter
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.expressions.IrConstructorCall
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 {
fun List<FirAnnotationCall>.toIrAnnotations(): List<IrConstructorCall> =
fun List<FirAnnotation>.toIrAnnotations(): List<IrConstructorCall> =
mapNotNull {
callGenerator.convertToIrConstructorCall(it) as? IrConstructorCall
}
@@ -36,7 +36,7 @@ class AnnotationGenerator(private val components: Fir2IrComponents) : Fir2IrComp
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)
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 {
val coneType = annotationCall.annotationTypeRef.coneTypeSafe<ConeLookupTagBasedType>()
fun convertToIrConstructorCall(annotation: FirAnnotation): IrExpression {
val coneType = annotation.annotationTypeRef.coneTypeSafe<ConeLookupTagBasedType>()
val type = coneType?.toIrType()
val symbol = type?.classifierOrNull
return annotationCall.convertWithOffsets { startOffset, endOffset ->
return annotation.convertWithOffsets { startOffset, endOffset ->
when (symbol) {
is IrClassSymbol -> {
val irClass = symbol.owner
val irConstructor = (annotationCall.toResolvedCallableSymbol() as? FirConstructorSymbol)?.let {
val irConstructor = (annotation.toResolvedCallableSymbol() as? FirConstructorSymbol)?.let {
this.declarationStorage.getIrConstructorSymbol(it)
} ?: run {
// Fallback for FirReferencePlaceholderForResolvedAnnotations from jar
@@ -419,11 +419,11 @@ class CallAndReferenceGenerator(
startOffset,
endOffset,
type ?: createErrorType(),
"Unresolved reference: ${annotationCall.render()}"
"Unresolved reference: ${annotation.render()}"
)
}
}
}.applyCallArguments(annotationCall, annotationMode = true)
}.applyCallArguments(annotation, annotationMode = true)
}
internal fun convertToGetObject(qualifier: FirResolvedQualifier): IrExpression {
@@ -487,11 +487,11 @@ class CallAndReferenceGenerator(
val calleeReference = when (call) {
is FirFunctionCall -> call.calleeReference
is FirDelegatedConstructorCall -> call.calleeReference
is FirAnnotationCall -> call.calleeReference
is FirAnnotation -> call.calleeReference
else -> null
}
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
firClass?.declarations?.filterIsInstance<FirConstructor>()?.firstOrNull()
} 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(
session: FirSession, javaTypeParameterStack: JavaTypeParameterStack
): List<FirAnnotationCall> = map { it.toFirAnnotationCall(session, javaTypeParameterStack) }
): List<FirAnnotation> = map { it.toFirAnnotationCall(session, javaTypeParameterStack) }
internal fun JavaAnnotationOwner.convertAnnotationsToFir(
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,
javaAnnotationOwner: JavaAnnotationOwner,
javaTypeParameterStack: JavaTypeParameterStack
@@ -165,8 +165,8 @@ internal fun MutableList<FirAnnotationCall>.addFromJava(
private fun JavaAnnotation.toFirAnnotationCall(
session: FirSession, javaTypeParameterStack: JavaTypeParameterStack
): FirAnnotationCall {
return buildAnnotationCall {
): FirAnnotation {
return buildAnnotation {
val lookupTag = when (classId) {
JAVA_TARGET_CLASS_ID -> ClassId.topLevel(StandardNames.FqNames.target)
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.declarations.*
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.references.FirControlFlowGraphReference
import org.jetbrains.kotlin.fir.scopes.FirScopeProvider
@@ -36,7 +36,7 @@ class FirJavaClass @FirImplementationDetail internal constructor(
@Volatile
override var resolvePhase: FirResolvePhase,
override val name: Name,
override val annotations: MutableList<FirAnnotationCall>,
override val annotations: MutableList<FirAnnotation>,
override var status: FirDeclarationStatus,
override val classKind: ClassKind,
override val declarations: MutableList<FirDeclaration>,
@@ -139,7 +139,7 @@ internal class FirJavaClassBuilder : FirRegularClassBuilder(), FirAnnotationCont
override var source: FirSourceElement? = null
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 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.declarations.*
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.FirDelegatedConstructorCall
import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference
@@ -35,7 +35,7 @@ class FirJavaConstructor @FirImplementationDetail constructor(
override var returnTypeRef: FirTypeRef,
override val valueParameters: MutableList<FirValueParameter>,
override val typeParameters: MutableList<FirTypeParameterRef>,
annotationBuilder: () -> List<FirAnnotationCall>,
annotationBuilder: () -> List<FirAnnotation>,
override var status: FirDeclarationStatus,
@Volatile
override var resolvePhase: FirResolvePhase,
@@ -61,7 +61,7 @@ class FirJavaConstructor @FirImplementationDetail constructor(
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 {
@@ -150,7 +150,7 @@ class FirJavaConstructorBuilder : FirConstructorBuilder() {
lateinit var visibility: Visibility
var isInner: Boolean by Delegates.notNull()
var isPrimary: Boolean by Delegates.notNull()
lateinit var annotationBuilder: () -> List<FirAnnotationCall>
lateinit var annotationBuilder: () -> List<FirAnnotation>
@OptIn(FirImplementationDetail::class)
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.declarations.*
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.languageVersionSettings
import org.jetbrains.kotlin.fir.symbols.impl.FirFieldSymbol
@@ -41,7 +41,7 @@ class FirJavaField @FirImplementationDetail constructor(
override var returnTypeRef: FirTypeRef,
override var status: FirDeclarationStatus,
override val isVar: Boolean,
annotationBuilder: () -> List<FirAnnotationCall>,
annotationBuilder: () -> List<FirAnnotation>,
override val typeParameters: MutableList<FirTypeParameterRef>,
override var initializer: FirExpression?,
override val dispatchReceiverType: ConeKotlinType?,
@@ -60,7 +60,7 @@ class FirJavaField @FirImplementationDetail constructor(
override val origin: FirDeclarationOrigin
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 {
annotations.getDeprecationInfosFromAnnotations(moduleData.session.languageVersionSettings.apiVersion, fromJava = true)
@@ -160,7 +160,7 @@ internal class FirJavaFieldBuilder : FirFieldBuilder() {
var modality: Modality? = null
lateinit var visibility: Visibility
var isStatic: Boolean by Delegates.notNull()
lateinit var annotationBuilder: () -> List<FirAnnotationCall>
lateinit var annotationBuilder: () -> List<FirAnnotation>
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.builder.FirFunctionBuilder
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.references.FirControlFlowGraphReference
import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
@@ -59,7 +59,7 @@ class FirJavaMethod @FirImplementationDetail constructor(
override val name: Name,
override var status: FirDeclarationStatus,
override val symbol: FirNamedFunctionSymbol,
annotationBuilder: () -> List<FirAnnotationCall>,
annotationBuilder: () -> List<FirAnnotation>,
override val dispatchReceiverType: ConeKotlinType?,
) : FirSimpleFunction() {
init {
@@ -83,7 +83,7 @@ class FirJavaMethod @FirImplementationDetail constructor(
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
override var deprecation: DeprecationsPerUseSite? = null
@@ -196,11 +196,11 @@ class FirJavaMethodBuilder : FirFunctionBuilder, FirTypeParametersOwnerBuilder,
override var dispatchReceiverType: ConeKotlinType? = null
lateinit var name: Name
lateinit var symbol: FirNamedFunctionSymbol
override val annotations: MutableList<FirAnnotationCall> = mutableListOf()
override val annotations: MutableList<FirAnnotation> = mutableListOf()
override val typeParameters: MutableList<FirTypeParameter> = mutableListOf()
var isStatic: Boolean by Delegates.notNull()
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)
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.declarations.*
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.references.FirControlFlowGraphReference
import org.jetbrains.kotlin.fir.symbols.impl.FirValueParameterSymbol
@@ -36,7 +36,7 @@ class FirJavaValueParameter @FirImplementationDetail constructor(
override var returnTypeRef: FirTypeRef,
override val name: Name,
override val symbol: FirValueParameterSymbol,
annotationBuilder: () -> List<FirAnnotationCall>,
annotationBuilder: () -> List<FirAnnotation>,
override var defaultValue: FirExpression?,
override val isVararg: Boolean,
) : FirValueParameter() {
@@ -56,7 +56,7 @@ class FirJavaValueParameter @FirImplementationDetail constructor(
override val isVar: Boolean
get() = false
override val annotations: List<FirAnnotationCall> by lazy { annotationBuilder() }
override val annotations: List<FirAnnotation> by lazy { annotationBuilder() }
override val origin: FirDeclarationOrigin
get() = FirDeclarationOrigin.Java
@@ -190,7 +190,7 @@ class FirJavaValueParameterBuilder {
var attributes: FirDeclarationAttributes = FirDeclarationAttributes()
lateinit var returnTypeRef: FirTypeRef
lateinit var name: Name
lateinit var annotationBuilder: () -> List<FirAnnotationCall>
lateinit var annotationBuilder: () -> List<FirAnnotation>
var defaultValue: FirExpression? = null
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) {
private fun loadAnnotation(
annotationClassId: ClassId, result: MutableList<FirAnnotationCall>,
annotationClassId: ClassId, result: MutableList<FirAnnotation>,
): KotlinJvmBinaryClass.AnnotationArgumentVisitor {
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? {
val list = mutableListOf<FirAnnotationCall>()
val list = mutableListOf<FirAnnotation>()
val visitor = loadAnnotation(classId, list)
return object : KotlinJvmBinaryClass.AnnotationArgumentVisitor by visitor {
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 {
val list = mutableListOf<FirAnnotationCall>()
val list = mutableListOf<FirAnnotation>()
val visitor = loadAnnotation(classId, list)
return object : KotlinJvmBinaryClass.AnnotationArgumentVisitor by visitor {
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.
if (isRepeatableWithImplicitContainer(lookupTag, argumentMap)) return
result += buildAnnotationCall {
result += buildAnnotation {
annotationTypeRef = lookupTag.toDefaultResolvedTypeRef()
argumentList = buildArgumentList {
for ((name, expression) in argumentMap) {
@@ -185,7 +185,7 @@ internal class AnnotationsLoader(private val session: FirSession, private val ko
}
internal fun loadAnnotationIfNotSpecial(
annotationClassId: ClassId, result: MutableList<FirAnnotationCall>,
annotationClassId: ClassId, result: MutableList<FirAnnotation>,
): KotlinJvmBinaryClass.AnnotationArgumentVisitor? {
if (annotationClassId in SpecialJvmAnnotations.SPECIAL_ANNOTATIONS) return null
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.fir.FirSession
import org.jetbrains.kotlin.fir.deserialization.AbstractAnnotationDeserializer
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
import org.jetbrains.kotlin.fir.expressions.builder.buildAnnotationCall
import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.expressions.builder.buildAnnotation
import org.jetbrains.kotlin.load.java.JvmAbi
import org.jetbrains.kotlin.load.kotlin.KotlinClassFinder
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()
return annotations.map { deserializeAnnotation(it, nameResolver) }
}
@@ -59,7 +59,7 @@ class JvmBinaryAnnotationDeserializer(
constructorProto: ProtoBuf.Constructor,
nameResolver: NameResolver,
typeTable: TypeTable
): List<FirAnnotationCall> {
): List<FirAnnotation> {
val signature = getCallableSignature(constructorProto, nameResolver, typeTable) ?: return emptyList()
return findJvmBinaryClassAndLoadMemberAnnotations(signature)
}
@@ -69,7 +69,7 @@ class JvmBinaryAnnotationDeserializer(
functionProto: ProtoBuf.Function,
nameResolver: NameResolver,
typeTable: TypeTable
): List<FirAnnotationCall> {
): List<FirAnnotation> {
val signature = getCallableSignature(functionProto, nameResolver, typeTable) ?: return emptyList()
return findJvmBinaryClassAndLoadMemberAnnotations(signature)
}
@@ -80,7 +80,7 @@ class JvmBinaryAnnotationDeserializer(
containingClassProto: ProtoBuf.Class?,
nameResolver: NameResolver,
typeTable: TypeTable
): List<FirAnnotationCall> {
): List<FirAnnotation> {
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 jvmClassFlags = runIf(containingClassProto?.hasExtension(JvmProtoBuf.jvmClassFlags) == true) {
@@ -91,7 +91,7 @@ class JvmBinaryAnnotationDeserializer(
signature,
searchInDefaultImpls = classIsInterface && allCompatibilityModeIsEnabled
).map {
buildAnnotationCall {
buildAnnotation {
annotationTypeRef = it.annotationTypeRef
argumentList = it.argumentList
useSiteTarget = AnnotationUseSiteTarget.PROPERTY
@@ -108,13 +108,13 @@ class JvmBinaryAnnotationDeserializer(
propertyProto: ProtoBuf.Property,
nameResolver: NameResolver,
typeTable: TypeTable
): List<FirAnnotationCall> {
): List<FirAnnotation> {
val signature = getPropertySignature(propertyProto, nameResolver, typeTable, field = true) ?: return emptyList()
if (signature.isDelegated) {
return emptyList()
}
return findJvmBinaryClassAndLoadMemberAnnotations(signature).map {
buildAnnotationCall {
buildAnnotation {
annotationTypeRef = it.annotationTypeRef
argumentList = it.argumentList
useSiteTarget = AnnotationUseSiteTarget.FIELD
@@ -128,13 +128,13 @@ class JvmBinaryAnnotationDeserializer(
propertyProto: ProtoBuf.Property,
nameResolver: NameResolver,
typeTable: TypeTable
): List<FirAnnotationCall> {
): List<FirAnnotation> {
val signature = getPropertySignature(propertyProto, nameResolver, typeTable, field = true) ?: return emptyList()
if (!signature.isDelegated) {
return emptyList()
}
return findJvmBinaryClassAndLoadMemberAnnotations(signature).map {
buildAnnotationCall {
buildAnnotation {
annotationTypeRef = it.annotationTypeRef
argumentList = it.argumentList
useSiteTarget = AnnotationUseSiteTarget.PROPERTY_DELEGATE_FIELD
@@ -149,7 +149,7 @@ class JvmBinaryAnnotationDeserializer(
nameResolver: NameResolver,
typeTable: TypeTable,
getterFlags: Int
): List<FirAnnotationCall> {
): List<FirAnnotation> {
val signature = getCallableSignature(propertyProto, nameResolver, typeTable, CallableKind.PROPERTY_GETTER) ?: return emptyList()
return findJvmBinaryClassAndLoadMemberAnnotations(signature)
}
@@ -160,7 +160,7 @@ class JvmBinaryAnnotationDeserializer(
nameResolver: NameResolver,
typeTable: TypeTable,
setterFlags: Int
): List<FirAnnotationCall> {
): List<FirAnnotation> {
val signature = getCallableSignature(propertyProto, nameResolver, typeTable, CallableKind.PROPERTY_SETTER) ?: return emptyList()
return findJvmBinaryClassAndLoadMemberAnnotations(signature)
}
@@ -174,7 +174,7 @@ class JvmBinaryAnnotationDeserializer(
typeTable: TypeTable,
kind: CallableKind,
parameterIndex: Int,
): List<FirAnnotationCall> {
): List<FirAnnotation> {
val methodSignature = getCallableSignature(callableProto, nameResolver, typeTable, kind) ?: return emptyList()
val index = parameterIndex + computeJvmParameterIndexShift(classProto, callableProto)
val paramSignature = MemberSignature.fromMethodSignatureAndParameterIndex(methodSignature, index)
@@ -187,7 +187,7 @@ class JvmBinaryAnnotationDeserializer(
nameResolver: NameResolver,
typeTable: TypeTable,
kind: CallableKind
): List<FirAnnotationCall> {
): List<FirAnnotation> {
val methodSignature = getCallableSignature(callableProto, nameResolver, typeTable, kind) ?: return emptyList()
val paramSignature = MemberSignature.fromMethodSignatureAndParameterIndex(methodSignature, 0)
return findJvmBinaryClassAndLoadMemberAnnotations(paramSignature)
@@ -274,7 +274,7 @@ class JvmBinaryAnnotationDeserializer(
private fun findJvmBinaryClassAndLoadMemberAnnotations(
memberSignature: MemberSignature, searchInDefaultImpls: Boolean = false
): List<FirAnnotationCall> {
): List<FirAnnotation> {
val info = if (searchInDefaultImpls) {
annotationInfoForDefaultImpls ?: return emptyList()
} else {
@@ -285,7 +285,7 @@ class JvmBinaryAnnotationDeserializer(
}
// 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?
private fun FirSession.loadMemberAnnotations(
@@ -293,7 +293,7 @@ private fun FirSession.loadMemberAnnotations(
byteContent: ByteArray?,
kotlinClassFinder: KotlinClassFinder,
): MemberAnnotations {
val memberAnnotations = hashMapOf<MemberSignature, MutableList<FirAnnotationCall>>()
val memberAnnotations = hashMapOf<MemberSignature, MutableList<FirAnnotation>>()
val annotationsLoader = AnnotationsLoader(this, kotlinClassFinder)
kotlinBinaryClass.visitMembers(object : KotlinJvmBinaryClass.MemberVisitor {
@@ -328,7 +328,7 @@ private fun FirSession.loadMemberAnnotations(
}
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? {
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.declarations.getDeprecationInfos
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.topLevelName
import org.jetbrains.kotlin.fir.languageVersionSettings
@@ -125,7 +125,7 @@ open class KotlinDeserializedJvmSymbolsProvider(
kotlinClass: KotlinClassFinder.Result.KotlinClass,
symbol: FirRegularClassSymbol
) {
val annotations = mutableListOf<FirAnnotationCall>()
val annotations = mutableListOf<FirAnnotation>()
kotlinClass.kotlinJvmBinaryClass.loadClassAnnotations(
object : KotlinJvmBinaryClass.AnnotationVisitor {
override fun visitAnnotation(classId: ClassId, source: SourceElement): KotlinJvmBinaryClass.AnnotationArgumentVisitor? {
@@ -137,7 +137,7 @@ open class KotlinDeserializedJvmSymbolsProvider(
},
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))
}
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,
javaTypeEnhancementState: JavaTypeEnhancementState,
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()
override val FirAnnotationCall.key: Any
override val FirAnnotation.key: Any
get() = coneClassLikeType!!.lookupTag
override val FirAnnotationCall.fqName: FqName?
override val FirAnnotation.fqName: FqName?
get() = coneClassLikeType?.lookupTag?.classId?.asSingleFqName()
override fun FirAnnotationCall.enumArguments(onlyValue: Boolean): Iterable<String> =
override fun FirAnnotation.enumArguments(onlyValue: Boolean): Iterable<String> =
arguments.flatMap { argument ->
if (!onlyValue || argument !is FirNamedArgumentExpression || argument.name == DEFAULT_ANNOTATION_MEMBER_NAME)
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.modality
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.JavaTypeParameterStack
import org.jetbrains.kotlin.fir.java.declarations.*
@@ -504,14 +504,14 @@ private class EnhancementSignatureParts(
override val forceOnlyHeadTypeConstructor: Boolean,
override val containerApplicabilityType: AnnotationQualifierApplicabilityType,
override val containerDefaultTypeQualifiers: JavaTypeQualifiersByElementType?
) : AbstractSignatureParts<FirAnnotationCall>() {
) : AbstractSignatureParts<FirAnnotation>() {
override val enableImprovementsInStrictMode: Boolean
get() = true
override val skipRawTypeArguments: Boolean
get() = false
override val containerAnnotations: Iterable<FirAnnotationCall>
override val containerAnnotations: Iterable<FirAnnotation>
get() = typeContainer?.annotations ?: emptyList()
override val containerIsVarargParameter: Boolean
@@ -520,10 +520,10 @@ private class EnhancementSignatureParts(
override val typeSystem: TypeSystemContext
get() = session.typeContext
override val FirAnnotationCall.forceWarning: Boolean
override val FirAnnotation.forceWarning: Boolean
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
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.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.FirTypeProjection
import org.jetbrains.kotlin.fir.types.FirUserTypeRef
@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.load.java.structure.JavaType
class FirJavaTypeRef(
val type: JavaType,
annotationBuilder: () -> List<FirAnnotationCall>,
annotationBuilder: () -> List<FirAnnotation>,
override val qualifier: MutableList<FirQualifierPart>
) : FirUserTypeRef() {
override val customRenderer: Boolean
@@ -33,7 +33,7 @@ class FirJavaTypeRef(
override val source: FirSourceElement?
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) {
for (part in qualifier) {
@@ -60,7 +60,7 @@ class FirJavaTypeRef(
@FirBuilderDsl
class FirJavaTypeRefBuilder {
lateinit var annotationBuilder: () -> List<FirAnnotationCall>
lateinit var annotationBuilder: () -> List<FirAnnotation>
lateinit var type: JavaType
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()
}
val fileAnnotationList = mutableListOf<FirAnnotationCall>()
val fileAnnotationList = mutableListOf<FirAnnotation>()
val importList = mutableListOf<FirImport>()
val firDeclarationList = mutableListOf<FirDeclaration>()
context.packageFqName = FqName.ROOT
@@ -287,7 +287,7 @@ class DeclarationsConverter(
/**
* [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 ->
when (node.tokenType) {
ANNOTATION -> container += convertAnnotation(node)
@@ -299,7 +299,7 @@ class DeclarationsConverter(
/**
* @see org.jetbrains.kotlin.parsing.KotlinParsing.parseAnnotationOrList
*/
fun convertAnnotation(annotationNode: LighterASTNode): List<FirAnnotationCall> {
fun convertAnnotation(annotationNode: LighterASTNode): List<FirAnnotation> {
var annotationTarget: AnnotationUseSiteTarget? = null
return annotationNode.forEachChildrenReturnList { node, container ->
when (node.tokenType) {
@@ -338,7 +338,7 @@ class DeclarationsConverter(
fun convertAnnotationEntry(
unescapedAnnotation: LighterASTNode,
defaultAnnotationUseSiteTarget: AnnotationUseSiteTarget? = null
): FirAnnotationCall {
): FirAnnotation {
var annotationUseSiteTarget: AnnotationUseSiteTarget? = null
lateinit var constructorCalleePair: Pair<FirTypeRef, List<FirExpression>>
unescapedAnnotation.forEachChildren {
@@ -348,7 +348,7 @@ class DeclarationsConverter(
}
}
val name = (constructorCalleePair.first as? FirUserTypeRef)?.qualifier?.last()?.name ?: Name.special("<no-annotation-name>")
return buildAnnotationCall {
return buildAnnotation {
source = unescapedAnnotation.toFirSourceElement()
useSiteTarget = annotationUseSiteTarget ?: defaultAnnotationUseSiteTarget
annotationTypeRef = constructorCalleePair.first
@@ -1775,7 +1775,7 @@ class DeclarationsConverter(
lateinit var identifier: String
lateinit var firType: FirTypeRef
lateinit var referenceExpression: LighterASTNode
val annotations = mutableListOf<FirAnnotationCall>()
val annotations = mutableListOf<FirAnnotation>()
typeConstraint.forEachChildren {
when (it.tokenType) {
//annotations will be saved later, on mapping stage with type parameters
@@ -1890,7 +1890,7 @@ class DeclarationsConverter(
}
for (modifierList in allTypeModifiers) {
(calculatedFirType.annotations as MutableList<FirAnnotationCall>) += modifierList.annotations
(calculatedFirType.annotations as MutableList<FirAnnotation>) += modifierList.annotations
}
return calculatedFirType
}
@@ -2116,7 +2116,7 @@ class DeclarationsConverter(
return ValueParameter(isVal, isVar, modifiers, firValueParameter, destructuringDeclaration)
}
private val extensionFunctionAnnotation = buildAnnotationCall {
private val extensionFunctionAnnotation = buildAnnotation {
annotationTypeRef = buildResolvedTypeRef {
type = ConeClassLikeTypeImpl(
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 {
var firExpression: FirElement? = null
val firAnnotationList = mutableListOf<FirAnnotationCall>()
val firAnnotationList = mutableListOf<FirAnnotation>()
annotatedExpression.forEachChildren {
when (it.tokenType) {
ANNOTATION -> firAnnotationList += declarationsConverter.convertAnnotation(it)
@@ -432,7 +432,7 @@ class ExpressionsConverter(
val result = firExpression ?: buildErrorExpression(null, ConeNotAnnotationContainer(firExpression?.render() ?: "???"))
require(result is FirAnnotationContainer)
(result.annotations as MutableList<FirAnnotationCall>) += firAnnotationList
(result.annotations as MutableList<FirAnnotation>) += firAnnotationList
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
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
class TypeConstraint(
val annotations: List<FirAnnotationCall>,
val annotations: List<FirAnnotation>,
val identifier: String,
val firTypeRef: FirTypeRef,
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.Visibilities
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.types.Variance
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) {
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)
}
private fun KtAnnotated.extractAnnotationsTo(container: MutableList<FirAnnotationCall>) {
private fun KtAnnotated.extractAnnotationsTo(container: MutableList<FirAnnotation>) {
for (annotationEntry in annotationEntries) {
container += annotationEntry.convert<FirAnnotationCall>()
container += annotationEntry.convert<FirAnnotation>()
}
}
@@ -864,7 +864,7 @@ open class RawFirBuilder(
source = file.packageDirective?.toFirPsiSourceElement()
}
for (annotationEntry in file.annotationEntries) {
annotations += annotationEntry.convert<FirAnnotationCall>()
annotations += annotationEntry.convert<FirAnnotation>()
}
for (importDirective in file.importDirectives) {
imports += buildImport {
@@ -1682,14 +1682,14 @@ open class RawFirBuilder(
for (modifierList in allModifierLists) {
for (annotationEntry in modifierList.annotationEntries) {
firTypeBuilder.annotations += annotationEntry.convert<FirAnnotationCall>()
firTypeBuilder.annotations += annotationEntry.convert<FirAnnotation>()
}
}
return firTypeBuilder.build()
}
override fun visitAnnotationEntry(annotationEntry: KtAnnotationEntry, data: Unit): FirElement {
return buildAnnotationCall {
return buildAnnotation {
source = annotationEntry.toFirSourceElement()
useSiteTarget = annotationEntry.useSiteTarget?.getAnnotationUseSiteTarget()
annotationTypeRef = annotationEntry.typeReference.toFirOrErrorType()
@@ -2354,7 +2354,7 @@ open class RawFirBuilder(
expression.toFirSourceElement(),
ConeNotAnnotationContainer(rawResult?.render() ?: "???")
)
expression.extractAnnotationsTo(result.annotations as MutableList<FirAnnotationCall>)
expression.extractAnnotationsTo(result.annotations as MutableList<FirAnnotation>)
return result
}
@@ -2418,7 +2418,7 @@ open class RawFirBuilder(
}
}
private val extensionFunctionAnnotation = buildAnnotationCall {
private val extensionFunctionAnnotation = buildAnnotation {
annotationTypeRef = buildResolvedTypeRef {
type = ConeClassLikeTypeImpl(
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.FirValueParameter
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.impl.FirNoReceiverExpression
import org.jetbrains.kotlin.fir.expressions.impl.FirStubStatement
@@ -183,7 +183,7 @@ abstract class AbstractRawFirBuilderTestCase : KtParsingTestCase(
private fun throwTwiceVisitingError(element: FirElement) {
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 FirStubReference || element.isExtensionFunctionAnnotation || element is FirEmptyArgumentList ||
element is FirStubStatement || element === FirResolvedDeclarationStatusImpl.DEFAULT_STATUS_FOR_STATUSLESS_DECLARATIONS
@@ -196,4 +196,4 @@ private fun throwTwiceVisitingError(element: FirElement) {
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
fun FirFunctionCall.copy(
annotations: List<FirAnnotationCall> = this.annotations,
annotations: List<FirAnnotation> = this.annotations,
argumentList: FirArgumentList = this.argumentList,
calleeReference: FirNamedReference = this.calleeReference,
explicitReceiver: FirExpression? = this.explicitReceiver,
@@ -85,7 +85,7 @@ fun FirAnonymousFunction.copy(
returnTypeRef: FirTypeRef = this.returnTypeRef,
valueParameters: List<FirValueParameter> = this.valueParameters,
body: FirBlock? = this.body,
annotations: List<FirAnnotationCall> = this.annotations,
annotations: List<FirAnnotation> = this.annotations,
typeRef: FirTypeRef = this.typeRef,
label: FirLabel? = this.label,
controlFlowGraphReference: FirControlFlowGraphReference? = this.controlFlowGraphReference,
@@ -137,7 +137,7 @@ fun FirTypeRef.errorTypeFromPrototype(
fun FirTypeParameter.copy(
bounds: List<FirTypeRef> = this.bounds,
annotations: List<FirAnnotationCall> = this.annotations
annotations: List<FirAnnotation> = this.annotations
): FirTypeParameter {
return buildTypeParameter {
source = this@copy.source
@@ -155,7 +155,7 @@ fun FirTypeParameter.copy(
fun FirWhenExpression.copy(
resultType: FirTypeRef = this.typeRef,
calleeReference: FirReference = this.calleeReference,
annotations: List<FirAnnotationCall> = this.annotations
annotations: List<FirAnnotation> = this.annotations
): FirWhenExpression = buildWhenExpression {
source = this@copy.source
subject = this@copy.subject
@@ -171,7 +171,7 @@ fun FirWhenExpression.copy(
fun FirTryExpression.copy(
resultType: FirTypeRef = this.typeRef,
calleeReference: FirReference = this.calleeReference,
annotations: List<FirAnnotationCall> = this.annotations
annotations: List<FirAnnotation> = this.annotations
): FirTryExpression = buildTryExpression {
source = this@copy.source
tryBlock = this@copy.tryBlock
@@ -185,7 +185,7 @@ fun FirTryExpression.copy(
fun FirCheckNotNullCall.copy(
resultType: FirTypeRef = this.typeRef,
calleeReference: FirReference = this.calleeReference,
annotations: List<FirAnnotationCall> = this.annotations
annotations: List<FirAnnotation> = this.annotations
): FirCheckNotNullCall = buildCheckNotNullCall {
source = this@copy.source
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? {
val reference = annotationCall.calleeReference as? FirSimpleNamedReference ?: return null
annotationCall.argumentList.transformArguments(transformer, ResolutionMode.ContextDependent)
fun resolveAnnotationCall(annotation: FirAnnotation): FirAnnotation? {
val reference = annotation.calleeReference as? FirSimpleNamedReference ?: return null
annotation.argumentList.transformArguments(transformer, ResolutionMode.ContextDependent)
val callInfo = CallInfo(
annotationCall,
annotation,
CallKind.Function,
name = reference.name,
explicitReceiver = null,
annotationCall.argumentList,
annotation.argumentList,
isPotentialQualifierPart = false,
isImplicitInvoke = false,
typeArguments = emptyList(),
@@ -507,7 +507,7 @@ class FirCallResolver(
components.containingDeclarations
)
val annotationClassSymbol = annotationCall.getCorrespondingClassSymbolOrNull(session)
val annotationClassSymbol = annotation.getCorrespondingClassSymbolOrNull(session)
val resolvedReference = if (annotationClassSymbol != null && annotationClassSymbol.fir.classKind == ClassKind.ANNOTATION_CLASS) {
val resolutionResult = createCandidateForAnnotationCall(annotationClassSymbol, callInfo)
?: ResolutionResult(callInfo, CandidateApplicability.HIDDEN, emptyList())
@@ -529,7 +529,7 @@ class FirCallResolver(
)
}
return annotationCall.transformCalleeReference(StoreNameReference, resolvedReference)
return annotation.transformCalleeReference(StoreNameReference, resolvedReference)
}
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 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
(annotationTypeRef.coneType as? ConeClassLikeType)?.lookupTag
fun FirAnnotationCall.toAnnotationClassId(): ClassId? =
fun FirAnnotation.toAnnotationClassId(): ClassId? =
toAnnotationLookupTag()?.classId
private fun FirAnnotationCall.toAnnotationClass(session: FirSession): FirRegularClass? =
private fun FirAnnotation.toAnnotationClass(session: FirSession): FirRegularClass? =
toAnnotationLookupTag()?.toSymbol(session)?.fir as? FirRegularClass
// TODO: this is temporary solution, we need something better
@@ -44,7 +44,7 @@ private val FirExpression.callableNameOfMetaAnnotationArgument: Name?
callableSymbol?.callableId?.callableName
}
fun FirAnnotationContainer.nonSourceAnnotations(session: FirSession): List<FirAnnotationCall> =
fun FirAnnotationContainer.nonSourceAnnotations(session: FirSession): List<FirAnnotation> =
annotations.filter { annotation ->
val firAnnotationClass = annotation.toAnnotationClass(session)
firAnnotationClass != null && firAnnotationClass.annotations.none { meta ->
@@ -56,10 +56,10 @@ fun FirAnnotationContainer.nonSourceAnnotations(session: FirSession): List<FirAn
inline val FirProperty.hasJvmFieldAnnotation: Boolean
get() = annotations.any { it.isJvmFieldAnnotation }
val FirAnnotationCall.isJvmFieldAnnotation: Boolean
val FirAnnotation.isJvmFieldAnnotation: Boolean
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
?.toAnnotationUseSiteTargets() ?: DEFAULT_USE_SITE_TARGETS
@@ -94,35 +94,35 @@ fun FirAnnotatedDeclaration.hasAnnotation(classId: ClassId): Boolean {
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)
}
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)
}
fun FirAnnotationContainer.getAnnotationByFqName(fqName: FqName): FirAnnotationCall? {
fun FirAnnotationContainer.getAnnotationByFqName(fqName: FqName): FirAnnotation? {
return annotations.find {
it.annotationTypeRef.coneTypeSafe<ConeClassLikeType>()?.lookupTag?.classId?.asSingleFqName() == fqName
}
}
fun FirAnnotationContainer.getAnnotationByClassId(classId: ClassId): FirAnnotationCall? {
fun FirAnnotationContainer.getAnnotationByClassId(classId: ClassId): FirAnnotation? {
return annotations.find {
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 {
it.annotationTypeRef.coneTypeSafe<ConeClassLikeType>()?.lookupTag?.classId?.asSingleFqName() == fqName
}
}
fun FirAnnotationCall.findArgumentByName(name: Name): FirExpression? {
fun FirAnnotation.findArgumentByName(name: Name): FirExpression? {
val argumentMapping = argumentMapping
if (argumentMapping != null) {
return argumentMapping.keys.find { argumentMapping[it]?.name == name }?.unwrapArgument()
@@ -138,7 +138,7 @@ fun FirAnnotationCall.findArgumentByName(name: Name): FirExpression? {
return arguments.singleOrNull()
}
fun FirAnnotationCall.getStringArgument(name: Name): String? =
fun FirAnnotation.getStringArgument(name: Name): String? =
findArgumentByName(name)?.let { expression ->
expression.safeAs<FirConstExpression<*>>()?.value as? String
}
@@ -151,4 +151,4 @@ fun FirAnnotationContainer.getJvmNameFromAnnotation(target: AnnotationUseSiteTar
return annotationCalls.firstNotNullOfOrNull { call ->
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
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.FirArgumentList
import org.jetbrains.kotlin.fir.expressions.impl.FirResolvedArgumentList
@@ -30,9 +30,9 @@ object FirGeneratedElementsValidator : FirDefaultVisitor<Unit, Any?>() {
element.acceptChildren(this, null)
}
override fun visitAnnotationCall(annotationCall: FirAnnotationCall, data: Any?) {
require(annotationCall.resolveStatus == FirAnnotationResolveStatus.Resolved)
annotationCall.acceptChildren(this, null)
override fun visitAnnotation(annotation: FirAnnotation, data: Any?) {
require(annotation.resolveStatus == FirAnnotationResolveStatus.Resolved)
annotation.acceptChildren(this, null)
}
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)
}
fun List<FirAnnotationCall>.getDeprecationInfosFromAnnotations(currentVersion: ApiVersion, fromJava: Boolean): DeprecationsPerUseSite {
fun List<FirAnnotation>.getDeprecationInfosFromAnnotations(currentVersion: ApiVersion, fromJava: Boolean): DeprecationsPerUseSite {
val deprecationByUseSite = extractDeprecationInfoPerUseSite(currentVersion, fromJava).toMap()
return DeprecationsPerUseSite.fromMap(deprecationByUseSite)
}
@@ -93,10 +93,10 @@ fun FirBasedSymbol<*>.getDeprecationForCallSite(
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) }
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
val arg = findArgumentByName(LEVEL_NAME) ?: arguments.lastOrNull()
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,
fromJava: Boolean
): 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 =
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
return symbol.classId.asSingleFqName()
}
@@ -419,7 +419,7 @@ private fun FirQualifiedAccess.expressionTypeOrUnitForAssignment(): ConeKotlinTy
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 {
if (it.isLocal) {
// 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.declarations.*
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.FirNamedArgumentExpression
import org.jetbrains.kotlin.fir.expressions.FirResolvedQualifier
@@ -365,7 +365,7 @@ class FirFakeArgumentForCallableReference(
override val typeRef: FirTypeRef
get() = error("should not be called")
override val annotations: List<FirAnnotationCall>
override val annotations: List<FirAnnotation>
get() = error("should not be called")
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 -----------------------------------
fun enterAnnotationCall(annotationCall: FirAnnotationCall) {
graphBuilder.enterAnnotationCall(annotationCall).mergeIncomingFlow()
fun enterAnnotationCall(annotation: FirAnnotation) {
graphBuilder.enterAnnotationCall(annotation).mergeIncomingFlow()
}
fun exitAnnotationCall(annotationCall: FirAnnotationCall) {
graphBuilder.exitAnnotationCall(annotationCall).mergeIncomingFlow()
fun exitAnnotationCall(annotation: FirAnnotation) {
graphBuilder.exitAnnotationCall(annotation).mergeIncomingFlow()
}
// ----------------------------------- 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 -----------------------------------
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 {
owner.enterNode = this
}
@@ -743,7 +743,7 @@ class AnnotationEnterNode(owner: ControlFlowGraph, override val fir: FirAnnotati
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 {
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 -----------------------------------
fun enterAnnotationCall(annotationCall: FirAnnotationCall): AnnotationEnterNode {
fun enterAnnotationCall(annotation: FirAnnotation): AnnotationEnterNode {
val graph = ControlFlowGraph(null, "STUB_GRAPH_FOR_ANNOTATION_CALL", ControlFlowGraph.Kind.AnnotationCall)
pushGraph(graph, Mode.Body)
return createAnnotationEnterNode(annotationCall).also {
return createAnnotationEnterNode(annotation).also {
lastNodes.push(it)
}
}
fun exitAnnotationCall(annotationCall: FirAnnotationCall): AnnotationExitNode {
val node = createAnnotationExitNode(annotationCall)
fun exitAnnotationCall(annotation: FirAnnotation): AnnotationExitNode {
val node = createAnnotationExitNode(annotation)
popAndAddEdge(node)
popGraph()
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 =
VariableAssignmentNode(currentGraph, fir, levelCounter, createId())
fun ControlFlowGraphBuilder.createAnnotationExitNode(fir: FirAnnotationCall): AnnotationExitNode =
fun ControlFlowGraphBuilder.createAnnotationExitNode(fir: FirAnnotation): AnnotationExitNode =
AnnotationExitNode(currentGraph, fir, levelCounter, createId())
fun ControlFlowGraphBuilder.createAnnotationEnterNode(fir: FirAnnotationCall): AnnotationEnterNode =
fun ControlFlowGraphBuilder.createAnnotationEnterNode(fir: FirAnnotation): AnnotationEnterNode =
AnnotationEnterNode(currentGraph, fir, levelCounter, createId())
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)
}
is FirAnnotationCall -> {
is FirAnnotation -> {
processCandidateIfApplicable(processor, processBlocks)
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
}
override fun transformAnnotationCall(
annotationCall: FirAnnotationCall,
override fun transformAnnotation(
annotation: FirAnnotation,
data: ExpectedArgumentType?
): FirStatement {
val calleeReference = annotationCall.calleeReference as? FirNamedReferenceWithCandidate
?: return annotationCall
annotationCall.transformCalleeReference(
val calleeReference = annotation.calleeReference as? FirNamedReferenceWithCandidate
?: return annotation
annotation.transformCalleeReference(
StoreCalleeReference,
calleeReference.toResolvedReference(),
)
val subCandidate = calleeReference.candidate
val expectedArgumentsTypeMapping = runIf(!calleeReference.isError) { subCandidate.createArgumentsMapping() }
withFirArrayOfCallTransformer {
annotationCall.argumentList.transformArguments(this, expectedArgumentsTypeMapping)
annotation.argumentList.transformArguments(this, expectedArgumentsTypeMapping)
var index = 0
subCandidate.argumentMapping = subCandidate.argumentMapping?.let {
LinkedHashMap<FirExpression, FirValueParameter>(it.size).let { newMapping ->
subCandidate.argumentMapping?.mapKeysTo(newMapping) { (_, _) ->
annotationCall.argumentList.arguments[index++]
annotation.argumentList.arguments[index++]
}
}
}
}
if (calleeReference.isError) {
subCandidate.argumentMapping?.let {
annotationCall.replaceArgumentList(buildArgumentListForErrorCall(annotationCall.argumentList, it))
annotation.replaceArgumentList(buildArgumentListForErrorCall(annotation.argumentList, it))
}
} else {
subCandidate.handleVarargs()
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() {
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.declarations.*
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.FirDelegatedConstructorCall
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.types.*
import org.jetbrains.kotlin.fir.types.builder.buildErrorTypeRef
import org.jetbrains.kotlin.fir.types.impl.FirImplicitBuiltinTypeRef
class FirTypeResolveProcessor(
session: FirSession,
@@ -204,8 +203,8 @@ open class FirTypeResolveTransformer(
return delegatedConstructorCall
}
override fun transformAnnotationCall(annotationCall: FirAnnotationCall, data: Any?): FirStatement {
annotationCall.transformAnnotationTypeRef(this, data)
return annotationCall
override fun transformAnnotation(annotation: FirAnnotation, data: Any?): FirStatement {
annotation.transformAnnotationTypeRef(this, data)
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].
*
* 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 {
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)
}
override fun transformAnnotationCall(annotationCall: FirAnnotationCall, data: ResolutionMode): FirStatement {
return expressionsTransformer.transformAnnotationCall(annotationCall, data)
override fun transformAnnotation(annotation: FirAnnotation, data: ResolutionMode): FirStatement {
return expressionsTransformer.transformAnnotation(annotation, data)
}
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
}
override fun transformAnnotationCall(annotationCall: FirAnnotationCall, data: ResolutionMode): FirStatement {
if (annotationCall.resolveStatus == FirAnnotationResolveStatus.Resolved) return annotationCall
return resolveAnnotationCall(annotationCall, FirAnnotationResolveStatus.Resolved)
override fun transformAnnotation(annotation: FirAnnotation, data: ResolutionMode): FirStatement {
if (annotation.resolveStatus == FirAnnotationResolveStatus.Resolved) return annotation
return resolveAnnotationCall(annotation, FirAnnotationResolveStatus.Resolved)
}
protected fun resolveAnnotationCall(
annotationCall: FirAnnotationCall,
annotation: FirAnnotation,
status: FirAnnotationResolveStatus
): FirAnnotationCall {
): FirAnnotation {
return withFirArrayOfCallTransformer {
annotationCall.transformAnnotationTypeRef(transformer, ResolutionMode.ContextIndependent)
if (status == FirAnnotationResolveStatus.PartiallyResolved) return annotationCall
dataFlowAnalyzer.enterAnnotationCall(annotationCall)
val result = callResolver.resolveAnnotationCall(annotationCall)
dataFlowAnalyzer.exitAnnotationCall(result ?: annotationCall)
if (result == null) return annotationCall
annotation.transformAnnotationTypeRef(transformer, ResolutionMode.ContextIndependent)
if (status == FirAnnotationResolveStatus.PartiallyResolved) return annotation
dataFlowAnalyzer.enterAnnotationCall(annotation)
val result = callResolver.resolveAnnotationCall(annotation)
dataFlowAnalyzer.exitAnnotationCall(result ?: annotation)
if (result == null) return annotation
callCompleter.completeCall(result, noExpectedType)
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 fun transformAnnotationCall(annotationCall: FirAnnotationCall, data: ResolutionMode): FirStatement {
return annotationCall
override fun transformAnnotation(annotation: FirAnnotation, data: ResolutionMode): FirStatement {
return annotation
}
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.FirSession
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.resolve.ScopeSession
import org.jetbrains.kotlin.fir.scopes.FirCompositeScope
@@ -22,7 +22,7 @@ internal abstract class FirAbstractAnnotationResolveTransformer<D, S>(
protected val session: FirSession,
protected val scopeSession: ScopeSession
) : 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
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
) : FirExpressionsResolveTransformer(transformer) {
override fun transformAnnotationCall(annotationCall: FirAnnotationCall, data: ResolutionMode): FirStatement {
if (annotationCall.resolveStatus >= FirAnnotationResolveStatus.PartiallyResolved) return annotationCall
dataFlowAnalyzer.enterAnnotationCall(annotationCall)
annotationCall.transformChildren(transformer, ResolutionMode.ContextDependent)
dataFlowAnalyzer.exitAnnotationCall(annotationCall)
annotationCall.replaceResolveStatus(FirAnnotationResolveStatus.PartiallyResolved)
return annotationCall
override fun transformAnnotation(annotation: FirAnnotation, data: ResolutionMode): FirStatement {
if (annotation.resolveStatus >= FirAnnotationResolveStatus.PartiallyResolved) return annotation
dataFlowAnalyzer.enterAnnotationCall(annotation)
annotation.transformChildren(transformer, ResolutionMode.ContextDependent)
dataFlowAnalyzer.exitAnnotationCall(annotation)
annotation.replaceResolveStatus(FirAnnotationResolveStatus.PartiallyResolved)
return annotation
}
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.FirRegularClass
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.extensions.*
import org.jetbrains.kotlin.fir.resolve.ScopeSession
@@ -102,11 +102,11 @@ private class FirAnnotationResolveTransformer(
owners = state
}
override fun transformAnnotationCall(
annotationCall: FirAnnotationCall,
override fun transformAnnotation(
annotation: FirAnnotation,
data: Multimap<AnnotationFqn, FirRegularClass>
): FirStatement {
return annotationCall.transformAnnotationTypeRef(
return annotation.transformAnnotationTypeRef(
typeResolverTransformer,
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.builder.FirAnnotationContainerBuilder
import org.jetbrains.kotlin.fir.builder.FirBuilderDsl
import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnostic
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.FirExpression
import org.jetbrains.kotlin.fir.expressions.FirFunctionCallOrigin
@@ -28,7 +27,7 @@ import org.jetbrains.kotlin.fir.types.builder.buildImplicitTypeRef
class FirIntegerOperatorCall @FirImplementationDetail constructor(
source: FirSourceElement?,
typeRef: FirTypeRef,
annotations: MutableList<FirAnnotationCall>,
annotations: MutableList<FirAnnotation>,
typeArguments: MutableList<FirTypeProjection>,
explicitReceiver: FirExpression?,
dispatchReceiver: FirExpression,
@@ -52,7 +51,7 @@ class FirIntegerOperatorCall @FirImplementationDetail constructor(
class FirIntegerOperatorCallBuilder : FirQualifiedAccessBuilder, FirCallBuilder, FirAnnotationContainerBuilder, FirExpressionBuilder {
override var source: FirSourceElement? = null
override var typeRef: FirTypeRef = buildImplicitTypeRef()
override val annotations: MutableList<FirAnnotationCall> = mutableListOf()
override val annotations: MutableList<FirAnnotation> = mutableListOf()
override val typeArguments: MutableList<FirTypeProjection> = mutableListOf()
override var explicitReceiver: FirExpression? = null
override var dispatchReceiver: FirExpression = FirNoReceiverExpression
@@ -79,4 +78,4 @@ class FirIntegerOperatorCallBuilder : FirQualifiedAccessBuilder, FirCallBuilder,
inline fun buildIntegerOperatorFunctionCall(init: FirIntegerOperatorCallBuilder.() -> Unit): FirIntegerOperatorCall {
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
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.visitors.*
/*
@@ -15,7 +15,7 @@ import org.jetbrains.kotlin.fir.visitors.*
interface FirAnnotationContainer : FirElement {
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)
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.FirSourceElement
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.*
/*
@@ -19,7 +19,7 @@ import org.jetbrains.kotlin.fir.visitors.*
@FirBuilderDsl
interface FirAnnotationContainerBuilder {
abstract var source: FirSourceElement?
abstract val annotations: MutableList<FirAnnotationCall>
abstract val annotations: MutableList<FirAnnotation>
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.FirModuleData
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.visitors.*
@@ -25,7 +25,7 @@ sealed class FirAnnotatedDeclaration : FirDeclaration(), FirAnnotationContainer
abstract override val resolvePhase: FirResolvePhase
abstract override val origin: FirDeclarationOrigin
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)
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.FirModuleData
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.references.FirControlFlowGraphReference
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 origin: FirDeclarationOrigin
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 status: FirDeclarationStatus
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.FirModuleData
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.scopes.FirScopeProvider
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 superTypeRefs: List<FirTypeRef>
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 controlFlowGraphReference: FirControlFlowGraphReference?
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.FirModuleData
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.FirStatement
import org.jetbrains.kotlin.fir.symbols.impl.FirBackingFieldSymbol
@@ -45,7 +45,7 @@ abstract class FirBackingField : FirVariable(), FirTypeParametersOwner, FirState
abstract override val symbol: FirBackingFieldSymbol
abstract val propertySymbol: FirPropertySymbol
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 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.FirModuleData
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.types.ConeKotlinType
import org.jetbrains.kotlin.fir.types.FirTypeRef
@@ -26,7 +26,7 @@ sealed class FirCallableDeclaration : FirTypedDeclaration(), FirMemberDeclaratio
abstract override val resolvePhase: FirResolvePhase
abstract override val origin: FirDeclarationOrigin
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 typeParameters: List<FirTypeParameterRef>
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.FirModuleData
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.scopes.FirScopeProvider
import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
@@ -33,7 +33,7 @@ sealed class FirClass : FirClassLikeDeclaration(), FirStatement, FirTypeParamete
abstract val classKind: ClassKind
abstract val superTypeRefs: List<FirTypeRef>
abstract val declarations: List<FirDeclaration>
abstract override val annotations: List<FirAnnotationCall>
abstract override val annotations: List<FirAnnotation>
abstract val scopeProvider: FirScopeProvider
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.FirModuleData
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.symbols.impl.FirClassLikeSymbol
import org.jetbrains.kotlin.fir.visitors.*
@@ -24,7 +24,7 @@ sealed class FirClassLikeDeclaration : FirAnnotatedDeclaration(), FirStatement {
abstract override val resolvePhase: FirResolvePhase
abstract override val origin: FirDeclarationOrigin
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 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.FirModuleData
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.FirDelegatedConstructorCall
import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference
@@ -38,7 +38,7 @@ abstract class FirConstructor : FirFunction(), FirTypeParameterRefsOwner {
abstract override val dispatchReceiverType: ConeKotlinType?
abstract override val controlFlowGraphReference: FirControlFlowGraphReference?
abstract override val valueParameters: List<FirValueParameter>
abstract override val annotations: List<FirAnnotationCall>
abstract override val annotations: List<FirAnnotation>
abstract override val symbol: FirConstructorSymbol
abstract val delegatedConstructor: FirDelegatedConstructorCall?
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.FirModuleData
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.symbols.impl.FirEnumEntrySymbol
import org.jetbrains.kotlin.fir.types.ConeKotlinType
@@ -43,7 +43,7 @@ abstract class FirEnumEntry : FirVariable() {
abstract override val getter: FirPropertyAccessor?
abstract override val setter: FirPropertyAccessor?
abstract override val backingField: FirBackingField?
abstract override val annotations: List<FirAnnotationCall>
abstract override val annotations: List<FirAnnotation>
abstract override val symbol: FirEnumEntrySymbol
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.diagnostics.ConeDiagnostic
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.references.FirControlFlowGraphReference
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 origin: FirDeclarationOrigin
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 status: FirDeclarationStatus
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.diagnostics.ConeDiagnostic
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.symbols.impl.FirErrorPropertySymbol
import org.jetbrains.kotlin.fir.types.ConeKotlinType
@@ -45,7 +45,7 @@ abstract class FirErrorProperty : FirVariable(), FirDiagnosticHolder {
abstract override val getter: FirPropertyAccessor?
abstract override val setter: FirPropertyAccessor?
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 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.FirModuleData
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.symbols.impl.FirFieldSymbol
import org.jetbrains.kotlin.fir.types.ConeKotlinType
@@ -43,7 +43,7 @@ abstract class FirField : FirVariable() {
abstract override val getter: FirPropertyAccessor?
abstract override val setter: FirPropertyAccessor?
abstract override val backingField: FirBackingField?
abstract override val annotations: List<FirAnnotationCall>
abstract override val annotations: List<FirAnnotation>
abstract override val symbol: FirFieldSymbol
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.FirPackageDirective
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.visitors.*
@@ -24,7 +24,7 @@ abstract class FirFile : FirAnnotatedDeclaration() {
abstract override val resolvePhase: FirResolvePhase
abstract override val origin: FirDeclarationOrigin
abstract override val attributes: FirDeclarationAttributes
abstract override val annotations: List<FirAnnotationCall>
abstract override val annotations: List<FirAnnotation>
abstract val packageDirective: FirPackageDirective
abstract val imports: List<FirImport>
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.FirSourceElement
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.FirStatement
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 origin: FirDeclarationOrigin
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 typeParameters: List<FirTypeParameterRef>
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.FirModuleData
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.references.FirControlFlowGraphReference
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 setter: FirPropertyAccessor?
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 symbol: FirPropertySymbol
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.FirSourceElement
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.references.FirControlFlowGraphReference
import org.jetbrains.kotlin.fir.symbols.impl.FirPropertyAccessorSymbol
@@ -44,7 +44,7 @@ abstract class FirPropertyAccessor : FirFunction(), FirContractDescriptionOwner,
abstract val propertySymbol: FirPropertySymbol?
abstract val isGetter: Boolean
abstract val isSetter: Boolean
abstract override val annotations: List<FirAnnotationCall>
abstract override val annotations: List<FirAnnotation>
abstract override val typeParameters: List<FirTypeParameter>
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.FirModuleData
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.scopes.FirScopeProvider
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 classKind: ClassKind
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 status: FirDeclarationStatus
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.FirSourceElement
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.references.FirControlFlowGraphReference
import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
@@ -42,7 +42,7 @@ abstract class FirSimpleFunction : FirFunction(), FirContractDescriptionOwner, F
abstract override val contractDescription: FirContractDescription
abstract val name: Name
abstract override val symbol: FirNamedFunctionSymbol
abstract override val annotations: List<FirAnnotationCall>
abstract override val annotations: List<FirAnnotation>
abstract override val typeParameters: List<FirTypeParameter>
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.FirModuleData
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.types.FirTypeRef
import org.jetbrains.kotlin.name.Name
@@ -31,7 +31,7 @@ abstract class FirTypeAlias : FirClassLikeDeclaration(), FirMemberDeclaration, F
abstract val name: Name
abstract override val symbol: FirTypeAliasSymbol
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)
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.FirModuleData
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.impl.FirTypeParameterSymbol
import org.jetbrains.kotlin.fir.types.FirTypeRef
@@ -33,7 +33,7 @@ abstract class FirTypeParameter : FirTypeParameterRef, FirAnnotatedDeclaration()
abstract val variance: Variance
abstract val isReified: Boolean
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)
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.FirModuleData
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.types.FirTypeRef
import org.jetbrains.kotlin.fir.visitors.*
@@ -25,7 +25,7 @@ sealed class FirTypedDeclaration : FirAnnotatedDeclaration() {
abstract override val resolvePhase: FirResolvePhase
abstract override val origin: FirDeclarationOrigin
abstract override val attributes: FirDeclarationAttributes
abstract override val annotations: List<FirAnnotationCall>
abstract override val annotations: List<FirAnnotation>
abstract val returnTypeRef: FirTypeRef
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.FirModuleData
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.references.FirControlFlowGraphReference
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 setter: FirPropertyAccessor?
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 symbol: FirValueParameterSymbol
abstract val defaultValue: FirExpression?

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