Wasm: Emit name subsections for locals, types and fields.

sjrd · sjrd · commit dbf84bc2ae99 · 2025-08-07T17:09:34.000+02:00
This completes the `name` custom section with everything that it
currently supports. It's worth noting that there is no provision
for storing the names of `global`s.
diff --git a/linker/shared/src/main/scala/org/scalajs/linker/backend/webassembly/BinaryWriter.scala b/linker/shared/src/main/scala/org/scalajs/linker/backend/webassembly/BinaryWriter.scala
@@ -268,8 +268,13 @@ private sealed class BinaryWriter(module: Module, emitDebugInfo: Boolean) {
   }
 
   private def writeNameCustomSection(): Unit = {
-    // Currently, we only emit the function names
+    writeFunctionNamesSubSection()
+    writeLocalNamesSubSection()
+    writeTypeNamesSubSection()
+    writeFieldNamesSubSection()
+  }
 
+  private def writeFunctionNamesSubSection(): Unit = {
     val importFunctionNames = module.imports.collect {
       case Import(_, _, ImportDesc.Func(id, origName, _)) if origName.isDefined =>
         id -> origName
@@ -287,6 +292,61 @@ private sealed class BinaryWriter(module: Module, emitDebugInfo: Boolean) {
     }
   }
 
+  private def writeLocalNamesSubSection(): Unit = {
+    buf.byte(0x02) // local names
+    buf.byteLengthSubSection {
+      /* For simplicity, we generate one group for every defined function,
+       * even if they don't declare any named local.
+       */
+      buf.vec(module.funcs) { func =>
+        writeFuncIdx(func.id)
+        val namedLocals =
+          (func.params ::: func.locals).zipWithIndex.filter(_._1.originalName.isDefined)
+        buf.vec(namedLocals) { localAndIndex =>
+          buf.u32(localAndIndex._2)
+          buf.name(localAndIndex._1.originalName.get)
+        }
+      }
+    }
+  }
+
+  private def writeTypeNamesSubSection(): Unit = {
+    buf.byte(0x04) // type names
+    buf.byteLengthSubSection {
+      val namedTypes = module.types.flatMap(_.subTypes.filter(_.originalName.isDefined))
+      buf.vec(namedTypes) { subType =>
+        writeTypeIdx(subType.id)
+        buf.name(subType.originalName.get)
+      }
+    }
+  }
+
+  private def writeFieldNamesSubSection(): Unit = {
+    buf.byte(0x0a) // field names
+    buf.byteLengthSubSection {
+      /* For simplicity, we generate one group for every struct type, even if
+       * they don't declare any named field.
+       */
+      val structSubTypes = for {
+        recType <- module.types
+        subType <- recType.subTypes
+        if subType.compositeType.isInstanceOf[StructType]
+      } yield {
+        subType
+      }
+
+      buf.vec(structSubTypes) { subType =>
+        writeTypeIdx(subType.id)
+        val namedFields = subType.compositeType.asInstanceOf[StructType].fields
+          .zipWithIndex.filter(_._1.originalName.isDefined)
+        buf.vec(namedFields) { fieldAndIndex =>
+          buf.u32(fieldAndIndex._2)
+          buf.name(fieldAndIndex._1.originalName.get)
+        }
+      }
+    }
+  }
+
   private def writeFunc(func: Function): Unit = {
     emitStartFuncPosition(func.pos)
 
diff --git a/linker/shared/src/main/scala/org/scalajs/linker/backend/webassembly/Modules.scala b/linker/shared/src/main/scala/org/scalajs/linker/backend/webassembly/Modules.scala
@@ -48,9 +48,10 @@ object Modules {
   /** A WebAssembly `func`, including names/types for parameters, locals and results.
    *
    *  @note
-   *    The `params`' types and the `results` are not strictly necessary, as
-   *    they can be derived from the `typeID` by resolving it to a function
-   *    type. The binary writer ignores them. They are used by the text writer.
+   *    From a semantic point of view, the `params`' types and the `results`
+   *    are not strictly necessary, as they can be derived from the `typeID` by
+   *    resolving it to a function type. The `params` are used to recover
+   *    original names. The text writer also uses the types, for simplicity.
    */
   final case class Function(
       id: FunctionID,
