From ab1c0e3c48f60d0e588e7799463bbccc7dcb50d5 Mon Sep 17 00:00:00 2001 From: Roman Efremov Date: Fri, 4 Aug 2023 13:09:36 +0200 Subject: [PATCH] [FE] Check annotations on actual class members including fake overrides ^KT-60668 ^KT-60936 --- ...DiagnosticsWithLightTreeTestGenerated.java | 24 +++++++ ...endMPPDiagnosticsWithPsiTestGenerated.java | 24 +++++++ .../FirExpectActualDeclarationChecker.kt | 6 +- .../mpp/FirExpectActualMatchingContextImpl.kt | 16 +++++ .../ExpectedActualDeclarationChecker.kt | 1 - ...IrExpectActualAnnotationMatchingChecker.kt | 2 +- .../IrExpectActualMatchingContext.kt | 12 ++++ ...tractExpectActualAnnotationMatchChecker.kt | 32 ++++++++- .../calls/mpp/ExpectActualMatchingContext.kt | 22 ++++++ .../ClassicExpectActualMatchingContext.kt | 32 ++++++++- .../multiplatform/ExpectedActualResolver.kt | 29 ++++++++ .../checkDiagnosticFullText.diag.txt | 10 ++- .../checkDiagnosticFullText.fir.diag.txt | 11 +-- .../checkDiagnosticFullText.fir.kt | 13 ++-- .../checkDiagnosticFullText.kt | 13 ++-- .../classScopeInnerClasses.fir.kt | 22 ++++++ .../classScopeInnerClasses.kt | 22 ++++++ .../classScopeViaTypealiasIncompatible.fir.kt | 27 ++++++++ .../classScopeViaTypealiasIncompatible.kt | 27 ++++++++ .../annotationMatching/fakeOverrides.fir.kt | 31 +++++++++ .../annotationMatching/fakeOverrides.kt | 3 +- .../substitutionOverrideInTwoClasses.fir.kt | 24 +++++++ .../substitutionOverrideInTwoClasses.kt | 24 +++++++ .../twoActualTypealiasesToSameClass.fir.kt | 21 ++++++ .../twoActualTypealiasesToSameClass.kt | 21 ++++++ .../annotationMatching/typealias.fir.kt | 67 ++++++++++++++++++- .../annotationMatching/typealias.kt | 67 ++++++++++++++++++- .../typealiasToKtLibrary.fir.kt | 4 +- .../typealiasToKtLibrary.kt | 4 +- .../test/runners/DiagnosticTestGenerated.java | 24 +++++++ 30 files changed, 601 insertions(+), 34 deletions(-) create mode 100644 compiler/testData/diagnostics/tests/multiplatform/annotationMatching/classScopeInnerClasses.fir.kt create mode 100644 compiler/testData/diagnostics/tests/multiplatform/annotationMatching/classScopeInnerClasses.kt create mode 100644 compiler/testData/diagnostics/tests/multiplatform/annotationMatching/classScopeViaTypealiasIncompatible.fir.kt create mode 100644 compiler/testData/diagnostics/tests/multiplatform/annotationMatching/classScopeViaTypealiasIncompatible.kt create mode 100644 compiler/testData/diagnostics/tests/multiplatform/annotationMatching/fakeOverrides.fir.kt create mode 100644 compiler/testData/diagnostics/tests/multiplatform/annotationMatching/substitutionOverrideInTwoClasses.fir.kt create mode 100644 compiler/testData/diagnostics/tests/multiplatform/annotationMatching/substitutionOverrideInTwoClasses.kt create mode 100644 compiler/testData/diagnostics/tests/multiplatform/annotationMatching/twoActualTypealiasesToSameClass.fir.kt create mode 100644 compiler/testData/diagnostics/tests/multiplatform/annotationMatching/twoActualTypealiasesToSameClass.kt diff --git a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendMPPDiagnosticsWithLightTreeTestGenerated.java b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendMPPDiagnosticsWithLightTreeTestGenerated.java index 279707dc95c..a3c0fc4b2eb 100644 --- a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendMPPDiagnosticsWithLightTreeTestGenerated.java +++ b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendMPPDiagnosticsWithLightTreeTestGenerated.java @@ -728,6 +728,18 @@ public class FirOldFrontendMPPDiagnosticsWithLightTreeTestGenerated extends Abst runTest("compiler/testData/diagnostics/tests/multiplatform/annotationMatching/checkDiagnosticFullText.kt"); } + @Test + @TestMetadata("classScopeInnerClasses.kt") + public void testClassScopeInnerClasses() throws Exception { + runTest("compiler/testData/diagnostics/tests/multiplatform/annotationMatching/classScopeInnerClasses.kt"); + } + + @Test + @TestMetadata("classScopeViaTypealiasIncompatible.kt") + public void testClassScopeViaTypealiasIncompatible() throws Exception { + runTest("compiler/testData/diagnostics/tests/multiplatform/annotationMatching/classScopeViaTypealiasIncompatible.kt"); + } + @Test @TestMetadata("compatibleOverrides.kt") public void testCompatibleOverrides() throws Exception { @@ -794,6 +806,18 @@ public class FirOldFrontendMPPDiagnosticsWithLightTreeTestGenerated extends Abst runTest("compiler/testData/diagnostics/tests/multiplatform/annotationMatching/sourceRetentionAnnotationsWhenTypealias.kt"); } + @Test + @TestMetadata("substitutionOverrideInTwoClasses.kt") + public void testSubstitutionOverrideInTwoClasses() throws Exception { + runTest("compiler/testData/diagnostics/tests/multiplatform/annotationMatching/substitutionOverrideInTwoClasses.kt"); + } + + @Test + @TestMetadata("twoActualTypealiasesToSameClass.kt") + public void testTwoActualTypealiasesToSameClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/multiplatform/annotationMatching/twoActualTypealiasesToSameClass.kt"); + } + @Test @TestMetadata("typealias.kt") public void testTypealias() throws Exception { diff --git a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendMPPDiagnosticsWithPsiTestGenerated.java b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendMPPDiagnosticsWithPsiTestGenerated.java index 34699a59442..4b4e96785fd 100644 --- a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendMPPDiagnosticsWithPsiTestGenerated.java +++ b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendMPPDiagnosticsWithPsiTestGenerated.java @@ -728,6 +728,18 @@ public class FirOldFrontendMPPDiagnosticsWithPsiTestGenerated extends AbstractFi runTest("compiler/testData/diagnostics/tests/multiplatform/annotationMatching/checkDiagnosticFullText.kt"); } + @Test + @TestMetadata("classScopeInnerClasses.kt") + public void testClassScopeInnerClasses() throws Exception { + runTest("compiler/testData/diagnostics/tests/multiplatform/annotationMatching/classScopeInnerClasses.kt"); + } + + @Test + @TestMetadata("classScopeViaTypealiasIncompatible.kt") + public void testClassScopeViaTypealiasIncompatible() throws Exception { + runTest("compiler/testData/diagnostics/tests/multiplatform/annotationMatching/classScopeViaTypealiasIncompatible.kt"); + } + @Test @TestMetadata("compatibleOverrides.kt") public void testCompatibleOverrides() throws Exception { @@ -794,6 +806,18 @@ public class FirOldFrontendMPPDiagnosticsWithPsiTestGenerated extends AbstractFi runTest("compiler/testData/diagnostics/tests/multiplatform/annotationMatching/sourceRetentionAnnotationsWhenTypealias.kt"); } + @Test + @TestMetadata("substitutionOverrideInTwoClasses.kt") + public void testSubstitutionOverrideInTwoClasses() throws Exception { + runTest("compiler/testData/diagnostics/tests/multiplatform/annotationMatching/substitutionOverrideInTwoClasses.kt"); + } + + @Test + @TestMetadata("twoActualTypealiasesToSameClass.kt") + public void testTwoActualTypealiasesToSameClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/multiplatform/annotationMatching/twoActualTypealiasesToSameClass.kt"); + } + @Test @TestMetadata("typealias.kt") public void testTypealias() throws Exception { diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirExpectActualDeclarationChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirExpectActualDeclarationChecker.kt index 2b40156ae55..71a67defad1 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirExpectActualDeclarationChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirExpectActualDeclarationChecker.kt @@ -6,7 +6,6 @@ package org.jetbrains.kotlin.fir.analysis.checkers.declaration import org.jetbrains.kotlin.KtFakeSourceElementKind -import org.jetbrains.kotlin.KtSourceElement import org.jetbrains.kotlin.config.LanguageFeature import org.jetbrains.kotlin.descriptors.ClassKind import org.jetbrains.kotlin.diagnostics.DiagnosticReporter @@ -29,10 +28,7 @@ import org.jetbrains.kotlin.fir.scopes.getDeclaredConstructors import org.jetbrains.kotlin.fir.scopes.impl.declaredMemberScope import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol import org.jetbrains.kotlin.fir.symbols.SymbolInternals -import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol -import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol -import org.jetbrains.kotlin.fir.symbols.impl.FirTypeAliasSymbol -import org.jetbrains.kotlin.fir.symbols.impl.FirValueParameterSymbol +import org.jetbrains.kotlin.fir.symbols.impl.* import org.jetbrains.kotlin.lexer.KtTokens import org.jetbrains.kotlin.name.StandardClassIds import org.jetbrains.kotlin.resolve.calls.mpp.AbstractExpectActualAnnotationMatchChecker diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/mpp/FirExpectActualMatchingContextImpl.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/mpp/FirExpectActualMatchingContextImpl.kt index fd839e972ab..5d433729a22 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/mpp/FirExpectActualMatchingContextImpl.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/mpp/FirExpectActualMatchingContextImpl.kt @@ -11,6 +11,7 @@ import org.jetbrains.kotlin.descriptors.Visibility import org.jetbrains.kotlin.fir.* import org.jetbrains.kotlin.fir.analysis.getRetention import org.jetbrains.kotlin.fir.declarations.* +import org.jetbrains.kotlin.fir.declarations.utils.isActual import org.jetbrains.kotlin.fir.expressions.FirAnnotation import org.jetbrains.kotlin.fir.expressions.FirConstExpression import org.jetbrains.kotlin.fir.expressions.FirExpression @@ -458,6 +459,21 @@ class FirExpectActualMatchingContextImpl private constructor( private fun Map.asMutableMap(): MutableMap = this as MutableMap + override val checkClassScopesForAnnotationCompatibility = true + + override fun skipCheckingAnnotationsOfActualClassMember(actualMember: DeclarationSymbolMarker): Boolean { + return (actualMember.asSymbol().fir as? FirMemberDeclaration)?.isActual == true + } + + override fun findPotentialExpectClassMembersForActual( + expectClass: RegularClassSymbolMarker, + actualClass: RegularClassSymbolMarker, + actualMember: DeclarationSymbolMarker, + ): Map, ExpectActualCompatibility<*>> { + val mapping = actualClass.asSymbol().fir.memberExpectForActual + return mapping?.get(actualMember to expectClass) ?: emptyMap() + } + object Factory : FirExpectActualMatchingContextFactory { override fun create( session: FirSession, scopeSession: ScopeSession, 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 065dc326be3..965231202fe 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/ExpectedActualDeclarationChecker.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/ExpectedActualDeclarationChecker.kt @@ -40,7 +40,6 @@ 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 private val implicitlyActualizedAnnotationFqn = FqName("kotlin.jvm.ImplicitlyActualizedByJvmDeclaration") 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 index 38204e623c7..1948af60ea1 100644 --- 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 @@ -40,7 +40,7 @@ internal class IrExpectActualAnnotationMatchingChecker( if (expectSymbol is IrTypeParameterSymbol) { continue } - if (expectSymbol.isFakeOverride || actualSymbol.isFakeOverride) { + if (expectSymbol.isFakeOverride) { continue } val incompatibility = 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 cd6824910e7..7b033e00d1e 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 @@ -28,6 +28,7 @@ import org.jetbrains.kotlin.resolve.calls.mpp.ExpectActualCollectionArgumentsCom import org.jetbrains.kotlin.resolve.calls.mpp.ExpectActualMatchingContext import org.jetbrains.kotlin.resolve.calls.mpp.ExpectActualMatchingContext.AnnotationCallInfo import org.jetbrains.kotlin.resolve.checkers.OptInNames +import org.jetbrains.kotlin.resolve.multiplatform.ExpectActualCompatibility import org.jetbrains.kotlin.types.AbstractTypeChecker import org.jetbrains.kotlin.types.TypeCheckerState import org.jetbrains.kotlin.types.Variance @@ -506,4 +507,15 @@ internal abstract class IrExpectActualMatchingContext( val ir = asIr() return ir.sourceElement() == null && ir.origin !is IrDeclarationOrigin.GeneratedByPlugin } + + // IR checker traverses member scope itself and collects mappings + override val checkClassScopesForAnnotationCompatibility = false + + override fun skipCheckingAnnotationsOfActualClassMember(actualMember: DeclarationSymbolMarker): Boolean = error("Should not be called") + + override fun findPotentialExpectClassMembersForActual( + expectClass: RegularClassSymbolMarker, + actualClass: RegularClassSymbolMarker, + actualMember: DeclarationSymbolMarker, + ): Map> = error("Should not be called") } diff --git a/compiler/resolution.common/src/org/jetbrains/kotlin/resolve/calls/mpp/AbstractExpectActualAnnotationMatchChecker.kt b/compiler/resolution.common/src/org/jetbrains/kotlin/resolve/calls/mpp/AbstractExpectActualAnnotationMatchChecker.kt index 48ed5a19d44..f1a0e27d02f 100644 --- a/compiler/resolution.common/src/org/jetbrains/kotlin/resolve/calls/mpp/AbstractExpectActualAnnotationMatchChecker.kt +++ b/compiler/resolution.common/src/org/jetbrains/kotlin/resolve/calls/mpp/AbstractExpectActualAnnotationMatchChecker.kt @@ -9,6 +9,7 @@ import org.jetbrains.kotlin.mpp.* import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.StandardClassIds import org.jetbrains.kotlin.resolve.checkers.OptInNames +import org.jetbrains.kotlin.resolve.multiplatform.ExpectActualCompatibility import org.jetbrains.kotlin.resolve.multiplatform.ExpectActualAnnotationsIncompatibilityType as IncompatibilityType object AbstractExpectActualAnnotationMatchChecker { @@ -33,7 +34,9 @@ object AbstractExpectActualAnnotationMatchChecker { expectSymbol: DeclarationSymbolMarker, actualSymbol: DeclarationSymbolMarker, context: ExpectActualMatchingContext<*>, - ): Incompatibility? = with(context) { areAnnotationsCompatible(expectSymbol, actualSymbol) } + ): Incompatibility? = with(context) { + areAnnotationsCompatible(expectSymbol, actualSymbol) + } context (ExpectActualMatchingContext<*>) private fun areAnnotationsCompatible( @@ -70,9 +73,13 @@ object AbstractExpectActualAnnotationMatchChecker { val expanded = actualSymbol.expandToRegularClass() ?: return null return areClassAnnotationsCompatible(expectSymbol, expanded) } + check(actualSymbol is RegularClassSymbolMarker) + commonForClassAndCallableChecks(expectSymbol, actualSymbol)?.let { return it } - // TODO(Roman.Efremov, KT-58551): fix actual typealias class members not checked in FE checkers - // TODO(Roman.Efremov, KT-58551): check annotations on fake overrides in case of implicit actualization + + if (checkClassScopesForAnnotationCompatibility) { + checkAnnotationsInClassMemberScope(expectSymbol, actualSymbol)?.let { return it } + } return null } @@ -137,4 +144,23 @@ object AbstractExpectActualAnnotationMatchChecker { ExpectActualCollectionArgumentsCompatibilityCheckStrategy.Default } } + + context (ExpectActualMatchingContext<*>) + private fun checkAnnotationsInClassMemberScope( + expectClass: RegularClassSymbolMarker, + actualClass: RegularClassSymbolMarker, + ): Incompatibility? { + for (actualMember in actualClass.collectAllMembers(isActualDeclaration = true)) { + if (skipCheckingAnnotationsOfActualClassMember(actualMember)) { + continue + } + val expectToCompatibilityMap = findPotentialExpectClassMembersForActual(expectClass, actualClass, actualMember) + val expectMember = expectToCompatibilityMap.filter { it.value == ExpectActualCompatibility.Compatible }.keys.singleOrNull() + // Check also incompatible members if only one is found + ?: expectToCompatibilityMap.keys.singleOrNull() + ?: continue + areAnnotationsCompatible(expectMember, actualMember)?.let { return it } + } + return null + } } \ No newline at end of file diff --git a/compiler/resolution.common/src/org/jetbrains/kotlin/resolve/calls/mpp/ExpectActualMatchingContext.kt b/compiler/resolution.common/src/org/jetbrains/kotlin/resolve/calls/mpp/ExpectActualMatchingContext.kt index 912ee4fb77f..df69d5c3d72 100644 --- a/compiler/resolution.common/src/org/jetbrains/kotlin/resolve/calls/mpp/ExpectActualMatchingContext.kt +++ b/compiler/resolution.common/src/org/jetbrains/kotlin/resolve/calls/mpp/ExpectActualMatchingContext.kt @@ -189,4 +189,26 @@ interface ExpectActualMatchingContext : TypeSystemC val isRetentionSource: Boolean val isOptIn: Boolean } + + val checkClassScopesForAnnotationCompatibility: Boolean + + /** + * Determines whether it is needed to skip checking annotations on class member in [AbstractExpectActualAnnotationMatchChecker]. + * + * This is needed to prevent checking member twice if it is real `actual` member (not fake override or member of + * class being typealiased). + * Example: + * ``` + * actual class A { + * actual fun foo() {} // 1: checked itself, 2: checked as member of A + * } + * ``` + */ + fun skipCheckingAnnotationsOfActualClassMember(actualMember: DeclarationSymbolMarker): Boolean + + fun findPotentialExpectClassMembersForActual( + expectClass: RegularClassSymbolMarker, + actualClass: RegularClassSymbolMarker, + actualMember: DeclarationSymbolMarker, + ): Map> } diff --git a/compiler/resolution/src/org/jetbrains/kotlin/resolve/multiplatform/ClassicExpectActualMatchingContext.kt b/compiler/resolution/src/org/jetbrains/kotlin/resolve/multiplatform/ClassicExpectActualMatchingContext.kt index e782de2a9f7..817b131402d 100644 --- a/compiler/resolution/src/org/jetbrains/kotlin/resolve/multiplatform/ClassicExpectActualMatchingContext.kt +++ b/compiler/resolution/src/org/jetbrains/kotlin/resolve/multiplatform/ClassicExpectActualMatchingContext.kt @@ -19,7 +19,6 @@ import org.jetbrains.kotlin.resolve.calls.mpp.ExpectActualMatchingContext import org.jetbrains.kotlin.resolve.calls.mpp.ExpectActualMatchingContext.AnnotationCallInfo import org.jetbrains.kotlin.resolve.checkers.OptInNames import org.jetbrains.kotlin.resolve.descriptorUtil.* -import org.jetbrains.kotlin.resolve.findTopMostOverriddenDescriptors import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter import org.jetbrains.kotlin.resolve.scopes.MemberScope import org.jetbrains.kotlin.resolve.scopes.getDescriptorsFiltered @@ -387,4 +386,35 @@ class ClassicExpectActualMatchingContext( this !is K1SyntheticClassifierSymbolMarker && !(this is CallableMemberDescriptor && kind == CallableMemberDescriptor.Kind.SYNTHESIZED) } + + override val checkClassScopesForAnnotationCompatibility = true + + override fun skipCheckingAnnotationsOfActualClassMember(actualMember: DeclarationSymbolMarker): Boolean = + (actualMember as MemberDescriptor).isActual + + override fun findPotentialExpectClassMembersForActual( + expectClass: RegularClassSymbolMarker, + actualClass: RegularClassSymbolMarker, + actualMember: DeclarationSymbolMarker, + ): Map> { + val compatibilityToExpects = ExpectedActualResolver.findExpectForActualClassMember( + actualMember as MemberDescriptor, + actualClass as ClassDescriptor, + expectClass as ClassDescriptor, + this, + ) + return buildMap { + for ((compatibility, expectMembers) in compatibilityToExpects.entries) { + for (expectMember in expectMembers) { + val oldValue = put(expectMember, compatibility) + if (oldValue != null) { + error( + "Several incompatibilities correspond to the same expect symbol: symbol=$expectMember, " + + "compatibilities=$oldValue, $compatibility" + ) + } + } + } + } + } } diff --git a/compiler/resolution/src/org/jetbrains/kotlin/resolve/multiplatform/ExpectedActualResolver.kt b/compiler/resolution/src/org/jetbrains/kotlin/resolve/multiplatform/ExpectedActualResolver.kt index bd13cd4cc22..8c83d049a44 100644 --- a/compiler/resolution/src/org/jetbrains/kotlin/resolve/multiplatform/ExpectedActualResolver.kt +++ b/compiler/resolution/src/org/jetbrains/kotlin/resolve/multiplatform/ExpectedActualResolver.kt @@ -54,6 +54,35 @@ object ExpectedActualResolver { } } + fun findExpectForActualClassMember( + actual: MemberDescriptor, + actualClass: ClassDescriptor, + expectClass: ClassDescriptor, + context: ClassicExpectActualMatchingContext, + ): Map, List> { + val candidates = with(context) { + expectClass.getMembersForExpectClass(actual.name) + } + return when (actual) { + is CallableMemberDescriptor -> { + matchActualCallableAgainstPotentialExpects( + actual, + candidates.filterIsInstance(), + actualClass, + context + ) + } + is ClassDescriptor -> { + matchActualClassAgainstPotentialExpects( + actual, + candidates.filterIsInstance(), + context + ) + } + else -> emptyMap() + } + } + fun findExpectedForActual( actual: MemberDescriptor, moduleFilter: (ModuleDescriptor) -> Boolean = allModulesProvidingExpectsFor(actual.module), diff --git a/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/checkDiagnosticFullText.diag.txt b/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/checkDiagnosticFullText.diag.txt index e0342f49327..29e0266a9a2 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/checkDiagnosticFullText.diag.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/checkDiagnosticFullText.diag.txt @@ -1,11 +1,11 @@ // -- Module: -- // -- Module: -- -/jvm.kt:27:14: warning: annotation `@Ann` is missing on actual declaration. +/jvm.kt:29:14: warning: annotation `@Ann` is missing on actual declaration. All annotations from expect `class OnClass defined in root package in file common.kt` must be present with the same arguments on actual `class OnClass defined in root package in file jvm.kt`, otherwise they might behave incorrectly. actual class OnClass ^ -/jvm.kt:30:16: warning: annotation `@Ann` is missing on actual declaration. +/jvm.kt:32:16: warning: annotation `@Ann` is missing on actual declaration. All annotations from expect `fun onMember(): Unit defined in OnMember` must be present with the same arguments on actual `fun onMember(): Unit defined in OnMember`, otherwise they might behave incorrectly. actual fun onMember() {} ^ @@ -13,7 +13,11 @@ All annotations from expect `fun onMember(): Unit defined in OnMember` must be p All annotations from expect `class ViaTypealias defined in root package in file common.kt` must be present with the same arguments on actual `class ViaTypealiasImpl defined in root package in file jvm.kt`, otherwise they might behave incorrectly. actual typealias ViaTypealias = ViaTypealiasImpl ^ -/jvm.kt:40:12: warning: annotation `@WithArg(s = "str")` has different arguments on actual declaration: `@WithArg(s = "other str")`. +/jvm.kt:42:18: warning: annotation `@Ann` is missing on actual declaration. +All annotations from expect `fun foo(): Unit defined in MemberScopeViaTypealias` must be present with the same arguments on actual `fun foo(): Unit defined in MemberScopeViaTypealiasImpl`, otherwise they might behave incorrectly. +actual typealias MemberScopeViaTypealias = MemberScopeViaTypealiasImpl + ^ +/jvm.kt:45:12: warning: annotation `@WithArg(s = "str")` has different arguments on actual declaration: `@WithArg(s = "other str")`. All annotations from expect `fun withDifferentArg(): Unit defined in root package in file common.kt` must be present with the same arguments on actual `fun withDifferentArg(): Unit defined in root package in file jvm.kt`, otherwise they might behave incorrectly. actual fun withDifferentArg() {} ^ 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 6ff2f0b4ef3..f3fe0e8065d 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,14 @@ -/jvm.kt:(86,93): warning: Annotation `@Ann()` is missing on actual declaration. +/jvm.kt:(88,95): warning: Annotation `@Ann()` is missing on actual declaration. All annotations from expect 'class OnClass : Any' must be present with the same arguments on actual 'class OnClass : Any', otherwise they might behave incorrectly. -/jvm.kt:(134,142): warning: Annotation `@Ann()` is missing on actual declaration. +/jvm.kt:(136,144): warning: Annotation `@Ann()` is missing on actual declaration. All annotations from expect 'fun onMember(): Unit' must be present with the same arguments on actual 'fun onMember(): Unit', otherwise they might behave incorrectly. -/jvm.kt:(213,225): warning: Annotation `@Ann()` is missing on actual declaration. +/jvm.kt:(194,206): warning: Annotation `@Ann()` is missing on actual declaration. All annotations from expect 'class ViaTypealias : Any' must be present with the same arguments on actual 'class ViaTypealiasImpl : Any', otherwise they might behave incorrectly. -/jvm.kt:(279,295): warning: Annotation `@WithArg(s = String(str))` has different arguments on actual declaration: `@WithArg(s = String(other str))`. +/jvm.kt:(299,322): warning: Annotation `@Ann()` is missing on actual declaration. +All annotations from expect 'fun foo(): Unit' must be present with the same arguments on actual 'fun foo(): Unit', otherwise they might behave incorrectly. + +/jvm.kt:(387,403): warning: Annotation `@WithArg(s = String(str))` has different arguments on actual declaration: `@WithArg(s = String(other str))`. All annotations from expect 'fun withDifferentArg(): Unit' must be present with the same arguments on actual 'fun withDifferentArg(): Unit', otherwise they might behave incorrectly. diff --git a/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/checkDiagnosticFullText.fir.kt b/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/checkDiagnosticFullText.fir.kt index 80c468a02d5..8da9e0b3283 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/checkDiagnosticFullText.fir.kt +++ b/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/checkDiagnosticFullText.fir.kt @@ -12,7 +12,9 @@ expect class OnMember { } @Ann -expect class ViaTypealias { +expect class ViaTypealias + +expect class MemberScopeViaTypealias { @Ann fun foo() } @@ -30,11 +32,14 @@ actual class OnMember { actual fun onMember() {} } -class ViaTypealiasImpl { +class ViaTypealiasImpl + +actual typealias ViaTypealias = ViaTypealiasImpl + +class MemberScopeViaTypealiasImpl { fun foo() {} } - -actual typealias ViaTypealias = ViaTypealiasImpl +actual typealias MemberScopeViaTypealias = MemberScopeViaTypealiasImpl @WithArg("other str") actual fun withDifferentArg() {} diff --git a/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/checkDiagnosticFullText.kt b/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/checkDiagnosticFullText.kt index 4d6fc140d06..912ff475112 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/checkDiagnosticFullText.kt +++ b/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/checkDiagnosticFullText.kt @@ -12,7 +12,9 @@ expect class OnMember { } @Ann -expect class ViaTypealias { +expect class ViaTypealias + +expect class MemberScopeViaTypealias { @Ann fun foo() } @@ -30,11 +32,14 @@ actual class OnMember { actual fun onMember() {} } -class ViaTypealiasImpl { - fun foo() {} -} +class ViaTypealiasImpl actual typealias ViaTypealias = ViaTypealiasImpl +class MemberScopeViaTypealiasImpl { + fun foo() {} +} +actual typealias MemberScopeViaTypealias = MemberScopeViaTypealiasImpl + @WithArg("other str") actual fun withDifferentArg() {} diff --git a/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/classScopeInnerClasses.fir.kt b/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/classScopeInnerClasses.fir.kt new file mode 100644 index 00000000000..6ca419d53e3 --- /dev/null +++ b/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/classScopeInnerClasses.fir.kt @@ -0,0 +1,22 @@ +// MODULE: m1-common +// FILE: common.kt +annotation class Ann + +expect class A { + class B { + class C { + @Ann + fun foo() + } + } +} + +// MODULE: m1-jvm()()(m1-common) +// FILE: jvm.kt +actual class A { + actual class B { + actual class C { + actual fun foo() {} + } + } +} diff --git a/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/classScopeInnerClasses.kt b/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/classScopeInnerClasses.kt new file mode 100644 index 00000000000..43897973e91 --- /dev/null +++ b/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/classScopeInnerClasses.kt @@ -0,0 +1,22 @@ +// MODULE: m1-common +// FILE: common.kt +annotation class Ann + +expect class A { + class B { + class C { + @Ann + fun foo() + } + } +} + +// MODULE: m1-jvm()()(m1-common) +// FILE: jvm.kt +actual class A { + actual class B { + actual class C { + actual fun foo() {} + } + } +} diff --git a/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/classScopeViaTypealiasIncompatible.fir.kt b/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/classScopeViaTypealiasIncompatible.fir.kt new file mode 100644 index 00000000000..e823fdf638a --- /dev/null +++ b/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/classScopeViaTypealiasIncompatible.fir.kt @@ -0,0 +1,27 @@ +// MODULE: m1-common +// FILE: common.kt +annotation class Ann + +expect class WeakIncompatibility { + @Ann + fun foo(p: String) +} + +expect class StrongIncompatibility { + @Ann + fun foo(p: Int) +} + +// MODULE: m1-jvm()()(m1-common) +// FILE: jvm.kt +class WeakIncompatibilityImpl { + fun foo(differentName: String) {} +} + +actual typealias WeakIncompatibility = WeakIncompatibilityImpl + +class StrongIncompatibilityImpl { + fun foo(p: String) {} // Different param type +} + +actual typealias StrongIncompatibility = StrongIncompatibilityImpl diff --git a/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/classScopeViaTypealiasIncompatible.kt b/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/classScopeViaTypealiasIncompatible.kt new file mode 100644 index 00000000000..9d1b6bec5af --- /dev/null +++ b/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/classScopeViaTypealiasIncompatible.kt @@ -0,0 +1,27 @@ +// MODULE: m1-common +// FILE: common.kt +annotation class Ann + +expect class WeakIncompatibility { + @Ann + fun foo(p: String) +} + +expect class StrongIncompatibility { + @Ann + fun foo(p: Int) +} + +// MODULE: m1-jvm()()(m1-common) +// FILE: jvm.kt +class WeakIncompatibilityImpl { + fun foo(differentName: String) {} +} + +actual typealias WeakIncompatibility = WeakIncompatibilityImpl + +class StrongIncompatibilityImpl { + fun foo(p: String) {} // Different param type +} + +actual typealias StrongIncompatibility = StrongIncompatibilityImpl diff --git a/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/fakeOverrides.fir.kt b/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/fakeOverrides.fir.kt new file mode 100644 index 00000000000..90a6eb2ffee --- /dev/null +++ b/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/fakeOverrides.fir.kt @@ -0,0 +1,31 @@ +// MODULE: m1-common +// FILE: common.kt +annotation class Ann + +abstract class A { + @Ann + open fun noAnnotationOnActual() {} +} + +expect class FakeOverrideExpect : A + +interface I { + fun noAnnotationOnActual() +} + +expect class FakeOverrideActual : I { + @Ann + override fun noAnnotationOnActual() +} + +// MODULE: m1-jvm()()(m1-common) +// FILE: jvm.kt +actual class FakeOverrideExpect : A() { + override fun noAnnotationOnActual() {} +} + +abstract class Intermediate : I { + override fun noAnnotationOnActual() {} +} + +actual class FakeOverrideActual : Intermediate(), I diff --git a/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/fakeOverrides.kt b/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/fakeOverrides.kt index ab00ecd2624..7fa00c05328 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/fakeOverrides.kt +++ b/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/fakeOverrides.kt @@ -1,4 +1,3 @@ -// FIR_IDENTICAL // MODULE: m1-common // FILE: common.kt annotation class Ann @@ -29,4 +28,4 @@ abstract class Intermediate : I { override fun noAnnotationOnActual() {} } -actual class FakeOverrideActual : Intermediate(), I +actual class FakeOverrideActual : Intermediate(), I diff --git a/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/substitutionOverrideInTwoClasses.fir.kt b/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/substitutionOverrideInTwoClasses.fir.kt new file mode 100644 index 00000000000..de586324a11 --- /dev/null +++ b/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/substitutionOverrideInTwoClasses.fir.kt @@ -0,0 +1,24 @@ +// MODULE: m1-common +// FILE: common.kt +annotation class Ann + +expect class WithAnn { + @Ann + fun foo(p: String) +} + +expect class WithoutAnn { + fun foo(p: String) +} + +// MODULE: m1-jvm()()(m1-common) +// FILE: jvm.kt +abstract class Parent { + open fun foo(p: T) {} +} + +abstract class Intermediate : Parent() + +actual class WithAnn : Intermediate() + +actual class WithoutAnn : Intermediate() diff --git a/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/substitutionOverrideInTwoClasses.kt b/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/substitutionOverrideInTwoClasses.kt new file mode 100644 index 00000000000..62eb9ba13fb --- /dev/null +++ b/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/substitutionOverrideInTwoClasses.kt @@ -0,0 +1,24 @@ +// MODULE: m1-common +// FILE: common.kt +annotation class Ann + +expect class WithAnn { + @Ann + fun foo(p: String) +} + +expect class WithoutAnn { + fun foo(p: String) +} + +// MODULE: m1-jvm()()(m1-common) +// FILE: jvm.kt +abstract class Parent { + open fun foo(p: T) {} +} + +abstract class Intermediate : Parent() + +actual class WithAnn : Intermediate() + +actual class WithoutAnn : Intermediate() diff --git a/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/twoActualTypealiasesToSameClass.fir.kt b/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/twoActualTypealiasesToSameClass.fir.kt new file mode 100644 index 00000000000..fd9c26265db --- /dev/null +++ b/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/twoActualTypealiasesToSameClass.fir.kt @@ -0,0 +1,21 @@ +// MODULE: m1-common +// FILE: common.kt +annotation class Ann + +expect class WithAnn { + @Ann + fun foo() +} + +expect class WithoutAnn { + fun foo() +} + +// MODULE: m1-jvm()()(m1-common) +// FILE: jvm.kt +class Impl { + fun foo() {} +} + +actual typealias WithAnn = Impl +actual typealias WithoutAnn = Impl diff --git a/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/twoActualTypealiasesToSameClass.kt b/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/twoActualTypealiasesToSameClass.kt new file mode 100644 index 00000000000..e3b99423d5d --- /dev/null +++ b/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/twoActualTypealiasesToSameClass.kt @@ -0,0 +1,21 @@ +// MODULE: m1-common +// FILE: common.kt +annotation class Ann + +expect class WithAnn { + @Ann + fun foo() +} + +expect class WithoutAnn { + fun foo() +} + +// MODULE: m1-jvm()()(m1-common) +// FILE: jvm.kt +class Impl { + fun foo() {} +} + +actual typealias WithAnn = Impl +actual typealias WithoutAnn = Impl diff --git a/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/typealias.fir.kt b/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/typealias.fir.kt index 2cd57e56f43..ee1e77b01ff 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/typealias.fir.kt +++ b/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/typealias.fir.kt @@ -1,7 +1,15 @@ // WITH_STDLIB // MODULE: m1-common // FILE: common.kt -@Target(AnnotationTarget.TYPEALIAS, AnnotationTarget.CLASS) +@Target( + AnnotationTarget.TYPEALIAS, + AnnotationTarget.CLASS, + AnnotationTarget.FUNCTION, + AnnotationTarget.PROPERTY, + AnnotationTarget.PROPERTY_GETTER, + AnnotationTarget.PROPERTY_SETTER, + AnnotationTarget.CONSTRUCTOR, +) annotation class Ann @Ann @@ -10,6 +18,32 @@ expect class KtTypealiasNotMatch @Ann expect class AnnotationsNotConsideredOnTypealias +annotation class ComplexAnn(val s: String) + +expect class MethodsInsideTypealias { + @Ann + fun foo() +} + +expect class ValueInsideTypealias { + @Ann + val value: String +} + +expect class ConstructorInsideTypealias @Ann constructor() + +expect class MethodWithComplexAnnInsideTypealias { + @ComplexAnn("1" + "2") + fun withComplexAnn() +} + +expect class InnerClassInsideTypealias { + class Foo { + @Ann + fun foo() + } +} + // MODULE: m1-jvm()()(m1-common) // FILE: jvm.kt class KtTypealiasNotMatchImpl @@ -20,3 +54,34 @@ class AnnotationsNotConsideredOnTypealiasImpl @Ann actual typealias AnnotationsNotConsideredOnTypealias = AnnotationsNotConsideredOnTypealiasImpl + +class MethodsInsideTypealiasImpl { + fun foo() {} +} + +actual typealias MethodsInsideTypealias = MethodsInsideTypealiasImpl + +class ValueInsideTypealiasImpl { + val value: String = "" +} + +actual typealias ValueInsideTypealias = ValueInsideTypealiasImpl + +class ConstructorInsideTypealiasImpl + +actual typealias ConstructorInsideTypealias = ConstructorInsideTypealiasImpl + +class MethodWithComplexAnnInsideTypealiasImpl { + @ComplexAnn("13") + fun withComplexAnn() {} +} + +actual typealias MethodWithComplexAnnInsideTypealias = MethodWithComplexAnnInsideTypealiasImpl + +class InnerClassInsideTypealiasImpl { + class Foo { + fun foo() {} + } +} + +actual typealias InnerClassInsideTypealias = InnerClassInsideTypealiasImpl diff --git a/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/typealias.kt b/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/typealias.kt index b6f9aba3ec1..3c752198dee 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/typealias.kt +++ b/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/typealias.kt @@ -1,7 +1,15 @@ // WITH_STDLIB // MODULE: m1-common // FILE: common.kt -@Target(AnnotationTarget.TYPEALIAS, AnnotationTarget.CLASS) +@Target( + AnnotationTarget.TYPEALIAS, + AnnotationTarget.CLASS, + AnnotationTarget.FUNCTION, + AnnotationTarget.PROPERTY, + AnnotationTarget.PROPERTY_GETTER, + AnnotationTarget.PROPERTY_SETTER, + AnnotationTarget.CONSTRUCTOR, +) annotation class Ann @Ann @@ -10,6 +18,32 @@ expect class KtTypealiasNotMatch @Ann expect class AnnotationsNotConsideredOnTypealias +annotation class ComplexAnn(val s: String) + +expect class MethodsInsideTypealias { + @Ann + fun foo() +} + +expect class ValueInsideTypealias { + @Ann + val value: String +} + +expect class ConstructorInsideTypealias @Ann constructor() + +expect class MethodWithComplexAnnInsideTypealias { + @ComplexAnn("1" + "2") + fun withComplexAnn() +} + +expect class InnerClassInsideTypealias { + class Foo { + @Ann + fun foo() + } +} + // MODULE: m1-jvm()()(m1-common) // FILE: jvm.kt class KtTypealiasNotMatchImpl @@ -20,3 +54,34 @@ class AnnotationsNotConsideredOnTypealiasImpl @Ann actual typealias AnnotationsNotConsideredOnTypealias = AnnotationsNotConsideredOnTypealiasImpl + +class MethodsInsideTypealiasImpl { + fun foo() {} +} + +actual typealias MethodsInsideTypealias = MethodsInsideTypealiasImpl + +class ValueInsideTypealiasImpl { + val value: String = "" +} + +actual typealias ValueInsideTypealias = ValueInsideTypealiasImpl + +class ConstructorInsideTypealiasImpl + +actual typealias ConstructorInsideTypealias = ConstructorInsideTypealiasImpl + +class MethodWithComplexAnnInsideTypealiasImpl { + @ComplexAnn("13") + fun withComplexAnn() {} +} + +actual typealias MethodWithComplexAnnInsideTypealias = MethodWithComplexAnnInsideTypealiasImpl + +class InnerClassInsideTypealiasImpl { + class Foo { + fun foo() {} + } +} + +actual typealias InnerClassInsideTypealias = InnerClassInsideTypealiasImpl diff --git a/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/typealiasToKtLibrary.fir.kt b/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/typealiasToKtLibrary.fir.kt index 605cb6c9b96..0e3e656ac34 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/typealiasToKtLibrary.fir.kt +++ b/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/typealiasToKtLibrary.fir.kt @@ -1,5 +1,5 @@ // WITH_STDLIB -// DIAGNOSTICS: -ACTUAL_TYPEALIAS_TO_SPECIAL_ANNOTATION +// DIAGNOSTICS: -ACTUAL_TYPEALIAS_TO_SPECIAL_ANNOTATION, -ACTUAL_CLASSIFIER_MUST_HAVE_THE_SAME_MEMBERS_AS_NON_FINAL_EXPECT_CLASSIFIER, -ACTUAL_CLASSIFIER_MUST_HAVE_THE_SAME_SUPERTYPES_AS_NON_FINAL_EXPECT_CLASSIFIER // MODULE: m1-common // FILE: common.kt @Target( @@ -40,4 +40,4 @@ expect abstract class MyAbstractIterator { actual typealias MyDeprecatedMatch = kotlin.Deprecated -actual typealias MyAbstractIterator = AbstractIterator +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 ac03cf1fb3b..5c258a46d87 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/typealiasToKtLibrary.kt +++ b/compiler/testData/diagnostics/tests/multiplatform/annotationMatching/typealiasToKtLibrary.kt @@ -1,5 +1,5 @@ // WITH_STDLIB -// DIAGNOSTICS: -ACTUAL_TYPEALIAS_TO_SPECIAL_ANNOTATION +// DIAGNOSTICS: -ACTUAL_TYPEALIAS_TO_SPECIAL_ANNOTATION, -ACTUAL_CLASSIFIER_MUST_HAVE_THE_SAME_MEMBERS_AS_NON_FINAL_EXPECT_CLASSIFIER, -ACTUAL_CLASSIFIER_MUST_HAVE_THE_SAME_SUPERTYPES_AS_NON_FINAL_EXPECT_CLASSIFIER // MODULE: m1-common // FILE: common.kt @Target( @@ -40,4 +40,4 @@ actual typealias MyDeprecatedNotMatch actual typealias MyDeprecatedMatch = kotlin.Deprecated -actual typealias MyAbstractIterator = AbstractIterator +actual typealias MyAbstractIterator = AbstractIterator 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 c244a2280db..b0675f35bcb 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 @@ -23497,6 +23497,18 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { runTest("compiler/testData/diagnostics/tests/multiplatform/annotationMatching/checkDiagnosticFullText.kt"); } + @Test + @TestMetadata("classScopeInnerClasses.kt") + public void testClassScopeInnerClasses() throws Exception { + runTest("compiler/testData/diagnostics/tests/multiplatform/annotationMatching/classScopeInnerClasses.kt"); + } + + @Test + @TestMetadata("classScopeViaTypealiasIncompatible.kt") + public void testClassScopeViaTypealiasIncompatible() throws Exception { + runTest("compiler/testData/diagnostics/tests/multiplatform/annotationMatching/classScopeViaTypealiasIncompatible.kt"); + } + @Test @TestMetadata("compatibleOverrides.kt") public void testCompatibleOverrides() throws Exception { @@ -23563,6 +23575,18 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { runTest("compiler/testData/diagnostics/tests/multiplatform/annotationMatching/sourceRetentionAnnotationsWhenTypealias.kt"); } + @Test + @TestMetadata("substitutionOverrideInTwoClasses.kt") + public void testSubstitutionOverrideInTwoClasses() throws Exception { + runTest("compiler/testData/diagnostics/tests/multiplatform/annotationMatching/substitutionOverrideInTwoClasses.kt"); + } + + @Test + @TestMetadata("twoActualTypealiasesToSameClass.kt") + public void testTwoActualTypealiasesToSameClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/multiplatform/annotationMatching/twoActualTypealiasesToSameClass.kt"); + } + @Test @TestMetadata("typealias.kt") public void testTypealias() throws Exception {