From 2980179bd78060d35353afb57cc9c8d39b4c2c2b Mon Sep 17 00:00:00 2001 From: Roman Efremov Date: Thu, 22 Jun 2023 12:30:52 +0200 Subject: [PATCH] [IR] Implement IR checker for expect actual annotations matching ^KT-58551 --- .../ExpectedActualDeclarationChecker.kt | 1 + .../backend/common/CommonBackendErrors.kt | 17 +++++- .../backend/common/actualizer/IrActualizer.kt | 1 + .../common/actualizer/IrActualizerUtils.kt | 12 ++++ ...IrExpectActualAnnotationMatchingChecker.kt | 55 +++++++++++++++++++ .../IrExpectActualMatchingContext.kt | 23 ++++++-- .../irConstExpressionValuesEqualityChecker.kt | 45 +++++++++++++++ ...annotationArgumentsConstExpressions.fir.kt | 12 ++-- .../annotationArgumentsDefaults.fir.kt | 11 ++++ .../annotationArgumentsDefaults.kt | 1 - .../annotationTypeParameters.fir.kt | 28 +++++----- .../basicOnDeclaration.fir.kt | 41 ++++++++++++++ .../annotationMatching/basicOnDeclaration.kt | 1 - .../checkDiagnosticFullText.diag.txt | 6 +- .../checkDiagnosticFullText.fir.diag.txt | 6 +- .../checkDiagnosticFullText.fir.kt | 33 +++++++++++ .../checkDiagnosticFullText.kt | 1 - .../compatibleOverrides.fir.kt | 18 ++++++ .../annotationMatching/compatibleOverrides.kt | 1 - .../annotationMatching/differentOrder.fir.kt | 4 +- .../floatNumbersComparison.fir.kt | 4 +- .../annotationMatching/typealias.fir.kt | 22 ++++++++ .../annotationMatching/typealias.kt | 1 - .../typealiasToJavaLibrary.fir.kt | 2 +- .../typealiasToKtLibrary.fir.kt | 12 +++- .../typealiasToKtLibrary.kt | 10 ++++ 26 files changed, 324 insertions(+), 44 deletions(-) create mode 100644 compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/actualizer/IrExpectActualAnnotationMatchingChecker.kt create mode 100644 compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/actualizer/irConstExpressionValuesEqualityChecker.kt create mode 100644 compiler/testData/diagnostics/tests/multiplatform/annotationMatching/annotationArgumentsDefaults.fir.kt create mode 100644 compiler/testData/diagnostics/tests/multiplatform/annotationMatching/basicOnDeclaration.fir.kt create mode 100644 compiler/testData/diagnostics/tests/multiplatform/annotationMatching/checkDiagnosticFullText.fir.kt create mode 100644 compiler/testData/diagnostics/tests/multiplatform/annotationMatching/compatibleOverrides.fir.kt create mode 100644 compiler/testData/diagnostics/tests/multiplatform/annotationMatching/typealias.fir.kt diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/ExpectedActualDeclarationChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/ExpectedActualDeclarationChecker.kt index 5fce14f8fd0..ebedb3aae1a 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/ExpectedActualDeclarationChecker.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/ExpectedActualDeclarationChecker.kt @@ -37,6 +37,7 @@ import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter import org.jetbrains.kotlin.resolve.source.KotlinSourceElement import org.jetbrains.kotlin.resolve.source.PsiSourceFile import org.jetbrains.kotlin.types.KotlinType +import org.jetbrains.kotlin.utils.addToStdlib.cast import java.io.File class ExpectedActualDeclarationChecker( diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/CommonBackendErrors.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/CommonBackendErrors.kt index 7ad75ad7339..347b3b01a88 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/CommonBackendErrors.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/CommonBackendErrors.kt @@ -7,9 +7,10 @@ package org.jetbrains.kotlin.backend.common import com.intellij.psi.PsiElement import org.jetbrains.kotlin.backend.common.BackendDiagnosticRenderers.INCOMPATIBILITY +import org.jetbrains.kotlin.backend.common.BackendDiagnosticRenderers.SYMBOL_OWNER_DECLARATION_FQ_NAME import org.jetbrains.kotlin.descriptors.ModuleDescriptor import org.jetbrains.kotlin.diagnostics.KtDiagnosticFactoryToRendererMap -import org.jetbrains.kotlin.diagnostics.error0 +import org.jetbrains.kotlin.diagnostics.SourceElementPositioningStrategies.ACTUAL_DECLARATION_NAME import org.jetbrains.kotlin.diagnostics.error2 import org.jetbrains.kotlin.diagnostics.error3 import org.jetbrains.kotlin.diagnostics.rendering.BaseDiagnosticRendererFactory @@ -17,6 +18,10 @@ import org.jetbrains.kotlin.diagnostics.rendering.CommonRenderers.STRING import org.jetbrains.kotlin.diagnostics.rendering.Renderer import org.jetbrains.kotlin.diagnostics.rendering.Renderers.MODULE_WITH_PLATFORM import org.jetbrains.kotlin.diagnostics.rendering.RootDiagnosticRendererFactory +import org.jetbrains.kotlin.diagnostics.warning2 +import org.jetbrains.kotlin.ir.declarations.IrDeclarationWithName +import org.jetbrains.kotlin.ir.symbols.IrSymbol +import org.jetbrains.kotlin.ir.util.fqNameWhenAvailable import org.jetbrains.kotlin.resolve.multiplatform.ExpectActualCompatibility object CommonBackendErrors { @@ -24,6 +29,7 @@ object CommonBackendErrors { val MANY_INTERFACES_MEMBER_NOT_IMPLEMENTED by error2() val MANY_IMPL_MEMBER_NOT_IMPLEMENTED by error2() val INCOMPATIBLE_MATCHING by error3>() + val ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT by warning2() init { RootDiagnosticRendererFactory.registerFactory(KtDefaultCommonBackendErrorMessages) @@ -57,6 +63,12 @@ object KtDefaultCommonBackendErrorMessages : BaseDiagnosticRendererFactory() { STRING, INCOMPATIBILITY ) + map.put( + CommonBackendErrors.ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT, + "All annotations from expect declaration `{0}` must be present with the same arguments on actual declaration `{1}` otherwise they have no effect", + SYMBOL_OWNER_DECLARATION_FQ_NAME, + SYMBOL_OWNER_DECLARATION_FQ_NAME, + ) } } @@ -64,4 +76,7 @@ object BackendDiagnosticRenderers { val INCOMPATIBILITY = Renderer> { it.reason ?: "" } + val SYMBOL_OWNER_DECLARATION_FQ_NAME = Renderer { + (it.owner as? IrDeclarationWithName)?.fqNameWhenAvailable?.asString() ?: "unknown name" + } } diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/actualizer/IrActualizer.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/actualizer/IrActualizer.kt index 751a198a14a..1ad15cb11b5 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/actualizer/IrActualizer.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/actualizer/IrActualizer.kt @@ -33,6 +33,7 @@ object IrActualizer { typeSystemContext, ktDiagnosticReporter ).collect() + IrExpectActualAnnotationMatchingChecker(expectActualMap, actualDeclarations, typeSystemContext, ktDiagnosticReporter).check() // 2. Remove top-only expect declarations since they are not needed anymore and should not be presented in the final IrFragment // Expect fake-overrides from non-expect classes remain untouched since they will be actualized in the next phase. diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/actualizer/IrActualizerUtils.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/actualizer/IrActualizerUtils.kt index 44d1459d4c4..d5c9fe7ab41 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/actualizer/IrActualizerUtils.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/actualizer/IrActualizerUtils.kt @@ -122,6 +122,18 @@ internal fun KtDiagnosticReporterWithImplicitIrBasedContext.reportIncompatibleEx ) } +internal fun KtDiagnosticReporterWithImplicitIrBasedContext.reportActualAnnotationsNotMatchExpect( + expectSymbol: IrSymbol, + actualSymbol: IrSymbol, + reportOn: IrSymbol, +) { + at(reportOn.owner as IrDeclaration).report( + CommonBackendErrors.ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT, + expectSymbol, + actualSymbol, + ) +} + internal fun IrElement.containsOptionalExpectation(): Boolean { return this is IrClass && this.kind == ClassKind.ANNOTATION_CLASS && diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/actualizer/IrExpectActualAnnotationMatchingChecker.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/actualizer/IrExpectActualAnnotationMatchingChecker.kt new file mode 100644 index 00000000000..3e154a865a8 --- /dev/null +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/actualizer/IrExpectActualAnnotationMatchingChecker.kt @@ -0,0 +1,55 @@ +/* + * Copyright 2010-2023 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.backend.common.actualizer + +import org.jetbrains.kotlin.KtDiagnosticReporterWithImplicitIrBasedContext +import org.jetbrains.kotlin.backend.common.lower.parentsWithSelf +import org.jetbrains.kotlin.ir.declarations.IrClass +import org.jetbrains.kotlin.ir.declarations.IrDeclaration +import org.jetbrains.kotlin.ir.symbols.IrClassSymbol +import org.jetbrains.kotlin.ir.symbols.IrSymbol +import org.jetbrains.kotlin.ir.symbols.IrTypeAliasSymbol +import org.jetbrains.kotlin.ir.types.IrTypeSystemContext +import org.jetbrains.kotlin.ir.util.classIdOrFail +import org.jetbrains.kotlin.resolve.calls.mpp.AbstractExpectActualAnnotationMatchChecker + +internal class IrExpectActualAnnotationMatchingChecker( + private val matchedExpectToActual: Map, + private val classActualizationInfo: ClassActualizationInfo, + typeSystemContext: IrTypeSystemContext, + private val diagnosticsReporter: KtDiagnosticReporterWithImplicitIrBasedContext, +) { + private val context = object : IrExpectActualMatchingContext(typeSystemContext, classActualizationInfo.actualClasses) { + override fun onMatchedClasses(expectClassSymbol: IrClassSymbol, actualClassSymbol: IrClassSymbol) { + error("Must not be called") + } + + override fun onMatchedCallables(expectSymbol: IrSymbol, actualSymbol: IrSymbol) { + error("Must not be called") + } + } + + fun check() { + for ((expectSymbol, actualSymbol) in matchedExpectToActual.entries) { + val incompatibility = + AbstractExpectActualAnnotationMatchChecker.areAnnotationsCompatible(expectSymbol, actualSymbol, context) ?: continue + + val reportOn = getTypealiasSymbolIfActualizedViaTypealias(expectSymbol) ?: actualSymbol + diagnosticsReporter.reportActualAnnotationsNotMatchExpect( + incompatibility.expectSymbol as IrSymbol, + incompatibility.actualSymbol as IrSymbol, + reportOn, + ) + } + } + + private fun getTypealiasSymbolIfActualizedViaTypealias(expectSymbol: IrSymbol): IrTypeAliasSymbol? { + val expectDeclaration = expectSymbol.owner as IrDeclaration + val topLevelExpectClass = expectDeclaration.parentsWithSelf.filterIsInstance().lastOrNull() ?: return null + val classId = topLevelExpectClass.classIdOrFail + return classActualizationInfo.actualTypeAliases[classId] + } +} \ No newline at end of file diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/actualizer/IrExpectActualMatchingContext.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/actualizer/IrExpectActualMatchingContext.kt index 0583fc26ddc..356adf90ef6 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/actualizer/IrExpectActualMatchingContext.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/actualizer/IrExpectActualMatchingContext.kt @@ -11,6 +11,7 @@ import org.jetbrains.kotlin.descriptors.Visibilities import org.jetbrains.kotlin.descriptors.Visibility import org.jetbrains.kotlin.ir.declarations.* import org.jetbrains.kotlin.ir.expressions.IrConstructorCall +import org.jetbrains.kotlin.ir.expressions.IrExpression import org.jetbrains.kotlin.ir.symbols.* import org.jetbrains.kotlin.ir.types.* import org.jetbrains.kotlin.ir.types.impl.IrSimpleTypeImpl @@ -23,6 +24,7 @@ import org.jetbrains.kotlin.name.CallableId import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.resolve.calls.mpp.ExpectActualMatchingContext +import org.jetbrains.kotlin.resolve.calls.mpp.ExpectActualMatchingContext.AnnotationCallInfo import org.jetbrains.kotlin.types.AbstractTypeChecker import org.jetbrains.kotlin.types.TypeCheckerState import org.jetbrains.kotlin.types.Variance @@ -446,12 +448,21 @@ internal abstract class IrExpectActualMatchingContext( abstract fun onMatchedClasses(expectClassSymbol: IrClassSymbol, actualClassSymbol: IrClassSymbol) abstract fun onMatchedCallables(expectSymbol: IrSymbol, actualSymbol: IrSymbol) - override val DeclarationSymbolMarker.annotations: List - // TODO(Roman.Efremov): implement in subsequent commits - get() = emptyList() + override val DeclarationSymbolMarker.annotations: List + get() = asIr().annotations.map(::AnnotationCallInfoImpl) - override fun areAnnotationArgumentsEqual(annotation1: ExpectActualMatchingContext.AnnotationCallInfo, annotation2: ExpectActualMatchingContext.AnnotationCallInfo): Boolean { - // TODO(Roman.Efremov): implement in subsequent commits - return true + override fun areAnnotationArgumentsEqual(annotation1: AnnotationCallInfo, annotation2: AnnotationCallInfo): Boolean { + fun AnnotationCallInfo.getIrElement(): IrConstructorCall = (this as AnnotationCallInfoImpl).irElement + + return areIrExpressionConstValuesEqual(annotation1.getIrElement(), annotation2.getIrElement()) + } + + internal fun getClassIdAfterActualization(classId: ClassId): ClassId { + return expectToActualClassMap[classId]?.classId ?: classId + } + + private class AnnotationCallInfoImpl(val irElement: IrConstructorCall) : AnnotationCallInfo { + override val classId: ClassId? + get() = irElement.type.getClass()?.classId } } diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/actualizer/irConstExpressionValuesEqualityChecker.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/actualizer/irConstExpressionValuesEqualityChecker.kt new file mode 100644 index 00000000000..00b425f9578 --- /dev/null +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/actualizer/irConstExpressionValuesEqualityChecker.kt @@ -0,0 +1,45 @@ +/* + * Copyright 2010-2023 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.backend.common.actualizer + +import org.jetbrains.kotlin.ir.IrElement +import org.jetbrains.kotlin.ir.expressions.* +import org.jetbrains.kotlin.ir.types.classOrFail + +internal fun IrExpectActualMatchingContext.areIrExpressionConstValuesEqual(a: IrElement?, b: IrElement?): Boolean { + return when { + a == null || b == null -> (a == null) == (b == null) + + a::class != b::class -> false + + a is IrConst<*> && b is IrConst<*> -> a.value == b.value + + a is IrClassReference && b is IrClassReference -> equalBy(a, b) { + val classId = it.classType.classOrFail.classId + getClassIdAfterActualization(classId) + } + + a is IrGetEnumValue && b is IrGetEnumValue -> equalBy(a, b) { it.symbol.signature?.toString() } + + a is IrVararg && b is IrVararg -> { + equalBy(a, b) { it.elements.size } && + a.elements.zip(b.elements).all { (f, s) -> areIrExpressionConstValuesEqual(f, s) } + } + + a is IrConstructorCall && b is IrConstructorCall -> { + equalBy(a, b) { it.valueArgumentsCount } && + areCompatibleExpectActualTypes(a.type, b.type) && + (0.. + areIrExpressionConstValuesEqual(a.getValueArgument(i), b.getValueArgument(i)) + } + } + + else -> error("Not handled expression types $a $b") + } +} + +private inline fun equalBy(first: T, second: T, selector: (T) -> Any?): Boolean = + selector(first) == selector(second) diff --git a/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/annotationArgumentsConstExpressions.fir.kt b/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/annotationArgumentsConstExpressions.fir.kt index 4b9f7e7a1e4..49ce13342d6 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/annotationArgumentsConstExpressions.fir.kt +++ b/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/annotationArgumentsConstExpressions.fir.kt @@ -87,8 +87,8 @@ package test @ClassArgAnn(ClassForReference::class) actual fun getClassExpression() {} -@ClassArgAnn(ClassForReference::class) -actual fun differentClassesWithSameName() {} +@ClassArgAnn(ClassForReference::class) +actual fun differentClassesWithSameName() {} @StringArgAnn("1.9") actual fun stringConstant() {} @@ -114,8 +114,8 @@ actual fun varargInAnnotationWithArraySpread() {} @ArrayArgAnn(arrayOf("foo", "bar")) actual fun arrayInAnnotation() {} -@ArrayArgAnn(["foo"]) -actual fun arrayInAnnotationNotMatch() {} +@ArrayArgAnn(["foo"]) +actual fun arrayInAnnotationNotMatch() {} @NestedAnnArg( text = "root", @@ -127,7 +127,7 @@ actual fun arrayInAnnotationNotMatch() {} ) actual fun complexNestedAnnotations() {} -@NestedAnnArg( +@NestedAnnArg( text = "root", NestedAnnArg("1"), NestedAnnArg("2", @@ -135,4 +135,4 @@ actual fun complexNestedAnnotations() {} NestedAnnArg("DIFFERENT") ) ) -actual fun complexNestedAnnotationsNotMatch() {} +actual fun complexNestedAnnotationsNotMatch() {} diff --git a/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/annotationArgumentsDefaults.fir.kt b/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/annotationArgumentsDefaults.fir.kt new file mode 100644 index 00000000000..be1daa3a13e --- /dev/null +++ b/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/annotationArgumentsDefaults.fir.kt @@ -0,0 +1,11 @@ +// MODULE: m1-common +// FILE: common.kt +annotation class Ann(val p: String = "") +@Ann("") +expect fun explicitDefaultArgument() + +// MODULE: m1-jvm()()(m1-common) +// FILE: jvm.kt +// No special handling for this case +@Ann +actual fun explicitDefaultArgument() {} diff --git a/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/annotationArgumentsDefaults.kt b/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/annotationArgumentsDefaults.kt index ab0d99f2c73..c82eda5790b 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/annotationArgumentsDefaults.kt +++ b/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/annotationArgumentsDefaults.kt @@ -1,4 +1,3 @@ -// FIR_IDENTICAL // MODULE: m1-common // FILE: common.kt annotation class Ann(val p: String = "") diff --git a/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/annotationTypeParameters.fir.kt b/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/annotationTypeParameters.fir.kt index 9562eea8150..a4f45fad3c5 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/annotationTypeParameters.fir.kt +++ b/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/annotationTypeParameters.fir.kt @@ -62,26 +62,26 @@ expect fun explicitVsInfered() @Ann actual fun sameTypeParam() {} -@Ann -actual fun differentTypeParam() {} +@Ann +actual fun differentTypeParam() {} -@Ann -actual fun differentWithSameName() {} +@Ann +actual fun differentWithSameName() {} -@Ann -actual fun nonNullvsNull() {} +@Ann +actual fun nonNullvsNull() {} -@Ann> -actual fun differentVariance() {} +@Ann> +actual fun differentVariance() {} -@Ann> -actual fun varianceVsNoVariance() {} +@Ann> +actual fun varianceVsNoVariance() {} @Ann> actual fun sameVariance() {} -@Ann> -actual fun startProjection() {} +@Ann> +actual fun startProjection() {} @ComplexNested( ComplexNested(), @@ -89,11 +89,11 @@ actual fun ( +@ComplexNested( ComplexNested(), ComplexNested(), ) -actual fun complexDiffer() {} +actual fun complexDiffer() {} @NestedWithSameTypeArgument( NestedWithSameTypeArgument() diff --git a/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/basicOnDeclaration.fir.kt b/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/basicOnDeclaration.fir.kt new file mode 100644 index 00000000000..24b5ad2d430 --- /dev/null +++ b/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/basicOnDeclaration.fir.kt @@ -0,0 +1,41 @@ +// MODULE: m1-common +// FILE: common.kt +annotation class Ann + +@Ann +expect class AnnotationMatching + +@Ann +expect class AnnotationOnExpectOnly + +expect class AnnotationOnActualOnly + +expect class AnnotationInside { + @Ann + fun matches() + + @Ann + fun onlyOnExpect() + + fun onlyOnActual() +} + +// MODULE: m1-jvm()()(m1-common) +// FILE: jvm.kt +@Ann +actual class AnnotationMatching + +actual class AnnotationOnExpectOnly + +@Ann +actual class AnnotationOnActualOnly + +actual class AnnotationInside { + @Ann + actual fun matches() {} + + actual fun onlyOnExpect() {} + + @Ann + actual fun onlyOnActual() {} +} diff --git a/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/basicOnDeclaration.kt b/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/basicOnDeclaration.kt index b556a5b9340..2eded46b53a 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/basicOnDeclaration.kt +++ b/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/basicOnDeclaration.kt @@ -1,4 +1,3 @@ -// FIR_IDENTICAL // MODULE: m1-common // FILE: common.kt annotation class Ann diff --git a/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/checkDiagnosticFullText.diag.txt b/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/checkDiagnosticFullText.diag.txt index a3b3799c143..66159473d3e 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/checkDiagnosticFullText.diag.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/checkDiagnosticFullText.diag.txt @@ -1,17 +1,17 @@ // -- Module: -- // -- Module: -- -/jvm.kt:24:14: warning: all annotations from `expect` must be presented with same arguments on `actual`, otherwise they have no effect. +/jvm.kt:23:14: warning: all annotations from `expect` must be presented with same arguments on `actual`, otherwise they have no effect. Expected: @Ann public final expect class OnClass defined in root package in file common.kt Actual: public final actual class OnClass defined in root package in file jvm.kt actual class OnClass ^ -/jvm.kt:27:16: warning: all annotations from `expect` must be presented with same arguments on `actual`, otherwise they have no effect. +/jvm.kt:26:16: warning: all annotations from `expect` must be presented with same arguments on `actual`, otherwise they have no effect. Expected: @Ann public final expect fun onMember(): Unit defined in OnMember Actual: public final actual fun onMember(): Unit defined in OnMember actual fun onMember() {} ^ -/jvm.kt:34:18: warning: all annotations from `expect` must be presented with same arguments on `actual`, otherwise they have no effect. +/jvm.kt:33:18: warning: all annotations from `expect` must be presented with same arguments on `actual`, otherwise they have no effect. Expected: @Ann public final expect class ViaTypealias defined in root package in file common.kt Actual: public final class ViaTypealiasImpl defined in root package in file jvm.kt actual typealias ViaTypealias = ViaTypealiasImpl diff --git a/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/checkDiagnosticFullText.fir.diag.txt b/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/checkDiagnosticFullText.fir.diag.txt index 8fac224fe63..fc833b2f956 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/checkDiagnosticFullText.fir.diag.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/checkDiagnosticFullText.fir.diag.txt @@ -1,11 +1,11 @@ -/jvm.kt:(83,90): warning: All annotations from `expect` must be presented with same arguments on `actual`, otherwise they have no effect. +/jvm.kt:(82,89): warning: All annotations from `expect` must be presented with same arguments on `actual`, otherwise they have no effect. Expected: @Ann() public final expect class OnClass : Any Actual: public final actual class OnClass : Any -/jvm.kt:(131,139): warning: All annotations from `expect` must be presented with same arguments on `actual`, otherwise they have no effect. +/jvm.kt:(130,138): warning: All annotations from `expect` must be presented with same arguments on `actual`, otherwise they have no effect. Expected: @Ann() public final expect fun onMember(): Unit Actual: public final actual fun onMember(): Unit -/jvm.kt:(210,222): warning: All annotations from `expect` must be presented with same arguments on `actual`, otherwise they have no effect. +/jvm.kt:(209,221): warning: All annotations from `expect` must be presented with same arguments on `actual`, otherwise they have no effect. Expected: @Ann() public final expect class ViaTypealias : Any Actual: public final class ViaTypealiasImpl : Any diff --git a/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/checkDiagnosticFullText.fir.kt b/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/checkDiagnosticFullText.fir.kt new file mode 100644 index 00000000000..8a763049448 --- /dev/null +++ b/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/checkDiagnosticFullText.fir.kt @@ -0,0 +1,33 @@ +// RENDER_DIAGNOSTICS_FULL_TEXT +// MODULE: m1-common +// FILE: common.kt +annotation class Ann + +@Ann +expect class OnClass + +expect class OnMember { + @Ann + fun onMember() +} + +@Ann +expect class ViaTypealias { + @Ann + fun foo() +} + + +// MODULE: m1-jvm()()(m1-common) +// FILE: jvm.kt +actual class OnClass + +actual class OnMember { + actual fun onMember() {} +} + +class ViaTypealiasImpl { + fun foo() {} +} + +actual typealias ViaTypealias = ViaTypealiasImpl diff --git a/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/checkDiagnosticFullText.kt b/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/checkDiagnosticFullText.kt index e90fe80bea3..7d505921da2 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/checkDiagnosticFullText.kt +++ b/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/checkDiagnosticFullText.kt @@ -1,4 +1,3 @@ -// FIR_IDENTICAL // RENDER_DIAGNOSTICS_FULL_TEXT // MODULE: m1-common // FILE: common.kt diff --git a/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/compatibleOverrides.fir.kt b/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/compatibleOverrides.fir.kt new file mode 100644 index 00000000000..4f2604e7185 --- /dev/null +++ b/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/compatibleOverrides.fir.kt @@ -0,0 +1,18 @@ +// MODULE: m1-common +// FILE: common.kt +annotation class Ann + +expect class CompatibleOverrides { + fun foo() + + @Ann + fun foo(withArg: Any) +} + +// MODULE: m1-jvm()()(m1-common) +// FILE: jvm.kt +actual class CompatibleOverrides { + actual fun foo() {} + + actual fun foo(withArg: Any) {} +} diff --git a/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/compatibleOverrides.kt b/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/compatibleOverrides.kt index c5d1bc10d1b..4bbcd0e1af5 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/compatibleOverrides.kt +++ b/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/compatibleOverrides.kt @@ -1,4 +1,3 @@ -// FIR_IDENTICAL // MODULE: m1-common // FILE: common.kt annotation class Ann diff --git a/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/differentOrder.fir.kt b/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/differentOrder.fir.kt index 06ee04e8cd6..f7c74f21805 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/differentOrder.fir.kt +++ b/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/differentOrder.fir.kt @@ -24,8 +24,8 @@ expect fun differentArgumentsOrder() @Ann1 actual class AnnotationOrder -@Ann3(2, 1) -actual class ValuesOrderInsideAnnotationArgument +@Ann3(2, 1) +actual class ValuesOrderInsideAnnotationArgument @Ann4(arg2 = "2", arg1 = "1") actual fun differentArgumentsOrder() {} diff --git a/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/floatNumbersComparison.fir.kt b/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/floatNumbersComparison.fir.kt index 26d4b70e4b9..6496873cb1d 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/floatNumbersComparison.fir.kt +++ b/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/floatNumbersComparison.fir.kt @@ -7,5 +7,5 @@ expect fun floatNumbersComparison() // MODULE: m1-jvm()()(m1-common) // FILE: jvm.kt -@Ann(0.1 + 0.1 + 0.1) -actual fun floatNumbersComparison() {} +@Ann(0.1 + 0.1 + 0.1) +actual fun floatNumbersComparison() {} diff --git a/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/typealias.fir.kt b/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/typealias.fir.kt new file mode 100644 index 00000000000..2cd57e56f43 --- /dev/null +++ b/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/typealias.fir.kt @@ -0,0 +1,22 @@ +// WITH_STDLIB +// MODULE: m1-common +// FILE: common.kt +@Target(AnnotationTarget.TYPEALIAS, AnnotationTarget.CLASS) +annotation class Ann + +@Ann +expect class KtTypealiasNotMatch + +@Ann +expect class AnnotationsNotConsideredOnTypealias + +// MODULE: m1-jvm()()(m1-common) +// FILE: jvm.kt +class KtTypealiasNotMatchImpl + +actual typealias KtTypealiasNotMatch = KtTypealiasNotMatchImpl + +class AnnotationsNotConsideredOnTypealiasImpl + +@Ann +actual typealias AnnotationsNotConsideredOnTypealias = AnnotationsNotConsideredOnTypealiasImpl diff --git a/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/typealias.kt b/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/typealias.kt index 2d83224b0f2..b6f9aba3ec1 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/typealias.kt +++ b/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/typealias.kt @@ -1,4 +1,3 @@ -// FIR_IDENTICAL // WITH_STDLIB // MODULE: m1-common // FILE: common.kt diff --git a/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/typealiasToJavaLibrary.fir.kt b/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/typealiasToJavaLibrary.fir.kt index 7b383c136e2..5a4948d1a74 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/typealiasToJavaLibrary.fir.kt +++ b/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/typealiasToJavaLibrary.fir.kt @@ -9,6 +9,6 @@ expect annotation class MyDeprecatedMatch // MODULE: m1-jvm()()(m1-common) // FILE: jvm.kt -actual typealias MyDeprecatedNotMatch = java.lang.Deprecated +actual typealias MyDeprecatedNotMatch = java.lang.Deprecated actual typealias MyDeprecatedMatch = java.lang.Deprecated diff --git a/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/typealiasToKtLibrary.fir.kt b/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/typealiasToKtLibrary.fir.kt index fc432fcdd88..a97a63c68d1 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/typealiasToKtLibrary.fir.kt +++ b/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/typealiasToKtLibrary.fir.kt @@ -1,4 +1,5 @@ // WITH_STDLIB +// DIAGNOSTICS: -ACTUAL_TYPEALIAS_TO_SPECIAL_ANNOTATION // MODULE: m1-common // FILE: common.kt @Target( @@ -25,8 +26,17 @@ expect annotation class MyDeprecatedNotMatch ) expect annotation class MyDeprecatedMatch +annotation class Ann(val s: String) + +expect abstract class MyAbstractIterator { + @Ann("something" + "complex") + fun hasNext(): Boolean +} + // MODULE: m1-jvm()()(m1-common) // FILE: jvm.kt -actual typealias MyDeprecatedNotMatch = kotlin.Deprecated +actual typealias MyDeprecatedNotMatch = kotlin.Deprecated actual typealias MyDeprecatedMatch = kotlin.Deprecated + +actual typealias MyAbstractIterator = AbstractIterator diff --git a/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/typealiasToKtLibrary.kt b/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/typealiasToKtLibrary.kt index 81e80010d4b..cff8a1b7bde 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/typealiasToKtLibrary.kt +++ b/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/typealiasToKtLibrary.kt @@ -1,4 +1,5 @@ // WITH_STDLIB +// DIAGNOSTICS: -ACTUAL_TYPEALIAS_TO_SPECIAL_ANNOTATION // MODULE: m1-common // FILE: common.kt @Target( @@ -25,8 +26,17 @@ expect annotation class MyDeprecatedNotMatch ) expect annotation class MyDeprecatedMatch +annotation class Ann(val s: String) + +expect abstract class MyAbstractIterator { + @Ann("something" + "complex") + fun hasNext(): Boolean +} + // MODULE: m1-jvm()()(m1-common) // FILE: jvm.kt actual typealias MyDeprecatedNotMatch = kotlin.Deprecated actual typealias MyDeprecatedMatch = kotlin.Deprecated + +actual typealias MyAbstractIterator = AbstractIterator