Cleanup WasmParser module

Package.swift

@@ -104,6 +104,10 @@ let package = Package(
             name: "WasmKitTests",
             dependencies: ["WasmKit"]
         ),
+        .testTarget(
+            name: "WasmParserTests",
+            dependencies: ["WasmParser"]
+        ),
         .testTarget(
             name: "WASITests",
             dependencies: ["WASI"]

Sources/Spectest/TestCase.swift

@@ -515,7 +515,7 @@ extension Array where Element == Value {
 
 extension Swift.Error {
     var text: String {
-        if let error = self as? LegacyWasmParserError {
+        if let error = self as? WasmParserError {
             switch error {
             case .invalidMagicNumber:
                 return "magic header not detected"

Sources/WASI/WASI.swift

@@ -3,6 +3,7 @@ import SwiftShims  // For swift_stdlib_random
 import SystemExtras
 import SystemPackage
 import WasmKit
+import WasmParser
 
 protocol WASI {
     /// Reads command-line argument data.

Sources/WasmKit/Execution/Instructions/Expression.swift

@@ -1,3 +1,5 @@
+import WasmParser
+
 /// See spec's
 /// [definition](https://webassembly.github.io/spec/core/text/instructions.html?highlight=pseudo#control-instructions).
 /// > The `block`, `loop` and `if` instructions are structured instructions. They bracket nested sequences of
@@ -54,4 +56,4 @@ struct ExpressionRef: Equatable {
 /// > Note:
 /// <https://webassembly.github.io/spec/core/syntax/instructions.html#expressions>
 
-typealias Expression = [Instruction]
+typealias Expression = [WasmParser.Instruction]

Sources/WasmKit/Execution/Instructions/InstructionSupport.swift

@@ -1,5 +1,4 @@
-import struct WasmParser.MemArg
-import enum WasmParser.BlockType
+import WasmParser
 
 extension Instruction {
     typealias Memarg = MemArg
@@ -22,7 +21,7 @@ extension Instruction {
             case let .funcType(typeIndex):
                 let typeIndex = Int(typeIndex)
                 guard typeIndex < typeSection.count else {
-                    throw LegacyWasmParserError.invalidTypeSectionReference
+                    throw WasmParserError.invalidTypeSectionReference
                 }
                 let funcType = typeSection[typeIndex]
                 self = Instruction.BlockType(

Sources/WasmKit/Execution/Instructions/Numeric.swift

@@ -284,38 +284,34 @@ extension NumericInstruction {
             _ value1: Value,
             _ value2: Value
         ) throws -> Value {
-            guard case let .numeric(type) = value1.type else {
-                fatalError()
-            }
-
-            switch (self, type) {
-            case (.divS, _):
+            switch self {
+            case .divS:
                 guard !value2.isZero else { throw Trap.integerDividedByZero }
                 return try Value.divisionSigned(value1, value2)
-            case (.divU, _):
+            case .divU:
                 guard !value2.isZero else { throw Trap.integerDividedByZero }
                 return try Value.divisionUnsigned(value1, value2)
-            case (.remS, _):
+            case .remS:
                 guard !value2.isZero else { throw Trap.integerDividedByZero }
                 return try Value.remainderSigned(value1, value2)
-            case (.remU, _):
+            case .remU:
                 guard !value2.isZero else { throw Trap.integerDividedByZero }
                 return try Value.remainderUnsigned(value1, value2)
-            case (.and, _):
+            case .and:
                 return value1 & value2
-            case (.or, _):
+            case .or:
                 return value1 | value2
-            case (.xor, _):
+            case .xor:
                 return value1 ^ value2
-            case (.shl, _):
+            case .shl:
                 return value1 << value2
-            case (.shrS, _):
+            case .shrS:
                 return Value.rightShiftSigned(value1, value2)
-            case (.shrU, _):
+            case .shrU:
                 return Value.rightShiftUnsigned(value1, value2)
-            case (.rotl, _):
+            case .rotl:
                 return value1.rotl(value2)
-            case (.rotr, _):
+            case .rotr:
                 return value1.rotr(value2)
             }
         }

Sources/WasmKit/Execution/Runtime/Function.swift

@@ -1,3 +1,5 @@
+import WasmParser
+
 /// A WebAssembly guest function or host function
 public struct Function: Equatable {
     internal let address: FunctionAddress

Sources/WasmKit/Execution/Runtime/NameRegistry.swift

@@ -1,3 +1,7 @@
+import struct WasmParser.NameSectionParser
+import struct WasmParser.CustomSection
+import class WasmParser.StaticByteStream
+
 struct NameRegistry {
     private var functionNames: [FunctionAddress: String] = [:]
     private var materializers: [(inout NameRegistry) throws -> Void] = []
@@ -6,7 +10,7 @@ struct NameRegistry {
 
     mutating func register(instance: ModuleInstance, nameSection: CustomSection) throws {
         materializers.append { registry in
-            let stream = LegacyStaticByteStream(bytes: Array(nameSection.bytes))
+            let stream = StaticByteStream(bytes: Array(nameSection.bytes))
             let parser = NameSectionParser(stream: stream)
             for result in try parser.parseAll() {
                 switch result {

Sources/WasmKit/Execution/Runtime/Runtime.swift

@@ -73,12 +73,22 @@ extension Runtime {
                 let elementIndex = UInt32(elementIndex)
                 switch element.mode {
                 case let .active(tableIndex, offsetExpression):
-                    let initIseq = InstructionSequence(instructions: offsetExpression + [
+                    var instructions: [Instruction] = []
+                    switch offsetExpression.first {
+                    case .i32Const(let value):
+                        instructions.append(.numericConst(.i32(UInt32(bitPattern: value))))
+                    case .globalGet(let index):
+                        instructions.append(.globalGet(index: index))
+                    default:
+                        throw InstantiationError.unsupported("init expr in element section \(offsetExpression)")
+                    }
+                    instructions.append(contentsOf: [
                         .numericConst(.i32(0)),
                         .numericConst(.i32(UInt32(element.initializer.count))),
                         .tableInit(tableIndex, elementIndex),
                         .tableElementDrop(elementIndex),
                     ])
+                    let initIseq = InstructionSequence(instructions: instructions)
                     defer { initIseq.deallocate() }
                     try evaluateConstExpr(initIseq, instance: instance)
 
@@ -101,7 +111,18 @@ extension Runtime {
         do {
             for case let (dataIndex, .active(data)) in module.data.enumerated() {
                 assert(data.index == 0)
-                let iseq = InstructionSequence(instructions: data.offset + [
+                var instructions: [Instruction] = []
+                switch data.offset.first {
+                case .i32Const(let value):
+                    instructions.append(.numericConst(.i32(UInt32(bitPattern: value))))
+                case .i64Const(let value):
+                    instructions.append(.numericConst(.i64(UInt64(bitPattern: value))))
+                case .globalGet(let index):
+                    instructions.append(.globalGet(index: index))
+                default:
+                    throw InstantiationError.unsupported("init expr in data section \(data.offset)")
+                }
+                let iseq = InstructionSequence(instructions: instructions + [
                     .numericConst(.i32(0)),
                     .numericConst(.i32(UInt32(data.initializer.count))),
                     .memoryInit(UInt32(dataIndex)),
@@ -149,7 +170,26 @@ extension Runtime {
             }
 
             let globalInitializers = try module.globals.map { global in
-                let iseq = InstructionSequence(instructions: global.initializer)
+                var instructions: [Instruction] = []
+                switch global.initializer.first {
+                case .i32Const(let value):
+                    instructions.append(.numericConst(.i32(UInt32(bitPattern: value))))
+                case .i64Const(let value):
+                    instructions.append(.numericConst(.i64(UInt64(bitPattern: value))))
+                case .f32Const(let value):
+                    instructions.append(.numericConst(.f32(value.bitPattern)))
+                case .f64Const(let value):
+                    instructions.append(.numericConst(.f64(value.bitPattern)))
+                case .refNull(let type):
+                    instructions.append(.refNull(type))
+                case .refFunc(let functionIndex):
+                    instructions.append(.refFunc(functionIndex))
+                case .globalGet(let globalIndex):
+                    instructions.append(.globalGet(index: globalIndex))
+                default:
+                    throw InstantiationError.unsupported("init expr in global section \(global.initializer)")
+                }
+                let iseq = InstructionSequence(instructions: instructions)
                 defer { iseq.deallocate() }
                 return try evaluateConstExpr(iseq, instance: globalModuleInstance, arity: 1) { _, stack in
                     return stack.popValue()

Sources/WasmKit/Execution/Runtime/Store.swift

@@ -1,3 +1,5 @@
+import WasmParser
+
 /// > Note:
 /// <https://webassembly.github.io/spec/core/exec/runtime.html#addresses>
 public typealias FunctionAddress = Int

Sources/WasmKit/Execution/Types/Errors.swift

@@ -1,3 +1,5 @@
+import WasmParser
+
 public enum Trap: Error {
     // FIXME: for debugging purposes, to be eventually deleted
     case _raw(String)
@@ -8,7 +10,7 @@ public enum Trap: Error {
     /// Stack overflow
     case stackOverflow
     /// The stack value type does not match the expected type
-    case stackValueTypesMismatch(expected: ValueType, actual: ValueType)
+    case stackValueTypesMismatch(expected: WasmParser.ValueType, actual: WasmParser.ValueType)
     /// Too deep call stack
     case callStackExhausted
 
@@ -72,6 +74,7 @@ public enum InstantiationError: Error {
     case invalidTableExpression
     case outOfBoundsTableAccess
     case outOfBoundsMemoryAccess
+    case unsupported(String)
 
     /// Human-readable text representation of the trap that `.wast` text format expects in assertions
     public var assertionText: String {
@@ -80,6 +83,8 @@ public enum InstantiationError: Error {
             return "out of bounds table access"
         case .outOfBoundsMemoryAccess:
             return "out of bounds memory access"
+        case .unsupported(let message):
+            return "unsupported operation: \(message)"
         default:
             return String(describing: self)
         }

Sources/WasmKit/Execution/Types/Instances.swift

@@ -1,3 +1,5 @@
+import WasmParser
+
 /// A stateful runtime representation of a ``Module``.
 /// Usually instantiated by ``Runtime/instantiate(module:name:)``.
 /// > Note: