WasmGen: Remove Output assoctype from InstructionVisitor

because nobody used it. This removal also allows removing
`VoidInstructionVisitor`

Author: kateinoigakukun

Sources/WAT/ParseInstruction.swift

@@ -12,7 +12,7 @@ import WasmTypes
 /// - Returns: A closure that invokes the corresponding visitor method. Nil if the keyword is not recognized.
 ///
 /// Note: The returned closure does not consume any tokens.
-func parseTextInstruction<V: InstructionVisitor>(keyword: String, expressionParser: inout ExpressionParser<V>, wat: inout Wat) throws -> ((inout V) throws -> V.Output)? {
+func parseTextInstruction<V: InstructionVisitor>(keyword: String, expressionParser: inout ExpressionParser<V>, wat: inout Wat) throws -> ((inout V) throws -> Void)? {
     switch keyword {
     case "unreachable": return { return try $0.visitUnreachable() }
     case "nop": return { return try $0.visitNop() }

Sources/WAT/Parser/ExpressionParser.swift

@@ -115,7 +115,7 @@ struct ExpressionParser<Visitor: InstructionVisitor> {
         var wat = Wat.empty(features: features)
         // WAST allows extra const value instruction
         if try parser.takeParenBlockStart("ref.extern") {
-            _ = try visitor.visitRefExtern(value: parser.expectUnsignedInt())
+            try visitor.visitRefExtern(value: parser.expectUnsignedInt())
             try parser.expect(.rightParen)
             return true
         }
@@ -182,7 +182,7 @@ struct ExpressionParser<Visitor: InstructionVisitor> {
     }
 
     private struct Suspense {
-        let visit: ((inout Visitor, inout ExpressionParser) throws -> Visitor.Output)?
+        let visit: ((inout Visitor, inout ExpressionParser) throws -> Void)?
     }
 
     private mutating func foldedInstruction(visitor: inout Visitor, wat: inout Wat) throws -> Bool {
@@ -256,7 +256,7 @@ struct ExpressionParser<Visitor: InstructionVisitor> {
     }
 
     /// Parse a single instruction without consuming the surrounding parentheses and instruction keyword.
-    private mutating func parseTextInstruction(keyword: String, wat: inout Wat) throws -> ((inout Visitor) throws -> Visitor.Output) {
+    private mutating func parseTextInstruction(keyword: String, wat: inout Wat) throws -> ((inout Visitor) throws -> Void) {
         switch keyword {
         case "select":
             // Special handling for "select", which have two variants 1. with type, 2. without type

Sources/WAT/Parser/WastParser.swift

@@ -2,7 +2,7 @@ import WasmParser
 import WasmTypes
 
 protocol WastConstInstructionVisitor: InstructionVisitor {
-    mutating func visitRefExtern(value: UInt32) throws -> Output
+    mutating func visitRefExtern(value: UInt32) throws
 }
 
 /// A parser for WAST format.
@@ -53,7 +53,7 @@ struct WastParser {
         return result
     }
 
-    struct ConstExpressionCollector: VoidInstructionVisitor, WastConstInstructionVisitor {
+    struct ConstExpressionCollector: WastConstInstructionVisitor {
         let addValue: (Value) -> Void
 
         mutating func visitI32Const(value: Int32) throws { addValue(.i32(UInt32(bitPattern: value))) }

Sources/WasmParser/Docs.docc/Docs.md

@@ -53,7 +53,6 @@ while let payload = try parser.parseNext() {
 ### Visitor
 
 - ``InstructionVisitor``
-- ``VoidInstructionVisitor``
 - ``AnyInstructionVisitor``
 - ``InstructionTracingVisitor``
 

Sources/WasmParser/InstructionVisitor.swift

@@ -89,7 +89,7 @@ extension Code {
     /// ```swift
     /// import WasmParser
     ///
-    /// struct MyVisitor: VoidInstructionVisitor {
+    /// struct MyVisitor: InstructionVisitor {
     ///     func visitLocalGet(localIndex: UInt32) {
     ///         print("local.get \(localIndex)")
     ///     }
@@ -118,7 +118,7 @@ extension Code {
         let parser = Parser(stream: StaticByteStream(bytes: self.expression), features: self.features, hasDataCount: self.hasDataCount)
         var lastCode: InstructionCode?
         while try !parser.stream.hasReachedEnd() {
-            (lastCode, _) = try parser.parseInstruction(visitor: &visitor)
+            lastCode = try parser.parseInstruction(visitor: &visitor)
         }
         guard lastCode == .end else {
             throw WasmParserError.endOpcodeExpected
@@ -480,16 +480,17 @@ extension Parser {
 /// <https://webassembly.github.io/spec/core/binary/instructions.html>
 extension Parser {
     @inlinable
-    func parseInstruction<V: InstructionVisitor>(visitor v: inout V) throws -> (InstructionCode, V.Output) {
+    func parseInstruction<V: InstructionVisitor>(visitor v: inout V) throws -> InstructionCode {
         let rawCode = try stream.consumeAny()
         guard let code = InstructionCode(rawValue: rawCode) else {
             throw WasmParserError.illegalOpcode(rawCode)
         }
-        return (code, try doParseInstruction(code: code, visitor: &v))
+        try doParseInstruction(code: code, visitor: &v)
+        return code
     }
 
     @inlinable
-    func doParseInstruction<V: InstructionVisitor>(code: InstructionCode, visitor v: inout V) throws -> V.Output {
+    func doParseInstruction<V: InstructionVisitor>(code: InstructionCode, visitor v: inout V) throws {
         switch code {
         case .unreachable: return try v.visitUnreachable()
         case .nop: return try v.visitNop()
@@ -815,22 +816,20 @@ extension Parser {
     }
 
     struct InstructionFactory: AnyInstructionVisitor {
-        typealias Output = Instruction
+        var insts: [Instruction] = []
 
-        func visit(_ instruction: Instruction) throws -> Instruction {
-            return instruction
+        mutating func visit(_ instruction: Instruction) throws {
+            insts.append(instruction)
         }
     }
 
     func parseConstExpression() throws -> ConstExpression {
         var factory = InstructionFactory()
-        var insts: [Instruction] = []
-        var inst: Instruction
+        var inst: InstructionCode
         repeat {
-            (_, inst) = try self.parseInstruction(visitor: &factory)
-            insts.append(inst)
+            inst = try self.parseInstruction(visitor: &factory)
         } while inst != .end
-        return insts
+        return factory.insts
     }
 }
 

Sources/WasmParser/WasmParser.swift

@@ -63,9 +63,6 @@ enum WasmGen {
             /// The visitor pattern is used while parsing WebAssembly expressions to allow for easy extensibility.
             /// See the expression parsing method ``Code/parseExpression(visitor:)``
             public protocol InstructionVisitor {
-
-                /// The return type of visitor methods.
-                associatedtype Output
             """
 
         for instruction in instructions {
@@ -75,7 +72,7 @@ enum WasmGen {
             code += instruction.immediates.map { i in
                 "\(i.label): \(i.type)"
             }.joined(separator: ", ")
-            code += ") throws -> Output"
+            code += ") throws"
         }
 
         code += """
@@ -88,7 +85,7 @@ enum WasmGen {
 
             extension InstructionVisitor {
                 /// Visits an instruction.
-                public mutating func visit(_ instruction: Instruction) throws -> Output {
+                public mutating func visit(_ instruction: Instruction) throws {
                     switch instruction {
 
             """
@@ -113,19 +110,16 @@ enum WasmGen {
 
         code += """
 
-
-            /// A visitor for WebAssembly instructions that returns `Void` with default implementations.
-            public protocol VoidInstructionVisitor: InstructionVisitor where Output == Void {}
-
-            extension VoidInstructionVisitor {
+            // MARK: - Placeholder implementations
+            extension InstructionVisitor {
 
             """
         for instruction in instructions {
             code += "    public mutating func \(instruction.visitMethodName)("
             code += instruction.immediates.map { i in
                 "\(i.label): \(i.type)"
             }.joined(separator: ", ")
-            code += ") throws -> Void {}\n"
+            code += ") throws {}\n"
         }
         code += "}\n"
 
@@ -176,7 +170,7 @@ enum WasmGen {
             /// A visitor that visits all instructions by a single visit method.
             public protocol AnyInstructionVisitor: InstructionVisitor {
                 /// Visiting any instruction.
-                mutating func visit(_ instruction: Instruction) throws -> Output
+                mutating func visit(_ instruction: Instruction) throws
             }
 
             extension AnyInstructionVisitor {
@@ -188,7 +182,7 @@ enum WasmGen {
             code += instruction.immediates.map { i in
                 "\(i.label): \(i.type)"
             }.joined(separator: ", ")
-            code += ") throws -> Output { "
+            code += ") throws { "
             code += "return try self.visit(" + buildInstructionInstanceFromContext(instruction) + ")"
             code += " }\n"
         }
@@ -224,7 +218,7 @@ enum WasmGen {
             code += instruction.immediates.map { i in
                 "\(i.label): \(i.type)"
             }.joined(separator: ", ")
-            code += ") throws -> V.Output {\n"
+            code += ") throws {\n"
             code += "       trace("
             code += buildInstructionInstanceFromContext(instruction)
             code += ")\n"
@@ -253,7 +247,7 @@ enum WasmGen {
             /// - Returns: A closure that invokes the corresponding visitor method. Nil if the keyword is not recognized.
             ///
             /// Note: The returned closure does not consume any tokens.
-            func parseTextInstruction<V: InstructionVisitor>(keyword: String, expressionParser: inout ExpressionParser<V>, wat: inout Wat) throws -> ((inout V) throws -> V.Output)? {
+            func parseTextInstruction<V: InstructionVisitor>(keyword: String, expressionParser: inout ExpressionParser<V>, wat: inout Wat) throws -> ((inout V) throws -> Void)? {
                 switch keyword {
 
             """