Mark expect/actual classifiers as experimental

^KT-61573 Fixed
Review: https://jetbrains.team/p/kt/reviews/11969/timeline

Tests:
- MultiPlatformIntegrationTestGenerated
- CliTestGenerated
- MultiPlatformIntegrationTestGenerated
- DiagnosticTestGenerated.Multiplatform
- FirLightTreeOldFrontendDiagnosticsTestGenerated

Also add -Xexpect-actual-classes flag to all necessary ./libraries/* modules
Otherwise compilation of those modules failes because of `-Werror`

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,

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<PSI : PsiElement> : KtDiagnosticWithPsi<PSI> {
         override val diagnosticClass get() = ActualMissing::class
     }
 
+    interface ExpectActualClassifiersAreExperimentalWarning : KtFirDiagnostic<KtClassLikeDeclaration> {
+        override val diagnosticClass get() = ExpectActualClassifiersAreExperimentalWarning::class
+    }
+
     interface NotAMultiplatformCompilation : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = NotAMultiplatformCompilation::class
     }

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<KtNamedDeclaration>(firDiagnostic, token), KtFirDiagnostic.ActualMissing
 
+internal class ExpectActualClassifiersAreExperimentalWarningImpl(
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtClassLikeDeclaration>(firDiagnostic, token), KtFirDiagnostic.ExpectActualClassifiersAreExperimentalWarning
+
 internal class NotAMultiplatformCompilationImpl(
     firDiagnostic: KtPsiDiagnostic,
     token: KtLifetimeToken,

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

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)
         }

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
 

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 {

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 {

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<KtNamedDeclaration>(PositioningStrategy.ACTUAL_DECLARATION_NAME)
 
+        val EXPECT_ACTUAL_CLASSIFIERS_ARE_EXPERIMENTAL_WARNING by warning<KtClassLikeDeclaration>(PositioningStrategy.EXPECT_ACTUAL_MODIFIER)
+
         val NOT_A_MULTIPLATFORM_COMPILATION by error<PsiElement>()
 
         val EXPECT_ACTUAL_OPT_IN_ANNOTATION by error<KtNamedDeclaration>(PositioningStrategy.EXPECT_ACTUAL_MODIFIER)

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<KtNamedDeclaration, FirBasedSymbol<*>, Collection<FirModuleData>>(SourceElementPositioningStrategies.INCOMPATIBLE_DECLARATION)
     val NO_ACTUAL_CLASS_MEMBER_FOR_EXPECTED_CLASS by error2<KtNamedDeclaration, FirBasedSymbol<*>, List<Pair<FirBasedSymbol<*>, Map<Incompatible<FirBasedSymbol<*>>, Collection<FirBasedSymbol<*>>>>>>(SourceElementPositioningStrategies.ACTUAL_DECLARATION_NAME)
     val ACTUAL_MISSING by error0<KtNamedDeclaration>(SourceElementPositioningStrategies.ACTUAL_DECLARATION_NAME)
+    val EXPECT_ACTUAL_CLASSIFIERS_ARE_EXPERIMENTAL_WARNING by warning0<KtClassLikeDeclaration>(SourceElementPositioningStrategies.EXPECT_ACTUAL_MODIFIER)
     val NOT_A_MULTIPLATFORM_COMPILATION by error0<PsiElement>()
     val EXPECT_ACTUAL_OPT_IN_ANNOTATION by error0<KtNamedDeclaration>(SourceElementPositioningStrategies.EXPECT_ACTUAL_MODIFIER)
     val ACTUAL_TYPEALIAS_TO_SPECIAL_ANNOTATION by error1<KtTypeAlias, ClassId>(SourceElementPositioningStrategies.TYPEALIAS_TYPE_REFERENCE)

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<FirClassLikeChecker>
+        get() = setOf(
+            FirExpectActualClassifiersAreExperimentalChecker,
         )
 
     override val callableDeclarationCheckers: Set<FirCallableDeclarationChecker>

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)
+        }
+    }
+}

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(

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<KtClassLikeDeclaration> EXPECT_ACTUAL_CLASSIFIERS_ARE_EXPERIMENTAL_WARNING = DiagnosticFactory0.create(WARNING, EXPECT_ACTUAL_MODIFIER);
+
     DiagnosticFactory0<PsiElement> OPTIONAL_EXPECTATION_NOT_ON_EXPECTED = DiagnosticFactory0.create(ERROR);
     DiagnosticFactory0<PsiElement> OPTIONAL_DECLARATION_OUTSIDE_OF_ANNOTATION_ENTRY = DiagnosticFactory0.create(ERROR);
     DiagnosticFactory0<PsiElement> OPTIONAL_DECLARATION_USAGE_IN_NON_COMMON_SOURCE = DiagnosticFactory0.create(ERROR);

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");

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,

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))
+        }
+    }
+}

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)),

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(

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.

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.

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

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

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

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

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

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<T> {
+^
+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<T> constructor(value: T) {
+^
 OK

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

compiler/testData/diagnostics/tests/multiplatform/expectActualClassesAreExperimentalWarning.fir.kt

@@ -0,0 +1,49 @@
+// ENABLE_EXPECT_ACTUAL_CLASSES_WARNING
+// MODULE: m1-common
+// FILE: common.kt
+
+<!EXPECT_ACTUAL_CLASSIFIERS_ARE_EXPERIMENTAL_WARNING!>expect<!> class Clazz {
+    class <!EXPECT_ACTUAL_CLASSIFIERS_ARE_EXPERIMENTAL_WARNING!>Nested<!>
+
+    fun memberFun()
+    val memberProp: Clazz
+}
+
+<!EXPECT_ACTUAL_CLASSIFIERS_ARE_EXPERIMENTAL_WARNING!>expect<!> interface Interface
+
+<!EXPECT_ACTUAL_CLASSIFIERS_ARE_EXPERIMENTAL_WARNING!>expect<!> object Object
+
+<!EXPECT_ACTUAL_CLASSIFIERS_ARE_EXPERIMENTAL_WARNING!>expect<!> annotation class Annotation
+
+<!EXPECT_ACTUAL_CLASSIFIERS_ARE_EXPERIMENTAL_WARNING!>expect<!> enum class Enum
+
+<!EXPECT_ACTUAL_CLASSIFIERS_ARE_EXPERIMENTAL_WARNING!>expect<!> class ActualTypealias
+
+expect fun function()
+
+expect val property: Clazz
+
+// MODULE: m2-jvm()()(m1-common)
+// FILE: jvm.kt
+<!EXPECT_ACTUAL_CLASSIFIERS_ARE_EXPERIMENTAL_WARNING!>actual<!> class Clazz {
+    <!EXPECT_ACTUAL_CLASSIFIERS_ARE_EXPERIMENTAL_WARNING!>actual<!> class Nested
+
+    actual fun memberFun() {}
+    actual val memberProp: Clazz = null!!
+}
+
+<!EXPECT_ACTUAL_CLASSIFIERS_ARE_EXPERIMENTAL_WARNING!>actual<!> interface Interface
+
+<!EXPECT_ACTUAL_CLASSIFIERS_ARE_EXPERIMENTAL_WARNING!>actual<!> object Object
+
+<!EXPECT_ACTUAL_CLASSIFIERS_ARE_EXPERIMENTAL_WARNING!>actual<!> annotation class Annotation
+
+<!EXPECT_ACTUAL_CLASSIFIERS_ARE_EXPERIMENTAL_WARNING!>actual<!> enum class Enum
+
+<!EXPECT_ACTUAL_CLASSIFIERS_ARE_EXPERIMENTAL_WARNING!>actual<!> typealias ActualTypealias = ActualTypealiasImpl
+
+class ActualTypealiasImpl
+
+actual fun function() {}
+
+actual val property: Clazz = null!!

compiler/testData/diagnostics/tests/multiplatform/expectActualClassesAreExperimentalWarning.kt

@@ -0,0 +1,49 @@
+// ENABLE_EXPECT_ACTUAL_CLASSES_WARNING
+// MODULE: m1-common
+// FILE: common.kt
+
+<!EXPECT_ACTUAL_CLASSIFIERS_ARE_EXPERIMENTAL_WARNING, EXPECT_ACTUAL_CLASSIFIERS_ARE_EXPERIMENTAL_WARNING{JVM}!>expect<!> class Clazz {
+    class <!EXPECT_ACTUAL_CLASSIFIERS_ARE_EXPERIMENTAL_WARNING, EXPECT_ACTUAL_CLASSIFIERS_ARE_EXPERIMENTAL_WARNING{JVM}!>Nested<!>
+
+    fun memberFun()
+    val memberProp: Clazz
+}
+
+<!EXPECT_ACTUAL_CLASSIFIERS_ARE_EXPERIMENTAL_WARNING, EXPECT_ACTUAL_CLASSIFIERS_ARE_EXPERIMENTAL_WARNING{JVM}!>expect<!> interface Interface
+
+<!EXPECT_ACTUAL_CLASSIFIERS_ARE_EXPERIMENTAL_WARNING, EXPECT_ACTUAL_CLASSIFIERS_ARE_EXPERIMENTAL_WARNING{JVM}!>expect<!> object Object
+
+<!EXPECT_ACTUAL_CLASSIFIERS_ARE_EXPERIMENTAL_WARNING, EXPECT_ACTUAL_CLASSIFIERS_ARE_EXPERIMENTAL_WARNING{JVM}!>expect<!> annotation class Annotation
+
+<!EXPECT_ACTUAL_CLASSIFIERS_ARE_EXPERIMENTAL_WARNING, EXPECT_ACTUAL_CLASSIFIERS_ARE_EXPERIMENTAL_WARNING{JVM}!>expect<!> enum class Enum
+
+<!EXPECT_ACTUAL_CLASSIFIERS_ARE_EXPERIMENTAL_WARNING, EXPECT_ACTUAL_CLASSIFIERS_ARE_EXPERIMENTAL_WARNING{JVM}!>expect<!> class ActualTypealias
+
+expect fun function()
+
+expect val property: Clazz
+
+// MODULE: m2-jvm()()(m1-common)
+// FILE: jvm.kt
+<!EXPECT_ACTUAL_CLASSIFIERS_ARE_EXPERIMENTAL_WARNING!>actual<!> class Clazz {
+    <!EXPECT_ACTUAL_CLASSIFIERS_ARE_EXPERIMENTAL_WARNING!>actual<!> class Nested
+
+    actual fun memberFun() {}
+    actual val memberProp: Clazz = null!!
+}
+
+<!EXPECT_ACTUAL_CLASSIFIERS_ARE_EXPERIMENTAL_WARNING!>actual<!> interface Interface
+
+<!EXPECT_ACTUAL_CLASSIFIERS_ARE_EXPERIMENTAL_WARNING!>actual<!> object Object
+
+<!EXPECT_ACTUAL_CLASSIFIERS_ARE_EXPERIMENTAL_WARNING!>actual<!> annotation class Annotation
+
+<!EXPECT_ACTUAL_CLASSIFIERS_ARE_EXPERIMENTAL_WARNING!>actual<!> enum class Enum
+
+<!EXPECT_ACTUAL_CLASSIFIERS_ARE_EXPERIMENTAL_WARNING!>actual<!> typealias ActualTypealias = ActualTypealiasImpl
+
+class ActualTypealiasImpl
+
+actual fun function() {}
+
+actual val property: Clazz = null!!

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

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

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() {
+^

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

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

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

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

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

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) {
+^

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) {
+^

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

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

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() {
+^

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<A>
+^
+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<B : C2<B>>
+^
+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<D, E : MutableList<in D>>
+^
+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<F> : MutableList<F>
+^
 
 -- JVM --
 Exit code: COMPILATION_ERROR

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

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

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

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<A> {
+^
 
 -- 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<A> {
+^
+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<A> = C1Impl<A>
+^
 compiler/testData/multiplatform/implTypeAlias/generic/jvm.kt:3:13: warning: parameter 'a' is never used
     fun foo(a: A): List<A>? = null
             ^
-

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
+^

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<A>
+^
+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<B>
+^
+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<D, E : D>
+^
+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<F>
+^
+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

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

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

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)
        ^

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
+^

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

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()
+^

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

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 {
+^

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

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 {

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",

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
 }

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
 }

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
 }

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

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",

repo/gradle-build-conventions/buildsrc-compat/src/main/kotlin/wasm/wasmKotlinTest.kt

@@ -85,6 +85,7 @@ fun Project.configureWasmKotlinTest(
     tasks.withType<KotlinCompile<*>>().configureEach {
         kotlinOptions.freeCompilerArgs += listOf(
             "-Xallow-kotlin-package",
+            "-Xexpect-actual-classes",
             "-opt-in=kotlin.ExperimentalMultiplatform",
             "-opt-in=kotlin.contracts.ExperimentalContracts",
             "-Xwasm-target=$wasmTargetParameter"

repo/gradle-build-conventions/buildsrc-compat/src/main/kotlin/wasm/wasmStdLib.kt

@@ -146,6 +146,7 @@ fun Project.configureWasmStdLib(
     tasks.withType<KotlinCompile<*>>().configureEach {
         kotlinOptions.freeCompilerArgs += listOf(
             "-Xallow-kotlin-package",
+            "-Xexpect-actual-classes",
             "-opt-in=kotlin.ExperimentalMultiplatform",
             "-opt-in=kotlin.contracts.ExperimentalContracts",
             "-opt-in=kotlin.RequiresOptIn",