From 31a7d8d5a425452b7232af8d88748c2dd9511ffd Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Tue, 7 Sep 2021 12:35:18 +0300 Subject: [PATCH] [FIR] Split FirAnnotation into FirAnnotation and FirAnnotationCall FirAnnotation represents simple annotation placed on some element. This element contains only annotation type ref and simple argument mapping FirAnnotationCall is a element for call of annotation (`@Ann(args)`) which was written in user code. FirAnnotationCall is a resolvable call --- .../kotlin/fir/expressions/FirAnnotation.kt | 15 +--- .../FirAnnotationArgumentMapping.kt | 28 +++++++ .../fir/expressions/FirAnnotationCall.kt | 49 ++++++++++++ .../builder/FirAnnotationBuilder.kt | 21 ++---- .../builder/FirAnnotationCallBuilder.kt | 70 ++++++++++++++++++ .../expressions/impl/FirAnnotationCallImpl.kt | 74 +++++++++++++++++++ .../fir/expressions/impl/FirAnnotationImpl.kt | 36 ++------- .../kotlin/fir/visitors/FirTransformer.kt | 18 +++++ .../kotlin/fir/visitors/FirVisitor.kt | 6 ++ .../kotlin/fir/visitors/FirVisitorVoid.kt | 18 +++++ .../FirAnnotationArgumentMappingBuilder.kt | 50 +++++++++++++ .../impl/FirAnnotationArgumentMappingImpl.kt | 38 ++++++++++ .../fir/tree/generator/BuilderConfigurator.kt | 7 +- .../fir/tree/generator/FirTreeBuilder.kt | 4 +- .../generator/ImplementationConfigurator.kt | 15 +++- .../fir/tree/generator/NodeConfigurator.kt | 10 ++- .../kotlin/fir/tree/generator/Types.kt | 2 +- 17 files changed, 399 insertions(+), 62 deletions(-) create mode 100644 compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/FirAnnotationArgumentMapping.kt create mode 100644 compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/FirAnnotationCall.kt create mode 100644 compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/builder/FirAnnotationCallBuilder.kt create mode 100644 compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/impl/FirAnnotationCallImpl.kt create mode 100644 compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/builder/FirAnnotationArgumentMappingBuilder.kt create mode 100644 compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirAnnotationArgumentMappingImpl.kt diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/FirAnnotation.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/FirAnnotation.kt index 9fbbfb3b214..877a5ff1390 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/FirAnnotation.kt +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/FirAnnotation.kt @@ -8,7 +8,6 @@ package org.jetbrains.kotlin.fir.expressions import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.FirSourceElement -import org.jetbrains.kotlin.fir.references.FirReference import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.fir.visitors.* @@ -17,15 +16,13 @@ import org.jetbrains.kotlin.fir.visitors.* * DO NOT MODIFY IT MANUALLY */ -abstract class FirAnnotation : FirExpression(), FirCall, FirResolvable { +abstract class FirAnnotation : FirExpression() { abstract override val source: FirSourceElement? abstract override val typeRef: FirTypeRef abstract override val annotations: List - abstract override val argumentList: FirArgumentList - abstract override val calleeReference: FirReference abstract val useSiteTarget: AnnotationUseSiteTarget? abstract val annotationTypeRef: FirTypeRef - abstract val resolveStatus: FirAnnotationResolveStatus + abstract val argumentMapping: FirAnnotationArgumentMapping override fun accept(visitor: FirVisitor, data: D): R = visitor.visitAnnotation(this, data) @@ -35,15 +32,9 @@ abstract class FirAnnotation : FirExpression(), FirCall, FirResolvable { abstract override fun replaceTypeRef(newTypeRef: FirTypeRef) - abstract override fun replaceArgumentList(newArgumentList: FirArgumentList) - - abstract override fun replaceCalleeReference(newCalleeReference: FirReference) - - abstract fun replaceResolveStatus(newResolveStatus: FirAnnotationResolveStatus) + abstract fun replaceArgumentMapping(newArgumentMapping: FirAnnotationArgumentMapping) abstract override fun transformAnnotations(transformer: FirTransformer, data: D): FirAnnotation - abstract override fun transformCalleeReference(transformer: FirTransformer, data: D): FirAnnotation - abstract fun transformAnnotationTypeRef(transformer: FirTransformer, data: D): FirAnnotation } diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/FirAnnotationArgumentMapping.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/FirAnnotationArgumentMapping.kt new file mode 100644 index 00000000000..5e0bbdc5f91 --- /dev/null +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/FirAnnotationArgumentMapping.kt @@ -0,0 +1,28 @@ +/* + * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.fir.expressions + +import org.jetbrains.kotlin.fir.FirElement +import org.jetbrains.kotlin.fir.FirPureAbstractElement +import org.jetbrains.kotlin.fir.FirSourceElement +import org.jetbrains.kotlin.name.Name +import org.jetbrains.kotlin.fir.visitors.* + +/* + * This file was generated automatically + * DO NOT MODIFY IT MANUALLY + */ + +abstract class FirAnnotationArgumentMapping : FirPureAbstractElement(), FirElement { + abstract override val source: FirSourceElement? + abstract val mapping: Map + + override fun accept(visitor: FirVisitor, data: D): R = visitor.visitAnnotationArgumentMapping(this, data) + + @Suppress("UNCHECKED_CAST") + override fun transform(transformer: FirTransformer, data: D): E = + transformer.transformAnnotationArgumentMapping(this, data) as E +} diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/FirAnnotationCall.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/FirAnnotationCall.kt new file mode 100644 index 00000000000..17dd56d86e5 --- /dev/null +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/FirAnnotationCall.kt @@ -0,0 +1,49 @@ +/* + * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.fir.expressions + +import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget +import org.jetbrains.kotlin.fir.FirElement +import org.jetbrains.kotlin.fir.FirSourceElement +import org.jetbrains.kotlin.fir.references.FirReference +import org.jetbrains.kotlin.fir.types.FirTypeRef +import org.jetbrains.kotlin.fir.visitors.* + +/* + * This file was generated automatically + * DO NOT MODIFY IT MANUALLY + */ + +abstract class FirAnnotationCall : FirAnnotation(), FirCall, FirResolvable { + abstract override val source: FirSourceElement? + abstract override val typeRef: FirTypeRef + abstract override val annotations: List + abstract override val useSiteTarget: AnnotationUseSiteTarget? + abstract override val annotationTypeRef: FirTypeRef + abstract override val argumentList: FirArgumentList + abstract override val calleeReference: FirReference + abstract override val argumentMapping: FirAnnotationArgumentMapping + + override fun accept(visitor: FirVisitor, data: D): R = visitor.visitAnnotationCall(this, data) + + @Suppress("UNCHECKED_CAST") + override fun transform(transformer: FirTransformer, data: D): E = + transformer.transformAnnotationCall(this, data) as E + + abstract override fun replaceTypeRef(newTypeRef: FirTypeRef) + + abstract override fun replaceArgumentList(newArgumentList: FirArgumentList) + + abstract override fun replaceCalleeReference(newCalleeReference: FirReference) + + abstract override fun replaceArgumentMapping(newArgumentMapping: FirAnnotationArgumentMapping) + + abstract override fun transformAnnotations(transformer: FirTransformer, data: D): FirAnnotationCall + + abstract override fun transformAnnotationTypeRef(transformer: FirTransformer, data: D): FirAnnotationCall + + abstract override fun transformCalleeReference(transformer: FirTransformer, data: D): FirAnnotationCall +} diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/builder/FirAnnotationBuilder.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/builder/FirAnnotationBuilder.kt index bee1be3917b..c426df25cd4 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/builder/FirAnnotationBuilder.kt +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/builder/FirAnnotationBuilder.kt @@ -11,13 +11,9 @@ 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.expressions.FirAnnotation -import org.jetbrains.kotlin.fir.expressions.FirAnnotationResolveStatus -import org.jetbrains.kotlin.fir.expressions.FirArgumentList -import org.jetbrains.kotlin.fir.expressions.FirEmptyArgumentList -import org.jetbrains.kotlin.fir.expressions.builder.FirCallBuilder +import org.jetbrains.kotlin.fir.expressions.FirAnnotationArgumentMapping import org.jetbrains.kotlin.fir.expressions.builder.FirExpressionBuilder import org.jetbrains.kotlin.fir.expressions.impl.FirAnnotationImpl -import org.jetbrains.kotlin.fir.references.FirReference import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.fir.visitors.* @@ -27,24 +23,18 @@ import org.jetbrains.kotlin.fir.visitors.* */ @FirBuilderDsl -class FirAnnotationBuilder : FirCallBuilder, FirAnnotationContainerBuilder, FirExpressionBuilder { +class FirAnnotationBuilder : FirAnnotationContainerBuilder, FirExpressionBuilder { override var source: FirSourceElement? = null - override val annotations: MutableList = mutableListOf() - override var argumentList: FirArgumentList = FirEmptyArgumentList - lateinit var calleeReference: FirReference var useSiteTarget: AnnotationUseSiteTarget? = null lateinit var annotationTypeRef: FirTypeRef - var resolveStatus: FirAnnotationResolveStatus = FirAnnotationResolveStatus.Unresolved + lateinit var argumentMapping: FirAnnotationArgumentMapping override fun build(): FirAnnotation { return FirAnnotationImpl( source, - annotations, - argumentList, - calleeReference, useSiteTarget, annotationTypeRef, - resolveStatus, + argumentMapping, ) } @@ -55,6 +45,9 @@ class FirAnnotationBuilder : FirCallBuilder, FirAnnotationContainerBuilder, FirE set(_) { throw IllegalStateException() } + + @Deprecated("Modification of 'annotations' has no impact for FirAnnotationBuilder", level = DeprecationLevel.HIDDEN) + override val annotations: MutableList = mutableListOf() } @OptIn(ExperimentalContracts::class) diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/builder/FirAnnotationCallBuilder.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/builder/FirAnnotationCallBuilder.kt new file mode 100644 index 00000000000..249c07947fc --- /dev/null +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/builder/FirAnnotationCallBuilder.kt @@ -0,0 +1,70 @@ +/* + * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.fir.expressions.builder + +import kotlin.contracts.* +import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget +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.expressions.FirAnnotation +import org.jetbrains.kotlin.fir.expressions.FirAnnotationArgumentMapping +import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall +import org.jetbrains.kotlin.fir.expressions.FirArgumentList +import org.jetbrains.kotlin.fir.expressions.FirEmptyArgumentList +import org.jetbrains.kotlin.fir.expressions.builder.FirCallBuilder +import org.jetbrains.kotlin.fir.expressions.builder.FirExpressionBuilder +import org.jetbrains.kotlin.fir.expressions.impl.FirAnnotationCallImpl +import org.jetbrains.kotlin.fir.expressions.impl.FirEmptyAnnotationArgumentMapping +import org.jetbrains.kotlin.fir.references.FirReference +import org.jetbrains.kotlin.fir.types.FirTypeRef +import org.jetbrains.kotlin.fir.types.impl.FirImplicitTypeRefImpl +import org.jetbrains.kotlin.fir.visitors.* + +/* + * This file was generated automatically + * DO NOT MODIFY IT MANUALLY + */ + +@FirBuilderDsl +class FirAnnotationCallBuilder : FirCallBuilder, FirAnnotationContainerBuilder, FirExpressionBuilder { + override var source: FirSourceElement? = null + var useSiteTarget: AnnotationUseSiteTarget? = null + var annotationTypeRef: FirTypeRef = FirImplicitTypeRefImpl(null) + override var argumentList: FirArgumentList = FirEmptyArgumentList + lateinit var calleeReference: FirReference + var argumentMapping: FirAnnotationArgumentMapping = FirEmptyAnnotationArgumentMapping + + override fun build(): FirAnnotationCall { + return FirAnnotationCallImpl( + source, + useSiteTarget, + annotationTypeRef, + argumentList, + calleeReference, + argumentMapping, + ) + } + + + @Deprecated("Modification of 'typeRef' has no impact for FirAnnotationCallBuilder", level = DeprecationLevel.HIDDEN) + override var typeRef: FirTypeRef + get() = throw IllegalStateException() + set(_) { + throw IllegalStateException() + } + + @Deprecated("Modification of 'annotations' has no impact for FirAnnotationCallBuilder", level = DeprecationLevel.HIDDEN) + override val annotations: MutableList = mutableListOf() +} + +@OptIn(ExperimentalContracts::class) +inline fun buildAnnotationCall(init: FirAnnotationCallBuilder.() -> Unit): FirAnnotationCall { + contract { + callsInPlace(init, kotlin.contracts.InvocationKind.EXACTLY_ONCE) + } + return FirAnnotationCallBuilder().apply(init).build() +} diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/impl/FirAnnotationCallImpl.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/impl/FirAnnotationCallImpl.kt new file mode 100644 index 00000000000..00c256db147 --- /dev/null +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/impl/FirAnnotationCallImpl.kt @@ -0,0 +1,74 @@ +/* + * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.fir.expressions.impl + +import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget +import org.jetbrains.kotlin.fir.FirSourceElement +import org.jetbrains.kotlin.fir.expressions.FirAnnotation +import org.jetbrains.kotlin.fir.expressions.FirAnnotationArgumentMapping +import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall +import org.jetbrains.kotlin.fir.expressions.FirArgumentList +import org.jetbrains.kotlin.fir.references.FirReference +import org.jetbrains.kotlin.fir.types.FirTypeRef +import org.jetbrains.kotlin.fir.visitors.* + +/* + * This file was generated automatically + * DO NOT MODIFY IT MANUALLY + */ + +internal class FirAnnotationCallImpl( + override val source: FirSourceElement?, + override val useSiteTarget: AnnotationUseSiteTarget?, + override var annotationTypeRef: FirTypeRef, + override var argumentList: FirArgumentList, + override var calleeReference: FirReference, + override var argumentMapping: FirAnnotationArgumentMapping, +) : FirAnnotationCall() { + override val typeRef: FirTypeRef get() = annotationTypeRef + override val annotations: List get() = emptyList() + + override fun acceptChildren(visitor: FirVisitor, data: D) { + annotationTypeRef.accept(visitor, data) + argumentList.accept(visitor, data) + calleeReference.accept(visitor, data) + } + + override fun transformChildren(transformer: FirTransformer, data: D): FirAnnotationCallImpl { + transformAnnotationTypeRef(transformer, data) + argumentList = argumentList.transform(transformer, data) + transformCalleeReference(transformer, data) + return this + } + + override fun transformAnnotations(transformer: FirTransformer, data: D): FirAnnotationCallImpl { + return this + } + + override fun transformAnnotationTypeRef(transformer: FirTransformer, data: D): FirAnnotationCallImpl { + annotationTypeRef = annotationTypeRef.transform(transformer, data) + return this + } + + override fun transformCalleeReference(transformer: FirTransformer, data: D): FirAnnotationCallImpl { + calleeReference = calleeReference.transform(transformer, data) + return this + } + + override fun replaceTypeRef(newTypeRef: FirTypeRef) {} + + override fun replaceArgumentList(newArgumentList: FirArgumentList) { + argumentList = newArgumentList + } + + override fun replaceCalleeReference(newCalleeReference: FirReference) { + calleeReference = newCalleeReference + } + + override fun replaceArgumentMapping(newArgumentMapping: FirAnnotationArgumentMapping) { + argumentMapping = newArgumentMapping + } +} diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/impl/FirAnnotationImpl.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/impl/FirAnnotationImpl.kt index ef00deaa47b..031c64d292f 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/impl/FirAnnotationImpl.kt +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/impl/FirAnnotationImpl.kt @@ -8,9 +8,7 @@ package org.jetbrains.kotlin.fir.expressions.impl import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget import org.jetbrains.kotlin.fir.FirSourceElement 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.references.FirReference +import org.jetbrains.kotlin.fir.expressions.FirAnnotationArgumentMapping import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.fir.visitors.* @@ -21,37 +19,25 @@ import org.jetbrains.kotlin.fir.visitors.* internal class FirAnnotationImpl( override val source: FirSourceElement?, - override val annotations: MutableList, - override var argumentList: FirArgumentList, - override var calleeReference: FirReference, override val useSiteTarget: AnnotationUseSiteTarget?, override var annotationTypeRef: FirTypeRef, - override var resolveStatus: FirAnnotationResolveStatus, + override var argumentMapping: FirAnnotationArgumentMapping, ) : FirAnnotation() { override val typeRef: FirTypeRef get() = annotationTypeRef + override val annotations: List get() = emptyList() override fun acceptChildren(visitor: FirVisitor, data: D) { - annotations.forEach { it.accept(visitor, data) } - argumentList.accept(visitor, data) - calleeReference.accept(visitor, data) annotationTypeRef.accept(visitor, data) + argumentMapping.accept(visitor, data) } override fun transformChildren(transformer: FirTransformer, data: D): FirAnnotationImpl { - transformAnnotations(transformer, data) - argumentList = argumentList.transform(transformer, data) - transformCalleeReference(transformer, data) transformAnnotationTypeRef(transformer, data) + argumentMapping = argumentMapping.transform(transformer, data) return this } override fun transformAnnotations(transformer: FirTransformer, data: D): FirAnnotationImpl { - annotations.transformInplace(transformer, data) - return this - } - - override fun transformCalleeReference(transformer: FirTransformer, data: D): FirAnnotationImpl { - calleeReference = calleeReference.transform(transformer, data) return this } @@ -62,15 +48,7 @@ internal class FirAnnotationImpl( override fun replaceTypeRef(newTypeRef: FirTypeRef) {} - override fun replaceArgumentList(newArgumentList: FirArgumentList) { - argumentList = newArgumentList - } - - override fun replaceCalleeReference(newCalleeReference: FirReference) { - calleeReference = newCalleeReference - } - - override fun replaceResolveStatus(newResolveStatus: FirAnnotationResolveStatus) { - resolveStatus = newResolveStatus + override fun replaceArgumentMapping(newArgumentMapping: FirAnnotationArgumentMapping) { + argumentMapping = newArgumentMapping } } diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirTransformer.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirTransformer.kt index bda55c2484c..992d0e7956c 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirTransformer.kt +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirTransformer.kt @@ -71,6 +71,8 @@ import org.jetbrains.kotlin.fir.types.FirTypeProjectionWithVariance import org.jetbrains.kotlin.fir.expressions.FirArgumentList import org.jetbrains.kotlin.fir.expressions.FirCall import org.jetbrains.kotlin.fir.expressions.FirAnnotation +import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall +import org.jetbrains.kotlin.fir.expressions.FirAnnotationArgumentMapping import org.jetbrains.kotlin.fir.expressions.FirComparisonExpression import org.jetbrains.kotlin.fir.expressions.FirTypeOperatorCall import org.jetbrains.kotlin.fir.expressions.FirAssignmentOperatorStatement @@ -405,6 +407,14 @@ abstract class FirTransformer : FirVisitor() { return transformElement(annotation, data) } + open fun transformAnnotationCall(annotationCall: FirAnnotationCall, data: D): FirStatement { + return transformElement(annotationCall, data) + } + + open fun transformAnnotationArgumentMapping(annotationArgumentMapping: FirAnnotationArgumentMapping, data: D): FirAnnotationArgumentMapping { + return transformElement(annotationArgumentMapping, data) + } + open fun transformComparisonExpression(comparisonExpression: FirComparisonExpression, data: D): FirStatement { return transformElement(comparisonExpression, data) } @@ -925,6 +935,14 @@ abstract class FirTransformer : FirVisitor() { return transformAnnotation(annotation, data) } + final override fun visitAnnotationCall(annotationCall: FirAnnotationCall, data: D): FirStatement { + return transformAnnotationCall(annotationCall, data) + } + + final override fun visitAnnotationArgumentMapping(annotationArgumentMapping: FirAnnotationArgumentMapping, data: D): FirAnnotationArgumentMapping { + return transformAnnotationArgumentMapping(annotationArgumentMapping, data) + } + final override fun visitComparisonExpression(comparisonExpression: FirComparisonExpression, data: D): FirStatement { return transformComparisonExpression(comparisonExpression, data) } diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirVisitor.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirVisitor.kt index 9b5aba2eedf..486071c1761 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirVisitor.kt +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirVisitor.kt @@ -71,6 +71,8 @@ import org.jetbrains.kotlin.fir.types.FirTypeProjectionWithVariance import org.jetbrains.kotlin.fir.expressions.FirArgumentList import org.jetbrains.kotlin.fir.expressions.FirCall import org.jetbrains.kotlin.fir.expressions.FirAnnotation +import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall +import org.jetbrains.kotlin.fir.expressions.FirAnnotationArgumentMapping import org.jetbrains.kotlin.fir.expressions.FirComparisonExpression import org.jetbrains.kotlin.fir.expressions.FirTypeOperatorCall import org.jetbrains.kotlin.fir.expressions.FirAssignmentOperatorStatement @@ -274,6 +276,10 @@ abstract class FirVisitor { open fun visitAnnotation(annotation: FirAnnotation, data: D): R = visitElement(annotation, data) + open fun visitAnnotationCall(annotationCall: FirAnnotationCall, data: D): R = visitElement(annotationCall, data) + + open fun visitAnnotationArgumentMapping(annotationArgumentMapping: FirAnnotationArgumentMapping, data: D): R = visitElement(annotationArgumentMapping, data) + open fun visitComparisonExpression(comparisonExpression: FirComparisonExpression, data: D): R = visitElement(comparisonExpression, data) open fun visitTypeOperatorCall(typeOperatorCall: FirTypeOperatorCall, data: D): R = visitElement(typeOperatorCall, data) diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirVisitorVoid.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirVisitorVoid.kt index 3f51710ec47..ec03263ccba 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirVisitorVoid.kt +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirVisitorVoid.kt @@ -71,6 +71,8 @@ import org.jetbrains.kotlin.fir.types.FirTypeProjectionWithVariance import org.jetbrains.kotlin.fir.expressions.FirArgumentList import org.jetbrains.kotlin.fir.expressions.FirCall import org.jetbrains.kotlin.fir.expressions.FirAnnotation +import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall +import org.jetbrains.kotlin.fir.expressions.FirAnnotationArgumentMapping import org.jetbrains.kotlin.fir.expressions.FirComparisonExpression import org.jetbrains.kotlin.fir.expressions.FirTypeOperatorCall import org.jetbrains.kotlin.fir.expressions.FirAssignmentOperatorStatement @@ -404,6 +406,14 @@ abstract class FirVisitorVoid : FirVisitor() { visitElement(annotation) } + open fun visitAnnotationCall(annotationCall: FirAnnotationCall) { + visitElement(annotationCall) + } + + open fun visitAnnotationArgumentMapping(annotationArgumentMapping: FirAnnotationArgumentMapping) { + visitElement(annotationArgumentMapping) + } + open fun visitComparisonExpression(comparisonExpression: FirComparisonExpression) { visitElement(comparisonExpression) } @@ -924,6 +934,14 @@ abstract class FirVisitorVoid : FirVisitor() { visitAnnotation(annotation) } + final override fun visitAnnotationCall(annotationCall: FirAnnotationCall, data: Nothing?) { + visitAnnotationCall(annotationCall) + } + + final override fun visitAnnotationArgumentMapping(annotationArgumentMapping: FirAnnotationArgumentMapping, data: Nothing?) { + visitAnnotationArgumentMapping(annotationArgumentMapping) + } + final override fun visitComparisonExpression(comparisonExpression: FirComparisonExpression, data: Nothing?) { visitComparisonExpression(comparisonExpression) } diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/builder/FirAnnotationArgumentMappingBuilder.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/builder/FirAnnotationArgumentMappingBuilder.kt new file mode 100644 index 00000000000..239ed7e0847 --- /dev/null +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/builder/FirAnnotationArgumentMappingBuilder.kt @@ -0,0 +1,50 @@ +/* + * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.fir.expressions.builder + +import org.jetbrains.kotlin.fir.FirSourceElement +import org.jetbrains.kotlin.fir.builder.FirBuilderDsl +import org.jetbrains.kotlin.fir.expressions.FirAnnotationArgumentMapping +import org.jetbrains.kotlin.fir.expressions.FirArgumentList +import org.jetbrains.kotlin.fir.expressions.FirExpression +import org.jetbrains.kotlin.fir.expressions.impl.FirAnnotationArgumentMappingImpl +import org.jetbrains.kotlin.fir.expressions.impl.FirEmptyAnnotationArgumentMapping +import org.jetbrains.kotlin.fir.expressions.impl.FirResolvedArgumentList +import org.jetbrains.kotlin.name.Name +import kotlin.annotations.jvm.UnderMigration +import kotlin.contracts.ExperimentalContracts +import kotlin.contracts.InvocationKind +import kotlin.contracts.contract + +@FirBuilderDsl +class FirAnnotationArgumentMappingBuilder { + var source: FirSourceElement? = null + val mapping: MutableMap = mutableMapOf() + + fun build(): FirAnnotationArgumentMapping { + if (source == null && mapping.isEmpty()) return FirEmptyAnnotationArgumentMapping + return FirAnnotationArgumentMappingImpl(source, mapping) + } +} + +@OptIn(ExperimentalContracts::class) +inline fun buildAnnotationArgumentMapping(init: FirAnnotationArgumentMappingBuilder.() -> Unit = {}): FirAnnotationArgumentMapping { + contract { + callsInPlace(init, InvocationKind.EXACTLY_ONCE) + } + return FirAnnotationArgumentMappingBuilder().apply(init).build() +} + +fun FirArgumentList.toAnnotationArgumentMapping(): FirAnnotationArgumentMapping { + return buildAnnotationArgumentMapping { + source = this@toAnnotationArgumentMapping.source + if (this@toAnnotationArgumentMapping is FirResolvedArgumentList) { + this@toAnnotationArgumentMapping.mapping + .map { (argument, parameter) -> parameter.name to argument } + .toMap(mapping) + } + } +} diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirAnnotationArgumentMappingImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirAnnotationArgumentMappingImpl.kt new file mode 100644 index 00000000000..78e342f5ad3 --- /dev/null +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirAnnotationArgumentMappingImpl.kt @@ -0,0 +1,38 @@ +/* + * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.fir.expressions.impl + +import org.jetbrains.kotlin.fir.FirElement +import org.jetbrains.kotlin.fir.FirSourceElement +import org.jetbrains.kotlin.fir.expressions.FirAnnotationArgumentMapping +import org.jetbrains.kotlin.fir.expressions.FirExpression +import org.jetbrains.kotlin.fir.visitors.FirTransformer +import org.jetbrains.kotlin.fir.visitors.FirVisitor +import org.jetbrains.kotlin.name.Name + +class FirAnnotationArgumentMappingImpl( + override val source: FirSourceElement?, + override val mapping: Map +) : FirAnnotationArgumentMapping() { + override fun acceptChildren(visitor: FirVisitor, data: D) {} + + override fun transformChildren(transformer: FirTransformer, data: D): FirElement { + return this + } +} + +object FirEmptyAnnotationArgumentMapping : FirAnnotationArgumentMapping() { + override val source: FirSourceElement? + get() = null + override val mapping: Map + get() = emptyMap() + + override fun acceptChildren(visitor: FirVisitor, data: D) {} + + override fun transformChildren(transformer: FirTransformer, data: D): FirElement { + return this + } +} diff --git a/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/BuilderConfigurator.kt b/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/BuilderConfigurator.kt index 5b86eeb43a8..2e3b2048461 100644 --- a/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/BuilderConfigurator.kt +++ b/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/BuilderConfigurator.kt @@ -108,13 +108,14 @@ object BuilderConfigurator : AbstractBuilderConfigurator(FirTree withCopy() } - builder(annotation) { + builder(annotationCall) { parents += callBuilder default("argumentList") { value = "FirEmptyArgumentList" } - default("resolveStatus", "FirAnnotationResolveStatus.Unresolved") - useTypes(emptyArgumentListType) + default("argumentMapping", "FirEmptyAnnotationArgumentMapping") + default("annotationTypeRef", "FirImplicitTypeRefImpl(null)") + useTypes(emptyArgumentListType, emptyAnnotationArgumentMappingType, implicitTypeRefType) } builder(arrayOfCall) { diff --git a/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/FirTreeBuilder.kt b/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/FirTreeBuilder.kt index 322751d53c5..525a6a73119 100644 --- a/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/FirTreeBuilder.kt +++ b/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/FirTreeBuilder.kt @@ -89,7 +89,9 @@ object FirTreeBuilder : AbstractFirTreeBuilder() { val typeProjectionWithVariance by element(TypeRef, typeProjection) val argumentList by element(Expression) val call by sealedElement(Expression, statement) // TODO: may smth like `CallWithArguments` or `ElementWithArguments`? - val annotation by element(Expression, expression, call, resolvable) + val annotation by element(Expression, expression) + val annotationCall by element(Expression, annotation, call, resolvable) + val annotationArgumentMapping by element(Expression) val comparisonExpression by element(Expression, expression) val typeOperatorCall by element(Expression, expression, call) val assignmentOperatorStatement by element(Expression, statement) diff --git a/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/ImplementationConfigurator.kt b/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/ImplementationConfigurator.kt index 513ce4e704e..e3389437219 100644 --- a/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/ImplementationConfigurator.kt +++ b/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/ImplementationConfigurator.kt @@ -73,13 +73,25 @@ object ImplementationConfigurator : AbstractFirTreeImplementationConfigurator() delegateFields(listOf("aliasName", "importedFqName", "isAllUnder", "source"), "delegate") } - impl(annotation) { + fun ImplementationContext.commonAnnotationConfig(): Unit { + defaultEmptyList("annotations") default("typeRef") { value = "annotationTypeRef" withGetter = true } } + impl(annotation) { + commonAnnotationConfig() + } + + impl(annotationCall) { + commonAnnotationConfig() + default("argumentMapping") { + needAcceptAndTransform = false + } + } + impl(arrayOfCall) impl(callableReferenceAccess) @@ -501,6 +513,7 @@ object ImplementationConfigurator : AbstractFirTreeImplementationConfigurator() } noImpl(argumentList) + noImpl(annotationArgumentMapping) val implementationsWithoutStatusAndTypeParameters = listOf( "FirAnonymousFunctionImpl", diff --git a/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/NodeConfigurator.kt b/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/NodeConfigurator.kt index 4306759ea69..167515be859 100644 --- a/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/NodeConfigurator.kt +++ b/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/NodeConfigurator.kt @@ -447,7 +447,15 @@ object NodeConfigurator : AbstractFieldConfigurator(FirTreeBuild annotation.configure { +field("useSiteTarget", annotationUseSiteTargetType, nullable = true) +field("annotationTypeRef", typeRef).withTransform() - +field("resolveStatus", annotationResolveStatusType, withReplace = true) + +field("argumentMapping", annotationArgumentMapping, withReplace = true) + } + + annotationCall.configure { + +field("argumentMapping", annotationArgumentMapping, withReplace = true) + } + + annotationArgumentMapping.configure { + +field("mapping", type("Map") to listOf(nameType, expression)) } augmentedArraySetCall.configure { diff --git a/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/Types.kt b/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/Types.kt index 7e6a0e26450..14c152cf838 100644 --- a/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/Types.kt +++ b/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/Types.kt @@ -83,7 +83,6 @@ val dslBuilderAnnotationType = generatedType("builder", "FirBuilderDsl") val firImplementationDetailType = generatedType("FirImplementationDetail") val declarationOriginType = generatedType("declarations", "FirDeclarationOrigin") val declarationAttributesType = generatedType("declarations", "FirDeclarationAttributes") -val annotationResolveStatusType = generatedType("expressions", "FirAnnotationResolveStatus") val exhaustivenessStatusType = generatedType("expressions", "ExhaustivenessStatus") @@ -94,6 +93,7 @@ val functionCallOrigin = type("fir.expressions", "FirFunctionCallOrigin") val resolvedDeclarationStatusImplType = type("fir.declarations.impl", "FirResolvedDeclarationStatusImpl") val deprecationsPerUseSiteType = type("fir.declarations", "DeprecationsPerUseSite") +val emptyAnnotationArgumentMappingType = type("fir.expressions.impl", "FirEmptyAnnotationArgumentMapping") val firPropertySymbolType = type("fir.symbols.impl", "FirPropertySymbol")