[JS] Allow exporting parameter names in function types in .d.ts files

Actually exporting those names will be implemented in the next commit.

Author: broadwaylamb

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

@@ -648,7 +648,12 @@ class ExportModelGenerator(val context: JsIrBackendContext, val generateNamespac
             nonNullType.isArray() -> ExportedType.Array(exportTypeArgument(nonNullType.arguments[0], typeOwner))
             nonNullType.isSuspendFunction() -> ExportedType.ErrorType("Suspend functions are not supported")
             nonNullType.isFunction() -> ExportedType.Function(
-                parameterTypes = nonNullType.arguments.dropLast(1).memoryOptimizedMap { exportTypeArgument(it, typeOwner) },
+                parameters = nonNullType.arguments.dropLast(1).memoryOptimizedMap {
+                    ExportedParameter(
+                        name = null,
+                        type = exportTypeArgument(it, typeOwner),
+                    )
+                },
                 returnType = exportTypeArgument(nonNullType.arguments.last(), typeOwner)
             )
 

compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/export/ExportModelGenerator.kt

@@ -204,7 +204,12 @@ class ExportModelGenerator(val context: WasmBackendContext) {
             nonNullType == jsRelatedSymbols.jsAnyType -> ExportedType.Primitive.Unknown
             nonNullType.isUnit() || nonNullType == context.wasmSymbols.voidType -> ExportedType.Primitive.Unit
             nonNullType.isFunction() -> ExportedType.Function(
-                parameterTypes = nonNullType.arguments.dropLast(1).memoryOptimizedMap { exportTypeArgument(it) },
+                parameters = nonNullType.arguments.dropLast(1).memoryOptimizedMap {
+                    ExportedParameter(
+                        name = null,
+                        type = exportTypeArgument(it),
+                    )
+                },
                 returnType = exportTypeArgument(nonNullType.arguments.last())
             )
             nonNullType.isNothing() -> ExportedType.Primitive.Nothing

js/typescript-export-model/src/org/jetbrains/kotlin/ir/backend/js/tsexport/ExportModel.kt

@@ -119,7 +119,7 @@ public data class ExportedObject(
 ) : ExportedClass()
 
 public class ExportedParameter(
-    public val name: String,
+    public val name: String?,
     public val type: ExportedType,
     public val hasDefaultValue: Boolean = false
 )
@@ -162,7 +162,7 @@ public sealed class ExportedType {
     }
 
     public class Function(
-        public val parameterTypes: List<ExportedType>,
+        public val parameters: List<ExportedParameter>,
         public val returnType: ExportedType
     ) : ExportedType()
 

js/typescript-export-standalone/src/org/jetbrains/kotlin/js/tsexport/TypeExporter.kt

@@ -16,6 +16,7 @@ import org.jetbrains.kotlin.analysis.api.symbols.KaClassKind
 import org.jetbrains.kotlin.analysis.api.symbols.KaNamedClassSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KaTypeAliasSymbol
 import org.jetbrains.kotlin.analysis.api.types.*
+import org.jetbrains.kotlin.ir.backend.js.tsexport.ExportedParameter
 import org.jetbrains.kotlin.ir.backend.js.tsexport.ExportedType
 import org.jetbrains.kotlin.ir.backend.js.tsexport.ExportedType.*
 import org.jetbrains.kotlin.ir.backend.js.tsexport.ExportedType.Array
@@ -97,10 +98,27 @@ internal class TypeExporter(private val config: TypeScriptExportConfig) {
                 ErrorType("Suspend function types are not supported")
             } else {
                 Function(
-                    parameterTypes = buildList {
-                        type.contextReceivers.mapTo(this) { exportType(it.type) }
-                        type.receiverType?.let { add(exportType(it)) }
-                        type.parameterTypes.mapTo(this) { exportType(it) }
+                    parameters = buildList {
+                        type.contextReceivers.mapTo(this) {
+                            ExportedParameter(
+                                name = null,
+                                type = exportType(it.type),
+                            )
+                        }
+                        type.receiverType?.let {
+                            add(
+                                ExportedParameter(
+                                    name = null,
+                                    type = exportType(it),
+                                )
+                            )
+                        }
+                        type.parameterTypes.mapTo(this) {
+                            ExportedParameter(
+                                name = null,
+                                type = exportType(it),
+                            )
+                        }
                     },
                     returnType = exportType(type.returnType),
                 )

js/typescript-printer/src/org/jetbrains/kotlin/ir/backend/js/tsexport/ExportModelToTsDeclarations.kt

@@ -469,15 +469,17 @@ public class ExportModelToTsDeclarations(private val moduleKind: ModuleKind) {
 
     private fun List<ExportedParameter>.generateTypeScriptString(indent: String): String {
         var couldBeOptional = true
-        val parameters = foldRight(mutableListOf<String>()) { it, acc ->
-            if (!it.hasDefaultValue) couldBeOptional = false
-            acc.apply { add(0, it.toTypeScript(indent, couldBeOptional)) }
-        }
-        return parameters.joinToString(", ")
+        return asReversed()
+            .mapIndexed { index, parameter ->
+                if (!parameter.hasDefaultValue) couldBeOptional = false
+                parameter.toTypeScript(indent, size - index - 1, couldBeOptional)
+            }
+            .asReversed()
+            .joinToString()
     }
 
-    private fun ExportedParameter.toTypeScript(indent: String, couldBeOptional: Boolean): String {
-        val name = makeValidES5Identifier(name, withHash = false)
+    private fun ExportedParameter.toTypeScript(indent: String, index: Int, couldBeOptional: Boolean): String {
+        val name = name?.let { makeValidES5Identifier(it, withHash = false) } ?: "p$index"
         val type = if (hasDefaultValue && !couldBeOptional) {
             ExportedType.UnionType(type, ExportedType.Primitive.Undefined)
         } else type
@@ -490,11 +492,8 @@ public class ExportModelToTsDeclarations(private val moduleKind: ModuleKind) {
         is ExportedType.Array -> "Array<${elementType.toTypeScript(indent, isInCommentContext)}>"
         is ExportedType.ObjectsParentType -> "$ObjectInheritanceIntrinsic<${constructor.toTypeScript(indent, isInCommentContext)}>()"
 
-        is ExportedType.Function -> "(" + parameterTypes
-            .withIndex()
-            .joinToString(", ") { (index, type) ->
-                "p$index: ${type.toTypeScript(indent, isInCommentContext)}"
-            } + ") => " + returnType.toTypeScript(indent, isInCommentContext)
+        is ExportedType.Function ->
+            "(" + parameters.generateTypeScriptString(indent) + ") => " + returnType.toTypeScript(indent, isInCommentContext)
 
         is ExportedType.ConstructorType ->
             "abstract new " + (if (typeParameters.isNotEmpty()) "<${