[FIR] Use FirDefaultOverridesBackwardCompatibilityHelper with common metadata compilation

Also, use it with JS compilation ^KT-57735 Fixed
2023-04-06 20:08:56 +02:00
parent 4969a0e4f6
commit 9a5cc39588
19 changed files with 201 additions and 106 deletions
@@ -54,6 +54,12 @@ public class FirLightTreeOldFrontendNativeDiagnosticsTestGenerated extends Abstr
        runTest("compiler/testData/diagnostics/nativeTests/objCRefinement.kt");
    }

+    @Test
+    @TestMetadata("overridesMemberWithPlatformDependent.kt")
+    public void testOverridesMemberWithPlatformDependent() throws Exception {
+        runTest("compiler/testData/diagnostics/nativeTests/overridesMemberWithPlatformDependent.kt");
+    }
+
    @Test
    @TestMetadata("sharedImmutable.kt")
    public void testSharedImmutable() throws Exception {
@@ -54,6 +54,12 @@ public class FirPsiOldFrontendNativeDiagnosticsTestGenerated extends AbstractFir
        runTest("compiler/testData/diagnostics/nativeTests/objCRefinement.kt");
    }

+    @Test
+    @TestMetadata("overridesMemberWithPlatformDependent.kt")
+    public void testOverridesMemberWithPlatformDependent() throws Exception {
+        runTest("compiler/testData/diagnostics/nativeTests/overridesMemberWithPlatformDependent.kt");
+    }
+
    @Test
    @TestMetadata("sharedImmutable.kt")
    public void testSharedImmutable() throws Exception {
@@ -7,91 +7,24 @@ package org.jetbrains.kotlin.fir.analysis.jvm

 import org.jetbrains.kotlin.builtins.jvm.JavaToKotlinClassMap
 import org.jetbrains.kotlin.fir.analysis.FirOverridesBackwardCompatibilityHelper
-import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
-import org.jetbrains.kotlin.fir.analysis.checkers.unsubstitutedScope
 import org.jetbrains.kotlin.fir.containingClassLookupTag
-import org.jetbrains.kotlin.fir.declarations.FirProperty
-import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
-import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
+import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration
 import org.jetbrains.kotlin.fir.declarations.isJavaOrEnhancement
-import org.jetbrains.kotlin.fir.declarations.utils.isAbstract
-import org.jetbrains.kotlin.fir.declarations.utils.isFinal
-import org.jetbrains.kotlin.fir.declarations.utils.isInterface
-import org.jetbrains.kotlin.fir.dispatchReceiverClassTypeOrNull
-import org.jetbrains.kotlin.fir.originalOrSelf
-import org.jetbrains.kotlin.fir.resolve.toFirRegularClassSymbol
-import org.jetbrains.kotlin.fir.scopes.getDirectOverriddenFunctions
-import org.jetbrains.kotlin.fir.scopes.getDirectOverriddenProperties
-import org.jetbrains.kotlin.fir.symbols.SymbolInternals
-import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase
-import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
-import org.jetbrains.kotlin.fir.types.ConeClassLikeType
-import org.jetbrains.kotlin.fir.types.classId
-import org.jetbrains.kotlin.fir.types.coneTypeSafe
-import org.jetbrains.kotlin.fir.types.toRegularClassSymbol
-import org.jetbrains.kotlin.name.ClassId

 /**
- * Helper that determines if `override` keyword can be omitted for certain overrides. In general it can be omitted if
- *
- * 1. the super member is annotated with `@kotlin.internal.PlatformDependent`, OR
- * 2. the super member is declared in a Java class that has special Kotlin class mapping. For example, overriding members of
+ * With JVM compilation
+ * `override` keyword can be omitted if the super member is declared in a Java class that has a special Kotlin class mapping.
+ * For example, overriding members of
 *    `kotlin.Throwable` does not require `override` keyword.
- *
- * Note that, in case of multi-override, if any super member requires `override`, then the `override` keyword cannot be omitted.
 */
-object FirJvmOverridesBackwardCompatibilityHelper : FirOverridesBackwardCompatibilityHelper {
-    private val platformDependentAnnotation = ClassId.fromString("kotlin/internal/PlatformDependent")
-
-    override fun overrideCanBeOmitted(
-        overriddenMemberSymbols: List<FirCallableSymbol<*>>,
-        context: CheckerContext
-    ): Boolean {
-        // Members could share the same common interface up in the hierarchy. Hence we track the visited members to avoid redundant work.
-        val visitedSymbols = hashSetOf<FirCallableSymbol<*>>()
-        return overriddenMemberSymbols.all { isPlatformSpecificSymbolThatCanBeImplicitlyOverridden(it, visitedSymbols, context) }
-    }
-
-    private fun isPlatformSpecificSymbolThatCanBeImplicitlyOverridden(
-        symbol: FirCallableSymbol<*>,
-        visitedSymbols: MutableSet<FirCallableSymbol<*>>,
-        context: CheckerContext
-    ): Boolean {
-        if (symbol.isFinal) return false
-
-        if (symbol in visitedSymbols) return true
-        visitedSymbols += symbol
-
-        val originalMemberSymbol = symbol.originalOrSelf()
-        originalMemberSymbol.lazyResolveToPhase(FirResolvePhase.BODY_RESOLVE)
-        @OptIn(SymbolInternals::class)
-        val originalMember = originalMemberSymbol.fir
-        if (originalMember.annotations.any { it.annotationTypeRef.coneTypeSafe<ConeClassLikeType>()?.classId == platformDependentAnnotation }) {
-            return true
-        }
-
-        if (!originalMember.isJavaOrEnhancement) return false
-        val containingClassName = originalMember.containingClassLookupTag()?.classId?.asSingleFqName()?.toUnsafe() ?: return false
+object FirJvmOverridesBackwardCompatibilityHelper : FirOverridesBackwardCompatibilityHelper() {
+    override fun additionalCheck(member: FirCallableDeclaration): Boolean? {
+        if (!member.isJavaOrEnhancement) return false
+        val containingClassName = member.containingClassLookupTag()?.classId?.asSingleFqName()?.toUnsafe() ?: return false
        // If the super class is mapped to a Kotlin built-in class, then we don't require `override` keyword.
        if (JavaToKotlinClassMap.mapKotlinToJava(containingClassName) != null) {
            return true
        }
-
-        if (!originalMember.isAbstract) {
-            val containingClass = originalMember.containingClassLookupTag()?.toFirRegularClassSymbol(context.session)
-            if (containingClass?.isInterface == false) {
-                return false
-            }
-        }
-
-        val scope =
-            symbol.dispatchReceiverClassTypeOrNull()?.toRegularClassSymbol(context.session)?.unsubstitutedScope(context) ?: return false
-        val overriddenSymbols = when (originalMember) {
-            is FirSimpleFunction -> scope.getDirectOverriddenFunctions(originalMember.symbol)
-            is FirProperty -> scope.getDirectOverriddenProperties(originalMember.symbol)
-            else -> return false
-        }
-        if (overriddenSymbols.isEmpty()) return false
-        return overriddenSymbols.all { isPlatformSpecificSymbolThatCanBeImplicitlyOverridden(it, visitedSymbols, context) }
+        return null
    }
 }
@@ -0,0 +1,8 @@
+/*
+ * 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
+
+object FirDefaultOverridesBackwardCompatibilityHelper : FirOverridesBackwardCompatibilityHelper()
@@ -0,0 +1,13 @@
+/*
+ * 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
+
+import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
+import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
+
+object FirEmptyOverridesBackwardCompatibilityHelper : FirOverridesBackwardCompatibilityHelper() {
+    override fun overrideCanBeOmitted(overriddenMemberSymbols: List<FirCallableSymbol<*>>, context: CheckerContext): Boolean = false
+}
@@ -5,17 +5,82 @@

 package org.jetbrains.kotlin.fir.analysis

-import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.FirSessionComponent
+import org.jetbrains.kotlin.fir.*
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
+import org.jetbrains.kotlin.fir.analysis.checkers.unsubstitutedScope
+import org.jetbrains.kotlin.fir.declarations.*
+import org.jetbrains.kotlin.fir.declarations.utils.isAbstract
+import org.jetbrains.kotlin.fir.declarations.utils.isFinal
+import org.jetbrains.kotlin.fir.declarations.utils.isInterface
+import org.jetbrains.kotlin.fir.resolve.toFirRegularClassSymbol
+import org.jetbrains.kotlin.fir.scopes.getDirectOverriddenFunctions
+import org.jetbrains.kotlin.fir.scopes.getDirectOverriddenProperties
+import org.jetbrains.kotlin.fir.symbols.SymbolInternals
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
+import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase
+import org.jetbrains.kotlin.fir.types.toRegularClassSymbol
+import org.jetbrains.kotlin.name.ClassId

-interface FirOverridesBackwardCompatibilityHelper : FirSessionComponent {
-    fun overrideCanBeOmitted(overriddenMemberSymbols: List<FirCallableSymbol<*>>, context: CheckerContext): Boolean
+/**
+ * Helper that determines if `override` keyword can be omitted for certain overrides.
+ * In general, it can be omitted if
+ *
+ * 1. the super member is annotated with `@kotlin.internal.PlatformDependent`, OR
+ * 2. the additionalCheck returns not null result.
+ *    This check can be implemented in subclass
+ *
+ * Note that, in case of multi-override, if any super member requires `override`, then the `override` keyword cannot be omitted.
+ */
+abstract class FirOverridesBackwardCompatibilityHelper : FirSessionComponent {
+    private val platformDependentAnnotation = ClassId.fromString("kotlin/internal/PlatformDependent")

-    class Default : FirOverridesBackwardCompatibilityHelper {
-        override fun overrideCanBeOmitted(overriddenMemberSymbols: List<FirCallableSymbol<*>>, context: CheckerContext): Boolean = false
+    open fun overrideCanBeOmitted(
+        overriddenMemberSymbols: List<FirCallableSymbol<*>>,
+        context: CheckerContext
+    ): Boolean {
+        // Members could share the same common interface up in the hierarchy. Hence, we track the visited members to avoid redundant work.
+        val visitedSymbols = hashSetOf<FirCallableSymbol<*>>()
+        return overriddenMemberSymbols.all { isPlatformSpecificSymbolThatCanBeImplicitlyOverridden(it, visitedSymbols, context) }
    }
+
+    private fun isPlatformSpecificSymbolThatCanBeImplicitlyOverridden(
+        symbol: FirCallableSymbol<*>,
+        visitedSymbols: MutableSet<FirCallableSymbol<*>>,
+        context: CheckerContext
+    ): Boolean {
+        if (symbol.isFinal) return false
+
+        if (!visitedSymbols.add(symbol)) return true
+
+        val originalMemberSymbol = symbol.originalOrSelf()
+        originalMemberSymbol.lazyResolveToPhase(FirResolvePhase.BODY_RESOLVE)
+        @OptIn(SymbolInternals::class)
+        val originalMember = originalMemberSymbol.fir
+        if (originalMember.hasAnnotation(platformDependentAnnotation, context.session)) {
+            return true
+        }
+
+        additionalCheck(originalMember)?.let { return it }
+
+        if (!originalMember.isAbstract) {
+            val containingClass = originalMember.containingClassLookupTag()?.toFirRegularClassSymbol(context.session)
+            if (containingClass?.isInterface == false) {
+                return false
+            }
+        }
+
+        val scope =
+            symbol.dispatchReceiverClassTypeOrNull()?.toRegularClassSymbol(context.session)?.unsubstitutedScope(context) ?: return false
+        val overriddenSymbols = when (originalMember) {
+            is FirSimpleFunction -> scope.getDirectOverriddenFunctions(originalMember.symbol)
+            is FirProperty -> scope.getDirectOverriddenProperties(originalMember.symbol)
+            else -> return false
+        }
+        if (overriddenSymbols.isEmpty()) return false
+        return overriddenSymbols.all { isPlatformSpecificSymbolThatCanBeImplicitlyOverridden(it, visitedSymbols, context) }
+    }
+
+    protected open fun additionalCheck(member: FirCallableDeclaration): Boolean? = null
 }

 val FirSession.overridesBackwardCompatibilityHelper: FirOverridesBackwardCompatibilityHelper by FirSession.sessionComponentAccessor()
@@ -9,18 +9,20 @@ import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.config.LanguageVersionSettingsImpl
 import org.jetbrains.kotlin.fir.FirModuleData
 import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.checkers.registerJsCheckers
-import org.jetbrains.kotlin.fir.checkers.registerJvmCheckers
-import org.jetbrains.kotlin.fir.checkers.registerNativeCheckers
+import org.jetbrains.kotlin.fir.FirVisibilityChecker
+import org.jetbrains.kotlin.fir.SessionConfiguration
+import org.jetbrains.kotlin.fir.analysis.FirDefaultOverridesBackwardCompatibilityHelper
+import org.jetbrains.kotlin.fir.analysis.FirOverridesBackwardCompatibilityHelper
 import org.jetbrains.kotlin.fir.declarations.FirDeclarationOrigin
 import org.jetbrains.kotlin.fir.deserialization.ModuleDataProvider
 import org.jetbrains.kotlin.fir.deserialization.SingleModuleDataProvider
 import org.jetbrains.kotlin.fir.extensions.FirExtensionRegistrar
 import org.jetbrains.kotlin.fir.java.FirProjectSessionProvider
+import org.jetbrains.kotlin.fir.resolve.calls.ConeCallConflictResolverFactory
 import org.jetbrains.kotlin.fir.resolve.providers.impl.FirBuiltinSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.providers.impl.FirCloneableSymbolProvider
 import org.jetbrains.kotlin.fir.scopes.FirKotlinScopeProvider
-import org.jetbrains.kotlin.fir.session.FirSessionFactoryHelper.registerDefaultExtraComponentsForModuleBased
+import org.jetbrains.kotlin.fir.scopes.FirPlatformClassMapper
 import org.jetbrains.kotlin.fir.session.environment.AbstractProjectEnvironment
 import org.jetbrains.kotlin.fir.session.environment.AbstractProjectFileSearchScope
 import org.jetbrains.kotlin.incremental.components.EnumWhenTracker
@@ -78,6 +80,7 @@ object FirCommonSessionFactory : FirAbstractSessionFactory() {
        )
    }

+    @OptIn(SessionConfiguration::class)
    fun createModuleBasedSession(
        moduleData: FirModuleData,
        sessionProvider: FirProjectSessionProvider,
@@ -99,7 +102,10 @@ object FirCommonSessionFactory : FirAbstractSessionFactory() {
            enumWhenTracker,
            init,
            registerExtraComponents = {
-                it.registerDefaultExtraComponentsForModuleBased()
+                it.register(FirVisibilityChecker::class, FirVisibilityChecker.Default)
+                it.register(ConeCallConflictResolverFactory::class, DefaultCallConflictResolverFactory)
+                it.register(FirPlatformClassMapper::class, FirPlatformClassMapper.Default)
+                it.register(FirOverridesBackwardCompatibilityHelper::class, FirDefaultOverridesBackwardCompatibilityHelper)
                registerExtraComponents(it)
            },
            registerExtraCheckers = {},
@@ -11,6 +11,7 @@ import org.jetbrains.kotlin.fir.FirModuleData
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.FirVisibilityChecker
 import org.jetbrains.kotlin.fir.SessionConfiguration
+import org.jetbrains.kotlin.fir.analysis.FirEmptyOverridesBackwardCompatibilityHelper
 import org.jetbrains.kotlin.fir.analysis.FirOverridesBackwardCompatibilityHelper
 import org.jetbrains.kotlin.fir.analysis.checkers.FirPlatformDiagnosticSuppressor
 import org.jetbrains.kotlin.fir.analysis.js.checkers.FirJsPlatformDiagnosticSuppressor
@@ -98,7 +99,7 @@ object FirJsSessionFactory : FirAbstractSessionFactory() {
        register(FirVisibilityChecker::class, FirVisibilityChecker.Default)
        register(ConeCallConflictResolverFactory::class, JsCallConflictResolverFactory)
        register(FirPlatformClassMapper::class, FirPlatformClassMapper.Default)
-        register(FirOverridesBackwardCompatibilityHelper::class, FirOverridesBackwardCompatibilityHelper.Default())
+        register(FirOverridesBackwardCompatibilityHelper::class, FirEmptyOverridesBackwardCompatibilityHelper)
        register(FirPlatformDiagnosticSuppressor::class, FirJsPlatformDiagnosticSuppressor())
    }
 }
@@ -6,18 +6,19 @@
 package org.jetbrains.kotlin.fir.session

 import org.jetbrains.kotlin.config.LanguageVersionSettings
-import org.jetbrains.kotlin.fir.BinaryModuleData
-import org.jetbrains.kotlin.fir.FirModuleData
-import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.*
+import org.jetbrains.kotlin.fir.analysis.FirEmptyOverridesBackwardCompatibilityHelper
+import org.jetbrains.kotlin.fir.analysis.FirOverridesBackwardCompatibilityHelper
 import org.jetbrains.kotlin.fir.checkers.registerNativeCheckers
 import org.jetbrains.kotlin.fir.deserialization.ModuleDataProvider
 import org.jetbrains.kotlin.fir.extensions.FirExtensionRegistrar
 import org.jetbrains.kotlin.fir.java.FirProjectSessionProvider
+import org.jetbrains.kotlin.fir.resolve.calls.ConeCallConflictResolverFactory
 import org.jetbrains.kotlin.fir.resolve.providers.impl.FirBuiltinSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.providers.impl.FirCloneableSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.providers.impl.FirExtensionSyntheticFunctionInterfaceProvider
 import org.jetbrains.kotlin.fir.scopes.FirKotlinScopeProvider
-import org.jetbrains.kotlin.fir.session.FirSessionFactoryHelper.registerDefaultExtraComponentsForModuleBased
+import org.jetbrains.kotlin.fir.scopes.FirPlatformClassMapper
 import org.jetbrains.kotlin.library.metadata.resolver.KotlinResolvedLibrary
 import org.jetbrains.kotlin.name.Name

@@ -59,6 +60,7 @@ object FirNativeSessionFactory : FirAbstractSessionFactory() {
            })
    }

+    @OptIn(SessionConfiguration::class)
    fun createModuleBasedSession(
        moduleData: FirModuleData,
        sessionProvider: FirProjectSessionProvider,
@@ -75,9 +77,12 @@ object FirNativeSessionFactory : FirAbstractSessionFactory() {
            null,
            null,
            init,
-            registerExtraComponents = { session ->
-                session.registerDefaultExtraComponentsForModuleBased()
-                registerExtraComponents(session)
+            registerExtraComponents = {
+                it.register(FirVisibilityChecker::class, FirVisibilityChecker.Default)
+                it.register(ConeCallConflictResolverFactory::class, DefaultCallConflictResolverFactory)
+                it.register(FirPlatformClassMapper::class, FirPlatformClassMapper.Default)
+                it.register(FirOverridesBackwardCompatibilityHelper::class, FirEmptyOverridesBackwardCompatibilityHelper)
+                registerExtraComponents(it)
            },
            registerExtraCheckers = { it.registerNativeCheckers() },
            createKotlinScopeProvider = { FirKotlinScopeProvider { _, declaredMemberScope, _, _, _ -> declaredMemberScope } },
@@ -8,11 +8,8 @@ package org.jetbrains.kotlin.fir.session
 import org.jetbrains.annotations.TestOnly
 import org.jetbrains.kotlin.config.*
 import org.jetbrains.kotlin.fir.*
-import org.jetbrains.kotlin.fir.analysis.FirOverridesBackwardCompatibilityHelper
 import org.jetbrains.kotlin.fir.extensions.FirExtensionRegistrar
 import org.jetbrains.kotlin.fir.java.FirProjectSessionProvider
-import org.jetbrains.kotlin.fir.resolve.calls.ConeCallConflictResolverFactory
-import org.jetbrains.kotlin.fir.scopes.FirPlatformClassMapper
 import org.jetbrains.kotlin.fir.session.environment.AbstractProjectEnvironment
 import org.jetbrains.kotlin.fir.session.environment.AbstractProjectFileSearchScope
 import org.jetbrains.kotlin.incremental.components.EnumWhenTracker
@@ -120,12 +117,4 @@ object FirSessionFactoryHelper {
            ))
        }
    }
-
-    @OptIn(SessionConfiguration::class)
-    fun FirSession.registerDefaultExtraComponentsForModuleBased() {
-        register(FirVisibilityChecker::class, FirVisibilityChecker.Default)
-        register(ConeCallConflictResolverFactory::class, DefaultCallConflictResolverFactory)
-        register(FirPlatformClassMapper::class, FirPlatformClassMapper.Default)
-        register(FirOverridesBackwardCompatibilityHelper::class, FirOverridesBackwardCompatibilityHelper.Default())
-    }
 }
@@ -0,0 +1,5 @@
+$TESTDATA_DIR$/noVirtualFileHiddenForMemberWithPlatformDependentAnnotation.kt
+-d
+$TEMP_DIR$
+-language-version
+2.0
@@ -0,0 +1,5 @@
+expect abstract class ConcurrentMap<Key, Value>(
+    initialCapacity: Int = 32
+) : MutableMap<Key, Value> {
+    fun remove(key: Key, value: Value): Boolean
+}
@@ -0,0 +1,2 @@
+warning: language version 2.0 is experimental, there are no backwards compatibility guarantees for new language and library features
+OK
@@ -0,0 +1,14 @@
+// FIR_IDENTICAL
+// ISSUE: KT-57858
+@file:Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
+
+import kotlin.internal.PlatformDependent
+
+interface I {
+    @PlatformDependent
+    fun f() {}
+}
+
+class C : I {
+    fun <!VIRTUAL_MEMBER_HIDDEN!>f<!>() {}
+}
@@ -0,0 +1,14 @@
+// FIR_IDENTICAL
+// ISSUE: KT-57858
+@file:Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
+
+import kotlin.internal.PlatformDependent
+
+interface I {
+    @PlatformDependent
+    fun f() {}
+}
+
+class C : I {
+    fun <!VIRTUAL_MEMBER_HIDDEN!>f<!>() {}
+}
@@ -54,6 +54,12 @@ public class DiagnosticsNativeTestGenerated extends AbstractDiagnosticsNativeTes
        runTest("compiler/testData/diagnostics/nativeTests/objCRefinement.kt");
    }

