[K/JS] Fix exporting interfaces with companions to ES modules

^KT-79926 Fixed

Author: JSMonk

compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/tsexport/ExportModelGenerator.kt

@@ -337,15 +337,12 @@ class ExportModelGenerator(val context: JsIrBackendContext, val generateNamespac
                     members.addIfNotNull(exportProperty(candidate)?.withAttributesFor(candidate))
 
                 is IrClass -> {
-                    if (klass.isInterface) {
-                        nestedClasses.addIfNotNull(klass.companionObject()?.let { exportClass(it) as? ExportedClass }?.withAttributesFor(candidate))
+                    if (klass.isInterface && !candidate.isCompanion) continue
+                    val ec = exportClass(candidate)?.withAttributesFor(candidate)
+                    if (ec is ExportedClass) {
+                        nestedClasses.add(ec)
                     } else {
-                        val ec = exportClass(candidate)?.withAttributesFor(candidate)
-                        if (ec is ExportedClass) {
-                            nestedClasses.add(ec)
-                        } else {
-                            members.addIfNotNull(ec)
-                        }
+                        members.addIfNotNull(ec)
                     }
                 }
 

compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/tsexport/ExportModelToTsDeclarations.kt

@@ -192,8 +192,7 @@ class ExportModelToTsDeclarations(private val moduleKind: ModuleKind) {
     }
 
     private fun ExportedObject.generateTypeScriptString(indent: String, prefix: String): String {
-        val shouldGenerateObjectWithGetInstance = isEsModules && !isExternal && !(isInsideInterface && isCompanion)
-
+        val shouldGenerateObjectWithGetInstance = isEsModules && !isExternal
         val constructorTypeReference =
             if (shouldGenerateObjectWithGetInstance) MetadataConstructor else "$name.$Metadata.$MetadataConstructor"
 

js/js.translator/testData/typescript-export/js/module-systems-in-exported-file/esm.d.ts

@@ -6,7 +6,8 @@ export declare interface KtList<E> /* extends Collection<E> */ {
         readonly "kotlin.collections.KtList": unique symbol;
     };
 }
-export declare abstract class KtList<E> extends KtSingleton<KtList.$metadata$.constructor>() {
+export declare abstract class KtList<E> {
+    static readonly getInstance: () => typeof KtList.$metadata$.type;
     private constructor();
 }
 export declare namespace KtList {
@@ -16,6 +17,9 @@ export declare namespace KtList {
             fromJsArray<E>(array: ReadonlyArray<E>): KtList<E>;
             private constructor();
         }
+        abstract class type<E> extends KtSingleton<constructor>() {
+            private constructor();
+        }
     }
 }
 export declare const value: { get(): number; };
@@ -80,11 +84,15 @@ export declare interface AnInterfaceWithCompanion {
         readonly "foo.AnInterfaceWithCompanion": unique symbol;
     };
 }
-export declare abstract class AnInterfaceWithCompanion extends KtSingleton<AnInterfaceWithCompanion.$metadata$.constructor>() {
+export declare abstract class AnInterfaceWithCompanion {
+    static readonly getInstance: () => typeof AnInterfaceWithCompanion.$metadata$.type;
     private constructor();
 }
 /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
 export declare namespace AnInterfaceWithCompanion.$metadata$ {
+    abstract class type extends KtSingleton<constructor>() {
+        private constructor();
+    }
     abstract class constructor {
         get someValue(): string;
         private constructor();

js/js.translator/testData/typescript-export/js/module-systems/esm.d.ts

@@ -6,7 +6,8 @@ export declare interface KtList<E> /* extends Collection<E> */ {
         readonly "kotlin.collections.KtList": unique symbol;
     };
 }
-export declare abstract class KtList<E> extends KtSingleton<KtList.$metadata$.constructor>() {
+export declare abstract class KtList<E> {
+    static readonly getInstance: () => typeof KtList.$metadata$.type;
     private constructor();
 }
 export declare namespace KtList {
@@ -16,6 +17,9 @@ export declare namespace KtList {
             fromJsArray<E>(array: ReadonlyArray<E>): KtList<E>;
             private constructor();
         }
+        abstract class type<E> extends KtSingleton<constructor>() {
+            private constructor();
+        }
     }
 }
 export declare const value: { get(): number; };
@@ -80,11 +84,15 @@ export declare interface AnInterfaceWithCompanion {
         readonly "foo.AnInterfaceWithCompanion": unique symbol;
     };
 }
-export declare abstract class AnInterfaceWithCompanion extends KtSingleton<AnInterfaceWithCompanion.$metadata$.constructor>() {
+export declare abstract class AnInterfaceWithCompanion {
+    static readonly getInstance: () => typeof AnInterfaceWithCompanion.$metadata$.type;
     private constructor();
 }
 /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
 export declare namespace AnInterfaceWithCompanion.$metadata$ {
+    abstract class type extends KtSingleton<constructor>() {
+        private constructor();
+    }
     abstract class constructor {
         get someValue(): string;
         private constructor();