Address comment in the emitters.

sjrd · sjrd · commit ffd3e3c8a6d7 · 2025-03-03T17:32:11.000+01:00
diff --git a/linker/shared/src/main/scala/org/scalajs/linker/backend/emitter/FunctionEmitter.scala b/linker/shared/src/main/scala/org/scalajs/linker/backend/emitter/FunctionEmitter.scala
@@ -2352,11 +2352,14 @@ private[emitter] class FunctionEmitter(sjsGen: SJSGen) {
         case ApplyTypedClosure(_, fun, args) =>
           val newFun = transformExprNoChar(checkNotNull(fun))
           val newArgs = fun.tpe match {
-            case ClosureType(paramTypes, resultType, _) =>
+            case ClosureType(paramTypes, _, _) =>
               for ((arg, paramType) <- args.zip(paramTypes)) yield
                 transformExpr(arg, paramType)
-            case _ =>
+            case NothingType | NullType =>
               args.map(transformExpr(_, preserveChar = true))
+            case _ =>
+              throw new AssertionError(
+                  s"Unexpected type for the fun of ApplyTypedClosure: ${fun.tpe}")
           }
           js.Apply.makeProtected(newFun, newArgs)
 
diff --git a/linker/shared/src/main/scala/org/scalajs/linker/backend/wasmemitter/FunctionEmitter.scala b/linker/shared/src/main/scala/org/scalajs/linker/backend/wasmemitter/FunctionEmitter.scala
@@ -74,24 +74,21 @@ object FunctionEmitter {
       functionID: wanme.FunctionID,
       originalName: OriginalName,
       funTypeID: wanme.TypeID,
-      enclosingClassName: Option[ClassName],
-      captureParamDefs: Option[List[ParamDef]],
-      receiverType: Option[watpe.Type],
+      captureParamDefs: List[ParamDef],
       paramDefs: List[ParamDef],
-      restParam: Option[ParamDef],
       body: Tree,
       resultType: Type
   )(implicit ctx: WasmContext, pos: Position): Unit = {
     val emitter = prepareEmitter(
       functionID,
       originalName,
-      enclosingClassName,
-      captureParamDefs,
+      enclosingClassName = None,
+      Some(captureParamDefs),
       captureDataAsRefStruct = true,
       preSuperVarDefs = None,
       hasNewTarget = false,
-      receiverType,
-      paramDefs ::: restParam.toList,
+      receiverType = None,
+      paramDefs,
       transformResultType(resultType)
     )
     emitter.fb.setFunctionType(funTypeID)
@@ -1309,11 +1306,10 @@ private class FunctionEmitter private (
         NothingType
 
       case closureType @ ClosureType(paramTypes, resultType, _) =>
-        genTreeAuto(tree.fun)
-
         val (funTypeID, typedClosureTypeID) = ctx.genTypedClosureStructType(closureType)
         val funLocal = addSyntheticLocal(watpe.RefType(typedClosureTypeID))
 
+        genTreeAuto(tree.fun)
         genAsNonNullOrNPEFor(tree.fun)
         fb += wa.LocalTee(funLocal)
         fb += wa.StructGet(typedClosureTypeID, genFieldID.typedClosure.data)
@@ -3156,11 +3152,8 @@ private class FunctionEmitter private (
       closureFuncID,
       closureFuncOrigName,
       funTypeID,
-      enclosingClassName = None,
-      Some(tree.captureParams),
-      receiverType = None,
+      tree.captureParams,
       tree.params,
-      restParam = None,
       tree.body,
       tree.resultType
     )
diff --git a/linker/shared/src/main/scala/org/scalajs/linker/backend/wasmemitter/TypeTransformer.scala b/linker/shared/src/main/scala/org/scalajs/linker/backend/wasmemitter/TypeTransformer.scala
@@ -95,7 +95,8 @@ object TypeTransformer {
         watpe.RefType(nullable, genTypeID.forArrayClass(arrayTypeRef))
 
       case tpe @ ClosureType(_, _, nullable) =>
-        watpe.RefType(nullable, ctx.genTypedClosureStructType(tpe)._2)
+        val (_, typedClosureTypeID) = ctx.genTypedClosureStructType(tpe)
+        watpe.RefType(nullable, typedClosureTypeID)
 
       case RecordType(fields) =>
         throw new AssertionError(s"Unexpected record type $tpe")
diff --git a/linker/shared/src/main/scala/org/scalajs/linker/backend/wasmemitter/WasmContext.scala b/linker/shared/src/main/scala/org/scalajs/linker/backend/wasmemitter/WasmContext.scala
@@ -181,19 +181,29 @@ final class WasmContext(
     )
   }
 
+  /** Generates the struct type for a `ClosureType`.
+   *
+   *  @return
+   *    `(funTypeID, structTypeID)`, where `funTypeID` is the function type of
+   *    the `ref.func`s, and `structTypeID` is the struct type that contains
+   *    the capture data and the `ref.func` (i.e., the actual Wasm type of
+   *    values of the given `ClosureType`).
+   */
   def genTypedClosureStructType(tpe0: ClosureType): (wanme.TypeID, wanme.TypeID) = {
     // Normalize to the non-nullable variant
     val tpe = tpe0.toNonNullable
 
     typedClosureTypes.getOrElseUpdate(tpe, {
       implicit val ctx = this
 
+      val tpeNameString = tpe.show()
+
       val funType = watpe.FunctionType(
         watpe.RefType.struct :: tpe.paramTypes.map(TypeTransformer.transformParamType(_)),
         TypeTransformer.transformResultType(tpe.resultType)
       )
       val funTypeID = genTypeID.forClosureFunType(tpe)
-      mainRecType.addSubType(funTypeID, OriginalName("fun" + tpe.show()), funType)
+      mainRecType.addSubType(funTypeID, OriginalName("fun" + tpeNameString), funType)
 
       val fields: List[watpe.StructField] = List(
         watpe.StructField(
@@ -212,7 +222,7 @@ final class WasmContext(
 
       val structTypeID = genTypeID.forClosureType(tpe)
       val structType = watpe.StructType(fields)
-      mainRecType.addSubType(structTypeID, OriginalName(tpe.show()), structType)
+      mainRecType.addSubType(structTypeID, OriginalName(tpeNameString), structType)
 
       (funTypeID, structTypeID)
     })
