Add wasm2wat function and CLI

Sources/CLI/CLI.swift

@@ -11,6 +11,7 @@ struct CLI: AsyncParsableCommand {
             Explore.self,
             Run.self,
             Wat2wasm.self,
+            Wasm2wat.self,
         ]
     )
 }

Sources/CLICommands/Wasm2wat.swift

@@ -0,0 +1,49 @@
+import ArgumentParser
+import SystemPackage
+import WAT
+import WasmParser
+
+package struct Wasm2wat: ParsableCommand {
+    package static let configuration = CommandConfiguration(
+        commandName: "wasm2wat",
+        abstract: "Disassemble a WebAssembly binary into WebAssembly text format"
+    )
+
+    @Argument(help: "Path to a WebAssembly binary (`.wasm`) file to disassemble.")
+    var path: String
+
+    @Option(
+        name: [.short, .long],
+        help: """
+            Path to the output WebAssembly Text Format (`.wat`) file.
+            If not provided, the text is written to standard output.
+            """
+    )
+    var output: String?
+
+    package init() {}
+
+    package func run() throws {
+        let filePath = FilePath(path)
+        let fileHandle = try FileDescriptor.open(filePath, .readOnly)
+        defer { try? fileHandle.close() }
+
+        let stream = try FileHandleStream(fileHandle: fileHandle)
+
+        let wat = try wasm2wat(stream)
+
+        if let outputPath = output {
+            let outPath = FilePath(outputPath)
+            let outHandle = try FileDescriptor.open(
+                outPath,
+                .writeOnly,
+                options: [.create, .truncate],
+                permissions: [.ownerReadWrite, .groupRead, .otherRead]
+            )
+            defer { try? outHandle.close() }
+            try outHandle.writeAll(Array(wat.utf8))
+        } else {
+            print(wat)
+        }
+    }
+}

Sources/WAT/TextFormat/ModuleCollector.swift

@@ -0,0 +1,100 @@
+import WasmParser
+import WasmTypes
+
+/// Collected information from all sections of a WebAssembly binary module.
+struct ModuleInfo {
+    var types: [FunctionType] = []
+    var imports: [Import] = []
+    /// Type indices from the function section (one per local function).
+    var functionTypeIndices: [TypeIndex] = []
+    var tables: [Table] = []
+    var memories: [Memory] = []
+    var globals: [Global] = []
+    var exports: [Export] = []
+    var start: FunctionIndex? = nil
+    var elements: [ElementSegment] = []
+    /// Code bodies for local functions (parallel to functionTypeIndices).
+    var codes: [Code] = []
+    var data: [DataSegment] = []
+    /// Function names from the `name` custom section (index → name).
+    var functionNames: [UInt32: String] = [:]
+    /// Local variable names from the `name` custom section
+    /// (function index → (local index → name)).
+    var localNames: [UInt32: [UInt32: String]] = [:]
+
+    /// Total number of functions (imports + local definitions).
+    var functionCount: Int {
+        let importedFunctions = imports.filter {
+            if case .function = $0.descriptor { return true }
+            return false
+        }.count
+        return importedFunctions + functionTypeIndices.count
+    }
+
+    /// Number of imported functions (occupy the first N function indices).
+    var importedFunctionCount: Int {
+        imports.filter {
+            if case .function = $0.descriptor { return true }
+            return false
+        }.count
+    }
+}
+
+/// Parses a WebAssembly binary and collects all sections into a `ModuleInfo`.
+///
+/// - Parameters:
+///   - bytes: The raw bytes of the WebAssembly binary.
+///   - features: The feature set to use while parsing.
+/// - Returns: A populated `ModuleInfo`.
+func collectModule<Stream: ByteStream>(stream: Stream, features: WasmFeatureSet = .default) throws -> ModuleInfo {
+    var info = ModuleInfo()
+    var parser = WasmParser.Parser(stream: stream, features: features)
+    while let payload = try parser.parseNext() {
+        switch payload {
+        case .header:
+            break
+        case .typeSection(let types):
+            info.types = types
+        case .importSection(let imports):
+            info.imports = imports
+        case .functionSection(let indices):
+            info.functionTypeIndices = indices
+        case .tableSection(let tables):
+            info.tables = tables
+        case .memorySection(let memories):
+            info.memories = memories
+        case .globalSection(let globals):
+            info.globals = globals
+        case .exportSection(let exports):
+            info.exports = exports
+        case .startSection(let start):
+            info.start = start
+        case .elementSection(let elements):
+            info.elements = elements
+        case .codeSection(let codes):
+            info.codes = codes
+        case .dataSection(let data):
+            info.data = data
+        case .dataCount:
+            break
+        case .customSection(let section) where section.name == "name":
+            parseNameSection(section.bytes, into: &info)
+        case .customSection:
+            break
+        }
+    }
+    return info
+}
+
+// MARK: - Name section decoding
+
+private func parseNameSection(_ bytes: ArraySlice<UInt8>, into info: inout ModuleInfo) {
+    let stream = StaticByteStream(bytes: bytes)
+    let nameParser = NameSectionParser(stream: stream)
+    guard let parsedNames = try? nameParser.parseAll() else { return }
+    for parsedName in parsedNames {
+        if case .functions(let nameMap) = parsedName {
+            info.functionNames = nameMap
+        }
+    }
+}