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 874aac50332..e734b0d0f91 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 @@ -24,6 +24,7 @@ import org.jetbrains.kotlin.psi.KtBinaryExpression import org.jetbrains.kotlin.psi.KtBinaryExpressionWithTypeRHS import org.jetbrains.kotlin.psi.KtCallExpression import org.jetbrains.kotlin.psi.KtClass +import org.jetbrains.kotlin.psi.KtClassLikeDeclaration import org.jetbrains.kotlin.psi.KtClassOrObject import org.jetbrains.kotlin.psi.KtConstructor import org.jetbrains.kotlin.psi.KtConstructorDelegationCall @@ -3666,6 +3667,12 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert token, ) } + add(FirErrors.EXPECT_ACTUAL_CLASSIFIERS_ARE_EXPERIMENTAL_WARNING) { firDiagnostic -> + ExpectActualClassifiersAreExperimentalWarningImpl( + firDiagnostic as KtPsiDiagnostic, + token, + ) + } add(FirErrors.NOT_A_MULTIPLATFORM_COMPILATION) { firDiagnostic -> NotAMultiplatformCompilationImpl( firDiagnostic as KtPsiDiagnostic, 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 a1777c0b831..35802340cc1 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 @@ -43,6 +43,7 @@ import org.jetbrains.kotlin.psi.KtBinaryExpression import org.jetbrains.kotlin.psi.KtBinaryExpressionWithTypeRHS import org.jetbrains.kotlin.psi.KtCallExpression import org.jetbrains.kotlin.psi.KtClass +import org.jetbrains.kotlin.psi.KtClassLikeDeclaration import org.jetbrains.kotlin.psi.KtClassOrObject import org.jetbrains.kotlin.psi.KtConstructor import org.jetbrains.kotlin.psi.KtConstructorDelegationCall @@ -2565,6 +2566,10 @@ sealed interface KtFirDiagnostic : KtDiagnosticWithPsi { override val diagnosticClass get() = ActualMissing::class } + interface ExpectActualClassifiersAreExperimentalWarning : KtFirDiagnostic { + override val diagnosticClass get() = ExpectActualClassifiersAreExperimentalWarning::class + } + interface NotAMultiplatformCompilation : KtFirDiagnostic { override val diagnosticClass get() = NotAMultiplatformCompilation::class } 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 605b8fec4e4..79f12c50bb7 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 @@ -44,6 +44,7 @@ import org.jetbrains.kotlin.psi.KtBinaryExpression import org.jetbrains.kotlin.psi.KtBinaryExpressionWithTypeRHS import org.jetbrains.kotlin.psi.KtCallExpression import org.jetbrains.kotlin.psi.KtClass +import org.jetbrains.kotlin.psi.KtClassLikeDeclaration import org.jetbrains.kotlin.psi.KtClassOrObject import org.jetbrains.kotlin.psi.KtConstructor import org.jetbrains.kotlin.psi.KtConstructorDelegationCall @@ -3092,6 +3093,11 @@ internal class ActualMissingImpl( token: KtLifetimeToken, ) : KtAbstractFirDiagnostic(firDiagnostic, token), KtFirDiagnostic.ActualMissing +internal class ExpectActualClassifiersAreExperimentalWarningImpl( + firDiagnostic: KtPsiDiagnostic, + token: KtLifetimeToken, +) : KtAbstractFirDiagnostic(firDiagnostic, token), KtFirDiagnostic.ExpectActualClassifiersAreExperimentalWarning + internal class NotAMultiplatformCompilationImpl( firDiagnostic: KtPsiDiagnostic, token: KtLifetimeToken, diff --git a/compiler/cli/cli-common/gen/org/jetbrains/kotlin/cli/common/arguments/CommonCompilerArgumentsCopyGenerated.kt b/compiler/cli/cli-common/gen/org/jetbrains/kotlin/cli/common/arguments/CommonCompilerArgumentsCopyGenerated.kt index 04611e68ecc..b054e02d0cb 100644 --- a/compiler/cli/cli-common/gen/org/jetbrains/kotlin/cli/common/arguments/CommonCompilerArgumentsCopyGenerated.kt +++ b/compiler/cli/cli-common/gen/org/jetbrains/kotlin/cli/common/arguments/CommonCompilerArgumentsCopyGenerated.kt @@ -31,6 +31,7 @@ fun copyCommonCompilerArguments(from: CommonCompilerArguments, to: CommonCompile to.effectSystem = from.effectSystem to.enableBuilderInference = from.enableBuilderInference to.enableSignatureClashChecks = from.enableSignatureClashChecks + to.expectActualClasses = from.expectActualClasses to.expectActualLinker = from.expectActualLinker to.experimental = from.experimental?.copyOf() to.explicitApi = from.explicitApi diff --git a/compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/arguments/CommonCompilerArguments.kt b/compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/arguments/CommonCompilerArguments.kt index fe6661a4458..d4adf21451b 100644 --- a/compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/arguments/CommonCompilerArguments.kt +++ b/compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/arguments/CommonCompilerArguments.kt @@ -632,6 +632,17 @@ abstract class CommonCompilerArguments : CommonToolArguments() { field = value } + @Argument( + value = "-Xexpect-actual-classes", + description = "The expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature.\n" + + "Kotlin reports a warning every time you use them. You can use this flag to mute the warning." + ) + var expectActualClasses = false + set(value) { + checkFrozen() + field = value + } + @Argument( value = "-Xunrestricted-builder-inference", description = "Eliminate builder inference restrictions like allowance of returning type variables of a builder inference call" @@ -796,6 +807,7 @@ abstract class CommonCompilerArguments : CommonToolArguments() { put(AnalysisFlags.extendedCompilerChecks, extendedCompilerChecks) put(AnalysisFlags.allowKotlinPackage, allowKotlinPackage) put(AnalysisFlags.builtInsFromSources, builtInsFromSources) + put(AnalysisFlags.muteExpectActualClassesWarning, expectActualClasses) put(AnalysisFlags.allowFullyQualifiedNameInKClass, true) put(AnalysisFlags.dontWarnOnErrorSuppression, dontWarnOnErrorSuppression) } diff --git a/compiler/config/src/org/jetbrains/kotlin/config/AnalysisFlags.kt b/compiler/config/src/org/jetbrains/kotlin/config/AnalysisFlags.kt index 3d234572819..cf0f1b1d458 100644 --- a/compiler/config/src/org/jetbrains/kotlin/config/AnalysisFlags.kt +++ b/compiler/config/src/org/jetbrains/kotlin/config/AnalysisFlags.kt @@ -54,6 +54,9 @@ object AnalysisFlags { @JvmStatic val builtInsFromSources by AnalysisFlag.Delegates.Boolean + @JvmStatic + val muteExpectActualClassesWarning by AnalysisFlag.Delegates.Boolean + @JvmStatic val allowFullyQualifiedNameInKClass by AnalysisFlag.Delegates.Boolean 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 a761ea2284f..d93d1449fdb 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 @@ -121,6 +121,12 @@ public class FirOldFrontendMPPDiagnosticsWithLightTreeTestGenerated extends Abst runTest("compiler/testData/diagnostics/tests/multiplatform/expectAbstractToString.kt"); } + @Test + @TestMetadata("expectActualClassesAreExperimentalWarning.kt") + public void testExpectActualClassesAreExperimentalWarning() throws Exception { + runTest("compiler/testData/diagnostics/tests/multiplatform/expectActualClassesAreExperimentalWarning.kt"); + } + @Test @TestMetadata("expectDataObject.kt") public void testExpectDataObject() 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 919e63e1e1e..68a6d3b41d4 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 @@ -121,6 +121,12 @@ public class FirOldFrontendMPPDiagnosticsWithPsiTestGenerated extends AbstractFi runTest("compiler/testData/diagnostics/tests/multiplatform/expectAbstractToString.kt"); } + @Test + @TestMetadata("expectActualClassesAreExperimentalWarning.kt") + public void testExpectActualClassesAreExperimentalWarning() throws Exception { + runTest("compiler/testData/diagnostics/tests/multiplatform/expectActualClassesAreExperimentalWarning.kt"); + } + @Test @TestMetadata("expectDataObject.kt") public void testExpectDataObject() 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 c38664cc9c0..a17d704d71d 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 @@ -1254,6 +1254,8 @@ object DIAGNOSTICS_LIST : DiagnosticList("FirErrors") { val ACTUAL_MISSING by error(PositioningStrategy.ACTUAL_DECLARATION_NAME) + val EXPECT_ACTUAL_CLASSIFIERS_ARE_EXPERIMENTAL_WARNING by warning(PositioningStrategy.EXPECT_ACTUAL_MODIFIER) + val NOT_A_MULTIPLATFORM_COMPILATION by error() val EXPECT_ACTUAL_OPT_IN_ANNOTATION by error(PositioningStrategy.EXPECT_ACTUAL_MODIFIER) 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 e574de1a1f2..30400197071 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 @@ -68,6 +68,7 @@ import org.jetbrains.kotlin.psi.KtBinaryExpression import org.jetbrains.kotlin.psi.KtBinaryExpressionWithTypeRHS import org.jetbrains.kotlin.psi.KtCallExpression import org.jetbrains.kotlin.psi.KtClass +import org.jetbrains.kotlin.psi.KtClassLikeDeclaration import org.jetbrains.kotlin.psi.KtClassOrObject import org.jetbrains.kotlin.psi.KtConstructor import org.jetbrains.kotlin.psi.KtConstructorDelegationCall @@ -656,6 +657,7 @@ object FirErrors { val AMBIGUOUS_EXPECTS by error2, Collection>(SourceElementPositioningStrategies.INCOMPATIBLE_DECLARATION) val NO_ACTUAL_CLASS_MEMBER_FOR_EXPECTED_CLASS by error2, List, Map>, Collection>>>>>(SourceElementPositioningStrategies.ACTUAL_DECLARATION_NAME) val ACTUAL_MISSING by error0(SourceElementPositioningStrategies.ACTUAL_DECLARATION_NAME) + val EXPECT_ACTUAL_CLASSIFIERS_ARE_EXPERIMENTAL_WARNING by warning0(SourceElementPositioningStrategies.EXPECT_ACTUAL_MODIFIER) val NOT_A_MULTIPLATFORM_COMPILATION by error0() val EXPECT_ACTUAL_OPT_IN_ANNOTATION by error0(SourceElementPositioningStrategies.EXPECT_ACTUAL_MODIFIER) val ACTUAL_TYPEALIAS_TO_SPECIAL_ANNOTATION by error1(SourceElementPositioningStrategies.TYPEALIAS_TYPE_REFERENCE) diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/CommonDeclarationCheckers.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/CommonDeclarationCheckers.kt index fbfaf27d41b..f17d97d55e9 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/CommonDeclarationCheckers.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/CommonDeclarationCheckers.kt @@ -34,7 +34,12 @@ object CommonDeclarationCheckers : DeclarationCheckers() { FirPublishedApiChecker, FirOptInMarkedDeclarationChecker, FirExpectConsistencyChecker, - FirOptionalExpectationDeclarationChecker + FirOptionalExpectationDeclarationChecker, + ) + + override val classLikeCheckers: Set + get() = setOf( + FirExpectActualClassifiersAreExperimentalChecker, ) override val callableDeclarationCheckers: Set diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirExpectActualClassifiersAreExperimentalChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirExpectActualClassifiersAreExperimentalChecker.kt new file mode 100644 index 00000000000..fa0f18ace20 --- /dev/null +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirExpectActualClassifiersAreExperimentalChecker.kt @@ -0,0 +1,27 @@ +/* + * 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.fir.analysis.checkers.declaration + +import org.jetbrains.kotlin.config.AnalysisFlags +import org.jetbrains.kotlin.config.LanguageFeature +import org.jetbrains.kotlin.diagnostics.DiagnosticReporter +import org.jetbrains.kotlin.diagnostics.reportOn +import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext +import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors +import org.jetbrains.kotlin.fir.declarations.* +import org.jetbrains.kotlin.fir.declarations.utils.isActual +import org.jetbrains.kotlin.fir.declarations.utils.isExpect + +object FirExpectActualClassifiersAreExperimentalChecker : FirClassLikeChecker() { + override fun check(declaration: FirClassLikeDeclaration, context: CheckerContext, reporter: DiagnosticReporter) { + if (!context.languageVersionSettings.supportsFeature(LanguageFeature.MultiPlatformProjects)) return + if (context.languageVersionSettings.getFlag(AnalysisFlags.muteExpectActualClassesWarning)) return + + if (declaration.isExpect || declaration.isActual) { + reporter.reportOn(declaration.source, FirErrors.EXPECT_ACTUAL_CLASSIFIERS_ARE_EXPERIMENTAL_WARNING, context) + } + } +} 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 3bc7957989c..d3297cead1d 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 @@ -227,6 +227,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.EXPECTED_LATEINIT import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.EXPECTED_PRIVATE_DECLARATION import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.EXPECTED_PROPERTY_INITIALIZER import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.EXPECTED_TAILREC_FUNCTION +import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.EXPECT_ACTUAL_CLASSIFIERS_ARE_EXPERIMENTAL_WARNING import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.EXPECT_ACTUAL_OPT_IN_ANNOTATION import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.EXPECT_CLASS_AS_FUNCTION import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.EXPLICIT_BACKING_FIELD_IN_ABSTRACT_PROPERTY @@ -1984,6 +1985,11 @@ object FirErrorsDefaultMessages : BaseDiagnosticRendererFactory() { FirIncompatibleExpectedActualClassScopesRenderer.TEXT ) map.put(ACTUAL_MISSING, "Declaration must be marked with 'actual'.") + map.put( + EXPECT_ACTUAL_CLASSIFIERS_ARE_EXPERIMENTAL_WARNING, + "The expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. " + + "You can use -Xexpect-actual-classes flag to suppress this warning." + ) map.put(NOT_A_MULTIPLATFORM_COMPILATION, "'expect' and 'actual' declarations can be used only in multiplatform projects. Learn more about Kotlin Multiplatform: https://kotl.in/multiplatform-setup") map.put(EXPECT_ACTUAL_OPT_IN_ANNOTATION, "Opt-in annotations are prohibited to be 'expect' or 'actual'. Instead, declare annotation once in common sources.") map.put( diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java index 80ece07e405..990a0642d81 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java @@ -866,6 +866,8 @@ public interface Errors { ACTUAL_CLASSIFIER_MUST_HAVE_THE_SAME_SUPERTYPES_AS_NON_FINAL_EXPECT_CLASSIFIER = DiagnosticFactory3.create(ERROR, DECLARATION_NAME); + DiagnosticFactory0 EXPECT_ACTUAL_CLASSIFIERS_ARE_EXPERIMENTAL_WARNING = DiagnosticFactory0.create(WARNING, EXPECT_ACTUAL_MODIFIER); + DiagnosticFactory0 OPTIONAL_EXPECTATION_NOT_ON_EXPECTED = DiagnosticFactory0.create(ERROR); DiagnosticFactory0 OPTIONAL_DECLARATION_OUTSIDE_OF_ANNOTATION_ENTRY = DiagnosticFactory0.create(ERROR); DiagnosticFactory0 OPTIONAL_DECLARATION_USAGE_IN_NON_COMMON_SOURCE = 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 96941d9ed63..27beb72be1f 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java @@ -16,7 +16,6 @@ import org.jetbrains.kotlin.diagnostics.Errors; import org.jetbrains.kotlin.diagnostics.UnboundDiagnostic; import org.jetbrains.kotlin.metadata.deserialization.VersionRequirement; import org.jetbrains.kotlin.resolve.VarianceConflictDiagnosticData; -import org.jetbrains.kotlin.resolve.multiplatform.ExpectActualCompatibility; import org.jetbrains.kotlin.resolve.multiplatform.ExpectActualCompatibility.Incompatible; import org.jetbrains.kotlin.types.KotlinTypeKt; import org.jetbrains.kotlin.util.OperatorNameConventions; @@ -431,6 +430,10 @@ public class DefaultErrorMessages { new ListRenderer<>(TO_STRING, (elem) -> "'" + elem + "'"), NAME); + MAP.put(EXPECT_ACTUAL_CLASSIFIERS_ARE_EXPERIMENTAL_WARNING, + "The expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. " + + "You can use -Xexpect-actual-classes flag to suppress this warning."); + MAP.put(OPTIONAL_EXPECTATION_NOT_ON_EXPECTED, "'@OptionalExpectation' can only be used on an expected annotation class"); MAP.put(OPTIONAL_DECLARATION_OUTSIDE_OF_ANNOTATION_ENTRY, "Declaration annotated with '@OptionalExpectation' can only be used inside an annotation entry"); MAP.put(OPTIONAL_DECLARATION_USAGE_IN_NON_COMMON_SOURCE, "Declaration annotated with '@OptionalExpectation' can only be used in common module sources"); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/PlatformConfiguratorBase.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/PlatformConfiguratorBase.kt index cab9aa77e2e..396e50a13cc 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/PlatformConfiguratorBase.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/PlatformConfiguratorBase.kt @@ -17,6 +17,7 @@ import org.jetbrains.kotlin.types.DynamicTypesSettings private val DEFAULT_DECLARATION_CHECKERS = listOf( ExpectActualInTheSameModuleChecker, ActualClassifierMustHasTheSameMembersAsNonFinalExpectClassifierChecker, + ExpectActualClassifiersAreExperimentalChecker, DataClassDeclarationChecker(), ConstModifierChecker, UnderscoreChecker, diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/ExpectActualClassifiersAreExperimentalChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/ExpectActualClassifiersAreExperimentalChecker.kt new file mode 100644 index 00000000000..dc2d96548b2 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/ExpectActualClassifiersAreExperimentalChecker.kt @@ -0,0 +1,37 @@ +/* + * 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.resolve.checkers + +import org.jetbrains.kotlin.config.AnalysisFlags +import org.jetbrains.kotlin.config.LanguageFeature +import org.jetbrains.kotlin.descriptors.ClassDescriptor +import org.jetbrains.kotlin.descriptors.ClassifierDescriptorWithTypeParameters +import org.jetbrains.kotlin.descriptors.DeclarationDescriptor +import org.jetbrains.kotlin.descriptors.TypeAliasDescriptor +import org.jetbrains.kotlin.diagnostics.Errors +import org.jetbrains.kotlin.psi.KtClassLikeDeclaration +import org.jetbrains.kotlin.psi.KtClassOrObject +import org.jetbrains.kotlin.psi.KtDeclaration +import org.jetbrains.kotlin.psi.KtTypeAlias + +object ExpectActualClassifiersAreExperimentalChecker : DeclarationChecker { + override fun check(declaration: KtDeclaration, descriptor: DeclarationDescriptor, context: DeclarationCheckerContext) { + if (!context.languageVersionSettings.supportsFeature(LanguageFeature.MultiPlatformProjects)) return + if (context.languageVersionSettings.getFlag(AnalysisFlags.muteExpectActualClassesWarning)) return + if (descriptor !is TypeAliasDescriptor && descriptor !is ClassDescriptor) return + check(declaration is KtClassOrObject || declaration is KtTypeAlias) + + // Common supertype of KtTypeAlias and KtClassOrObject is KtClassLikeDeclaration. + // Common supertype of TypeAliasDescriptor and ClassDescriptor is ClassifierDescriptorWithTypeParameters. + // The explicit casts won't be necessary when we start compiling kotlin with K2. + check(declaration is KtClassLikeDeclaration) + check(descriptor is ClassifierDescriptorWithTypeParameters) + + if (descriptor.isExpect || descriptor.isActual) { + context.trace.report(Errors.EXPECT_ACTUAL_CLASSIFIERS_ARE_EXPERIMENTAL_WARNING.on(declaration)) + } + } +} diff --git a/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/builders/LanguageVersionSettingsBuilder.kt b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/builders/LanguageVersionSettingsBuilder.kt index 984772cf7bf..df1a2bb005c 100644 --- a/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/builders/LanguageVersionSettingsBuilder.kt +++ b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/builders/LanguageVersionSettingsBuilder.kt @@ -103,6 +103,7 @@ class LanguageVersionSettingsBuilder { analysisFlag(AnalysisFlags.allowResultReturnType, trueOrNull(LanguageSettingsDirectives.ALLOW_RESULT_RETURN_TYPE in directives)), analysisFlag(AnalysisFlags.explicitApiMode, directives.singleOrZeroValue(LanguageSettingsDirectives.EXPLICIT_API_MODE)), analysisFlag(AnalysisFlags.allowKotlinPackage, trueOrNull(LanguageSettingsDirectives.ALLOW_KOTLIN_PACKAGE in directives)), + analysisFlag(AnalysisFlags.muteExpectActualClassesWarning, trueOrNull(LanguageSettingsDirectives.ENABLE_EXPECT_ACTUAL_CLASSES_WARNING in directives) != true), analysisFlag(AnalysisFlags.dontWarnOnErrorSuppression, trueOrNull(LanguageSettingsDirectives.DONT_WARN_ON_ERROR_SUPPRESSION in directives)), analysisFlag(JvmAnalysisFlags.jvmDefaultMode, directives.singleOrZeroValue(LanguageSettingsDirectives.JVM_DEFAULT_MODE)), diff --git a/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/directives/LanguageSettingsDirectives.kt b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/directives/LanguageSettingsDirectives.kt index 50e47d6c236..d90924e5d78 100644 --- a/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/directives/LanguageSettingsDirectives.kt +++ b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/directives/LanguageSettingsDirectives.kt @@ -64,6 +64,11 @@ object LanguageSettingsDirectives : SimpleDirectivesContainer() { description = "Allow compiling code in package 'kotlin' and allow not requiring kotlin.stdlib in module-info (AnalysisFlags.allowKotlinPackage)" ) + // It's inverted because otherwise we would have warnings in almost all KMP tests + val ENABLE_EXPECT_ACTUAL_CLASSES_WARNING by stringDirective( + description = "Disables -Xexpect-actual-classes key" + ) + // --------------------- Jvm Analysis Flags --------------------- val JVM_DEFAULT_MODE by enumDirective( diff --git a/compiler/testData/cli/js/jsExtraHelp.out b/compiler/testData/cli/js/jsExtraHelp.out index 8e3600a096e..d83c674dc02 100644 --- a/compiler/testData/cli/js/jsExtraHelp.out +++ b/compiler/testData/cli/js/jsExtraHelp.out @@ -87,6 +87,8 @@ where advanced options include: The corresponding calls' declarations may not be marked with @BuilderInference. -Xklib-enable-signature-clash-checks Enable the checks on uniqueness of signatures + -Xexpect-actual-classes The expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. + Kotlin reports a warning every time you use them. You can use this flag to mute the warning. -Xexpect-actual-linker Enable experimental expect/actual linker -Xexplicit-api={strict|warning|disable} Force compiler to report errors on all public API declarations without explicit visibility or return type. diff --git a/compiler/testData/cli/jvm/extraHelp.out b/compiler/testData/cli/jvm/extraHelp.out index 9d224733eb9..78e8138634b 100644 --- a/compiler/testData/cli/jvm/extraHelp.out +++ b/compiler/testData/cli/jvm/extraHelp.out @@ -178,6 +178,8 @@ where advanced options include: The corresponding calls' declarations may not be marked with @BuilderInference. -Xklib-enable-signature-clash-checks Enable the checks on uniqueness of signatures + -Xexpect-actual-classes The expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. + Kotlin reports a warning every time you use them. You can use this flag to mute the warning. -Xexpect-actual-linker Enable experimental expect/actual linker -Xexplicit-api={strict|warning|disable} Force compiler to report errors on all public API declarations without explicit visibility or return type. diff --git a/compiler/testData/cli/jvm/firMultiplatformCompilationWithPsiWithoutErrors.out b/compiler/testData/cli/jvm/firMultiplatformCompilationWithPsiWithoutErrors.out index 165fe4ed0bd..49568287ba3 100644 --- a/compiler/testData/cli/jvm/firMultiplatformCompilationWithPsiWithoutErrors.out +++ b/compiler/testData/cli/jvm/firMultiplatformCompilationWithPsiWithoutErrors.out @@ -9,4 +9,10 @@ as no stability/compatibility guarantees are given on compiler or generated code. Use it at your own risk! warning: language version 2.0 is experimental, there are no backwards compatibility guarantees for new language and library features +compiler/testData/cli/jvm/firMultiplatformCompilationWithoutErrors/common.kt:1:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect interface A { +^ +compiler/testData/cli/jvm/firMultiplatformCompilationWithoutErrors/jvm.kt:1:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +actual interface A { +^ OK diff --git a/compiler/testData/cli/jvm/firMultiplatformCompilationWithoutErrors.out b/compiler/testData/cli/jvm/firMultiplatformCompilationWithoutErrors.out index 165fe4ed0bd..49568287ba3 100644 --- a/compiler/testData/cli/jvm/firMultiplatformCompilationWithoutErrors.out +++ b/compiler/testData/cli/jvm/firMultiplatformCompilationWithoutErrors.out @@ -9,4 +9,10 @@ as no stability/compatibility guarantees are given on compiler or generated code. Use it at your own risk! warning: language version 2.0 is experimental, there are no backwards compatibility guarantees for new language and library features +compiler/testData/cli/jvm/firMultiplatformCompilationWithoutErrors/common.kt:1:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect interface A { +^ +compiler/testData/cli/jvm/firMultiplatformCompilationWithoutErrors/jvm.kt:1:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +actual interface A { +^ OK diff --git a/compiler/testData/cli/jvm/hmpp/lowLanguageVersion.out b/compiler/testData/cli/jvm/hmpp/lowLanguageVersion.out index b0896917c8e..adc7a7b700b 100644 --- a/compiler/testData/cli/jvm/hmpp/lowLanguageVersion.out +++ b/compiler/testData/cli/jvm/hmpp/lowLanguageVersion.out @@ -8,4 +8,16 @@ as no stability/compatibility guarantees are given on compiler or generated code. Use it at your own risk! warning: -Xfragments flag is not supported for language version < 2.0 +compiler/testData/cli/jvm/hmpp/src/a.kt:1:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect class A { +^ +compiler/testData/cli/jvm/hmpp/src/a.kt:5:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect class B { +^ +compiler/testData/cli/jvm/hmpp/src/b.kt:1:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +actual class A { +^ +compiler/testData/cli/jvm/hmpp/src/c.kt:1:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +actual class B { +^ OK diff --git a/compiler/testData/cli/jvm/hmpp/successfulCompilation.out b/compiler/testData/cli/jvm/hmpp/successfulCompilation.out index 0afdba6a4b9..77e4fcd7c72 100644 --- a/compiler/testData/cli/jvm/hmpp/successfulCompilation.out +++ b/compiler/testData/cli/jvm/hmpp/successfulCompilation.out @@ -8,4 +8,16 @@ as no stability/compatibility guarantees are given on compiler or generated code. Use it at your own risk! warning: language version 2.0 is experimental, there are no backwards compatibility guarantees for new language and library features +compiler/testData/cli/jvm/hmpp/src/a.kt:1:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect class A { +^ +compiler/testData/cli/jvm/hmpp/src/a.kt:5:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect class B { +^ +compiler/testData/cli/jvm/hmpp/src/b.kt:1:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +actual class A { +^ +compiler/testData/cli/jvm/hmpp/src/c.kt:1:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +actual class B { +^ OK diff --git a/compiler/testData/cli/jvm/hmpp/successfulCompilation2.out b/compiler/testData/cli/jvm/hmpp/successfulCompilation2.out index 0afdba6a4b9..77e4fcd7c72 100644 --- a/compiler/testData/cli/jvm/hmpp/successfulCompilation2.out +++ b/compiler/testData/cli/jvm/hmpp/successfulCompilation2.out @@ -8,4 +8,16 @@ as no stability/compatibility guarantees are given on compiler or generated code. Use it at your own risk! warning: language version 2.0 is experimental, there are no backwards compatibility guarantees for new language and library features +compiler/testData/cli/jvm/hmpp/src/a.kt:1:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect class A { +^ +compiler/testData/cli/jvm/hmpp/src/a.kt:5:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect class B { +^ +compiler/testData/cli/jvm/hmpp/src/b.kt:1:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +actual class A { +^ +compiler/testData/cli/jvm/hmpp/src/c.kt:1:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +actual class B { +^ OK diff --git a/compiler/testData/cli/jvm/k2SimpleMultiplatformGenericClass.out b/compiler/testData/cli/jvm/k2SimpleMultiplatformGenericClass.out index 86ca0241885..47f8018352a 100644 --- a/compiler/testData/cli/jvm/k2SimpleMultiplatformGenericClass.out +++ b/compiler/testData/cli/jvm/k2SimpleMultiplatformGenericClass.out @@ -1,2 +1,8 @@ warning: language version 2.0 is experimental, there are no backwards compatibility guarantees for new language and library features +compiler/testData/cli/jvm/k2SimpleMultiplatformGenericClass/common.kt:1:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect class AtomicRef { +^ +compiler/testData/cli/jvm/k2SimpleMultiplatformGenericClass/jvm.kt:1:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +actual class AtomicRef constructor(value: T) { +^ OK diff --git a/compiler/testData/cli/metadata/optionalExpectationUsage.out b/compiler/testData/cli/metadata/optionalExpectationUsage.out index d86bac9de59..060b56821af 100644 --- a/compiler/testData/cli/metadata/optionalExpectationUsage.out +++ b/compiler/testData/cli/metadata/optionalExpectationUsage.out @@ -1 +1,4 @@ +compiler/testData/cli/metadata/optionalExpectationUsage.kt:3:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect annotation class Ann() +^ OK diff --git a/compiler/testData/diagnostics/tests/multiplatform/expectActualClassesAreExperimentalWarning.fir.kt b/compiler/testData/diagnostics/tests/multiplatform/expectActualClassesAreExperimentalWarning.fir.kt new file mode 100644 index 00000000000..7be5336b02b --- /dev/null +++ b/compiler/testData/diagnostics/tests/multiplatform/expectActualClassesAreExperimentalWarning.fir.kt @@ -0,0 +1,49 @@ +// ENABLE_EXPECT_ACTUAL_CLASSES_WARNING +// MODULE: m1-common +// FILE: common.kt + +expect class Clazz { + class Nested + + fun memberFun() + val memberProp: Clazz +} + +expect interface Interface + +expect object Object + +expect annotation class Annotation + +expect enum class Enum + +expect class ActualTypealias + +expect fun function() + +expect val property: Clazz + +// MODULE: m2-jvm()()(m1-common) +// FILE: jvm.kt +actual class Clazz { + actual class Nested + + actual fun memberFun() {} + actual val memberProp: Clazz = null!! +} + +actual interface Interface + +actual object Object + +actual annotation class Annotation + +actual enum class Enum + +actual typealias ActualTypealias = ActualTypealiasImpl + +class ActualTypealiasImpl + +actual fun function() {} + +actual val property: Clazz = null!! diff --git a/compiler/testData/diagnostics/tests/multiplatform/expectActualClassesAreExperimentalWarning.kt b/compiler/testData/diagnostics/tests/multiplatform/expectActualClassesAreExperimentalWarning.kt new file mode 100644 index 00000000000..92c282028be --- /dev/null +++ b/compiler/testData/diagnostics/tests/multiplatform/expectActualClassesAreExperimentalWarning.kt @@ -0,0 +1,49 @@ +// ENABLE_EXPECT_ACTUAL_CLASSES_WARNING +// MODULE: m1-common +// FILE: common.kt + +expect class Clazz { + class Nested + + fun memberFun() + val memberProp: Clazz +} + +expect interface Interface + +expect object Object + +expect annotation class Annotation + +expect enum class Enum + +expect class ActualTypealias + +expect fun function() + +expect val property: Clazz + +// MODULE: m2-jvm()()(m1-common) +// FILE: jvm.kt +actual class Clazz { + actual class Nested + + actual fun memberFun() {} + actual val memberProp: Clazz = null!! +} + +actual interface Interface + +actual object Object + +actual annotation class Annotation + +actual enum class Enum + +actual typealias ActualTypealias = ActualTypealiasImpl + +class ActualTypealiasImpl + +actual fun function() {} + +actual val property: Clazz = null!! diff --git a/compiler/testData/multiplatform/classScopes/constructorIncorrectSignature/output.txt b/compiler/testData/multiplatform/classScopes/constructorIncorrectSignature/output.txt index b1fd9e3f372..7dea75e3f67 100644 --- a/compiler/testData/multiplatform/classScopes/constructorIncorrectSignature/output.txt +++ b/compiler/testData/multiplatform/classScopes/constructorIncorrectSignature/output.txt @@ -1,6 +1,9 @@ -- Common -- Exit code: OK Output: +compiler/testData/multiplatform/classScopes/constructorIncorrectSignature/common.kt:1:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect class Foo { +^ -- JVM -- Exit code: COMPILATION_ERROR diff --git a/compiler/testData/multiplatform/classScopes/enumsWithDifferentEntries/output.txt b/compiler/testData/multiplatform/classScopes/enumsWithDifferentEntries/output.txt index 0a966348ea2..6e318a94d34 100644 --- a/compiler/testData/multiplatform/classScopes/enumsWithDifferentEntries/output.txt +++ b/compiler/testData/multiplatform/classScopes/enumsWithDifferentEntries/output.txt @@ -1,6 +1,24 @@ -- Common -- Exit code: OK Output: +compiler/testData/multiplatform/classScopes/enumsWithDifferentEntries/common.kt:1:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect enum class AB { A, B } +^ +compiler/testData/multiplatform/classScopes/enumsWithDifferentEntries/common.kt:1:24: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect enum class AB { A, B } + ^ +compiler/testData/multiplatform/classScopes/enumsWithDifferentEntries/common.kt:1:27: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect enum class AB { A, B } + ^ +compiler/testData/multiplatform/classScopes/enumsWithDifferentEntries/common.kt:3:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect enum class CD { C, D } +^ +compiler/testData/multiplatform/classScopes/enumsWithDifferentEntries/common.kt:3:24: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect enum class CD { C, D } + ^ +compiler/testData/multiplatform/classScopes/enumsWithDifferentEntries/common.kt:3:27: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect enum class CD { C, D } + ^ -- JVM -- Exit code: COMPILATION_ERROR diff --git a/compiler/testData/multiplatform/classScopes/fakeOverrides/output.txt b/compiler/testData/multiplatform/classScopes/fakeOverrides/output.txt index b08950d503d..40c83f76310 100644 --- a/compiler/testData/multiplatform/classScopes/fakeOverrides/output.txt +++ b/compiler/testData/multiplatform/classScopes/fakeOverrides/output.txt @@ -1,7 +1,25 @@ -- Common -- Exit code: OK Output: +compiler/testData/multiplatform/classScopes/fakeOverrides/common.kt:1:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect open class Base { +^ +compiler/testData/multiplatform/classScopes/fakeOverrides/common.kt:5:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect class Derived : Base { +^ -- JVM -- Exit code: OK Output: +compiler/testData/multiplatform/classScopes/fakeOverrides/common.kt:1:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect open class Base { +^ +compiler/testData/multiplatform/classScopes/fakeOverrides/common.kt:5:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect class Derived : Base { +^ +compiler/testData/multiplatform/classScopes/fakeOverrides/jvm.kt:1:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +actual open class Base { +^ +compiler/testData/multiplatform/classScopes/fakeOverrides/jvm.kt:5:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +actual class Derived : Base() { +^ diff --git a/compiler/testData/multiplatform/classScopes/functionAndPropertyWithSameName/output.txt b/compiler/testData/multiplatform/classScopes/functionAndPropertyWithSameName/output.txt index 53b906c28d9..32022ba8eff 100644 --- a/compiler/testData/multiplatform/classScopes/functionAndPropertyWithSameName/output.txt +++ b/compiler/testData/multiplatform/classScopes/functionAndPropertyWithSameName/output.txt @@ -1,6 +1,9 @@ -- Common -- Exit code: OK Output: +compiler/testData/multiplatform/classScopes/functionAndPropertyWithSameName/common.kt:3:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect class Foo { +^ -- JVM -- Exit code: COMPILATION_ERROR diff --git a/compiler/testData/multiplatform/classScopes/functionIncorrectSignature/output.txt b/compiler/testData/multiplatform/classScopes/functionIncorrectSignature/output.txt index ecca778177b..e21737ea24d 100644 --- a/compiler/testData/multiplatform/classScopes/functionIncorrectSignature/output.txt +++ b/compiler/testData/multiplatform/classScopes/functionIncorrectSignature/output.txt @@ -1,6 +1,9 @@ -- Common -- Exit code: OK Output: +compiler/testData/multiplatform/classScopes/functionIncorrectSignature/common.kt:1:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect class Foo { +^ -- JVM -- Exit code: COMPILATION_ERROR diff --git a/compiler/testData/multiplatform/classScopes/functionIncorrectSignatureFromSuperclass/output.txt b/compiler/testData/multiplatform/classScopes/functionIncorrectSignatureFromSuperclass/output.txt index f67c45e003d..cccf0bfe302 100644 --- a/compiler/testData/multiplatform/classScopes/functionIncorrectSignatureFromSuperclass/output.txt +++ b/compiler/testData/multiplatform/classScopes/functionIncorrectSignatureFromSuperclass/output.txt @@ -1,6 +1,9 @@ -- Common -- Exit code: OK Output: +compiler/testData/multiplatform/classScopes/functionIncorrectSignatureFromSuperclass/common.kt:1:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect class Foo { +^ -- JVM -- Exit code: COMPILATION_ERROR diff --git a/compiler/testData/multiplatform/classScopes/missingConstructor/output.txt b/compiler/testData/multiplatform/classScopes/missingConstructor/output.txt index 04e32a8058a..c8e4db7c33f 100644 --- a/compiler/testData/multiplatform/classScopes/missingConstructor/output.txt +++ b/compiler/testData/multiplatform/classScopes/missingConstructor/output.txt @@ -1,6 +1,9 @@ -- Common -- Exit code: OK Output: +compiler/testData/multiplatform/classScopes/missingConstructor/common.kt:1:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect class Foo { +^ -- JVM -- Exit code: COMPILATION_ERROR diff --git a/compiler/testData/multiplatform/classScopes/missingFunction/output.txt b/compiler/testData/multiplatform/classScopes/missingFunction/output.txt index 0540d1da425..7dc719aef4a 100644 --- a/compiler/testData/multiplatform/classScopes/missingFunction/output.txt +++ b/compiler/testData/multiplatform/classScopes/missingFunction/output.txt @@ -1,6 +1,9 @@ -- Common -- Exit code: OK Output: +compiler/testData/multiplatform/classScopes/missingFunction/common.kt:1:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect class Foo { +^ -- JVM -- Exit code: COMPILATION_ERROR diff --git a/compiler/testData/multiplatform/classScopes/simple/output.txt b/compiler/testData/multiplatform/classScopes/simple/output.txt index ce9e219309f..ba11aa056bd 100644 --- a/compiler/testData/multiplatform/classScopes/simple/output.txt +++ b/compiler/testData/multiplatform/classScopes/simple/output.txt @@ -1,8 +1,16 @@ -- Common -- Exit code: OK Output: +compiler/testData/multiplatform/classScopes/simple/common.kt:1:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect class Foo(param: String) { +^ -- JVM -- Exit code: OK Output: - +compiler/testData/multiplatform/classScopes/simple/common.kt:1:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect class Foo(param: String) { +^ +compiler/testData/multiplatform/classScopes/simple/jvm.kt:1:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +actual class Foo actual constructor(param: String) { +^ diff --git a/compiler/testData/multiplatform/createImplClassInPlatformModule/output.txt b/compiler/testData/multiplatform/createImplClassInPlatformModule/output.txt index b08950d503d..f3b15142cc1 100644 --- a/compiler/testData/multiplatform/createImplClassInPlatformModule/output.txt +++ b/compiler/testData/multiplatform/createImplClassInPlatformModule/output.txt @@ -1,7 +1,16 @@ -- Common -- Exit code: OK Output: +compiler/testData/multiplatform/createImplClassInPlatformModule/common.kt:1:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect class Foo +^ -- JVM -- Exit code: OK Output: +compiler/testData/multiplatform/createImplClassInPlatformModule/common.kt:1:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect class Foo +^ +compiler/testData/multiplatform/createImplClassInPlatformModule/jvm.kt:1:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +actual class Foo(x: Int) { +^ diff --git a/compiler/testData/multiplatform/defaultArguments/methodDefaultArgsViaTypealias/output.txt b/compiler/testData/multiplatform/defaultArguments/methodDefaultArgsViaTypealias/output.txt index 558a97a6950..5c8148480aa 100644 --- a/compiler/testData/multiplatform/defaultArguments/methodDefaultArgsViaTypealias/output.txt +++ b/compiler/testData/multiplatform/defaultArguments/methodDefaultArgsViaTypealias/output.txt @@ -1,6 +1,9 @@ -- Common -- Exit code: OK Output: +compiler/testData/multiplatform/defaultArguments/methodDefaultArgsViaTypealias/common.kt:3:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect class A(p: String = "constructor") { +^ -- JVM -- Exit code: COMPILATION_ERROR @@ -11,4 +14,4 @@ compiler/testData/multiplatform/defaultArguments/methodDefaultArgsViaTypealias/j public final expect fun foo(p: String = ...): Unit actual typealias A = AImpl -^ \ No newline at end of file +^ diff --git a/compiler/testData/multiplatform/defaultArguments/useDefaultArgumentsInDependency/output.txt b/compiler/testData/multiplatform/defaultArguments/useDefaultArgumentsInDependency/output.txt index e2a887ac2ae..0f35cfee8a6 100644 --- a/compiler/testData/multiplatform/defaultArguments/useDefaultArgumentsInDependency/output.txt +++ b/compiler/testData/multiplatform/defaultArguments/useDefaultArgumentsInDependency/output.txt @@ -1,10 +1,37 @@ -- Common -- Exit code: OK Output: +compiler/testData/multiplatform/defaultArguments/useDefaultArgumentsInDependency/common.kt:5:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect class C(x: Int, y: String = "OK") +^ +compiler/testData/multiplatform/defaultArguments/useDefaultArgumentsInDependency/common.kt:7:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect annotation class Anno1(val x: Int, val y: String = "OK") +^ +compiler/testData/multiplatform/defaultArguments/useDefaultArgumentsInDependency/common.kt:9:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect annotation class Anno2(val x: Int, val y: String = "OK") +^ -- JVM -- Exit code: OK Output: +compiler/testData/multiplatform/defaultArguments/useDefaultArgumentsInDependency/common.kt:5:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect class C(x: Int, y: String = "OK") +^ +compiler/testData/multiplatform/defaultArguments/useDefaultArgumentsInDependency/common.kt:7:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect annotation class Anno1(val x: Int, val y: String = "OK") +^ +compiler/testData/multiplatform/defaultArguments/useDefaultArgumentsInDependency/common.kt:9:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect annotation class Anno2(val x: Int, val y: String = "OK") +^ +compiler/testData/multiplatform/defaultArguments/useDefaultArgumentsInDependency/jvm.kt:5:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +actual class C actual constructor(x: Int, y: String) {} +^ +compiler/testData/multiplatform/defaultArguments/useDefaultArgumentsInDependency/jvm.kt:7:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +actual annotation class Anno1(actual val x: Int, actual val y: String = "OK") +^ +compiler/testData/multiplatform/defaultArguments/useDefaultArgumentsInDependency/jvm.kt:9:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +actual annotation class Anno2(actual val x: Int, actual val y: String) +^ -- JVM (2) -- Exit code: OK diff --git a/compiler/testData/multiplatform/explicitActualOnOverrideOfAbstractMethod/output.txt b/compiler/testData/multiplatform/explicitActualOnOverrideOfAbstractMethod/output.txt index b08950d503d..5f4c9e45613 100644 --- a/compiler/testData/multiplatform/explicitActualOnOverrideOfAbstractMethod/output.txt +++ b/compiler/testData/multiplatform/explicitActualOnOverrideOfAbstractMethod/output.txt @@ -1,7 +1,25 @@ -- Common -- Exit code: OK Output: +compiler/testData/multiplatform/explicitActualOnOverrideOfAbstractMethod/common.kt:1:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect abstract class Base { +^ +compiler/testData/multiplatform/explicitActualOnOverrideOfAbstractMethod/common.kt:5:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect class DerivedImplicit : Base { +^ -- JVM -- Exit code: OK Output: +compiler/testData/multiplatform/explicitActualOnOverrideOfAbstractMethod/common.kt:1:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect abstract class Base { +^ +compiler/testData/multiplatform/explicitActualOnOverrideOfAbstractMethod/common.kt:5:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect class DerivedImplicit : Base { +^ +compiler/testData/multiplatform/explicitActualOnOverrideOfAbstractMethod/jvm.kt:1:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +actual abstract class Base { +^ +compiler/testData/multiplatform/explicitActualOnOverrideOfAbstractMethod/jvm.kt:5:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +actual class DerivedImplicit : Base() { +^ diff --git a/compiler/testData/multiplatform/genericDeclarations/output.txt b/compiler/testData/multiplatform/genericDeclarations/output.txt index d2bfed57d19..bfc6bec2304 100644 --- a/compiler/testData/multiplatform/genericDeclarations/output.txt +++ b/compiler/testData/multiplatform/genericDeclarations/output.txt @@ -1,6 +1,18 @@ -- Common -- Exit code: OK Output: +compiler/testData/multiplatform/genericDeclarations/common.kt:9:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect class C1 +^ +compiler/testData/multiplatform/genericDeclarations/common.kt:10:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect class C2> +^ +compiler/testData/multiplatform/genericDeclarations/common.kt:11:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect class C3> +^ +compiler/testData/multiplatform/genericDeclarations/common.kt:13:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect abstract class AbstractList : MutableList +^ -- JVM -- Exit code: COMPILATION_ERROR diff --git a/compiler/testData/multiplatform/implTypeAlias/actualTypealiasToNothing/output.txt b/compiler/testData/multiplatform/implTypeAlias/actualTypealiasToNothing/output.txt index f0b81fda85e..d5860ca7ac1 100644 --- a/compiler/testData/multiplatform/implTypeAlias/actualTypealiasToNothing/output.txt +++ b/compiler/testData/multiplatform/implTypeAlias/actualTypealiasToNothing/output.txt @@ -1,6 +1,12 @@ -- Common -- Exit code: OK Output: +compiler/testData/multiplatform/implTypeAlias/actualTypealiasToNothing/common.kt:1:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect class E01 +^ +compiler/testData/multiplatform/implTypeAlias/actualTypealiasToNothing/common.kt:2:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect class E02 +^ -- JVM -- Exit code: COMPILATION_ERROR diff --git a/compiler/testData/multiplatform/implTypeAlias/actualTypealiasToNullableType/output.txt b/compiler/testData/multiplatform/implTypeAlias/actualTypealiasToNullableType/output.txt index 8f8ee891c33..5119bc132a6 100644 --- a/compiler/testData/multiplatform/implTypeAlias/actualTypealiasToNullableType/output.txt +++ b/compiler/testData/multiplatform/implTypeAlias/actualTypealiasToNullableType/output.txt @@ -1,6 +1,12 @@ -- Common -- Exit code: OK Output: +compiler/testData/multiplatform/implTypeAlias/actualTypealiasToNullableType/common.kt:1:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect class E01 +^ +compiler/testData/multiplatform/implTypeAlias/actualTypealiasToNullableType/common.kt:2:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect class E02 +^ -- JVM -- Exit code: COMPILATION_ERROR diff --git a/compiler/testData/multiplatform/implTypeAlias/discriminateHeaderClassInFavorOfTypeAlias/output.txt b/compiler/testData/multiplatform/implTypeAlias/discriminateHeaderClassInFavorOfTypeAlias/output.txt index e2a887ac2ae..31a68575446 100644 --- a/compiler/testData/multiplatform/implTypeAlias/discriminateHeaderClassInFavorOfTypeAlias/output.txt +++ b/compiler/testData/multiplatform/implTypeAlias/discriminateHeaderClassInFavorOfTypeAlias/output.txt @@ -1,10 +1,19 @@ -- Common -- Exit code: OK Output: +compiler/testData/multiplatform/implTypeAlias/discriminateHeaderClassInFavorOfTypeAlias/common.kt:3:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect class A +^ -- JVM -- Exit code: OK Output: +compiler/testData/multiplatform/implTypeAlias/discriminateHeaderClassInFavorOfTypeAlias/common.kt:3:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect class A +^ +compiler/testData/multiplatform/implTypeAlias/discriminateHeaderClassInFavorOfTypeAlias/jvm.kt:1:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +actual typealias A = AImpl +^ -- JVM (2) -- Exit code: OK diff --git a/compiler/testData/multiplatform/implTypeAlias/generic/output.txt b/compiler/testData/multiplatform/implTypeAlias/generic/output.txt index 20ef6bcbadd..61f57dab307 100644 --- a/compiler/testData/multiplatform/implTypeAlias/generic/output.txt +++ b/compiler/testData/multiplatform/implTypeAlias/generic/output.txt @@ -1,11 +1,19 @@ -- Common -- Exit code: OK Output: +compiler/testData/multiplatform/implTypeAlias/generic/common.kt:1:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect class C1 { +^ -- JVM -- Exit code: OK Output: +compiler/testData/multiplatform/implTypeAlias/generic/common.kt:1:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect class C1 { +^ +compiler/testData/multiplatform/implTypeAlias/generic/jvm.kt:1:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +actual typealias C1 = C1Impl +^ compiler/testData/multiplatform/implTypeAlias/generic/jvm.kt:3:13: warning: parameter 'a' is never used fun foo(a: A): List? = null ^ - diff --git a/compiler/testData/multiplatform/implTypeAlias/nestedClassesViaTypeAlias/output.txt b/compiler/testData/multiplatform/implTypeAlias/nestedClassesViaTypeAlias/output.txt index b08950d503d..3e4d1175dc4 100644 --- a/compiler/testData/multiplatform/implTypeAlias/nestedClassesViaTypeAlias/output.txt +++ b/compiler/testData/multiplatform/implTypeAlias/nestedClassesViaTypeAlias/output.txt @@ -1,7 +1,22 @@ -- Common -- Exit code: OK Output: +compiler/testData/multiplatform/implTypeAlias/nestedClassesViaTypeAlias/common.kt:1:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect class ByTypeAlias { +^ +compiler/testData/multiplatform/implTypeAlias/nestedClassesViaTypeAlias/common.kt:2:15: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. + interface Nested + ^ -- JVM -- Exit code: OK Output: +compiler/testData/multiplatform/implTypeAlias/nestedClassesViaTypeAlias/common.kt:1:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect class ByTypeAlias { +^ +compiler/testData/multiplatform/implTypeAlias/nestedClassesViaTypeAlias/common.kt:2:15: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. + interface Nested + ^ +compiler/testData/multiplatform/implTypeAlias/nestedClassesViaTypeAlias/jvm.kt:5:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +actual typealias ByTypeAlias = ByTypeAliasImpl +^ diff --git a/compiler/testData/multiplatform/incompatibleClasses/output.txt b/compiler/testData/multiplatform/incompatibleClasses/output.txt index bd83b800147..ddc50eb5a28 100644 --- a/compiler/testData/multiplatform/incompatibleClasses/output.txt +++ b/compiler/testData/multiplatform/incompatibleClasses/output.txt @@ -1,6 +1,57 @@ -- Common -- Exit code: OK Output: +compiler/testData/multiplatform/incompatibleClasses/common.kt:1:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect class PClass +^ +compiler/testData/multiplatform/incompatibleClasses/common.kt:2:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect interface PInterface +^ +compiler/testData/multiplatform/incompatibleClasses/common.kt:3:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect object PObject +^ +compiler/testData/multiplatform/incompatibleClasses/common.kt:4:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect enum class PEnumClass +^ +compiler/testData/multiplatform/incompatibleClasses/common.kt:5:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect annotation class PAnnotationClass +^ +compiler/testData/multiplatform/incompatibleClasses/common.kt:7:10: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +internal expect object InternalObject + ^ +compiler/testData/multiplatform/incompatibleClasses/common.kt:8:8: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +public expect object PublicObject + ^ +compiler/testData/multiplatform/incompatibleClasses/common.kt:10:6: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +open expect class OpenClass + ^ +compiler/testData/multiplatform/incompatibleClasses/common.kt:11:10: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +abstract expect class AbstractClass + ^ +compiler/testData/multiplatform/incompatibleClasses/common.kt:12:7: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +final expect class FinalClass + ^ +compiler/testData/multiplatform/incompatibleClasses/common.kt:14:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect class C1 +^ +compiler/testData/multiplatform/incompatibleClasses/common.kt:15:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect class C2 +^ +compiler/testData/multiplatform/incompatibleClasses/common.kt:16:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect class C3 +^ +compiler/testData/multiplatform/incompatibleClasses/common.kt:18:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect class C4 +^ +compiler/testData/multiplatform/incompatibleClasses/common.kt:21:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect abstract class ExtendsNumber : Number +^ +compiler/testData/multiplatform/incompatibleClasses/common.kt:23:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect fun interface FunInterface { +^ +compiler/testData/multiplatform/incompatibleClasses/common.kt:27:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect fun interface FunInterface2 { +^ -- JVM -- Exit code: COMPILATION_ERROR diff --git a/compiler/testData/multiplatform/incompatibleNestedClasses/output.txt b/compiler/testData/multiplatform/incompatibleNestedClasses/output.txt index a2a91fa1182..7d42753d5e6 100644 --- a/compiler/testData/multiplatform/incompatibleNestedClasses/output.txt +++ b/compiler/testData/multiplatform/incompatibleNestedClasses/output.txt @@ -1,6 +1,42 @@ -- Common -- Exit code: OK Output: +compiler/testData/multiplatform/incompatibleNestedClasses/common.kt:1:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect class O1 { +^ +compiler/testData/multiplatform/incompatibleNestedClasses/common.kt:2:11: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. + class N1 + ^ +compiler/testData/multiplatform/incompatibleNestedClasses/common.kt:3:15: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. + interface N2 + ^ +compiler/testData/multiplatform/incompatibleNestedClasses/common.kt:4:12: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. + object N3 + ^ +compiler/testData/multiplatform/incompatibleNestedClasses/common.kt:7:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect class O2 { +^ +compiler/testData/multiplatform/incompatibleNestedClasses/common.kt:8:11: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. + class N2 + ^ +compiler/testData/multiplatform/incompatibleNestedClasses/common.kt:9:17: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. + inner class I2 + ^ +compiler/testData/multiplatform/incompatibleNestedClasses/common.kt:12:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect class O3 { +^ +compiler/testData/multiplatform/incompatibleNestedClasses/common.kt:13:12: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. + object Companion + ^ +compiler/testData/multiplatform/incompatibleNestedClasses/common.kt:14:22: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. + companion object Factory + ^ +compiler/testData/multiplatform/incompatibleNestedClasses/common.kt:17:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect class O4 { +^ +compiler/testData/multiplatform/incompatibleNestedClasses/common.kt:18:15: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. + companion object + ^ -- JVM -- Exit code: COMPILATION_ERROR diff --git a/compiler/testData/multiplatform/incorrectImplInClass/output.txt b/compiler/testData/multiplatform/incorrectImplInClass/output.txt index d46cc2ba8bf..d34418cefad 100644 --- a/compiler/testData/multiplatform/incorrectImplInClass/output.txt +++ b/compiler/testData/multiplatform/incorrectImplInClass/output.txt @@ -1,6 +1,9 @@ -- Common -- Exit code: OK Output: +compiler/testData/multiplatform/incorrectImplInClass/common.kt:1:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect class Foo +^ -- JVM -- Exit code: COMPILATION_ERROR diff --git a/compiler/testData/multiplatform/inlineClasses/output.txt b/compiler/testData/multiplatform/inlineClasses/output.txt index f429c0d5dcd..0170a267ec7 100644 --- a/compiler/testData/multiplatform/inlineClasses/output.txt +++ b/compiler/testData/multiplatform/inlineClasses/output.txt @@ -1,9 +1,15 @@ -- Common -- Exit code: OK Output: +compiler/testData/multiplatform/inlineClasses/common.kt:3:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect inline class Foo1(val x: Int) +^ compiler/testData/multiplatform/inlineClasses/common.kt:3:8: warning: 'inline' modifier is deprecated. Use 'value' instead expect inline class Foo1(val x: Int) ^ +compiler/testData/multiplatform/inlineClasses/common.kt:4:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect inline class Foo2(val y: String) +^ compiler/testData/multiplatform/inlineClasses/common.kt:4:8: warning: 'inline' modifier is deprecated. Use 'value' instead expect inline class Foo2(val y: String) ^ diff --git a/compiler/testData/multiplatform/jsNameClash/output.txt b/compiler/testData/multiplatform/jsNameClash/output.txt index 6b3f5dfc27f..6c6585741cb 100644 --- a/compiler/testData/multiplatform/jsNameClash/output.txt +++ b/compiler/testData/multiplatform/jsNameClash/output.txt @@ -1,7 +1,16 @@ -- Common -- Exit code: OK Output: +compiler/testData/multiplatform/jsNameClash/common.kt:1:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect class ClassWithImplByExtension +^ -- JS -- Exit code: OK Output: +compiler/testData/multiplatform/jsNameClash/common.kt:1:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect class ClassWithImplByExtension +^ +compiler/testData/multiplatform/jsNameClash/js.kt:1:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +actual class ClassWithImplByExtension +^ diff --git a/compiler/testData/multiplatform/missingOverload/output.txt b/compiler/testData/multiplatform/missingOverload/output.txt index d70edc5368b..45968c1aed1 100644 --- a/compiler/testData/multiplatform/missingOverload/output.txt +++ b/compiler/testData/multiplatform/missingOverload/output.txt @@ -1,6 +1,9 @@ -- Common -- Exit code: OK Output: +compiler/testData/multiplatform/missingOverload/common.kt:1:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect class Foo { +^ -- JVM -- Exit code: COMPILATION_ERROR diff --git a/compiler/testData/multiplatform/optionalExpectation/output.txt b/compiler/testData/multiplatform/optionalExpectation/output.txt index ac1ad3921a5..e276560a215 100644 --- a/compiler/testData/multiplatform/optionalExpectation/output.txt +++ b/compiler/testData/multiplatform/optionalExpectation/output.txt @@ -1,11 +1,23 @@ -- Common -- Exit code: OK Output: +compiler/testData/multiplatform/optionalExpectation/common.kt:5:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect annotation class A() +^ -- JVM -- Exit code: OK Output: +compiler/testData/multiplatform/optionalExpectation/common.kt:5:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect annotation class A() +^ +compiler/testData/multiplatform/optionalExpectation/jvm.kt:1:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +actual annotation class A +^ -- JS -- Exit code: OK Output: +compiler/testData/multiplatform/optionalExpectation/common.kt:5:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect annotation class A() +^ diff --git a/compiler/testData/multiplatform/regressions/incompatibleClassScopesWithImplTypeAlias/output.txt b/compiler/testData/multiplatform/regressions/incompatibleClassScopesWithImplTypeAlias/output.txt index 46258567763..f6e4cdb903b 100644 --- a/compiler/testData/multiplatform/regressions/incompatibleClassScopesWithImplTypeAlias/output.txt +++ b/compiler/testData/multiplatform/regressions/incompatibleClassScopesWithImplTypeAlias/output.txt @@ -1,6 +1,9 @@ -- Common -- Exit code: OK Output: +compiler/testData/multiplatform/regressions/incompatibleClassScopesWithImplTypeAlias/common.kt:3:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect abstract class Writer protected constructor() +^ -- JVM -- Exit code: COMPILATION_ERROR diff --git a/compiler/testData/multiplatform/simple/output.txt b/compiler/testData/multiplatform/simple/output.txt index ac1ad3921a5..e091f6b1720 100644 --- a/compiler/testData/multiplatform/simple/output.txt +++ b/compiler/testData/multiplatform/simple/output.txt @@ -1,11 +1,26 @@ -- Common -- Exit code: OK Output: +compiler/testData/multiplatform/simple/common.kt:1:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect class Printer() { +^ -- JVM -- Exit code: OK Output: +compiler/testData/multiplatform/simple/common.kt:1:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect class Printer() { +^ +compiler/testData/multiplatform/simple/jvm.kt:1:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +actual class Printer { +^ -- JS -- Exit code: OK Output: +compiler/testData/multiplatform/simple/common.kt:1:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect class Printer() { +^ +compiler/testData/multiplatform/simple/js.kt:1:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +actual class Printer { +^ diff --git a/compiler/testData/multiplatform/weakIncompatibilityWithoutActualModifier/output.txt b/compiler/testData/multiplatform/weakIncompatibilityWithoutActualModifier/output.txt index 49a77a190b8..c203ce7f53d 100644 --- a/compiler/testData/multiplatform/weakIncompatibilityWithoutActualModifier/output.txt +++ b/compiler/testData/multiplatform/weakIncompatibilityWithoutActualModifier/output.txt @@ -1,6 +1,9 @@ -- Common -- Exit code: OK Output: +compiler/testData/multiplatform/weakIncompatibilityWithoutActualModifier/common.kt:1:1: warning: the expect/actual classes (including interfaces, objects, annotations, enums, actual typealiases) are an experimental feature. You can use -Xexpect-actual-classes flag to suppress this warning. +expect class Foo +^ -- JVM -- Exit code: COMPILATION_ERROR 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 d8105c6e006..18c62c9b8da 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 @@ -23032,6 +23032,12 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { runTest("compiler/testData/diagnostics/tests/multiplatform/expectAbstractToString.kt"); } + @Test + @TestMetadata("expectActualClassesAreExperimentalWarning.kt") + public void testExpectActualClassesAreExperimentalWarning() throws Exception { + runTest("compiler/testData/diagnostics/tests/multiplatform/expectActualClassesAreExperimentalWarning.kt"); + } + @Test @TestMetadata("expectDataObject.kt") public void testExpectDataObject() throws Exception { diff --git a/kotlin-native/runtime/build.gradle.kts b/kotlin-native/runtime/build.gradle.kts index 0c6c5289857..75fae6dda76 100644 --- a/kotlin-native/runtime/build.gradle.kts +++ b/kotlin-native/runtime/build.gradle.kts @@ -512,6 +512,7 @@ konanArtifacts { extraOpts(project.globalBuildArgs) extraOpts( "-Werror", + "-Xexpect-actual-classes", "-module-name", "stdlib", "-opt-in=kotlin.RequiresOptIn", "-opt-in=kotlin.contracts.ExperimentalContracts", diff --git a/libraries/kotlin.test/junit/build.gradle b/libraries/kotlin.test/junit/build.gradle index 0ae72fb1a3c..8604b0e1143 100644 --- a/libraries/kotlin.test/junit/build.gradle +++ b/libraries/kotlin.test/junit/build.gradle @@ -32,6 +32,7 @@ RepoArtifacts.javadocJar(project) compileKotlin { kotlinOptions.freeCompilerArgs = [ "-Xallow-kotlin-package", + "-Xexpect-actual-classes", ] kotlinOptions.moduleName = project.name } diff --git a/libraries/kotlin.test/junit5/build.gradle b/libraries/kotlin.test/junit5/build.gradle index aaac1522dcb..12a4089f4de 100644 --- a/libraries/kotlin.test/junit5/build.gradle +++ b/libraries/kotlin.test/junit5/build.gradle @@ -33,6 +33,7 @@ RepoArtifacts.javadocJar(project) compileKotlin { kotlinOptions.freeCompilerArgs = [ "-Xallow-kotlin-package", + "-Xexpect-actual-classes", ] kotlinOptions.moduleName = project.name } diff --git a/libraries/kotlin.test/testng/build.gradle b/libraries/kotlin.test/testng/build.gradle index 47440ef9e2b..4c5f524484b 100644 --- a/libraries/kotlin.test/testng/build.gradle +++ b/libraries/kotlin.test/testng/build.gradle @@ -34,6 +34,7 @@ RepoArtifacts.javadocJar(project) compileKotlin { kotlinOptions.freeCompilerArgs = [ "-Xallow-kotlin-package", + "-Xexpect-actual-classes", ] kotlinOptions.moduleName = project.name } diff --git a/libraries/stdlib/build.gradle.kts b/libraries/stdlib/build.gradle.kts index 702117b5208..11f5291de3e 100644 --- a/libraries/stdlib/build.gradle.kts +++ b/libraries/stdlib/build.gradle.kts @@ -110,6 +110,7 @@ kotlin { // providing exhaustive list of args here freeCompilerArgs = listOf( "-Xallow-kotlin-package", + "-Xexpect-actual-classes", "-Xmultifile-parts-inherit", "-Xuse-14-inline-classes-mangling-scheme", "-Xbuiltins-from-sources", @@ -168,6 +169,7 @@ kotlin { kotlinOptions { freeCompilerArgs += listOf( "-Xallow-kotlin-package", // TODO: maybe rename test packages + "-Xexpect-actual-classes", ) if (kotlinBuildProperties.useFir) { freeCompilerArgs += "-Xuse-k2" @@ -256,6 +258,7 @@ kotlin { main.apply { kotlinOptions { freeCompilerArgs += "-Xir-module-name=kotlin" + freeCompilerArgs += "-Xexpect-actual-classes" if (!kotlinBuildProperties.disableWerror) { allWarningsAsErrors = true diff --git a/libraries/stdlib/jvm-minimal-for-test/build.gradle.kts b/libraries/stdlib/jvm-minimal-for-test/build.gradle.kts index d8c26f5e9d3..3e116a2ee48 100644 --- a/libraries/stdlib/jvm-minimal-for-test/build.gradle.kts +++ b/libraries/stdlib/jvm-minimal-for-test/build.gradle.kts @@ -63,6 +63,7 @@ tasks.compileKotlin { kotlinOptions { freeCompilerArgs += listOf( "-Xallow-kotlin-package", + "-Xexpect-actual-classes", "-Xmulti-platform", "-opt-in=kotlin.RequiresOptIn", "-opt-in=kotlin.contracts.ExperimentalContracts", diff --git a/repo/gradle-build-conventions/buildsrc-compat/src/main/kotlin/wasm/wasmKotlinTest.kt b/repo/gradle-build-conventions/buildsrc-compat/src/main/kotlin/wasm/wasmKotlinTest.kt index b5e34976079..5ef1abb734c 100644 --- a/repo/gradle-build-conventions/buildsrc-compat/src/main/kotlin/wasm/wasmKotlinTest.kt +++ b/repo/gradle-build-conventions/buildsrc-compat/src/main/kotlin/wasm/wasmKotlinTest.kt @@ -85,6 +85,7 @@ fun Project.configureWasmKotlinTest( tasks.withType>().configureEach { kotlinOptions.freeCompilerArgs += listOf( "-Xallow-kotlin-package", + "-Xexpect-actual-classes", "-opt-in=kotlin.ExperimentalMultiplatform", "-opt-in=kotlin.contracts.ExperimentalContracts", "-Xwasm-target=$wasmTargetParameter" diff --git a/repo/gradle-build-conventions/buildsrc-compat/src/main/kotlin/wasm/wasmStdLib.kt b/repo/gradle-build-conventions/buildsrc-compat/src/main/kotlin/wasm/wasmStdLib.kt index 86a5ed20a38..fda4bdca4ad 100644 --- a/repo/gradle-build-conventions/buildsrc-compat/src/main/kotlin/wasm/wasmStdLib.kt +++ b/repo/gradle-build-conventions/buildsrc-compat/src/main/kotlin/wasm/wasmStdLib.kt @@ -146,6 +146,7 @@ fun Project.configureWasmStdLib( tasks.withType>().configureEach { kotlinOptions.freeCompilerArgs += listOf( "-Xallow-kotlin-package", + "-Xexpect-actual-classes", "-opt-in=kotlin.ExperimentalMultiplatform", "-opt-in=kotlin.contracts.ExperimentalContracts", "-opt-in=kotlin.RequiresOptIn",