From f578381726e784c3985945549b71bdf552263dfb Mon Sep 17 00:00:00 2001 From: Nikolay Lunyak Date: Wed, 28 Sep 2022 13:38:18 +0000 Subject: [PATCH] [FIR] KT-46483: Forbid annotations in where Clauses Merge-request: KT-MR-7208 Merged-by: Nikolay Lunyak --- .../diagnostics/KtFirDataClassConverters.kt | 6 ++ .../api/fir/diagnostics/KtFirDiagnostics.kt | 4 + .../fir/diagnostics/KtFirDiagnosticsImpl.kt | 5 + ...CompilerTestFE10TestdataTestGenerated.java | 6 ++ ...irOldFrontendDiagnosticsTestGenerated.java | 6 ++ ...DiagnosticsWithLightTreeTestGenerated.java | 6 ++ .../diagnostics/FirDiagnosticsList.kt | 1 + .../fir/analysis/diagnostics/FirErrors.kt | 1 + .../ErrorNodeDiagnosticCollectorComponent.kt | 5 + .../diagnostics/FirErrorsDefaultMessages.kt | 5 + .../coneDiagnosticToFirDiagnostic.kt | 1 + .../converter/DeclarationsConverter.kt | 54 +++++++---- .../kotlin/fir/builder/RawFirBuilder.kt | 21 +++++ .../body/resolve/FirBodyResolveTransformer.kt | 4 + .../fir/expressions/FirErrorAnnotationCall.kt | 58 ++++++++++++ .../builder/FirErrorAnnotationCallBuilder.kt | 78 ++++++++++++++++ .../impl/FirErrorAnnotationCallImpl.kt | 92 +++++++++++++++++++ .../kotlin/fir/visitors/FirDefaultVisitor.kt | 1 + .../fir/visitors/FirDefaultVisitorVoid.kt | 1 + .../kotlin/fir/visitors/FirTransformer.kt | 9 ++ .../kotlin/fir/visitors/FirVisitor.kt | 3 + .../kotlin/fir/visitors/FirVisitorVoid.kt | 9 ++ .../fir/diagnostics/ConeSimpleDiagnostic.kt | 1 + .../fir/tree/generator/BuilderConfigurator.kt | 8 ++ .../fir/tree/generator/FirTreeBuilder.kt | 1 + .../generator/ImplementationConfigurator.kt | 7 ++ .../fir/tree/generator/NodeConfigurator.kt | 4 + .../jetbrains/kotlin/diagnostics/Errors.java | 2 + .../rendering/DefaultErrorMessages.java | 2 + .../kotlin/resolve/DeclarationsChecker.kt | 6 ++ .../kotlin/psi/KtTypeConstraint.java | 19 +++- .../testData/diagnostics/tests/kt46483.fir.kt | 11 +++ .../testData/diagnostics/tests/kt46483.kt | 11 +++ .../testData/diagnostics/tests/kt46483.txt | 24 +++++ .../test/runners/DiagnosticTestGenerated.java | 6 ++ .../annotations/type-annotations/neg/5.fir.kt | 2 +- .../annotations/type-annotations/neg/5.kt | 2 +- 37 files changed, 462 insertions(+), 20 deletions(-) create mode 100644 compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/FirErrorAnnotationCall.kt create mode 100644 compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/builder/FirErrorAnnotationCallBuilder.kt create mode 100644 compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/impl/FirErrorAnnotationCallImpl.kt create mode 100644 compiler/testData/diagnostics/tests/kt46483.fir.kt create mode 100644 compiler/testData/diagnostics/tests/kt46483.kt create mode 100644 compiler/testData/diagnostics/tests/kt46483.txt diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDataClassConverters.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDataClassConverters.kt index 0d776c244d5..725f6a741e6 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDataClassConverters.kt +++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDataClassConverters.kt @@ -955,6 +955,12 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert token, ) } + add(FirErrors.ANNOTATION_IN_WHERE_CLAUSE_ERROR) { firDiagnostic -> + AnnotationInWhereClauseErrorImpl( + firDiagnostic as KtPsiDiagnostic, + token, + ) + } add(FirErrors.OPT_IN_USAGE) { firDiagnostic -> OptInUsageImpl( firDiagnostic.a, diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDiagnostics.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDiagnostics.kt index 44bd20a4b51..4d256c0adba 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDiagnostics.kt +++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDiagnostics.kt @@ -689,6 +689,10 @@ sealed class KtFirDiagnostic : KtDiagnosticWithPsi { override val diagnosticClass get() = WrongExtensionFunctionTypeWarning::class } + abstract class AnnotationInWhereClauseError : KtFirDiagnostic() { + override val diagnosticClass get() = AnnotationInWhereClauseError::class + } + abstract class OptInUsage : KtFirDiagnostic() { override val diagnosticClass get() = OptInUsage::class abstract val optInMarkerFqName: FqName diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDiagnosticsImpl.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDiagnosticsImpl.kt index 07ee64bcdc3..c5cbcf53615 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDiagnosticsImpl.kt +++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDiagnosticsImpl.kt @@ -827,6 +827,11 @@ internal class WrongExtensionFunctionTypeWarningImpl( override val token: KtLifetimeToken, ) : KtFirDiagnostic.WrongExtensionFunctionTypeWarning(), KtAbstractFirDiagnostic +internal class AnnotationInWhereClauseErrorImpl( + override val firDiagnostic: KtPsiDiagnostic, + override val token: KtLifetimeToken, +) : KtFirDiagnostic.AnnotationInWhereClauseError(), KtAbstractFirDiagnostic + internal class OptInUsageImpl( override val optInMarkerFqName: FqName, override val message: String, diff --git a/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/DiagnosisCompilerTestFE10TestdataTestGenerated.java b/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/DiagnosisCompilerTestFE10TestdataTestGenerated.java index bc33d456e0f..741bdf7af23 100644 --- a/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/DiagnosisCompilerTestFE10TestdataTestGenerated.java +++ b/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/DiagnosisCompilerTestFE10TestdataTestGenerated.java @@ -423,6 +423,12 @@ public class DiagnosisCompilerTestFE10TestdataTestGenerated extends AbstractDiag runTest("compiler/testData/diagnostics/tests/kt435.kt"); } + @Test + @TestMetadata("kt46483.kt") + public void testKt46483() throws Exception { + runTest("compiler/testData/diagnostics/tests/kt46483.kt"); + } + @Test @TestMetadata("kt49438.kt") public void testKt49438() throws Exception { diff --git a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsTestGenerated.java b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsTestGenerated.java index 6d915e1c30f..c619546737b 100644 --- a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsTestGenerated.java +++ b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsTestGenerated.java @@ -423,6 +423,12 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti runTest("compiler/testData/diagnostics/tests/kt435.kt"); } + @Test + @TestMetadata("kt46483.kt") + public void testKt46483() throws Exception { + runTest("compiler/testData/diagnostics/tests/kt46483.kt"); + } + @Test @TestMetadata("kt49438.kt") public void testKt49438() throws Exception { diff --git a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsWithLightTreeTestGenerated.java b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsWithLightTreeTestGenerated.java index 37eb99e774c..464cd7bff9f 100644 --- a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsWithLightTreeTestGenerated.java +++ b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsWithLightTreeTestGenerated.java @@ -423,6 +423,12 @@ public class FirOldFrontendDiagnosticsWithLightTreeTestGenerated extends Abstrac runTest("compiler/testData/diagnostics/tests/kt435.kt"); } + @Test + @TestMetadata("kt46483.kt") + public void testKt46483() throws Exception { + runTest("compiler/testData/diagnostics/tests/kt46483.kt"); + } + @Test @TestMetadata("kt49438.kt") public void testKt49438() throws Exception { diff --git a/compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/diagnostics/FirDiagnosticsList.kt b/compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/diagnostics/FirDiagnosticsList.kt index d584772346f..3ea2a8b8394 100644 --- a/compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/diagnostics/FirDiagnosticsList.kt +++ b/compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/diagnostics/FirDiagnosticsList.kt @@ -291,6 +291,7 @@ object DIAGNOSTICS_LIST : DiagnosticList("FirErrors") { val NOT_A_CLASS by error() val WRONG_EXTENSION_FUNCTION_TYPE by error() val WRONG_EXTENSION_FUNCTION_TYPE_WARNING by warning() + val ANNOTATION_IN_WHERE_CLAUSE_ERROR by error() } val OPT_IN by object : DiagnosticGroup("OptIn") { diff --git a/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrors.kt b/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrors.kt index 63baedf3bf8..e684c1971a3 100644 --- a/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrors.kt +++ b/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrors.kt @@ -256,6 +256,7 @@ object FirErrors { val NOT_A_CLASS by error0() val WRONG_EXTENSION_FUNCTION_TYPE by error0() val WRONG_EXTENSION_FUNCTION_TYPE_WARNING by warning0() + val ANNOTATION_IN_WHERE_CLAUSE_ERROR by error0() // OptIn val OPT_IN_USAGE by warning2(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED) diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/components/ErrorNodeDiagnosticCollectorComponent.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/components/ErrorNodeDiagnosticCollectorComponent.kt index d5006e4beeb..5fb6413f4c2 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/components/ErrorNodeDiagnosticCollectorComponent.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/components/ErrorNodeDiagnosticCollectorComponent.kt @@ -46,6 +46,11 @@ class ErrorNodeDiagnosticCollectorComponent( } } + override fun visitErrorAnnotationCall(errorAnnotationCall: FirErrorAnnotationCall, data: CheckerContext) { + val source = errorAnnotationCall.source ?: return + reportFirDiagnostic(errorAnnotationCall.diagnostic, source, data) + } + override fun visitErrorNamedReference(errorNamedReference: FirErrorNamedReference, data: CheckerContext) { val source = errorNamedReference.source ?: return val qualifiedAccessOrAnnotationCall = data.qualifiedAccessOrAnnotationCalls.lastOrNull()?.takeIf { diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrorsDefaultMessages.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrorsDefaultMessages.kt index d1142002b3a..5be29957496 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrorsDefaultMessages.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrorsDefaultMessages.kt @@ -67,6 +67,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ANNOTATION_ARGUME import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ANNOTATION_ARGUMENT_MUST_BE_KCLASS_LITERAL import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ANNOTATION_CLASS_CONSTRUCTOR_CALL import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ANNOTATION_CLASS_MEMBER +import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ANNOTATION_IN_WHERE_CLAUSE_ERROR import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ANNOTATION_ON_SUPERCLASS import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ANNOTATION_PARAMETER_DEFAULT_VALUE_MUST_BE_CONSTANT import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ANNOTATION_USED_AS_ANNOTATION_ARGUMENT @@ -887,6 +888,10 @@ object FirErrorsDefaultMessages : BaseDiagnosticRendererFactory() { WRONG_EXTENSION_FUNCTION_TYPE_WARNING, "ExtensionFunctionType makes no sense on a non-function type. It will be an error in a future release. See https://youtrack.jetbrains.com/issue/KT-43527" ) + map.put( + ANNOTATION_IN_WHERE_CLAUSE_ERROR, + "Type parameter annotations are not allowed inside where clauses. You should probably move annotations to the type parameter declaration", + ) // Exposed visibility group // # map.put( diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/coneDiagnosticToFirDiagnostic.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/coneDiagnosticToFirDiagnostic.kt index 88a07c40d72..129cea12127 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/coneDiagnosticToFirDiagnostic.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/coneDiagnosticToFirDiagnostic.kt @@ -512,6 +512,7 @@ private fun ConeSimpleDiagnostic.getFactory(source: KtSourceElement): KtDiagnost DiagnosticKind.EnumEntryAsType -> FirErrors.ENUM_ENTRY_AS_TYPE DiagnosticKind.NotASupertype -> FirErrors.NOT_A_SUPERTYPE DiagnosticKind.SuperNotAvailable -> FirErrors.SUPER_NOT_AVAILABLE + DiagnosticKind.AnnotationNotAllowed -> FirErrors.ANNOTATION_IN_WHERE_CLAUSE_ERROR DiagnosticKind.UnresolvedSupertype, DiagnosticKind.UnresolvedExpandedType, DiagnosticKind.Other -> FirErrors.OTHER_ERROR diff --git a/compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/converter/DeclarationsConverter.kt b/compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/converter/DeclarationsConverter.kt index d5c2e6ed0ef..16b2b2d5a76 100644 --- a/compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/converter/DeclarationsConverter.kt +++ b/compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/converter/DeclarationsConverter.kt @@ -12,6 +12,7 @@ import org.jetbrains.kotlin.* import org.jetbrains.kotlin.ElementTypeUtils.isExpression import org.jetbrains.kotlin.KtNodeTypes.* import org.jetbrains.kotlin.builtins.StandardNames +import org.jetbrains.kotlin.config.LanguageFeature import org.jetbrains.kotlin.descriptors.ClassKind import org.jetbrains.kotlin.descriptors.Modality import org.jetbrains.kotlin.descriptors.Visibilities @@ -29,6 +30,7 @@ import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.builder.* import org.jetbrains.kotlin.fir.declarations.impl.* import org.jetbrains.kotlin.fir.declarations.utils.* +import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnostic import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnostic import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind import org.jetbrains.kotlin.fir.expressions.* @@ -367,7 +369,8 @@ class DeclarationsConverter( */ fun convertAnnotationEntry( unescapedAnnotation: LighterASTNode, - defaultAnnotationUseSiteTarget: AnnotationUseSiteTarget? = null + defaultAnnotationUseSiteTarget: AnnotationUseSiteTarget? = null, + diagnostic: ConeDiagnostic? = null, ): FirAnnotationCall { var annotationUseSiteTarget: AnnotationUseSiteTarget? = null lateinit var constructorCalleePair: Pair> @@ -379,21 +382,34 @@ class DeclarationsConverter( } val qualifier = (constructorCalleePair.first as? FirUserTypeRef)?.qualifier?.last() val name = qualifier?.name ?: Name.special("") - return buildAnnotationCall { - source = unescapedAnnotation.toFirSourceElement() - useSiteTarget = annotationUseSiteTarget ?: defaultAnnotationUseSiteTarget - annotationTypeRef = constructorCalleePair.first - calleeReference = buildSimpleNamedReference { - source = unescapedAnnotation - .getChildNodeByType(CONSTRUCTOR_CALLEE) - ?.getChildNodeByType(TYPE_REFERENCE) - ?.getChildNodeByType(USER_TYPE) - ?.getChildNodeByType(REFERENCE_EXPRESSION) - ?.toFirSourceElement() - this.name = name + val theCalleeReference = buildSimpleNamedReference { + source = unescapedAnnotation + .getChildNodeByType(CONSTRUCTOR_CALLEE) + ?.getChildNodeByType(TYPE_REFERENCE) + ?.getChildNodeByType(USER_TYPE) + ?.getChildNodeByType(REFERENCE_EXPRESSION) + ?.toFirSourceElement() + this.name = name + } + return if (diagnostic == null) { + buildAnnotationCall { + source = unescapedAnnotation.toFirSourceElement() + useSiteTarget = annotationUseSiteTarget ?: defaultAnnotationUseSiteTarget + annotationTypeRef = constructorCalleePair.first + calleeReference = theCalleeReference + extractArgumentsFrom(constructorCalleePair.second) + typeArguments += qualifier?.typeArgumentList?.typeArguments ?: listOf() + } + } else { + buildErrorAnnotationCall { + source = unescapedAnnotation.toFirSourceElement() + useSiteTarget = annotationUseSiteTarget ?: defaultAnnotationUseSiteTarget + annotationTypeRef = constructorCalleePair.first + this.diagnostic = diagnostic + calleeReference = theCalleeReference + extractArgumentsFrom(constructorCalleePair.second) + typeArguments += qualifier?.typeArgumentList?.typeArguments ?: listOf() } - extractArgumentsFrom(constructorCalleePair.second) - typeArguments += qualifier?.typeArgumentList?.typeArguments ?: listOf() } } @@ -1875,11 +1891,15 @@ class DeclarationsConverter( lateinit var identifier: String lateinit var firType: FirTypeRef lateinit var referenceExpression: LighterASTNode + + val diagnostic = ConeSimpleDiagnostic( + "Type parameter annotations are not allowed inside where clauses", DiagnosticKind.AnnotationNotAllowed, + ) + val annotations = mutableListOf() typeConstraint.forEachChildren { when (it.tokenType) { - //annotations will be saved later, on mapping stage with type parameters - ANNOTATION, ANNOTATION_ENTRY -> annotations += convertAnnotation(it) + ANNOTATION_ENTRY -> annotations += convertAnnotationEntry(it, diagnostic = diagnostic) REFERENCE_EXPRESSION -> { identifier = it.asText referenceExpression = it diff --git a/compiler/fir/raw-fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/RawFirBuilder.kt b/compiler/fir/raw-fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/RawFirBuilder.kt index 6487a9e6b15..62f8716448e 100644 --- a/compiler/fir/raw-fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/RawFirBuilder.kt +++ b/compiler/fir/raw-fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/RawFirBuilder.kt @@ -9,6 +9,7 @@ import com.intellij.psi.PsiElement import com.intellij.psi.tree.IElementType import org.jetbrains.kotlin.* import org.jetbrains.kotlin.builtins.StandardNames.BACKING_FIELD +import org.jetbrains.kotlin.config.LanguageFeature import org.jetbrains.kotlin.descriptors.ClassKind import org.jetbrains.kotlin.descriptors.Modality import org.jetbrains.kotlin.descriptors.Visibilities @@ -702,9 +703,29 @@ open class RawFirBuilder( val owner = parameter.getStrictParentOfType() ?: return@buildTypeParameter for (typeConstraint in owner.typeConstraints) { val subjectName = typeConstraint.subjectTypeParameterName?.getReferencedNameAsName() + if (subjectName == parameterName) { bounds += typeConstraint.boundTypeReference.toFirOrErrorType() } + + for (entry in typeConstraint.annotationEntries) { + annotations += buildErrorAnnotationCall { + source = entry.toFirSourceElement() + useSiteTarget = entry.useSiteTarget?.getAnnotationUseSiteTarget() + annotationTypeRef = entry.typeReference.toFirOrErrorType() + diagnostic = ConeSimpleDiagnostic( + "Type parameter annotations are not allowed inside where clauses", DiagnosticKind.AnnotationNotAllowed, + ) + val name = (annotationTypeRef as? FirUserTypeRef)?.qualifier?.last()?.name + ?: Name.special("") + calleeReference = buildSimpleNamedReference { + source = (entry.typeReference?.typeElement as? KtUserType)?.referenceExpression?.toFirSourceElement() + this.name = name + } + entry.extractArgumentsTo(this) + typeArguments.appendTypeArguments(entry.typeArguments) + } + } } addDefaultBoundIfNecessary() } 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 dd992d55407..4f5e817ae50 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 @@ -219,6 +219,10 @@ open class FirBodyResolveTransformer( return expressionsTransformer.transformAnnotationCall(annotationCall, data) } + override fun transformErrorAnnotationCall(errorAnnotationCall: FirErrorAnnotationCall, data: ResolutionMode): FirStatement { + return transformAnnotationCall(errorAnnotationCall, data) + } + override fun transformDelegatedConstructorCall( delegatedConstructorCall: FirDelegatedConstructorCall, data: ResolutionMode diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/FirErrorAnnotationCall.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/FirErrorAnnotationCall.kt new file mode 100644 index 00000000000..6692e22ef97 --- /dev/null +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/FirErrorAnnotationCall.kt @@ -0,0 +1,58 @@ +/* + * 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.expressions + +import org.jetbrains.kotlin.KtSourceElement +import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget +import org.jetbrains.kotlin.fir.FirElement +import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnostic +import org.jetbrains.kotlin.fir.diagnostics.FirDiagnosticHolder +import org.jetbrains.kotlin.fir.references.FirReference +import org.jetbrains.kotlin.fir.types.FirTypeProjection +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 FirErrorAnnotationCall : FirAnnotationCall(), FirDiagnosticHolder { + abstract override val source: KtSourceElement? + abstract override val typeRef: FirTypeRef + abstract override val annotations: List + abstract override val useSiteTarget: AnnotationUseSiteTarget? + abstract override val annotationTypeRef: FirTypeRef + abstract override val typeArguments: List + abstract override val argumentList: FirArgumentList + abstract override val calleeReference: FirReference + abstract override val diagnostic: ConeDiagnostic + abstract override val argumentMapping: FirAnnotationArgumentMapping + + override fun accept(visitor: FirVisitor, data: D): R = visitor.visitErrorAnnotationCall(this, data) + + @Suppress("UNCHECKED_CAST") + override fun transform(transformer: FirTransformer, data: D): E = + transformer.transformErrorAnnotationCall(this, data) as E + + abstract override fun replaceTypeRef(newTypeRef: FirTypeRef) + + abstract override fun replaceTypeArguments(newTypeArguments: List) + + 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): FirErrorAnnotationCall + + abstract override fun transformAnnotationTypeRef(transformer: FirTransformer, data: D): FirErrorAnnotationCall + + abstract override fun transformTypeArguments(transformer: FirTransformer, data: D): FirErrorAnnotationCall + + abstract override fun transformCalleeReference(transformer: FirTransformer, data: D): FirErrorAnnotationCall +} diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/builder/FirErrorAnnotationCallBuilder.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/builder/FirErrorAnnotationCallBuilder.kt new file mode 100644 index 00000000000..b631c57f887 --- /dev/null +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/builder/FirErrorAnnotationCallBuilder.kt @@ -0,0 +1,78 @@ +/* + * 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. + */ + +@file:Suppress("DuplicatedCode") + +package org.jetbrains.kotlin.fir.expressions.builder + +import kotlin.contracts.* +import org.jetbrains.kotlin.KtSourceElement +import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget +import org.jetbrains.kotlin.fir.builder.FirAnnotationContainerBuilder +import org.jetbrains.kotlin.fir.builder.FirBuilderDsl +import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnostic +import org.jetbrains.kotlin.fir.expressions.FirAnnotation +import org.jetbrains.kotlin.fir.expressions.FirAnnotationArgumentMapping +import org.jetbrains.kotlin.fir.expressions.FirArgumentList +import org.jetbrains.kotlin.fir.expressions.FirEmptyArgumentList +import org.jetbrains.kotlin.fir.expressions.FirErrorAnnotationCall +import org.jetbrains.kotlin.fir.expressions.builder.FirCallBuilder +import org.jetbrains.kotlin.fir.expressions.builder.FirExpressionBuilder +import org.jetbrains.kotlin.fir.expressions.impl.FirEmptyAnnotationArgumentMapping +import org.jetbrains.kotlin.fir.expressions.impl.FirErrorAnnotationCallImpl +import org.jetbrains.kotlin.fir.references.FirReference +import org.jetbrains.kotlin.fir.types.FirTypeProjection +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 FirErrorAnnotationCallBuilder : FirCallBuilder, FirAnnotationContainerBuilder, FirExpressionBuilder { + override var source: KtSourceElement? = null + var useSiteTarget: AnnotationUseSiteTarget? = null + var annotationTypeRef: FirTypeRef = FirImplicitTypeRefImpl(null) + val typeArguments: MutableList = mutableListOf() + override var argumentList: FirArgumentList = FirEmptyArgumentList + lateinit var calleeReference: FirReference + lateinit var diagnostic: ConeDiagnostic + var argumentMapping: FirAnnotationArgumentMapping = FirEmptyAnnotationArgumentMapping + + override fun build(): FirErrorAnnotationCall { + return FirErrorAnnotationCallImpl( + source, + useSiteTarget, + annotationTypeRef, + typeArguments, + argumentList, + calleeReference, + diagnostic, + argumentMapping, + ) + } + + + @Deprecated("Modification of 'typeRef' has no impact for FirErrorAnnotationCallBuilder", level = DeprecationLevel.HIDDEN) + override var typeRef: FirTypeRef + get() = throw IllegalStateException() + set(_) { + throw IllegalStateException() + } + + @Deprecated("Modification of 'annotations' has no impact for FirErrorAnnotationCallBuilder", level = DeprecationLevel.HIDDEN) + override val annotations: MutableList = mutableListOf() +} + +@OptIn(ExperimentalContracts::class) +inline fun buildErrorAnnotationCall(init: FirErrorAnnotationCallBuilder.() -> Unit): FirErrorAnnotationCall { + contract { + callsInPlace(init, kotlin.contracts.InvocationKind.EXACTLY_ONCE) + } + return FirErrorAnnotationCallBuilder().apply(init).build() +} diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/impl/FirErrorAnnotationCallImpl.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/impl/FirErrorAnnotationCallImpl.kt new file mode 100644 index 00000000000..f7294a31781 --- /dev/null +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/impl/FirErrorAnnotationCallImpl.kt @@ -0,0 +1,92 @@ +/* + * 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. + */ + +@file:Suppress("DuplicatedCode") + +package org.jetbrains.kotlin.fir.expressions.impl + +import org.jetbrains.kotlin.KtSourceElement +import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget +import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnostic +import org.jetbrains.kotlin.fir.expressions.FirAnnotation +import org.jetbrains.kotlin.fir.expressions.FirAnnotationArgumentMapping +import org.jetbrains.kotlin.fir.expressions.FirArgumentList +import org.jetbrains.kotlin.fir.expressions.FirErrorAnnotationCall +import org.jetbrains.kotlin.fir.references.FirReference +import org.jetbrains.kotlin.fir.types.FirTypeProjection +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 FirErrorAnnotationCallImpl( + override val source: KtSourceElement?, + override val useSiteTarget: AnnotationUseSiteTarget?, + override var annotationTypeRef: FirTypeRef, + override val typeArguments: MutableList, + override var argumentList: FirArgumentList, + override var calleeReference: FirReference, + override val diagnostic: ConeDiagnostic, + override var argumentMapping: FirAnnotationArgumentMapping, +) : FirErrorAnnotationCall() { + override val typeRef: FirTypeRef get() = annotationTypeRef + override val annotations: List get() = emptyList() + + override fun acceptChildren(visitor: FirVisitor, data: D) { + annotationTypeRef.accept(visitor, data) + typeArguments.forEach { it.accept(visitor, data) } + argumentList.accept(visitor, data) + calleeReference.accept(visitor, data) + } + + override fun transformChildren(transformer: FirTransformer, data: D): FirErrorAnnotationCallImpl { + transformAnnotationTypeRef(transformer, data) + transformTypeArguments(transformer, data) + argumentList = argumentList.transform(transformer, data) + transformCalleeReference(transformer, data) + return this + } + + override fun transformAnnotations(transformer: FirTransformer, data: D): FirErrorAnnotationCallImpl { + return this + } + + override fun transformAnnotationTypeRef(transformer: FirTransformer, data: D): FirErrorAnnotationCallImpl { + annotationTypeRef = annotationTypeRef.transform(transformer, data) + return this + } + + override fun transformTypeArguments(transformer: FirTransformer, data: D): FirErrorAnnotationCallImpl { + typeArguments.transformInplace(transformer, data) + return this + } + + override fun transformCalleeReference(transformer: FirTransformer, data: D): FirErrorAnnotationCallImpl { + calleeReference = calleeReference.transform(transformer, data) + return this + } + + override fun replaceTypeRef(newTypeRef: FirTypeRef) {} + + override fun replaceTypeArguments(newTypeArguments: List) { + typeArguments.clear() + typeArguments.addAll(newTypeArguments) + } + + 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/visitors/FirDefaultVisitor.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirDefaultVisitor.kt index a70c39e0c26..3ad383ffbf6 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirDefaultVisitor.kt +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirDefaultVisitor.kt @@ -73,6 +73,7 @@ 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.FirErrorAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirComparisonExpression import org.jetbrains.kotlin.fir.expressions.FirTypeOperatorCall import org.jetbrains.kotlin.fir.expressions.FirAssignmentOperatorStatement diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirDefaultVisitorVoid.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirDefaultVisitorVoid.kt index f86caa2366b..97953d33647 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirDefaultVisitorVoid.kt +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirDefaultVisitorVoid.kt @@ -73,6 +73,7 @@ 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.FirErrorAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirComparisonExpression import org.jetbrains.kotlin.fir.expressions.FirTypeOperatorCall import org.jetbrains.kotlin.fir.expressions.FirAssignmentOperatorStatement 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 62eef479067..26997816329 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 @@ -73,6 +73,7 @@ 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.FirErrorAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirComparisonExpression import org.jetbrains.kotlin.fir.expressions.FirTypeOperatorCall import org.jetbrains.kotlin.fir.expressions.FirAssignmentOperatorStatement @@ -417,6 +418,10 @@ abstract class FirTransformer : FirVisitor() { return transformElement(annotationArgumentMapping, data) } + open fun transformErrorAnnotationCall(errorAnnotationCall: FirErrorAnnotationCall, data: D): FirStatement { + return transformElement(errorAnnotationCall, data) + } + open fun transformComparisonExpression(comparisonExpression: FirComparisonExpression, data: D): FirStatement { return transformElement(comparisonExpression, data) } @@ -953,6 +958,10 @@ abstract class FirTransformer : FirVisitor() { return transformAnnotationArgumentMapping(annotationArgumentMapping, data) } + final override fun visitErrorAnnotationCall(errorAnnotationCall: FirErrorAnnotationCall, data: D): FirStatement { + return transformErrorAnnotationCall(errorAnnotationCall, 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 e2a8dc29fdd..a5733b47566 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 @@ -73,6 +73,7 @@ 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.FirErrorAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirComparisonExpression import org.jetbrains.kotlin.fir.expressions.FirTypeOperatorCall import org.jetbrains.kotlin.fir.expressions.FirAssignmentOperatorStatement @@ -282,6 +283,8 @@ abstract class FirVisitor { open fun visitAnnotationArgumentMapping(annotationArgumentMapping: FirAnnotationArgumentMapping, data: D): R = visitElement(annotationArgumentMapping, data) + open fun visitErrorAnnotationCall(errorAnnotationCall: FirErrorAnnotationCall, data: D): R = visitElement(errorAnnotationCall, 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 67d0c7a9c15..4dca68e51da 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 @@ -73,6 +73,7 @@ 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.FirErrorAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirComparisonExpression import org.jetbrains.kotlin.fir.expressions.FirTypeOperatorCall import org.jetbrains.kotlin.fir.expressions.FirAssignmentOperatorStatement @@ -416,6 +417,10 @@ abstract class FirVisitorVoid : FirVisitor() { visitElement(annotationArgumentMapping) } + open fun visitErrorAnnotationCall(errorAnnotationCall: FirErrorAnnotationCall) { + visitElement(errorAnnotationCall) + } + open fun visitComparisonExpression(comparisonExpression: FirComparisonExpression) { visitElement(comparisonExpression) } @@ -952,6 +957,10 @@ abstract class FirVisitorVoid : FirVisitor() { visitAnnotationArgumentMapping(annotationArgumentMapping) } + final override fun visitErrorAnnotationCall(errorAnnotationCall: FirErrorAnnotationCall, data: Nothing?) { + visitErrorAnnotationCall(errorAnnotationCall) + } + final override fun visitComparisonExpression(comparisonExpression: FirComparisonExpression, data: Nothing?) { visitComparisonExpression(comparisonExpression) } diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/diagnostics/ConeSimpleDiagnostic.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/diagnostics/ConeSimpleDiagnostic.kt index b75356d5ffc..21b8d53087d 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/diagnostics/ConeSimpleDiagnostic.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/diagnostics/ConeSimpleDiagnostic.kt @@ -69,6 +69,7 @@ enum class DiagnosticKind { MissingStdlibClass, NotASupertype, SuperNotAvailable, + AnnotationNotAllowed, LoopInSupertype, RecursiveTypealiasExpansion, 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 70c4c08f717..e69cefda5a0 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 @@ -122,6 +122,14 @@ object BuilderConfigurator : AbstractBuilderConfigurator(FirTree useTypes(emptyArgumentListType, emptyAnnotationArgumentMappingType, implicitTypeRefType) } + builder(errorAnnotationCall) { + parents += callBuilder + default("argumentList", "FirEmptyArgumentList") + default("argumentMapping", "FirEmptyAnnotationArgumentMapping") + default("annotationTypeRef", "FirImplicitTypeRefImpl(null)") + useTypes(emptyArgumentListType, emptyAnnotationArgumentMappingType, implicitTypeRefType) + } + builder(arrayOfCall) { parents += callBuilder } 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 277f3d7cd12..a8416e278f3 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 @@ -94,6 +94,7 @@ object FirTreeBuilder : AbstractFirTreeBuilder() { val annotation by element(Expression, expression) val annotationCall by element(Expression, annotation, call, resolvable) val annotationArgumentMapping by element(Expression) + val errorAnnotationCall by element(Expression, annotationCall, diagnosticHolder) 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 792f8b5988a..67f53aeef66 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 @@ -96,6 +96,13 @@ object ImplementationConfigurator : AbstractFirTreeImplementationConfigurator() } } + impl(errorAnnotationCall) { + commonAnnotationConfig() + default("argumentMapping") { + needAcceptAndTransform = false + } + } + impl(arrayOfCall) impl(callableReferenceAccess) 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 5daf3ae37d8..ee43664b36c 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 @@ -469,6 +469,10 @@ object NodeConfigurator : AbstractFieldConfigurator(FirTreeBuild +field("argumentMapping", annotationArgumentMapping, withReplace = true) } + errorAnnotationCall.configure { + +field("argumentMapping", annotationArgumentMapping, withReplace = true) + } + annotationArgumentMapping.configure { +field("mapping", type("Map") to listOf(nameType, expression)) } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java index f54fde652ce..81adc89c5a1 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java @@ -343,6 +343,8 @@ public interface Errors { DiagnosticFactory0 NON_PARENTHESIZED_ANNOTATIONS_ON_FUNCTIONAL_TYPES = DiagnosticFactory0.create(ERROR); + DiagnosticFactory0 ANNOTATION_IN_WHERE_CLAUSE_WARNING = DiagnosticFactory0.create(WARNING); + // Const DiagnosticFactory0 CONST_VAL_NOT_TOP_LEVEL_OR_OBJECT = DiagnosticFactory0.create(ERROR); DiagnosticFactory0 CONST_VAL_WITH_GETTER = DiagnosticFactory0.create(ERROR); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java index d592c32b8b7..7ff56088dfd 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java @@ -187,6 +187,8 @@ public class DefaultErrorMessages { MAP.put(NON_PARENTHESIZED_ANNOTATIONS_ON_FUNCTIONAL_TYPES, "Non-parenthesized annotations on function types without receiver aren't yet supported (see KT-31734 for details)"); + MAP.put(ANNOTATION_IN_WHERE_CLAUSE_WARNING, "Type parameter annotations will not be allowed inside where clauses in future releases. You should probably move annotations to the type parameter declaration"); + MAP.put(REDUNDANT_MODIFIER, "Modifier ''{0}'' is redundant because ''{1}'' is present", TO_STRING, TO_STRING); MAP.put(REDUNDANT_OPEN_IN_INTERFACE, "Modifier 'open' is redundant for abstract interface members"); MAP.put(REDUNDANT_MODIFIER_IN_GETTER, "Visibility modifiers are redundant in getter"); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationsChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationsChecker.kt index adc1b304982..40b9283889b 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationsChecker.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationsChecker.kt @@ -537,6 +537,12 @@ class DeclarationsChecker( checkSupertypesForConsistency(typeParameterDescriptor, typeParameter) checkOnlyOneTypeParameterBound(typeParameterDescriptor, typeParameter, typeParameterListOwner) } + + for (constraint in constraints) { + constraint.annotationEntries.forEach { + trace.report(ANNOTATION_IN_WHERE_CLAUSE_WARNING.on(it)) + } + } } private fun checkConstructorInInterface(klass: KtClass) { diff --git a/compiler/psi/src/org/jetbrains/kotlin/psi/KtTypeConstraint.java b/compiler/psi/src/org/jetbrains/kotlin/psi/KtTypeConstraint.java index d77e061d85d..6eafecbf397 100644 --- a/compiler/psi/src/org/jetbrains/kotlin/psi/KtTypeConstraint.java +++ b/compiler/psi/src/org/jetbrains/kotlin/psi/KtTypeConstraint.java @@ -19,10 +19,15 @@ package org.jetbrains.kotlin.psi; import com.intellij.lang.ASTNode; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; +import org.jetbrains.kotlin.KtNodeTypes; +import org.jetbrains.kotlin.psi.psiUtil.KtPsiUtilKt; import org.jetbrains.kotlin.psi.stubs.KotlinPlaceHolderStub; import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes; -public class KtTypeConstraint extends KtElementImplStub> { +import java.util.List; + +public class KtTypeConstraint extends KtElementImplStub> + implements KtAnnotated, KtAnnotationsContainer { public KtTypeConstraint(@NotNull ASTNode node) { super(node); } @@ -45,4 +50,16 @@ public class KtTypeConstraint extends KtElementImplStub getAnnotations() { + return findChildrenByType(KtNodeTypes.ANNOTATION); + } + + @Override + @NotNull + public List getAnnotationEntries() { + return KtPsiUtilKt.collectAnnotationEntriesFromStubOrPsi(this); + } } diff --git a/compiler/testData/diagnostics/tests/kt46483.fir.kt b/compiler/testData/diagnostics/tests/kt46483.fir.kt new file mode 100644 index 00000000000..57e6f327681 --- /dev/null +++ b/compiler/testData/diagnostics/tests/kt46483.fir.kt @@ -0,0 +1,11 @@ +@Repeatable +@Target( AnnotationTarget.TYPE_PARAMETER) +annotation class TypeParameterAnn(val name: String) + +interface Generic + +fun <@TypeParameterAnn("T") T: Any> whereClauseWithAnnotation() where @TypeParameterAnn("Prohibit me!!!") T : Generic { +} + +class Foo<@TypeParameterAnn("T") T: Any> () where @TypeParameterAnn("Prohibit me!!!") T : Generic { +} diff --git a/compiler/testData/diagnostics/tests/kt46483.kt b/compiler/testData/diagnostics/tests/kt46483.kt new file mode 100644 index 00000000000..1e8b5a07149 --- /dev/null +++ b/compiler/testData/diagnostics/tests/kt46483.kt @@ -0,0 +1,11 @@ +@Repeatable +@Target( AnnotationTarget.TYPE_PARAMETER) +annotation class TypeParameterAnn(val name: String) + +interface Generic + +fun <@TypeParameterAnn("T") T: Any> whereClauseWithAnnotation() where @TypeParameterAnn("Prohibit me!!!") T : Generic { +} + +class Foo<@TypeParameterAnn("T") T: Any> () where @TypeParameterAnn("Prohibit me!!!") T : Generic { +} diff --git a/compiler/testData/diagnostics/tests/kt46483.txt b/compiler/testData/diagnostics/tests/kt46483.txt new file mode 100644 index 00000000000..f119154dde5 --- /dev/null +++ b/compiler/testData/diagnostics/tests/kt46483.txt @@ -0,0 +1,24 @@ +package + +public fun whereClauseWithAnnotation(): kotlin.Unit where T : Generic + +public final class Foo where T : Generic { + public constructor Foo() where T : Generic + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} + +public interface Generic { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} + +@kotlin.annotation.Repeatable @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE_PARAMETER}) public final annotation class TypeParameterAnn : kotlin.Annotation { + public constructor TypeParameterAnn(/*0*/ name: kotlin.String) + public final val name: kotlin.String + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} diff --git a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java index 8e602951456..da8b10a29a0 100644 --- a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java +++ b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java @@ -423,6 +423,12 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { runTest("compiler/testData/diagnostics/tests/kt435.kt"); } + @Test + @TestMetadata("kt46483.kt") + public void testKt46483() throws Exception { + runTest("compiler/testData/diagnostics/tests/kt46483.kt"); + } + @Test @TestMetadata("kt49438.kt") public void testKt49438() throws Exception { diff --git a/compiler/tests-spec/testData/diagnostics/notLinked/annotations/type-annotations/neg/5.fir.kt b/compiler/tests-spec/testData/diagnostics/notLinked/annotations/type-annotations/neg/5.fir.kt index a586eedc3be..3bc9d1af0ed 100644 --- a/compiler/tests-spec/testData/diagnostics/notLinked/annotations/type-annotations/neg/5.fir.kt +++ b/compiler/tests-spec/testData/diagnostics/notLinked/annotations/type-annotations/neg/5.fir.kt @@ -9,4 +9,4 @@ abstract class Barunresolved_reference) Any * TESTCASE NUMBER: 2 * UNEXPECTED BEHAVIOUR */ -class B where @Ann(unresolved_reference) T : Number +class B where @Ann(unresolved_reference) T : Number diff --git a/compiler/tests-spec/testData/diagnostics/notLinked/annotations/type-annotations/neg/5.kt b/compiler/tests-spec/testData/diagnostics/notLinked/annotations/type-annotations/neg/5.kt index 33e40f37135..18c5fce514b 100644 --- a/compiler/tests-spec/testData/diagnostics/notLinked/annotations/type-annotations/neg/5.kt +++ b/compiler/tests-spec/testData/diagnostics/notLinked/annotations/type-annotations/neg/5.kt @@ -18,4 +18,4 @@ abstract class Barunresolved_reference) Any * TESTCASE NUMBER: 2 * UNEXPECTED BEHAVIOUR */ -class B where @Ann(unresolved_reference) T : Number +class B where @Ann(unresolved_reference) T : Number