+    @Test
+    @TestMetadata("overridesMemberWithPlatformDependent.kt")
+    public void testOverridesMemberWithPlatformDependent() throws Exception {
+        runTest("compiler/testData/diagnostics/nativeTests/overridesMemberWithPlatformDependent.kt");
+    }
+
    @Test
    @TestMetadata("sharedImmutable.kt")
    public void testSharedImmutable() throws Exception {
@@ -60,6 +60,12 @@ public class DiagnosticsTestWithJsStdLibGenerated extends AbstractDiagnosticsTes
        runTest("compiler/testData/diagnostics/testsWithJsStdLib/noImpl.kt");
    }

+    @Test
+    @TestMetadata("overridesMemberWithPlatformDependent.kt")
+    public void testOverridesMemberWithPlatformDependent() throws Exception {
+        runTest("compiler/testData/diagnostics/testsWithJsStdLib/overridesMemberWithPlatformDependent.kt");
+    }
+
    @Test
    @TestMetadata("platformDependent.kt")
    public void testPlatformDependent() throws Exception {
@@ -1639,6 +1639,11 @@ public class CliTestGenerated extends AbstractCliTest {
            runTest("compiler/testData/cli/metadata/moduleNameWithFir.args");
        }

+        @TestMetadata("noVirtualFileHiddenForMemberWithPlatformDependentAnnotation.args")
+        public void testNoVirtualFileHiddenForMemberWithPlatformDependentAnnotation() throws Exception {
+            runTest("compiler/testData/cli/metadata/noVirtualFileHiddenForMemberWithPlatformDependentAnnotation.args");
+        }
+
        @TestMetadata("optionalAnnotationsFromMetadata.args")
        public void testOptionalAnnotationsFromMetadata() throws Exception {
            runTest("compiler/testData/cli/metadata/optionalAnnotationsFromMetadata.args");
@@ -61,6 +61,12 @@ public class FirPsiJsOldFrontendDiagnosticsTestGenerated extends AbstractFirPsiJ
        runTest("compiler/testData/diagnostics/testsWithJsStdLib/noImpl.kt");
    }

+    @Test
+    @TestMetadata("overridesMemberWithPlatformDependent.kt")
+    public void testOverridesMemberWithPlatformDependent() throws Exception {
+        runTest("compiler/testData/diagnostics/testsWithJsStdLib/overridesMemberWithPlatformDependent.kt");
+    }
+
    @Test
    @TestMetadata("platformDependent.kt")
    public void testPlatformDependent() throws Exception {