Remove changes unrelated to the protocol

Author: MaxDesiatov

Sources/WAT/Encoder.swift

@@ -158,7 +158,6 @@ extension TableType: WasmEncodable {
 struct ElementExprCollector: AnyInstructionVisitor {
     typealias Output = Void
 
-    var binaryOffset: Int = 0
     var isAllRefFunc: Bool = true
     var instructions: [Instruction] = []
 
@@ -444,7 +443,6 @@ extension WatParser.DataSegmentDecl {
 }
 
 struct ExpressionEncoder: BinaryInstructionEncoder {
-    var binaryOffset: Int = 0
     var encoder = Encoder()
     var hasDataSegmentInstruction: Bool = false
 

Sources/WAT/Parser/WastParser.swift

@@ -54,7 +54,6 @@ struct WastParser {
     }
 
     struct ConstExpressionCollector: WastConstInstructionVisitor {
-        var binaryOffset: Int = 0
         let addValue: (Value) -> Void
 
         mutating func visitI32Const(value: Int32) throws { addValue(.i32(UInt32(bitPattern: value))) }

Sources/WasmKit/Execution/Errors.swift

@@ -5,21 +5,19 @@ import struct WasmParser.Import
 /// The backtrace of the trap.
 struct Backtrace: CustomStringConvertible, Sendable {
     /// A symbol in the backtrace.
-    struct Symbol: @unchecked Sendable {
+    struct Symbol {
         /// The name of the symbol.
         let name: String?
-        let address: Pc
     }
 
     /// The symbols in the backtrace.
-    let symbols: [Symbol]
+    let symbols: [Symbol?]
 
     /// Textual description of the backtrace.
     var description: String {
-        print("backtrace contains \(symbols.count) symbols")
-        return symbols.enumerated().map { (index, symbol) in
-            let name = symbol.name ?? "unknown"
-            return "    \(index): (\(symbol.address)) \(name)"
+        symbols.enumerated().map { (index, symbol) in
+            let name = symbol?.name ?? "unknown"
+            return "    \(index): \(name)"
         }.joined(separator: "\n")
     }
 }

Sources/WasmKit/Execution/Execution.swift

@@ -4,7 +4,7 @@ import _CWasmKit
 ///
 /// Each new invocation through exported function has a separate ``Execution``
 /// even though the invocation happens during another invocation.
-struct Execution: ~Copyable {
+struct Execution {
     /// The reference to the ``Store`` associated with the execution.
     let store: StoreRef
     /// The end of the VM stack space.
@@ -14,13 +14,6 @@ struct Execution: ~Copyable {
     /// - Note: If the trap is set, it must be released manually.
     private var trap: (error: UnsafeRawPointer, sp: Sp)? = nil
 
-    #if WasmDebuggingSupport
-        package init(store: StoreRef, stackEnd: UnsafeMutablePointer<StackSlot>) {
-            self.store = store
-            self.stackEnd = stackEnd
-        }
-    #endif
-
     /// Executes the given closure with a new execution state associated with
     /// the given ``Store`` instance.
     static func with<T>(
@@ -68,15 +61,18 @@ struct Execution: ~Copyable {
 
     static func captureBacktrace(sp: Sp, store: Store) -> Backtrace {
         var frames = FrameIterator(sp: sp)
-        var symbols: [Backtrace.Symbol] = []
-
+        var symbols: [Backtrace.Symbol?] = []
         while let frame = frames.next() {
             guard let function = frame.function else {
-                symbols.append(.init(name: nil, address: frame.pc))
+                symbols.append(nil)
                 continue
             }
             let symbolName = store.nameRegistry.symbolicate(.wasm(function))
-            symbols.append(.init(name: symbolName, address: frame.pc))
+            symbols.append(
+                Backtrace.Symbol(
+                    name: symbolName
+                )
+            )
         }
         return Backtrace(symbols: symbols)
     }
@@ -252,7 +248,7 @@ extension Sp {
         nonmutating set { self[-1] = UInt64(UInt(bitPattern: newValue)) }
     }
 
-    var currentInstance: InternalInstance? {
+    fileprivate var currentInstance: InternalInstance? {
         currentFunction?.instance
     }
 }

Sources/WasmKit/Execution/Function.swift

@@ -243,7 +243,7 @@ struct WasmFunctionEntity {
         switch code {
         case .uncompiled(let code):
             return try compile(store: store, code: code)
-        case .compiled(let iseq), .debuggable(_, let iseq):
+        case .compiled(let iseq), .compiledAndPatchable(_, let iseq):
             return iseq
         }
     }
@@ -280,14 +280,10 @@ extension EntityHandle<WasmFunctionEntity> {
         case .uncompiled(let code):
             return try self.withValue {
                 let iseq = try $0.compile(store: store, code: code)
-                if $0.instance.isDebuggable {
-                    $0.code = .debuggable(code, iseq)
-                } else {
-                    $0.code = .compiled(iseq)
-                }
+                $0.code = .compiled(iseq)
                 return iseq
             }
-        case .compiled(let iseq), .debuggable(_, let iseq):
+        case .compiled(let iseq), .compiledAndPatchable(_, let iseq):
             return iseq
         }
     }
@@ -320,7 +316,7 @@ struct InstructionSequence {
 enum CodeBody {
     case uncompiled(InternalUncompiledCode)
     case compiled(InstructionSequence)
-    case debuggable(InternalUncompiledCode, InstructionSequence)
+    case compiledAndPatchable(InternalUncompiledCode, InstructionSequence)
 }
 
 extension Reference {

Sources/WasmKit/Execution/Instances.swift

@@ -83,15 +83,6 @@ struct InstanceEntity /* : ~Copyable */ {
     var functionRefs: Set<InternalFunction>
     var features: WasmFeatureSet
     var dataCount: UInt32?
-    var isDebuggable: Bool
-
-    /// Mapping from iSeq Pc to instruction addresses in the original binary.
-    /// Used for handling current call stack requests issued by a ``Debugger`` instance.
-    var iseqToWasmMapping: [Pc: Int]
-
-    /// Mapping from Wasm instruction addresses in the original binary to iSeq instruction addresses.
-    /// Used for handling breakpoint requests issued by a ``Debugger`` instance.
-    var wasmToIseqMapping: [Int: Pc]
 
     static var empty: InstanceEntity {
         InstanceEntity(
@@ -105,10 +96,7 @@ struct InstanceEntity /* : ~Copyable */ {
             exports: [:],
             functionRefs: [],
             features: [],
-            dataCount: nil,
-            isDebuggable: false,
-            iseqToWasmMapping: [:],
-            wasmToIseqMapping: [:]
+            dataCount: nil
         )
     }
 

Sources/WasmKit/Execution/StoreAllocator.swift

@@ -251,8 +251,7 @@ extension StoreAllocator {
         module: Module,
         engine: Engine,
         resourceLimiter: any ResourceLimiter,
-        imports: Imports,
-        isDebuggable: Bool
+        imports: Imports
     ) throws -> InternalInstance {
         // Step 1 of module allocation algorithm, according to Wasm 2.0 spec.
 
@@ -451,10 +450,7 @@ extension StoreAllocator {
             exports: exports,
             functionRefs: functionRefs,
             features: module.features,
-            dataCount: module.dataCount,
-            isDebuggable: isDebuggable,
-            iseqToWasmMapping: [:],
-            wasmToIseqMapping: [:]
+            dataCount: module.dataCount
         )
         instancePointer.initialize(to: instanceEntity)
         instanceInitialized = true

Sources/WasmKit/Module.swift

@@ -138,23 +138,9 @@ public struct Module {
         Instance(handle: try self.instantiateHandle(store: store, imports: imports), store: store)
     }
 
-    #if WasmDebuggingSupport
-        /// Instantiate this module in the given imports.
-        ///
-        /// - Parameters:
-        ///   - store: The ``Store`` to allocate the instance in.
-        ///   - imports: The imports to use for instantiation. All imported entities
-        ///     must be allocated in the given store.
-        ///   - isDebuggable: Whether the module should support debugging actions
-        ///     (breakpoints etc) after instantiation.
-        public func instantiate(store: Store, imports: Imports = [:], isDebuggable: Bool) throws -> Instance {
-            Instance(handle: try self.instantiateHandle(store: store, imports: imports, isDebuggable: isDebuggable), store: store)
-        }
-    #endif
-
     /// > Note:
     /// <https://webassembly.github.io/spec/core/exec/modules.html#instantiation>
-    private func instantiateHandle(store: Store, imports: Imports, isDebuggable: Bool = false) throws -> InternalInstance {
+    private func instantiateHandle(store: Store, imports: Imports) throws -> InternalInstance {
         try ModuleValidator(module: self).validate()
 
         // Steps 5-8.
@@ -166,8 +152,7 @@ public struct Module {
         let instance = try store.allocator.allocate(
             module: self, engine: store.engine,
             resourceLimiter: store.resourceLimiter,
-            imports: imports,
-            isDebuggable: isDebuggable
+            imports: imports
         )
 
         if let nameSection = customSections.first(where: { $0.name == "name" }) {