Remove unused types and functions

Author: kateinoigakukun

Sources/WasmKit/Execution/Instructions/Expression.swift

@@ -1,15 +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
-/// > instructions, called blocks, terminated with, or separated by, end or else pseudo-instructions. As the
-/// > grammar prescribes, they must be well-nested.
-enum PseudoInstruction {
-    case `else`
-    case end
-}
-
 struct InstructionSequence: Equatable {
     let instructions: UnsafeBufferPointer<Instruction>
 
@@ -52,8 +42,3 @@ struct ExpressionRef: Equatable {
         self._relativeOffset = UInt32(relativeOffset)
     }
 }
-
-/// > Note:
-/// <https://webassembly.github.io/spec/core/syntax/instructions.html#expressions>
-
-typealias Expression = [WasmParser.Instruction]

Sources/WasmKit/Execution/Runtime/ExecutionState.swift

@@ -82,9 +82,3 @@ extension ExecutionState {
         store.module(address: stack.currentFrame.module)
     }
 }
-
-extension ExecutionState {
-    mutating func pseudo(runtime: Runtime, pseudoInstruction: PseudoInstruction) throws {
-        fatalError("Unimplemented instruction: pseudo")
-    }
-}

Sources/WasmKit/Execution/Runtime/Stack.swift

@@ -1,21 +1,13 @@
 /// > Note:
 /// <https://webassembly.github.io/spec/core/exec/runtime.html#stack>
 struct Stack {
-    enum Element: Equatable {
-        case value(Value)
-        case frame(Frame)
-    }
 
     private var limit: UInt16 { UInt16.max }
     private var valueStack: ValueStack
     private var numberOfValues: Int { valueStack.count }
     private var frames: FixedSizeStack<Frame>
     var currentFrame: Frame!
 
-    var isEmpty: Bool {
-        self.frames.isEmpty && self.numberOfValues == 0
-    }
-
     init() {
         let limit = UInt16.max
         self.valueStack = ValueStack(capacity: Int(limit))

Sources/WasmKit/Execution/Types/Value.swift

@@ -445,30 +445,6 @@ extension Value {
         }
     }
 
-    var leadingZeroBitCount: Value {
-        switch self {
-        case let .i32(rawValue): return .i32(UInt32(rawValue.leadingZeroBitCount))
-        case let .i64(rawValue): return .i64(UInt64(rawValue.leadingZeroBitCount))
-        default: fatalError("Invalid type \(type) for `Value.\(#function)` implementation")
-        }
-    }
-
-    var trailingZeroBitCount: Value {
-        switch self {
-        case let .i32(rawValue): return .i32(UInt32(rawValue.trailingZeroBitCount))
-        case let .i64(rawValue): return .i64(UInt64(rawValue.trailingZeroBitCount))
-        default: fatalError("Invalid type \(type) for `Value.\(#function)` implementation")
-        }
-    }
-
-    var nonzeroBitCount: Value {
-        switch self {
-        case let .i32(rawValue): return .i32(UInt32(rawValue.nonzeroBitCount))
-        case let .i64(rawValue): return .i64(UInt64(rawValue.nonzeroBitCount))
-        default: fatalError("Invalid type \(type) for `Value.\(#function)` implementation")
-        }
-    }
-
     func rotl(_ l: Self) -> Self {
         switch (self, l) {
         case let (.i32(rawValue), .i32(l)):
@@ -527,36 +503,6 @@ extension Value {
         }
     }
 
-    static func + (lhs: Self, rhs: Self) -> Self {
-        switch (lhs, rhs) {
-        case let (.i32(lhs), .i32(rhs)): return .i32(lhs &+ rhs)
-        case let (.i64(lhs), .i64(rhs)): return .i64(lhs &+ rhs)
-        case let (.f32(lhs), .f32(rhs)): return .f32((Float32(bitPattern: lhs) + Float32(bitPattern: rhs)).bitPattern)
-        case let (.f64(lhs), .f64(rhs)): return .f64((Float64(bitPattern: lhs) + Float64(bitPattern: rhs)).bitPattern)
-        default: fatalError("Invalid types \(lhs.type) and \(rhs.type) for `Value.\(#function)` implementation")
-        }
-    }
-
-    static func - (lhs: Self, rhs: Self) -> Self {
-        switch (lhs, rhs) {
-        case let (.i32(lhs), .i32(rhs)): return .i32(lhs &- rhs)
-        case let (.i64(lhs), .i64(rhs)): return .i64(lhs &- rhs)
-        case let (.f32(lhs), .f32(rhs)): return .f32((Float32(bitPattern: lhs) - Float32(bitPattern: rhs)).bitPattern)
-        case let (.f64(lhs), .f64(rhs)): return .f64((Float64(bitPattern: lhs) - Float64(bitPattern: rhs)).bitPattern)
-        default: fatalError("Invalid types \(lhs.type) and \(rhs.type) for `Value.\(#function)` implementation")
-        }
-    }
-
-    static func * (lhs: Self, rhs: Self) -> Self {
-        switch (lhs, rhs) {
-        case let (.i32(lhs), .i32(rhs)): return .i32(lhs &* rhs)
-        case let (.i64(lhs), .i64(rhs)): return .i64(lhs &* rhs)
-        case let (.f32(lhs), .f32(rhs)): return .f32((Float32(bitPattern: lhs) * Float32(bitPattern: rhs)).bitPattern)
-        case let (.f64(lhs), .f64(rhs)): return .f64((Float64(bitPattern: lhs) * Float64(bitPattern: rhs)).bitPattern)
-        default: fatalError("Invalid types \(lhs.type) and \(rhs.type) for `Value.\(#function)` implementation")
-        }
-    }
-
     static func / (lhs: Self, rhs: Self) -> Self {
         switch (lhs, rhs) {
         case let (.f32(lhs), .f32(rhs)): return .f32((Float32(bitPattern: lhs) / Float32(bitPattern: rhs)).bitPattern)

Tests/WasmKitTests/Execution/HostModuleTests.swift

@@ -43,7 +43,7 @@ final class HostModuleTests: XCTestCase {
                     type: 0, locals: [],
                     body: {
                         [
-                            .control(.call(functionIndex: 1))
+                            .call(functionIndex: 1)
                         ]
                     }),
             ],