diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/FirUtils.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/FirUtils.kt index 4fe1b49158c..b2dec6a7f69 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/FirUtils.kt +++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/FirUtils.kt @@ -20,13 +20,9 @@ import org.jetbrains.kotlin.fir.references.FirReference import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference import org.jetbrains.kotlin.fir.resolve.diagnostics.* import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol -import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol -import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.psi.KtCallElement -import org.jetbrains.kotlin.psi.KtNameReferenceExpression import org.jetbrains.kotlin.util.OperatorNameConventions -import org.jetbrains.kotlin.utils.addToStdlib.safeAs /** * Returns `true` if the symbol is for a function named `invoke`. @@ -72,7 +68,7 @@ internal fun FirAnnotation.toKtAnnotationApplication(useSiteSession: FirSession) psi as? KtCallElement, useSiteTarget, FirAnnotationValueConverter.toNamedConstantValue( - mapAnnotationParameters(this, useSiteSession), + mapAnnotationParameters(this), useSiteSession, ) ) diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/annotations/KtFirAnnotationListForDeclaration.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/annotations/KtFirAnnotationListForDeclaration.kt index 007a4e0dab2..8c274cc23f9 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/annotations/KtFirAnnotationListForDeclaration.kt +++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/annotations/KtFirAnnotationListForDeclaration.kt @@ -51,7 +51,7 @@ internal class KtFirAnnotationListForDeclaration private constructor( useSiteSession: FirSession, token: KtLifetimeToken, ): KtAnnotationsList { - return if (firSymbol.annotations.isEmpty()) { + return if (firSymbol.resolvedAnnotationsWithArguments.isEmpty()) { KtEmptyAnnotationsList(token) } else { KtFirAnnotationListForDeclaration(firSymbol, useSiteSession, token) diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/annotations/firAnnotationUtils.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/annotations/firAnnotationUtils.kt index b489a520a88..e0bd78fdccf 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/annotations/firAnnotationUtils.kt +++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/annotations/firAnnotationUtils.kt @@ -5,88 +5,11 @@ package org.jetbrains.kotlin.analysis.api.fir.annotations -import org.jetbrains.kotlin.KtFakeSourceElementKind -import org.jetbrains.kotlin.fakeElement -import org.jetbrains.kotlin.fir.FirSession -import org.jetbrains.kotlin.fir.declarations.FirRegularClass -import org.jetbrains.kotlin.fir.declarations.FirValueParameter -import org.jetbrains.kotlin.fir.declarations.primaryConstructorIfAny import org.jetbrains.kotlin.fir.declarations.resolved import org.jetbrains.kotlin.fir.expressions.* -import org.jetbrains.kotlin.fir.expressions.builder.buildVarargArgumentsExpression -import org.jetbrains.kotlin.fir.resolve.fullyExpandedType -import org.jetbrains.kotlin.fir.resolve.toSymbol -import org.jetbrains.kotlin.fir.types.* -import org.jetbrains.kotlin.fir.types.builder.buildResolvedTypeRef -import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.Name -internal fun mapAnnotationParameters(annotation: FirAnnotation, session: FirSession): Map { - // TODO: Alas, argument mapping for annotations on [FirValueParameter] is not properly built, even after BODY_RESOLVE ensured. - // Once fixed, manual building of argument mapping below is redundant. I.e., this util can be as simple as: - // return if (annotation.resolved) - // annotation.argumentMapping.mapping.mapKeys { (name, _) -> name } - // else - // emptyMap() - if (annotation.resolved) return annotation.argumentMapping.mapping.mapKeys { (name, _) -> name } - if (annotation !is FirAnnotationCall) return emptyMap() - val annotationCone = (annotation.annotationTypeRef.coneType as? ConeClassLikeType)?.fullyExpandedType(session) - ?: return emptyMap() - - val annotationPrimaryCtor = (annotationCone.lookupTag.toSymbol(session)?.fir as? FirRegularClass)?.primaryConstructorIfAny(session)?.fir - val valueParameters = annotationPrimaryCtor?.valueParameters - val (varargValueParameters, nonVarargValueParameters) = valueParameters?.partition { it.isVararg } - ?: (emptyList() to emptyList()) - val annotationCtorParameterNames = nonVarargValueParameters.map { it.name } - - val resultMap = mutableMapOf() - - val namesSequence = annotationCtorParameterNames.asSequence().iterator() - - for (argument in annotation.argumentList.arguments.filterIsInstance()) { - resultMap[argument.name] = argument.expression - } - - val argumentSequence = annotation.argumentList.arguments.asSequence().iterator() - - while (namesSequence.hasNext()) { - val name = namesSequence.next() - if (name in resultMap) continue - while (argumentSequence.hasNext()) { - val argument = argumentSequence.next() - if (argument is FirNamedArgumentExpression) continue - - resultMap[name] = argument - break - } - } - - if (varargValueParameters.isNotEmpty() && argumentSequence.hasNext()) { - val varargValueParameter = varargValueParameters.single() - val arguments = buildList { - while (argumentSequence.hasNext()) { - val argument = argumentSequence.next() - if (argument is FirNamedArgumentExpression) continue - add(argument) - } - } - if (arguments.isNotEmpty()) { - val exp = buildVarargArgumentsExpression { - this.arguments.addAll(arguments) - val firstArgument = arguments.first() - firstArgument.source?.let { source = it.fakeElement(KtFakeSourceElementKind.VarargArgument) } - (varargValueParameter.returnTypeRef as? FirResolvedTypeRef)?.coneType?.varargElementType()?.let { - varargElementType = buildResolvedTypeRef { - source = varargValueParameter.returnTypeRef.source - type = it - } - } ?: firstArgument.typeRef.let { - varargElementType = it - } - } - resultMap[varargValueParameter.name] = exp - } - } - - return resultMap +internal fun mapAnnotationParameters(annotation: FirAnnotation): Map { + assert(annotation.resolved) { "By now the annotations argument mapping should have been resolved" } + return annotation.argumentMapping.mapping.mapKeys { (name, _) -> name } } diff --git a/analysis/analysis-api/testData/symbols/symbolByReference/functionReceiverParameter.kt b/analysis/analysis-api/testData/symbols/symbolByReference/functionReceiverParameter.kt index dfe964a9793..6ace32d2691 100644 --- a/analysis/analysis-api/testData/symbols/symbolByReference/functionReceiverParameter.kt +++ b/analysis/analysis-api/testData/symbols/symbolByReference/functionReceiverParameter.kt @@ -1,3 +1,4 @@ +// IGNORE_FIR annotation class ReceiverAnnotation @Target(AnnotationTarget.TYPE) annotation class ReceiverTypeAnnotation diff --git a/analysis/analysis-api/testData/symbols/symbolByReference/propertyReceiverParameter.kt b/analysis/analysis-api/testData/symbols/symbolByReference/propertyReceiverParameter.kt index 23b53024a61..b9212f10be1 100644 --- a/analysis/analysis-api/testData/symbols/symbolByReference/propertyReceiverParameter.kt +++ b/analysis/analysis-api/testData/symbols/symbolByReference/propertyReceiverParameter.kt @@ -1,3 +1,4 @@ +// IGNORE_FIR // DO_NOT_CHECK_NON_PSI_SYMBOL_RESTORE_K1 annotation class ReceiverAnnotation @Target(AnnotationTarget.TYPE) diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/lazy/resolve/LLFirModuleLazyDeclarationResolver.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/lazy/resolve/LLFirModuleLazyDeclarationResolver.kt index 1b93a9ded00..88e416f7bda 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/lazy/resolve/LLFirModuleLazyDeclarationResolver.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/lazy/resolve/LLFirModuleLazyDeclarationResolver.kt @@ -33,6 +33,7 @@ import org.jetbrains.kotlin.psi.KtClassBody import org.jetbrains.kotlin.psi.KtDeclaration import org.jetbrains.kotlin.psi.KtEnumEntry import org.jetbrains.kotlin.analysis.utils.errors.buildErrorWithAttachment +import org.jetbrains.kotlin.psi.KtPrimaryConstructor internal class LLFirModuleLazyDeclarationResolver(val moduleComponents: LLFirModuleResolveComponents) { /** @@ -308,10 +309,12 @@ internal class LLFirModuleLazyDeclarationResolver(val moduleComponents: LLFirMod ?: error("Container for local declaration cannot be null") val isLocalDeclarationResolveRequested = possiblyLocalDeclaration != nonLocalDeclaration + val isValueParameterInsidePrimaryConstructor = firDeclarationToResolve is FirValueParameter + && possiblyLocalDeclaration is KtPrimaryConstructor val declarationToResolve: FirDeclaration - if (isLocalDeclarationResolveRequested) { + if (isLocalDeclarationResolveRequested && !isValueParameterInsidePrimaryConstructor) { val enumEntry = possiblyLocalDeclaration.getContainingEnumEntryAsMemberOfEnumEntry() ?: return declarationToResolve = enumEntry.findSourceNonLocalFirDeclaration( diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/lazy/resolve/ResolveTreeBuilder.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/lazy/resolve/ResolveTreeBuilder.kt index 4ab6ae550e0..796a4bc0e02 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/lazy/resolve/ResolveTreeBuilder.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/lazy/resolve/ResolveTreeBuilder.kt @@ -33,6 +33,7 @@ internal object ResolveTreeBuilder { FirResolvePhase.ARGUMENTS_OF_ANNOTATIONS -> "ArgumentsOfAnnotations" FirResolvePhase.CONTRACTS -> "Contracts" FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE -> "ImplicitTypes" + FirResolvePhase.ANNOTATIONS_ARGUMENTS_MAPPING -> "AnnotationsArgumentsMapping" FirResolvePhase.BODY_RESOLVE -> "Body" else -> "?" } diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedAnnotationArgumentsMappingTransformer.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedAnnotationArgumentsMappingTransformer.kt new file mode 100644 index 00000000000..7f89a18f2e6 --- /dev/null +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedAnnotationArgumentsMappingTransformer.kt @@ -0,0 +1,61 @@ +/* + * Copyright 2010-2020 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.analysis.low.level.api.fir.transformers + +import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirPhaseRunner +import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDeclarationDesignationWithFile +import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.ResolveTreeBuilder +import org.jetbrains.kotlin.analysis.low.level.api.fir.transformers.LLFirLazyTransformer.Companion.updatePhaseDeep +import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkAnnotationArgumentsMappingIsResolved +import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkPhase +import org.jetbrains.kotlin.fir.FirSession +import org.jetbrains.kotlin.fir.declarations.FirDeclaration +import org.jetbrains.kotlin.fir.declarations.FirFile +import org.jetbrains.kotlin.fir.declarations.FirResolvePhase +import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall +import org.jetbrains.kotlin.fir.resolve.ResolutionMode +import org.jetbrains.kotlin.fir.resolve.ScopeSession +import org.jetbrains.kotlin.fir.resolve.transformers.plugin.FirAnnotationArgumentsMappingTransformer + +/** + * Transform designation into ANNOTATIONS_ARGUMENTS_MAPPING declaration. Affects only for target declaration, it's children and dependents + */ +internal class LLFirDesignatedAnnotationArgumentsMappingTransformer( + private val designation: FirDeclarationDesignationWithFile, + session: FirSession, + scopeSession: ScopeSession, +) : LLFirLazyTransformer, FirAnnotationArgumentsMappingTransformer(session, scopeSession, FirResolvePhase.ANNOTATIONS_ARGUMENTS_MAPPING) { + private val ideDeclarationTransformer = LLFirDeclarationTransformer(designation) + + override fun transformDeclarationContent(declaration: FirDeclaration, data: ResolutionMode): FirDeclaration = + ideDeclarationTransformer.transformDeclarationContent(this, declaration, data) { + super.transformDeclarationContent(declaration, data) + } + + override fun transformDeclaration(phaseRunner: LLFirPhaseRunner) { + if (designation.declaration.resolvePhase >= FirResolvePhase.ANNOTATIONS_ARGUMENTS_MAPPING) return + designation.declaration.checkPhase(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE) + + ResolveTreeBuilder.resolvePhase(designation.declaration, FirResolvePhase.ANNOTATIONS_ARGUMENTS_MAPPING) { + phaseRunner.runPhaseWithCustomResolve(FirResolvePhase.ANNOTATIONS_ARGUMENTS_MAPPING) { + designation.firFile.transform(this, ResolutionMode.ContextIndependent) + } + } + + updatePhaseDeep(designation.declaration, FirResolvePhase.ANNOTATIONS_ARGUMENTS_MAPPING) + checkIsResolved(designation.declaration) + } + + override fun checkIsResolved(declaration: FirDeclaration) { + declaration.checkPhase(FirResolvePhase.ANNOTATIONS_ARGUMENTS_MAPPING) + for (annotation in declaration.annotations) { + if (annotation is FirAnnotationCall) { + checkAnnotationArgumentsMappingIsResolved(annotation, declaration) + } + } + checkNestedDeclarationsAreResolved(declaration) + } +} diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LazyTransformerFactory.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LazyTransformerFactory.kt index c56178095c6..83fec7e2a68 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LazyTransformerFactory.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LazyTransformerFactory.kt @@ -67,6 +67,11 @@ internal object LazyTransformerFactory { scopeSession, towerDataContextCollector ) + FirResolvePhase.ANNOTATIONS_ARGUMENTS_MAPPING -> LLFirDesignatedAnnotationArgumentsMappingTransformer( + designation, + designation.firFile.moduleData.session, + scopeSession, + ) FirResolvePhase.BODY_RESOLVE -> LLFirDesignatedBodyResolveTransformer( designation, designation.firFile.moduleData.session, diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/util/firCheckResolvedUtils.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/util/firCheckResolvedUtils.kt index cc0a0e74264..83560329efb 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/util/firCheckResolvedUtils.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/util/firCheckResolvedUtils.kt @@ -10,6 +10,8 @@ import org.jetbrains.kotlin.analysis.utils.errors.checkWithAttachmentBuilder import org.jetbrains.kotlin.fir.contracts.FirResolvedContractDescription import org.jetbrains.kotlin.fir.contracts.impl.FirEmptyContractDescription import org.jetbrains.kotlin.fir.declarations.* +import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall +import org.jetbrains.kotlin.fir.expressions.impl.FirResolvedArgumentList import org.jetbrains.kotlin.fir.types.FirImplicitTypeRef import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef import org.jetbrains.kotlin.fir.types.FirTypeRef @@ -68,3 +70,24 @@ internal fun checkDeclarationStatusIsResolved(declaration: FirMemberDeclaration) withFirEntry("declaration", declaration) } } + +internal inline fun checkAnnotationArgumentsMappingIsResolved( + annotation: FirAnnotationCall, + owner: FirDeclaration, + extraAttachment: ExceptionAttachmentBuilder.() -> Unit = {} +) { + checkWithAttachmentBuilder( + condition = annotation.argumentList is FirResolvedArgumentList, + message = { + buildString { + append("Expected ${FirResolvedArgumentList::class.simpleName}") + append(" for ${annotation::class.simpleName} of ${owner::class.simpleName}(${owner.origin})") + append(" but ${annotation.argumentList::class.simpleName} found") + } + } + ) { + withFirEntry("annotation", annotation) + withFirEntry("firDeclaration", owner) + extraAttachment() + } +} diff --git a/analysis/low-level-api-fir/testdata/lazyResolve/annotationParameters.txt b/analysis/low-level-api-fir/testdata/lazyResolve/annotationParameters.txt index 9e0655433d5..cc85e3f1375 100644 --- a/analysis/low-level-api-fir/testdata/lazyResolve/annotationParameters.txt +++ b/analysis/low-level-api-fir/testdata/lazyResolve/annotationParameters.txt @@ -381,6 +381,45 @@ FILE: annotationParameters.kt } +ANNOTATIONS_ARGUMENTS_MAPPING: +FILE: annotationParameters.kt + public final [STATUS] enum class X : R|kotlin/Enum| { + private [STATUS] [ContainingClassKey=X] constructor(): R|X| { + super|>() + } + + public final static [STATUS] [ContainingClassKey=X] enum entry A: R|X| + public final static [BODY_RESOLVE] [ContainingClassKey=X] fun values(): R|kotlin/Array| { + } + + public final static [BODY_RESOLVE] [ContainingClassKey=X] fun valueOf([BODY_RESOLVE] value: R|kotlin/String|): R|X| { + } + + public final static [BODY_RESOLVE] [ContainingClassKey=X] val entries: R|kotlin/enums/EnumEntries| + public [RAW_FIR] get(): R|kotlin/enums/EnumEntries| + + } + public final [SUPER_TYPES] annotation class Anno : R|kotlin/Annotation| { + public [STATUS] [ContainingClassKey=Anno] constructor([STATUS] [CorrespondingProperty=/Anno.args] args: ): R|Anno| { + super() + } + + public? final? [SUPER_TYPES] [IsFromPrimaryConstructor=true] val args: A.X = R|/args| + public? [SUPER_TYPES] [ContainingClassKey=Anno] get(): A.X + + } + public final [STATUS] class B : R|kotlin/Any| { + public [STATUS] [ContainingClassKey=B] constructor(): R|B| { + super() + } + + @R|Anno|(args = Q|X|.R|/X.A|) public final [ANNOTATIONS_ARGUMENTS_MAPPING] fun resolveMe(): R|kotlin/Unit| { + } + + @R|Anno|(X#.A#) public final [STATUS] fun foo(): R|kotlin/Unit| { LAZY_BLOCK } + + } + EXPECT_ACTUAL_MATCHING: FILE: annotationParameters.kt public final [STATUS] enum class X : R|kotlin/Enum| { @@ -399,13 +438,13 @@ FILE: annotationParameters.kt public [RAW_FIR] get(): R|kotlin/enums/EnumEntries| } - public? final? [COMPILER_REQUIRED_ANNOTATIONS] annotation class Anno : R|kotlin/Annotation| { - public? [COMPILER_REQUIRED_ANNOTATIONS] [ContainingClassKey=Anno] constructor([COMPILER_REQUIRED_ANNOTATIONS] [CorrespondingProperty=/Anno.args] args: A.X): R|Anno| { + public final [SUPER_TYPES] annotation class Anno : R|kotlin/Annotation| { + public [STATUS] [ContainingClassKey=Anno] constructor([STATUS] [CorrespondingProperty=/Anno.args] args: ): R|Anno| { super() } - public? final? [COMPILER_REQUIRED_ANNOTATIONS] [IsFromPrimaryConstructor=true] val args: A.X = R|/args| - public? [COMPILER_REQUIRED_ANNOTATIONS] [ContainingClassKey=Anno] get(): A.X + public? final? [SUPER_TYPES] [IsFromPrimaryConstructor=true] val args: A.X = R|/args| + public? [SUPER_TYPES] [ContainingClassKey=Anno] get(): A.X } public final [STATUS] class B : R|kotlin/Any| { @@ -413,7 +452,7 @@ FILE: annotationParameters.kt super() } - @R|Anno|(Q|X|.R|/X.A|) public final [EXPECT_ACTUAL_MATCHING] fun resolveMe(): R|kotlin/Unit| { + @R|Anno|(args = Q|X|.R|/X.A|) public final [EXPECT_ACTUAL_MATCHING] fun resolveMe(): R|kotlin/Unit| { } @R|Anno|(X#.A#) public final [STATUS] fun foo(): R|kotlin/Unit| { LAZY_BLOCK } diff --git a/analysis/low-level-api-fir/testdata/lazyResolve/annotations.txt b/analysis/low-level-api-fir/testdata/lazyResolve/annotations.txt index 9015a84da75..21146218ee2 100644 --- a/analysis/low-level-api-fir/testdata/lazyResolve/annotations.txt +++ b/analysis/low-level-api-fir/testdata/lazyResolve/annotations.txt @@ -51,10 +51,16 @@ FILE: annotations.kt @R|kotlin/Suppress|(String(2)) public final [IMPLICIT_TYPES_BODY_RESOLVE] fun resolveMe(): R|kotlin/Unit| { } +ANNOTATIONS_ARGUMENTS_MAPPING: +FILE: annotations.kt + @FILE:Suppress(String(1)) + @R|kotlin/Suppress|(names = vararg(String(2))) public final [ANNOTATIONS_ARGUMENTS_MAPPING] fun resolveMe(): R|kotlin/Unit| { + } + EXPECT_ACTUAL_MATCHING: FILE: annotations.kt @FILE:Suppress(String(1)) - @R|kotlin/Suppress|(String(2)) public final [EXPECT_ACTUAL_MATCHING] fun resolveMe(): R|kotlin/Unit| { + @R|kotlin/Suppress|(names = vararg(String(2))) public final [EXPECT_ACTUAL_MATCHING] fun resolveMe(): R|kotlin/Unit| { } BODY_RESOLVE: diff --git a/analysis/low-level-api-fir/testdata/lazyResolve/classMembers.txt b/analysis/low-level-api-fir/testdata/lazyResolve/classMembers.txt index 3c9a8c3b5fb..b9d7b6d90da 100644 --- a/analysis/low-level-api-fir/testdata/lazyResolve/classMembers.txt +++ b/analysis/low-level-api-fir/testdata/lazyResolve/classMembers.txt @@ -183,6 +183,26 @@ FILE: classMembers.kt } +ANNOTATIONS_ARGUMENTS_MAPPING: +FILE: classMembers.kt + public final [STATUS] class A : R|kotlin/Any| { + public [STATUS] [ContainingClassKey=A] constructor(): R|A| { + super() + } + + public final [ANNOTATIONS_ARGUMENTS_MAPPING] fun resolveMe(): R|kotlin/Unit| { + receive#(functionWithLazyBody#()) + } + + public final [STATUS] val x: R|kotlin/Int| = LAZY_EXPRESSION + public [STATUS] [ContainingClassKey=A] get(): R|kotlin/Int| { LAZY_BLOCK } + + public final [STATUS] fun receive([STATUS] value: R|kotlin/String|): R|kotlin/Unit| { LAZY_BLOCK } + + public final [STATUS] fun functionWithLazyBody(): R|kotlin/String| { LAZY_BLOCK } + + } + EXPECT_ACTUAL_MATCHING: FILE: classMembers.kt public final [STATUS] class A : R|kotlin/Any| { diff --git a/analysis/low-level-api-fir/testdata/lazyResolve/classes/classWithTypeParameters.txt b/analysis/low-level-api-fir/testdata/lazyResolve/classes/classWithTypeParameters.txt index 01c3e552a56..6315170838c 100644 --- a/analysis/low-level-api-fir/testdata/lazyResolve/classes/classWithTypeParameters.txt +++ b/analysis/low-level-api-fir/testdata/lazyResolve/classes/classWithTypeParameters.txt @@ -89,6 +89,15 @@ FILE: classWithTypeParameters.kt } +ANNOTATIONS_ARGUMENTS_MAPPING: +FILE: classWithTypeParameters.kt + public final [ANNOTATIONS_ARGUMENTS_MAPPING] class ResolveMe<[ANNOTATIONS_ARGUMENTS_MAPPING] T : R|kotlin/Int|, [ANNOTATIONS_ARGUMENTS_MAPPING] K> : R|kotlin/Any| { + public [ANNOTATIONS_ARGUMENTS_MAPPING] [ContainingClassKey=ResolveMe] constructor<[ANNOTATIONS_ARGUMENTS_MAPPING] T : R|kotlin/Int|, [ANNOTATIONS_ARGUMENTS_MAPPING] K>(): R|ResolveMe| { + super() + } + + } + EXPECT_ACTUAL_MATCHING: FILE: classWithTypeParameters.kt public final [EXPECT_ACTUAL_MATCHING] class ResolveMe<[EXPECT_ACTUAL_MATCHING] T : R|kotlin/Int|, [EXPECT_ACTUAL_MATCHING] K> : R|kotlin/Any| { diff --git a/analysis/low-level-api-fir/testdata/lazyResolve/classes/functionInValueClass.txt b/analysis/low-level-api-fir/testdata/lazyResolve/classes/functionInValueClass.txt index 481b77440ac..7ebc32afa6e 100644 --- a/analysis/low-level-api-fir/testdata/lazyResolve/classes/functionInValueClass.txt +++ b/analysis/low-level-api-fir/testdata/lazyResolve/classes/functionInValueClass.txt @@ -141,6 +141,21 @@ FILE: functionInValueClass.kt } +ANNOTATIONS_ARGUMENTS_MAPPING: +FILE: functionInValueClass.kt + @R|kotlin/jvm/JvmInline|() public final inline [STATUS] [FirValueClassRepresentationKey=InlineClassRepresentation(underlyingPropertyName=value, underlyingType=kotlin/Int)] class Value : R|kotlin/Any| { + public [STATUS] [ContainingClassKey=Value] constructor([STATUS] [CorrespondingProperty=/Value.value] value: R|kotlin/Int|): R|Value| { + super() + } + + public final [STATUS] [IsFromPrimaryConstructor=true] val value: R|kotlin/Int| = R|/value| + public [STATUS] [ContainingClassKey=Value] get(): R|kotlin/Int| + + public final [ANNOTATIONS_ARGUMENTS_MAPPING] fun resolveMe(): R|kotlin/Unit| { + } + + } + EXPECT_ACTUAL_MATCHING: FILE: functionInValueClass.kt @R|kotlin/jvm/JvmInline|() public final inline [STATUS] [FirValueClassRepresentationKey=InlineClassRepresentation(underlyingPropertyName=value, underlyingType=kotlin/Int)] class Value : R|kotlin/Any| { diff --git a/analysis/low-level-api-fir/testdata/lazyResolve/delegates.txt b/analysis/low-level-api-fir/testdata/lazyResolve/delegates.txt index 59d960af472..e3e6043ef2c 100644 --- a/analysis/low-level-api-fir/testdata/lazyResolve/delegates.txt +++ b/analysis/low-level-api-fir/testdata/lazyResolve/delegates.txt @@ -299,6 +299,40 @@ FILE: delegates.kt D|/variableWithImplicitType|.setValue#(Null(null), ::R|/variableWithImplicitType|, R|/variableWithImplicitType|) } +ANNOTATIONS_ARGUMENTS_MAPPING: +FILE: delegates.kt + public final [ANNOTATIONS_ARGUMENTS_MAPPING] fun resolveMe(): R|kotlin/Unit| { + receive#(valueWithExplicitType#) + receive#(valueWithImplicitType#) + variableWithExplicitType# = IntegerLiteral(10) + variableWithImplicitType# = IntegerLiteral(10) + } + public? final? [RAW_FIR] fun receive([RAW_FIR] value: Int): R|kotlin/Unit| { LAZY_BLOCK } + public? final? [RAW_FIR] val delegate: = LAZY_EXPRESSION + public? [RAW_FIR] get(): + public? final? [RAW_FIR] val valueWithExplicitType: Intby LAZY_EXPRESSION + public? [RAW_FIR] get(): { + ^ D|/valueWithExplicitType|.getValue#(Null(null), ::R|/valueWithExplicitType|) + } + public? final? [RAW_FIR] val valueWithImplicitType: by LAZY_EXPRESSION + public? [RAW_FIR] get(): { + ^ D|/valueWithImplicitType|.getValue#(Null(null), ::R|/valueWithImplicitType|) + } + public? final? [RAW_FIR] var variableWithExplicitType: Intby LAZY_EXPRESSION + public? [RAW_FIR] get(): { + ^ D|/variableWithExplicitType|.getValue#(Null(null), ::R|/variableWithExplicitType|) + } + public? [RAW_FIR] set([RAW_FIR] : ): R|kotlin/Unit| { + D|/variableWithExplicitType|.setValue#(Null(null), ::R|/variableWithExplicitType|, R|/variableWithExplicitType|) + } + public? final? [RAW_FIR] var variableWithImplicitType: by LAZY_EXPRESSION + public? [RAW_FIR] get(): { + ^ D|/variableWithImplicitType|.getValue#(Null(null), ::R|/variableWithImplicitType|) + } + public? [RAW_FIR] set([RAW_FIR] : ): R|kotlin/Unit| { + D|/variableWithImplicitType|.setValue#(Null(null), ::R|/variableWithImplicitType|, R|/variableWithImplicitType|) + } + EXPECT_ACTUAL_MATCHING: FILE: delegates.kt public final [EXPECT_ACTUAL_MATCHING] fun resolveMe(): R|kotlin/Unit| { diff --git a/analysis/low-level-api-fir/testdata/lazyResolve/errors/anonympuseObjectInInvalidPosition.txt b/analysis/low-level-api-fir/testdata/lazyResolve/errors/anonympuseObjectInInvalidPosition.txt index e83e7c797bb..de26931600b 100644 --- a/analysis/low-level-api-fir/testdata/lazyResolve/errors/anonympuseObjectInInvalidPosition.txt +++ b/analysis/low-level-api-fir/testdata/lazyResolve/errors/anonympuseObjectInInvalidPosition.txt @@ -107,6 +107,24 @@ FILE: anonympuseObjectInInvalidPosition.kt } +ANNOTATIONS_ARGUMENTS_MAPPING: +FILE: anonympuseObjectInInvalidPosition.kt + private final [ANNOTATIONS_ARGUMENTS_MAPPING] val resolveMe: = ERROR_EXPR(Should have initializer)# = object : A { + private [RAW_FIR] [ContainingClassKey=] constructor(): R|| { + super<>() + } + + public? open? override [RAW_FIR] fun x(): R|kotlin/Unit| { + } + + } + + private [ANNOTATIONS_ARGUMENTS_MAPPING] get(): + public? final? [COMPILER_REQUIRED_ANNOTATIONS] interface A<[COMPILER_REQUIRED_ANNOTATIONS] T> : R|kotlin/Any| { + public? final? [COMPILER_REQUIRED_ANNOTATIONS] fun x(): R|kotlin/Unit| + + } + EXPECT_ACTUAL_MATCHING: FILE: anonympuseObjectInInvalidPosition.kt private final [EXPECT_ACTUAL_MATCHING] val resolveMe: = ERROR_EXPR(Should have initializer)# = object : A { diff --git a/analysis/low-level-api-fir/testdata/lazyResolve/functionWithParameter.txt b/analysis/low-level-api-fir/testdata/lazyResolve/functionWithParameter.txt index 245bce36ccf..5ceb9db143b 100644 --- a/analysis/low-level-api-fir/testdata/lazyResolve/functionWithParameter.txt +++ b/analysis/low-level-api-fir/testdata/lazyResolve/functionWithParameter.txt @@ -63,6 +63,14 @@ FILE: functionWithParameter.kt ^resolveMe Q|kotlin/Unit| } +ANNOTATIONS_ARGUMENTS_MAPPING: +FILE: functionWithParameter.kt + public? final? [COMPILER_REQUIRED_ANNOTATIONS] interface I : R|kotlin/Any| { + } + public final [ANNOTATIONS_ARGUMENTS_MAPPING] fun resolveMe([ANNOTATIONS_ARGUMENTS_MAPPING] param: R|I|): R|kotlin/Unit| { + ^resolveMe Q|kotlin/Unit| + } + EXPECT_ACTUAL_MATCHING: FILE: functionWithParameter.kt public? final? [COMPILER_REQUIRED_ANNOTATIONS] interface I : R|kotlin/Any| { diff --git a/analysis/low-level-api-fir/testdata/lazyResolve/functions/functionWithTypeParameters.txt b/analysis/low-level-api-fir/testdata/lazyResolve/functions/functionWithTypeParameters.txt index d13bb1be203..6137113a800 100644 --- a/analysis/low-level-api-fir/testdata/lazyResolve/functions/functionWithTypeParameters.txt +++ b/analysis/low-level-api-fir/testdata/lazyResolve/functions/functionWithTypeParameters.txt @@ -41,6 +41,11 @@ FILE: functionWithTypeParameters.kt public final [IMPLICIT_TYPES_BODY_RESOLVE] fun <[IMPLICIT_TYPES_BODY_RESOLVE] T : R|kotlin/Int|, [IMPLICIT_TYPES_BODY_RESOLVE] K> resolveMe(): R|kotlin/Unit| { } +ANNOTATIONS_ARGUMENTS_MAPPING: +FILE: functionWithTypeParameters.kt + public final [ANNOTATIONS_ARGUMENTS_MAPPING] fun <[ANNOTATIONS_ARGUMENTS_MAPPING] T : R|kotlin/Int|, [ANNOTATIONS_ARGUMENTS_MAPPING] K> resolveMe(): R|kotlin/Unit| { + } + EXPECT_ACTUAL_MATCHING: FILE: functionWithTypeParameters.kt public final [EXPECT_ACTUAL_MATCHING] fun <[EXPECT_ACTUAL_MATCHING] T : R|kotlin/Int|, [EXPECT_ACTUAL_MATCHING] K> resolveMe(): R|kotlin/Unit| { diff --git a/analysis/low-level-api-fir/testdata/lazyResolve/lambdaAsSAMInterface.txt b/analysis/low-level-api-fir/testdata/lazyResolve/lambdaAsSAMInterface.txt index b9e92e54d4f..3ea3e9a9054 100644 --- a/analysis/low-level-api-fir/testdata/lazyResolve/lambdaAsSAMInterface.txt +++ b/analysis/low-level-api-fir/testdata/lazyResolve/lambdaAsSAMInterface.txt @@ -159,6 +159,26 @@ FILE: lambdaAsSAMInterface.kt ) } +ANNOTATIONS_ARGUMENTS_MAPPING: +FILE: lambdaAsSAMInterface.kt + public? final? [RAW_FIR] class Arg : R|kotlin/Any| { + public? [RAW_FIR] [ContainingClassKey=Arg] constructor(): R|foo/Arg| { + super() + } + + } + public? final? fun [RAW_FIR] interface Foo : R|kotlin/Any| { + public? final? [RAW_FIR] fun foo([RAW_FIR] a: Arg): Arg + + } + public? final? [RAW_FIR] fun testMe([RAW_FIR] f: Foo): R|kotlin/Unit| { LAZY_BLOCK } + public final [ANNOTATIONS_ARGUMENTS_MAPPING] fun resolveMe(): R|kotlin/Unit| { + testMe#( = [STATUS] testMe@fun .([RAW_FIR] b: ): { + b# + } + ) + } + EXPECT_ACTUAL_MATCHING: FILE: lambdaAsSAMInterface.kt public? final? [RAW_FIR] class Arg : R|kotlin/Any| { diff --git a/analysis/low-level-api-fir/testdata/lazyResolve/parameterOfNonLocalSetter.txt b/analysis/low-level-api-fir/testdata/lazyResolve/parameterOfNonLocalSetter.txt index 11628cddec2..90c60d77a99 100644 --- a/analysis/low-level-api-fir/testdata/lazyResolve/parameterOfNonLocalSetter.txt +++ b/analysis/low-level-api-fir/testdata/lazyResolve/parameterOfNonLocalSetter.txt @@ -133,6 +133,21 @@ FILE: parameterOfNonLocalSetter.kt } +ANNOTATIONS_ARGUMENTS_MAPPING: +FILE: parameterOfNonLocalSetter.kt + public final [STATUS] class X : R|kotlin/Any| { + public [STATUS] [ContainingClassKey=X] constructor(): R|X| { + super() + } + + public final [ANNOTATIONS_ARGUMENTS_MAPPING] var x: R|kotlin/Int| = IntegerLiteral(2) + public [ANNOTATIONS_ARGUMENTS_MAPPING] [ContainingClassKey=X] get(): R|kotlin/Int| + public [ANNOTATIONS_ARGUMENTS_MAPPING] [ContainingClassKey=X] set([ANNOTATIONS_ARGUMENTS_MAPPING] resolveMe: R|kotlin/Int|): R|kotlin/Unit| { + ^ Unit# + } + + } + EXPECT_ACTUAL_MATCHING: FILE: parameterOfNonLocalSetter.kt public final [STATUS] class X : R|kotlin/Any| { diff --git a/analysis/low-level-api-fir/testdata/lazyResolve/properties/propertyWithTypeParameters.txt b/analysis/low-level-api-fir/testdata/lazyResolve/properties/propertyWithTypeParameters.txt index f43f03a5b82..7c31c9f4229 100644 --- a/analysis/low-level-api-fir/testdata/lazyResolve/properties/propertyWithTypeParameters.txt +++ b/analysis/low-level-api-fir/testdata/lazyResolve/properties/propertyWithTypeParameters.txt @@ -53,6 +53,13 @@ FILE: propertyWithTypeParameters.kt ^ TODO#() } +ANNOTATIONS_ARGUMENTS_MAPPING: +FILE: propertyWithTypeParameters.kt + public final [ANNOTATIONS_ARGUMENTS_MAPPING] val <[ANNOTATIONS_ARGUMENTS_MAPPING] T : R|kotlin/Int|, [ANNOTATIONS_ARGUMENTS_MAPPING] K> R|T|.resolveMe: R|K| + public [ANNOTATIONS_ARGUMENTS_MAPPING] get(): R|K| { + ^ TODO#() + } + EXPECT_ACTUAL_MATCHING: FILE: propertyWithTypeParameters.kt public final [EXPECT_ACTUAL_MATCHING] val <[EXPECT_ACTUAL_MATCHING] T : R|kotlin/Int|, [EXPECT_ACTUAL_MATCHING] K> R|T|.resolveMe: R|K| diff --git a/analysis/low-level-api-fir/testdata/lazyResolve/propertyWithGetter.txt b/analysis/low-level-api-fir/testdata/lazyResolve/propertyWithGetter.txt index c1422096075..5af72baa931 100644 --- a/analysis/low-level-api-fir/testdata/lazyResolve/propertyWithGetter.txt +++ b/analysis/low-level-api-fir/testdata/lazyResolve/propertyWithGetter.txt @@ -73,6 +73,15 @@ FILE: propertyWithGetter.kt public? final? [RAW_FIR] val withGetter: Int public? [RAW_FIR] get(): Int { LAZY_BLOCK } +ANNOTATIONS_ARGUMENTS_MAPPING: +FILE: propertyWithGetter.kt + public final [ANNOTATIONS_ARGUMENTS_MAPPING] fun resolveMe(): R|kotlin/Unit| { + receive#(withGetter#) + } + public? final? [RAW_FIR] fun receive([RAW_FIR] value: Int): R|kotlin/Unit| { LAZY_BLOCK } + public? final? [RAW_FIR] val withGetter: Int + public? [RAW_FIR] get(): Int { LAZY_BLOCK } + EXPECT_ACTUAL_MATCHING: FILE: propertyWithGetter.kt public final [EXPECT_ACTUAL_MATCHING] fun resolveMe(): R|kotlin/Unit| { diff --git a/analysis/low-level-api-fir/testdata/lazyResolve/propertyWithGetterAndSetter.txt b/analysis/low-level-api-fir/testdata/lazyResolve/propertyWithGetterAndSetter.txt index 661f49323fa..08eb8ccb2fa 100644 --- a/analysis/low-level-api-fir/testdata/lazyResolve/propertyWithGetterAndSetter.txt +++ b/analysis/low-level-api-fir/testdata/lazyResolve/propertyWithGetterAndSetter.txt @@ -85,6 +85,17 @@ FILE: propertyWithGetterAndSetter.kt public? [RAW_FIR] get(): Int { LAZY_BLOCK } public? [RAW_FIR] set([RAW_FIR] value: Int): R|kotlin/Unit| { LAZY_BLOCK } +ANNOTATIONS_ARGUMENTS_MAPPING: +FILE: propertyWithGetterAndSetter.kt + public final [ANNOTATIONS_ARGUMENTS_MAPPING] fun resolveMe(): R|kotlin/Unit| { + receive#(withGetterAndSetter#) + withGetterAndSetter# = IntegerLiteral(123) + } + public? final? [RAW_FIR] fun receive([RAW_FIR] value: Int): R|kotlin/Unit| { LAZY_BLOCK } + public? final? [RAW_FIR] var withGetterAndSetter: Int = LAZY_EXPRESSION + public? [RAW_FIR] get(): Int { LAZY_BLOCK } + public? [RAW_FIR] set([RAW_FIR] value: Int): R|kotlin/Unit| { LAZY_BLOCK } + EXPECT_ACTUAL_MATCHING: FILE: propertyWithGetterAndSetter.kt public final [EXPECT_ACTUAL_MATCHING] fun resolveMe(): R|kotlin/Unit| { diff --git a/analysis/low-level-api-fir/testdata/lazyResolve/propertyWithInitializer.txt b/analysis/low-level-api-fir/testdata/lazyResolve/propertyWithInitializer.txt index 8c1389a9a01..a107c71fb09 100644 --- a/analysis/low-level-api-fir/testdata/lazyResolve/propertyWithInitializer.txt +++ b/analysis/low-level-api-fir/testdata/lazyResolve/propertyWithInitializer.txt @@ -63,6 +63,14 @@ FILE: propertyWithInitializer.kt public? final? [RAW_FIR] val property: Int = LAZY_EXPRESSION public? [RAW_FIR] get(): Int +ANNOTATIONS_ARGUMENTS_MAPPING: +FILE: propertyWithInitializer.kt + public final [ANNOTATIONS_ARGUMENTS_MAPPING] fun resolveMe(): R|kotlin/Unit| { + receive#(property#) + } + public? final? [RAW_FIR] val property: Int = LAZY_EXPRESSION + public? [RAW_FIR] get(): Int + EXPECT_ACTUAL_MATCHING: FILE: propertyWithInitializer.kt public final [EXPECT_ACTUAL_MATCHING] fun resolveMe(): R|kotlin/Unit| { diff --git a/analysis/low-level-api-fir/testdata/lazyResolve/secondaryConstructor.txt b/analysis/low-level-api-fir/testdata/lazyResolve/secondaryConstructor.txt index 28e1f7db40f..83a27dcc6ec 100644 --- a/analysis/low-level-api-fir/testdata/lazyResolve/secondaryConstructor.txt +++ b/analysis/low-level-api-fir/testdata/lazyResolve/secondaryConstructor.txt @@ -123,6 +123,20 @@ FILE: secondaryConstructor.kt } +ANNOTATIONS_ARGUMENTS_MAPPING: +FILE: secondaryConstructor.kt + public final [ANNOTATIONS_ARGUMENTS_MAPPING] fun resolveMe(): R|kotlin/Unit| { + receive#(A#(IntegerLiteral(42))) + } + public? final? [RAW_FIR] fun receive([RAW_FIR] value: A): R|kotlin/Unit| { LAZY_BLOCK } + public? final? [RAW_FIR] class A : R|kotlin/Any| { + public? [RAW_FIR] [ContainingClassKey=A] constructor([RAW_FIR] x: Int): R|A| { + super() + [RAW_FIR] lval a: = x# + } + + } + EXPECT_ACTUAL_MATCHING: FILE: secondaryConstructor.kt public final [EXPECT_ACTUAL_MATCHING] fun resolveMe(): R|kotlin/Unit| { diff --git a/analysis/low-level-api-fir/testdata/lazyResolve/superTypes.txt b/analysis/low-level-api-fir/testdata/lazyResolve/superTypes.txt index a05e71dd1d0..ea45152c8ee 100644 --- a/analysis/low-level-api-fir/testdata/lazyResolve/superTypes.txt +++ b/analysis/low-level-api-fir/testdata/lazyResolve/superTypes.txt @@ -209,6 +209,27 @@ FILE: superTypes.kt } +ANNOTATIONS_ARGUMENTS_MAPPING: +FILE: superTypes.kt + public open [TYPES] class A : R|kotlin/Any| { + public [TYPES] [ContainingClassKey=A] constructor(): R|A| { + super() + } + + } + public? open [RAW_FIR] class B : A { + public? [RAW_FIR] [ContainingClassKey=B] constructor(): R|B| { + super() + } + + } + public open [ANNOTATIONS_ARGUMENTS_MAPPING] class resolveMe : R|A| { + public [ANNOTATIONS_ARGUMENTS_MAPPING] [ContainingClassKey=resolveMe] constructor(): R|resolveMe| { + super() + } + + } + EXPECT_ACTUAL_MATCHING: FILE: superTypes.kt public open [TYPES] class A : R|kotlin/Any| { diff --git a/analysis/low-level-api-fir/testdata/lazyResolve/superTypesLoop.txt b/analysis/low-level-api-fir/testdata/lazyResolve/superTypesLoop.txt index c6f663b0afd..c9c52ec9881 100644 --- a/analysis/low-level-api-fir/testdata/lazyResolve/superTypesLoop.txt +++ b/analysis/low-level-api-fir/testdata/lazyResolve/superTypesLoop.txt @@ -269,6 +269,33 @@ FILE: superTypesLoop.kt } +ANNOTATIONS_ARGUMENTS_MAPPING: +FILE: superTypesLoop.kt + public open [ANNOTATIONS_ARGUMENTS_MAPPING] class resolveMe : R|C| { + public [ANNOTATIONS_ARGUMENTS_MAPPING] [ContainingClassKey=resolveMe] constructor(): R|resolveMe| { + super() + } + + } + public? open [COMPILER_REQUIRED_ANNOTATIONS] class A : /B> { + public? [COMPILER_REQUIRED_ANNOTATIONS] [ContainingClassKey=A] constructor(): R|A| { + super() + } + + } + public? open [COMPILER_REQUIRED_ANNOTATIONS] class B : /C> { + public? [COMPILER_REQUIRED_ANNOTATIONS] [ContainingClassKey=B] constructor(): R|B| { + super() + } + + } + public open [TYPES] class C : /A> { + public [TYPES] [ContainingClassKey=C] constructor(): R|C| { + super() + } + + } + EXPECT_ACTUAL_MATCHING: FILE: superTypesLoop.kt public open [EXPECT_ACTUAL_MATCHING] class resolveMe : R|C| { diff --git a/analysis/low-level-api-fir/testdata/lazyResolve/topLevelFunctions.txt b/analysis/low-level-api-fir/testdata/lazyResolve/topLevelFunctions.txt index 13ccce70e25..02b03939c5c 100644 --- a/analysis/low-level-api-fir/testdata/lazyResolve/topLevelFunctions.txt +++ b/analysis/low-level-api-fir/testdata/lazyResolve/topLevelFunctions.txt @@ -63,6 +63,14 @@ FILE: topLevelFunctions.kt public? final? [RAW_FIR] fun receive([RAW_FIR] value: String): R|kotlin/Unit| { LAZY_BLOCK } public? final? [RAW_FIR] fun functionWithLazyBody(): String { LAZY_BLOCK } +ANNOTATIONS_ARGUMENTS_MAPPING: +FILE: topLevelFunctions.kt + public final [ANNOTATIONS_ARGUMENTS_MAPPING] fun resolveMe(): R|kotlin/Unit| { + receive#(functionWithLazyBody#()) + } + public? final? [RAW_FIR] fun receive([RAW_FIR] value: String): R|kotlin/Unit| { LAZY_BLOCK } + public? final? [RAW_FIR] fun functionWithLazyBody(): String { LAZY_BLOCK } + EXPECT_ACTUAL_MATCHING: FILE: topLevelFunctions.kt public final [EXPECT_ACTUAL_MATCHING] fun resolveMe(): R|kotlin/Unit| { diff --git a/analysis/low-level-api-fir/testdata/lazyResolve/topLevelFunctionsWithExpressionBodyAndExplicitType.txt b/analysis/low-level-api-fir/testdata/lazyResolve/topLevelFunctionsWithExpressionBodyAndExplicitType.txt index 904fa578f5d..27ea44e34ba 100644 --- a/analysis/low-level-api-fir/testdata/lazyResolve/topLevelFunctionsWithExpressionBodyAndExplicitType.txt +++ b/analysis/low-level-api-fir/testdata/lazyResolve/topLevelFunctionsWithExpressionBodyAndExplicitType.txt @@ -63,6 +63,14 @@ FILE: topLevelFunctionsWithExpressionBodyAndExplicitType.kt public? final? [RAW_FIR] fun receive([RAW_FIR] value: String): R|kotlin/Unit| { LAZY_BLOCK } public? final? [RAW_FIR] fun functionWithLazyBody(): String { LAZY_BLOCK } +ANNOTATIONS_ARGUMENTS_MAPPING: +FILE: topLevelFunctionsWithExpressionBodyAndExplicitType.kt + public final [ANNOTATIONS_ARGUMENTS_MAPPING] fun resolveMe(): R|kotlin/Unit| { + receive#(functionWithLazyBody#()) + } + public? final? [RAW_FIR] fun receive([RAW_FIR] value: String): R|kotlin/Unit| { LAZY_BLOCK } + public? final? [RAW_FIR] fun functionWithLazyBody(): String { LAZY_BLOCK } + EXPECT_ACTUAL_MATCHING: FILE: topLevelFunctionsWithExpressionBodyAndExplicitType.kt public final [EXPECT_ACTUAL_MATCHING] fun resolveMe(): R|kotlin/Unit| { diff --git a/analysis/low-level-api-fir/testdata/lazyResolve/topLevelFunctionsWithImplicitType.txt b/analysis/low-level-api-fir/testdata/lazyResolve/topLevelFunctionsWithImplicitType.txt index 0aea6704bb6..e33feff1072 100644 --- a/analysis/low-level-api-fir/testdata/lazyResolve/topLevelFunctionsWithImplicitType.txt +++ b/analysis/low-level-api-fir/testdata/lazyResolve/topLevelFunctionsWithImplicitType.txt @@ -63,6 +63,14 @@ FILE: topLevelFunctionsWithImplicitType.kt public? final? [RAW_FIR] fun receive([RAW_FIR] value: String): R|kotlin/Unit| { LAZY_BLOCK } public? final? [RAW_FIR] fun functionWithLazyBody(): { LAZY_BLOCK } +ANNOTATIONS_ARGUMENTS_MAPPING: +FILE: topLevelFunctionsWithImplicitType.kt + public final [ANNOTATIONS_ARGUMENTS_MAPPING] fun resolveMe(): R|kotlin/Unit| { + receive#(functionWithLazyBody#()) + } + public? final? [RAW_FIR] fun receive([RAW_FIR] value: String): R|kotlin/Unit| { LAZY_BLOCK } + public? final? [RAW_FIR] fun functionWithLazyBody(): { LAZY_BLOCK } + EXPECT_ACTUAL_MATCHING: FILE: topLevelFunctionsWithImplicitType.kt public final [EXPECT_ACTUAL_MATCHING] fun resolveMe(): R|kotlin/Unit| { diff --git a/analysis/low-level-api-fir/testdata/lazyResolve/typeAliases/typeAliasWithTypeParameters.txt b/analysis/low-level-api-fir/testdata/lazyResolve/typeAliases/typeAliasWithTypeParameters.txt index 663ced3f934..cc058be70ac 100644 --- a/analysis/low-level-api-fir/testdata/lazyResolve/typeAliases/typeAliasWithTypeParameters.txt +++ b/analysis/low-level-api-fir/testdata/lazyResolve/typeAliases/typeAliasWithTypeParameters.txt @@ -39,6 +39,10 @@ IMPLICIT_TYPES_BODY_RESOLVE: FILE: typeAliasWithTypeParameters.kt public final [IMPLICIT_TYPES_BODY_RESOLVE] typealias ResolveMe<[IMPLICIT_TYPES_BODY_RESOLVE] T : R|kotlin/Int|, [IMPLICIT_TYPES_BODY_RESOLVE] K> = R|kotlin/collections/Map| +ANNOTATIONS_ARGUMENTS_MAPPING: +FILE: typeAliasWithTypeParameters.kt + public final [ANNOTATIONS_ARGUMENTS_MAPPING] typealias ResolveMe<[ANNOTATIONS_ARGUMENTS_MAPPING] T : R|kotlin/Int|, [ANNOTATIONS_ARGUMENTS_MAPPING] K> = R|kotlin/collections/Map| + EXPECT_ACTUAL_MATCHING: FILE: typeAliasWithTypeParameters.kt public final [EXPECT_ACTUAL_MATCHING] typealias ResolveMe<[EXPECT_ACTUAL_MATCHING] T : R|kotlin/Int|, [EXPECT_ACTUAL_MATCHING] K> = R|kotlin/collections/Map| diff --git a/analysis/low-level-api-fir/testdata/lazyResolve/typeParameterOfNonLocalFunction.txt b/analysis/low-level-api-fir/testdata/lazyResolve/typeParameterOfNonLocalFunction.txt index 0f3480deb91..fcd93908f31 100644 --- a/analysis/low-level-api-fir/testdata/lazyResolve/typeParameterOfNonLocalFunction.txt +++ b/analysis/low-level-api-fir/testdata/lazyResolve/typeParameterOfNonLocalFunction.txt @@ -111,6 +111,18 @@ FILE: typeParameterOfNonLocalFunction.kt } +ANNOTATIONS_ARGUMENTS_MAPPING: +FILE: typeParameterOfNonLocalFunction.kt + public final [STATUS] class X : R|kotlin/Any| { + public [STATUS] [ContainingClassKey=X] constructor(): R|X| { + super() + } + + public final [ANNOTATIONS_ARGUMENTS_MAPPING] fun <[ANNOTATIONS_ARGUMENTS_MAPPING] resolveMe> ddd(): R|kotlin/Unit| { + } + + } + EXPECT_ACTUAL_MATCHING: FILE: typeParameterOfNonLocalFunction.kt public final [STATUS] class X : R|kotlin/Any| { diff --git a/analysis/low-level-api-fir/testdata/lazyResolve/typeParameterOfTopFunction.txt b/analysis/low-level-api-fir/testdata/lazyResolve/typeParameterOfTopFunction.txt index 0894e78173a..511e8d477bc 100644 --- a/analysis/low-level-api-fir/testdata/lazyResolve/typeParameterOfTopFunction.txt +++ b/analysis/low-level-api-fir/testdata/lazyResolve/typeParameterOfTopFunction.txt @@ -41,6 +41,11 @@ FILE: typeParameterOfTopFunction.kt public final [IMPLICIT_TYPES_BODY_RESOLVE] fun <[IMPLICIT_TYPES_BODY_RESOLVE] resolveMe> ddd(): R|kotlin/Unit| { } +ANNOTATIONS_ARGUMENTS_MAPPING: +FILE: typeParameterOfTopFunction.kt + public final [ANNOTATIONS_ARGUMENTS_MAPPING] fun <[ANNOTATIONS_ARGUMENTS_MAPPING] resolveMe> ddd(): R|kotlin/Unit| { + } + EXPECT_ACTUAL_MATCHING: FILE: typeParameterOfTopFunction.kt public final [EXPECT_ACTUAL_MATCHING] fun <[EXPECT_ACTUAL_MATCHING] resolveMe> ddd(): R|kotlin/Unit| { diff --git a/analysis/low-level-api-fir/testdata/lazyResolve/typeParameterOfTopSetter.txt b/analysis/low-level-api-fir/testdata/lazyResolve/typeParameterOfTopSetter.txt index 0fe43e5953d..b89281cef75 100644 --- a/analysis/low-level-api-fir/testdata/lazyResolve/typeParameterOfTopSetter.txt +++ b/analysis/low-level-api-fir/testdata/lazyResolve/typeParameterOfTopSetter.txt @@ -63,6 +63,14 @@ FILE: typeParameterOfTopSetter.kt ^ Unit# } +ANNOTATIONS_ARGUMENTS_MAPPING: +FILE: typeParameterOfTopSetter.kt + public final [ANNOTATIONS_ARGUMENTS_MAPPING] var x: R|kotlin/Int| = IntegerLiteral(2) + public [ANNOTATIONS_ARGUMENTS_MAPPING] get(): R|kotlin/Int| + public [ANNOTATIONS_ARGUMENTS_MAPPING] set([ANNOTATIONS_ARGUMENTS_MAPPING] resolveMe: R|kotlin/Int|): R|kotlin/Unit| { + ^ Unit# + } + EXPECT_ACTUAL_MATCHING: FILE: typeParameterOfTopSetter.kt public final [EXPECT_ACTUAL_MATCHING] var x: R|kotlin/Int| = IntegerLiteral(2) diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirCallCompletionResultsWriterTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirCallCompletionResultsWriterTransformer.kt index a2dad2e1aaa..95e6d525d13 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirCallCompletionResultsWriterTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirCallCompletionResultsWriterTransformer.kt @@ -304,6 +304,10 @@ class FirCallCompletionResultsWriterTransformer( return annotationCall } + override fun transformErrorAnnotationCall(errorAnnotationCall: FirErrorAnnotationCall, data: ExpectedArgumentType?): FirStatement { + return transformAnnotationCall(errorAnnotationCall, data) + } + private fun Candidate.handleVarargs() { val argumentMapping = this.argumentMapping val varargParameter = argumentMapping?.values?.firstOrNull { it.isVararg } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirTotalResolveProcessor.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirTotalResolveProcessor.kt index 15bd522b266..b8772c0598a 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirTotalResolveProcessor.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirTotalResolveProcessor.kt @@ -79,6 +79,7 @@ fun FirResolvePhase.createCompilerProcessorByPhase( ARGUMENTS_OF_ANNOTATIONS -> FirAnnotationArgumentsResolveProcessor(session, scopeSession) CONTRACTS -> FirContractResolveProcessor(session, scopeSession) IMPLICIT_TYPES_BODY_RESOLVE -> FirImplicitTypeBodyResolveProcessor(session, scopeSession) + ANNOTATIONS_ARGUMENTS_MAPPING -> FirAnnotationArgumentsMappingProcessor(session, scopeSession) BODY_RESOLVE -> FirBodyResolveProcessor(session, scopeSession) EXPECT_ACTUAL_MATCHING -> FirExpectActualMatcherProcessor(session, scopeSession) } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirBodyResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirBodyResolveTransformer.kt index e515b8abbd3..fd6b096ed41 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirBodyResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirBodyResolveTransformer.kt @@ -220,7 +220,7 @@ open class FirBodyResolveTransformer( } override fun transformErrorAnnotationCall(errorAnnotationCall: FirErrorAnnotationCall, data: ResolutionMode): FirStatement { - return transformAnnotationCall(errorAnnotationCall, data) + return expressionsTransformer.transformErrorAnnotationCall(errorAnnotationCall, data) } override fun transformDelegatedConstructorCall( diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirDeclarationsResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirDeclarationsResolveTransformer.kt index 65df91046ad..9a652224e8b 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirDeclarationsResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirDeclarationsResolveTransformer.kt @@ -68,7 +68,7 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor } } - private fun transformDeclarationContent(declaration: FirDeclaration, data: ResolutionMode): FirDeclaration { + protected fun transformDeclarationContent(declaration: FirDeclaration, data: ResolutionMode): FirDeclaration { transformer.firTowerDataContextCollector?.addDeclarationContext(declaration, context.towerDataContext) return transformer.transformDeclarationContent(declaration, data) } @@ -97,7 +97,7 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor return FirMemberTypeParameterScope(declaration) } - private fun doTransformTypeParameters(declaration: FirMemberDeclaration) { + protected fun doTransformTypeParameters(declaration: FirMemberDeclaration) { for (typeParameter in declaration.typeParameters) { typeParameter.transformChildren(transformer, ResolutionMode.ContextIndependent) } @@ -1103,7 +1103,7 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor private val FirVariable.initializerResolved: Boolean get() = initializer?.typeRef is FirResolvedTypeRef - private val FirFunction.bodyResolved: Boolean + protected val FirFunction.bodyResolved: Boolean get() = body !is FirLazyBlock && body?.typeRef is FirResolvedTypeRef } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt index b3200d2fc9c..d8014b67342 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt @@ -1059,14 +1059,17 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform dataFlowAnalyzer.exitAnnotation(result ?: annotationCall) if (result == null) return annotationCall callCompleter.completeCall(result, noExpectedType) - // TODO: FirBlackBoxCodegenTestGenerated.Annotations.testDelegatedPropertySetter, it fails with hard cast - (result.argumentList as? FirResolvedArgumentList)?.let { annotationCall.replaceArgumentMapping((it).toAnnotationArgumentMapping()) } + (result.argumentList as FirResolvedArgumentList).let { annotationCall.replaceArgumentMapping((it).toAnnotationArgumentMapping()) } annotationCall } } } - private inline fun withFirArrayOfCallTransformer(block: () -> T): T { + override fun transformErrorAnnotationCall(errorAnnotationCall: FirErrorAnnotationCall, data: ResolutionMode): FirStatement { + return transformAnnotationCall(errorAnnotationCall, data) + } + + protected inline fun withFirArrayOfCallTransformer(block: () -> T): T { enableArrayOfCallTransformation = true return try { block() diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirAnnotationArgumentsMappingProcessor.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirAnnotationArgumentsMappingProcessor.kt new file mode 100644 index 00000000000..1c799d16173 --- /dev/null +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirAnnotationArgumentsMappingProcessor.kt @@ -0,0 +1,37 @@ +/* + * Copyright 2010-2022 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.resolve.transformers.plugin + +import org.jetbrains.kotlin.fir.FirElement +import org.jetbrains.kotlin.fir.FirSession +import org.jetbrains.kotlin.fir.declarations.FirFile +import org.jetbrains.kotlin.fir.declarations.FirResolvePhase +import org.jetbrains.kotlin.fir.resolve.ResolutionMode +import org.jetbrains.kotlin.fir.resolve.ScopeSession +import org.jetbrains.kotlin.fir.resolve.transformers.AdapterForResolveProcessor +import org.jetbrains.kotlin.fir.resolve.transformers.FirTransformerBasedResolveProcessor +import org.jetbrains.kotlin.fir.visitors.FirTransformer + +@OptIn(AdapterForResolveProcessor::class) +class FirAnnotationArgumentsMappingProcessor( + session: FirSession, + scopeSession: ScopeSession +) : FirTransformerBasedResolveProcessor(session, scopeSession) { + override val transformer: FirTransformer = FirAnnotationArgumentsMappingTransformerAdapter(session, scopeSession) +} + +@AdapterForResolveProcessor +class FirAnnotationArgumentsMappingTransformerAdapter(session: FirSession, scopeSession: ScopeSession) : FirTransformer() { + private val transformer = FirAnnotationArgumentsMappingTransformer(session, scopeSession, FirResolvePhase.ANNOTATIONS_ARGUMENTS_MAPPING) + + override fun transformElement(element: E, data: Any?): E { + error("Should only be called via transformFile()") + } + + override fun transformFile(file: FirFile, data: Any?): FirFile { + return file.transform(transformer, ResolutionMode.ContextIndependent) + } +} diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirAnnotationArgumentsMappingTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirAnnotationArgumentsMappingTransformer.kt new file mode 100644 index 00000000000..8c8c0ce8463 --- /dev/null +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirAnnotationArgumentsMappingTransformer.kt @@ -0,0 +1,162 @@ +/* + * Copyright 2010-2022 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.resolve.transformers.plugin + +import org.jetbrains.kotlin.fir.FirSession +import org.jetbrains.kotlin.fir.declarations.* +import org.jetbrains.kotlin.fir.expressions.FirStatement +import org.jetbrains.kotlin.fir.resolve.ResolutionMode +import org.jetbrains.kotlin.fir.resolve.ScopeSession +import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.BodyResolveContext +import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirBodyResolveTransformer +import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirDeclarationsResolveTransformer + +open class FirAnnotationArgumentsMappingTransformer( + session: FirSession, + scopeSession: ScopeSession, + resolvePhase: FirResolvePhase, + outerBodyResolveContext: BodyResolveContext? = null +) : FirBodyResolveTransformer( + session, + resolvePhase, + implicitTypeOnly = false, + scopeSession, + outerBodyResolveContext = outerBodyResolveContext +) { + override val declarationsTransformer: FirDeclarationsResolveTransformer = + FirDeclarationsResolveTransformerForAnnotationArgumentsMapping(this) +} + +private class FirDeclarationsResolveTransformerForAnnotationArgumentsMapping( + transformer: FirBodyResolveTransformer +) : FirDeclarationsResolveTransformer(transformer) { + override fun transformRegularClass(regularClass: FirRegularClass, data: ResolutionMode): FirStatement { + regularClass.transformAnnotations(this, data) + doTransformTypeParameters(regularClass) + + context.withContainingClass(regularClass) { + context.withRegularClass(regularClass, components) { + transformDeclarationContent(regularClass, data) as FirRegularClass + } + } + + return regularClass + } + + override fun transformAnonymousInitializer( + anonymousInitializer: FirAnonymousInitializer, + data: ResolutionMode + ): FirAnonymousInitializer { + return anonymousInitializer + } + + override fun transformSimpleFunction( + simpleFunction: FirSimpleFunction, + data: ResolutionMode + ): FirSimpleFunction { + if (simpleFunction.bodyResolved) { + return simpleFunction + } + + doTransformTypeParameters(simpleFunction) + + context.withSimpleFunction(simpleFunction, session) { + simpleFunction + .transformReturnTypeRef(transformer, data) + .transformReceiverTypeRef(transformer, data) + .transformValueParameters(transformer, data) + .transformAnnotations(transformer, data) + } + + return simpleFunction + } + + override fun transformConstructor(constructor: FirConstructor, data: ResolutionMode): FirConstructor { + val containingClass = context.containerIfAny as? FirRegularClass + doTransformTypeParameters(constructor) + + context.withConstructor(constructor) { + constructor + .transformAnnotations(transformer, data) + .transformReceiverTypeRef(transformer, data) + .transformReturnTypeRef(transformer, data) + + context.forConstructorParameters(constructor, containingClass, components) { + constructor.transformValueParameters(transformer, data) + } + } + + return constructor + } + + override fun transformValueParameter(valueParameter: FirValueParameter, data: ResolutionMode): FirStatement { + context.withValueParameter(valueParameter, session) { + valueParameter + .transformAnnotations(transformer, data) + .transformReturnTypeRef(transformer, data) + } + + return valueParameter + } + + override fun transformProperty(property: FirProperty, data: ResolutionMode): FirProperty { + property.transformReceiverTypeRef(transformer, ResolutionMode.ContextIndependent) + doTransformTypeParameters(property) + + context.withProperty(property) { + property + .transformAnnotations(transformer, data) + .transformReceiverTypeRef(transformer, data) + .transformReturnTypeRef(transformer, data) + .transformGetter(transformer, data) + .transformSetter(transformer, data) + } + + return property + } + + override fun transformPropertyAccessor( + propertyAccessor: FirPropertyAccessor, + data: ResolutionMode + ): FirPropertyAccessor { + propertyAccessor + .transformValueParameters(transformer, data) + .transformReturnTypeRef(transformer, data) + .transformReceiverTypeRef(transformer, data) + .transformReturnTypeRef(transformer, data) + .transformAnnotations(transformer, data) + return propertyAccessor + } + + override fun transformDeclarationStatus(declarationStatus: FirDeclarationStatus, data: ResolutionMode): FirDeclarationStatus { + return declarationStatus + } + + override fun transformEnumEntry(enumEntry: FirEnumEntry, data: ResolutionMode): FirEnumEntry { + context.forEnumEntry { + enumEntry + .transformAnnotations(transformer, data) + .transformReceiverTypeRef(transformer, data) + .transformReturnTypeRef(transformer, data) + .transformTypeParameters(transformer, data) + } + return enumEntry + } + + override fun transformField(field: FirField, data: ResolutionMode): FirField { + context.withField(field) { + field.transformAnnotations(transformer, data) + } + + return field + } + + override fun transformTypeAlias(typeAlias: FirTypeAlias, data: ResolutionMode): FirTypeAlias { + doTransformTypeParameters(typeAlias) + typeAlias.transformAnnotations(transformer, data) + return typeAlias + } +} diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirAnnotationArgumentsResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirAnnotationArgumentsResolveTransformer.kt index 116fe2c4f57..13a6dd0e601 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirAnnotationArgumentsResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirAnnotationArgumentsResolveTransformer.kt @@ -148,6 +148,10 @@ private class FirExpressionsResolveTransformerForSpecificAnnotations( return transformAnnotation(annotationCall, data) } + override fun transformErrorAnnotationCall(errorAnnotationCall: FirErrorAnnotationCall, data: ResolutionMode): FirStatement { + return transformAnnotation(errorAnnotationCall, data) + } + override fun transformExpression(expression: FirExpression, data: ResolutionMode): FirStatement { return expression.transformChildren(transformer, data) as FirStatement } diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirResolvePhase.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirResolvePhase.kt index 5abf1dd7d31..c70887906ff 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirResolvePhase.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirResolvePhase.kt @@ -17,6 +17,7 @@ enum class FirResolvePhase(val noProcessor: Boolean = false) { ARGUMENTS_OF_ANNOTATIONS, CONTRACTS, IMPLICIT_TYPES_BODY_RESOLVE, + ANNOTATIONS_ARGUMENTS_MAPPING, EXPECT_ACTUAL_MATCHING, BODY_RESOLVE; diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/FirBasedSymbol.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/FirBasedSymbol.kt index 20af5295395..d0ccd7f9260 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/FirBasedSymbol.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/FirBasedSymbol.kt @@ -43,10 +43,7 @@ abstract class FirBasedSymbol { val resolvedAnnotationsWithArguments: List get() { - // NB: annotation argument mapping (w/ vararg) are built/replaced during call completion, hence BODY_RESOLVE. - // TODO(KT-53371): optimize ARGUMENTS_OF_ANNOTATIONS to build annotation argument mapping too. - // TODO(KT-53519): Even with BODY_RESOLVE, argument mapping for annotations on [FirValueParameter] is not properly built. - lazyResolveToPhase(FirResolvePhase.BODY_RESOLVE) + lazyResolveToPhase(FirResolvePhase.ANNOTATIONS_ARGUMENTS_MAPPING) return fir.annotations } diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirCallableSymbol.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirCallableSymbol.kt index 1bb4f7d4c65..03b77be14bb 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirCallableSymbol.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirCallableSymbol.kt @@ -71,7 +71,6 @@ abstract class FirCallableSymbol : FirBasedSymbol else -> lazyResolveToPhase(FirResolvePhase.TYPES) } } - override fun toString(): String = "${this::class.simpleName} $callableId" } diff --git a/compiler/testData/asJava/ultraLightClasses/annotations.fir.java b/compiler/testData/asJava/ultraLightClasses/annotations.fir.java index 79d7007f210..f978fee5d78 100644 --- a/compiler/testData/asJava/ultraLightClasses/annotations.fir.java +++ b/compiler/testData/asJava/ultraLightClasses/annotations.fir.java @@ -42,7 +42,7 @@ public static final class Companion /* AnnoWithCompanion.Companion*/ { @java.lang.annotation.Retention(value = java.lang.annotation.RetentionPolicy.RUNTIME) public abstract @interface Anno /* Anno*/ { - public abstract Anno[] x();// x() + public abstract Anno[] x() default {Anno(p = "a"), Anno(p = "b")};// x() public abstract java.lang.String p() default "";// p() @@ -71,7 +71,7 @@ public abstract @interface AnnotatedAttribute /* AnnotatedAttribute*/ { @java.lang.annotation.Retention(value = java.lang.annotation.RetentionPolicy.RUNTIME) public abstract @interface Deprecated /* Deprecated*/ { - public abstract ReplaceWith replaceWith();// replaceWith() + public abstract ReplaceWith replaceWith() default @ReplaceWith(expression = "");// replaceWith() public abstract java.lang.String message();// message() diff --git a/compiler/testData/asJava/ultraLightClasses/jvmWildcardAnnotations.fir.java b/compiler/testData/asJava/ultraLightClasses/jvmWildcardAnnotations.fir.java index 03f66b82624..b4284362298 100644 --- a/compiler/testData/asJava/ultraLightClasses/jvmWildcardAnnotations.fir.java +++ b/compiler/testData/asJava/ultraLightClasses/jvmWildcardAnnotations.fir.java @@ -43,7 +43,7 @@ public final class Container /* Container*/ { public final void deepOpen(@org.jetbrains.annotations.NotNull() Out>>);// deepOpen(Out>>) @org.jetbrains.annotations.NotNull() - public final OutPair, Out>> falseTrueFalse();// falseTrueFalse() + public final OutPair, Out>> falseTrueFalse();// falseTrueFalse() @org.jetbrains.annotations.NotNull() public final OutPair>> combination();// combination() diff --git a/compiler/testData/asJava/ultraLightFacades/jvmWildcardAnnotations.fir.java b/compiler/testData/asJava/ultraLightFacades/jvmWildcardAnnotations.fir.java index a83e6408533..a969a31ed89 100644 --- a/compiler/testData/asJava/ultraLightFacades/jvmWildcardAnnotations.fir.java +++ b/compiler/testData/asJava/ultraLightFacades/jvmWildcardAnnotations.fir.java @@ -21,7 +21,7 @@ public final class JvmWildcardAnnotationsKt /* JvmWildcardAnnotationsKt*/ { public static final void deepOpen(@org.jetbrains.annotations.NotNull() Out>>);// deepOpen(Out>>) @org.jetbrains.annotations.NotNull() - public static final OutPair, Out>> falseTrueFalse();// falseTrueFalse() + public static final OutPair, Out>> falseTrueFalse();// falseTrueFalse() @org.jetbrains.annotations.NotNull() public static final OutPair>> combination();// combination() diff --git a/compiler/testData/asJava/ultraLightFacades/wildcardOptimization.fir.java b/compiler/testData/asJava/ultraLightFacades/wildcardOptimization.fir.java deleted file mode 100644 index ad2dea7c20b..00000000000 --- a/compiler/testData/asJava/ultraLightFacades/wildcardOptimization.fir.java +++ /dev/null @@ -1,77 +0,0 @@ -public final class WildcardOptimizationKt /* WildcardOptimizationKt*/ { - @org.jetbrains.annotations.NotNull() - public static final In notDeepIn();// notDeepIn() - - @org.jetbrains.annotations.NotNull() - public static final Inv> skipWildcardsUntilInProjection();// skipWildcardsUntilInProjection() - - @org.jetbrains.annotations.NotNull() - public static final Inv>> skipAllInvWildcards();// skipAllInvWildcards() - - @org.jetbrains.annotations.NotNull() - public static final Inv>>> skipAllOutInvWildcards();// skipAllOutInvWildcards() - - @org.jetbrains.annotations.NotNull() - public static final Out>> skipWildcardsUntilIn1();// skipWildcardsUntilIn1() - - @org.jetbrains.annotations.NotNull() - public static final Out>> skipWildcardsUntilIn0();// skipWildcardsUntilIn0() - - @org.jetbrains.annotations.NotNull() - public static final Out>>> skipWildcardsUntilIn2();// skipWildcardsUntilIn2() - - public static final void typeParameter(@org.jetbrains.annotations.NotNull() Out, @org.jetbrains.annotations.NotNull() In);// typeParameter(Out, In) - - public static final void arrayOfOutFinal(@org.jetbrains.annotations.NotNull() Out[]);// arrayOfOutFinal(Out[]) - - public static final void arrayOfOutOpen(@org.jetbrains.annotations.NotNull() Out[]);// arrayOfOutOpen(Out[]) - - public static final void deepFinal(@org.jetbrains.annotations.NotNull() Out>>);// deepFinal(Out>>) - - public static final void deepOpen(@org.jetbrains.annotations.NotNull() Out>>);// deepOpen(Out>>) - - public static final void finalClassArgument(@org.jetbrains.annotations.NotNull() Out, @org.jetbrains.annotations.NotNull() In);// finalClassArgument(Out, In) - - public static final void inAny(@org.jetbrains.annotations.NotNull() In);// inAny(In) - - public static final void inFinal(@org.jetbrains.annotations.NotNull() In);// inFinal(In) - - public static final void inOutFinal(@org.jetbrains.annotations.NotNull() In>);// inOutFinal(In>) - - public static final void invFinal(@org.jetbrains.annotations.NotNull() Inv);// invFinal(Inv) - - public static final void invIn(@org.jetbrains.annotations.NotNull() Out>);// invIn(Out>) - - public static final void invInAny(@org.jetbrains.annotations.NotNull() Out>);// invInAny(Out>) - - public static final void invInOutFinal(@org.jetbrains.annotations.NotNull() Inv>>);// invInOutFinal(Inv>>) - - public static final void invInOutOpen(@org.jetbrains.annotations.NotNull() Inv>>);// invInOutOpen(Inv>>) - - public static final void invInv(@org.jetbrains.annotations.NotNull() Out>);// invInv(Out>) - - public static final void invOpen(@org.jetbrains.annotations.NotNull() Inv);// invOpen(Inv) - - public static final void invOut(@org.jetbrains.annotations.NotNull() Out>);// invOut(Out>) - - public static final void invOutFinal(@org.jetbrains.annotations.NotNull() Inv>);// invOutFinal(Inv>) - - public static final void invOutFinal(@org.jetbrains.annotations.NotNull() Out>);// invOutFinal(Out>) - - public static final void invOutOpen(@org.jetbrains.annotations.NotNull() Inv>);// invOutOpen(Inv>) - - public static final void invOutProjectedOutFinal(@org.jetbrains.annotations.NotNull() Inv>);// invOutProjectedOutFinal(Inv>) - - public static final void oneArgumentFinal(@org.jetbrains.annotations.NotNull() OutPair);// oneArgumentFinal(OutPair) - - public static final void openClassArgument(@org.jetbrains.annotations.NotNull() Out, @org.jetbrains.annotations.NotNull() In);// openClassArgument(Out, In) - - public static final void outIn(@org.jetbrains.annotations.NotNull() Out>);// outIn(Out>) - - public static final void outInAny(@org.jetbrains.annotations.NotNull() Out>);// outInAny(Out>) - - public static final void outOfArrayOpen(@org.jetbrains.annotations.NotNull() Out);// outOfArrayOpen(Out) - - public static final void outOfArrayOutOpen(@org.jetbrains.annotations.NotNull() Out);// outOfArrayOutOpen(Out) - -}