Overhaul diagnostics

Author: kateinoigakukun

Sources/WasmKit/Execution/ConstEvaluation.swift

@@ -50,7 +50,7 @@ extension ConstExpression {
 
     private func _evaluate<C: ConstEvaluationContextProtocol>(context: C) throws -> Value {
         guard self.last == .end, self.count == 2 else {
-            throw InstantiationError.unsupported("Expect `end` at the end of offset expression")
+            throw ValidationError(.expectedEndAtOffsetExpression)
         }
         let constInst = self[0]
         switch constInst {
@@ -68,7 +68,7 @@ extension ConstExpression {
         case .refFunc(let functionIndex):
             return try .ref(context.functionRef(functionIndex))
         default:
-            throw InstantiationError.unsupported("illegal const expression instruction: \(constInst)")
+            throw ValidationError(.illegalConstExpressionInstruction(constInst))
         }
     }
 }
@@ -97,10 +97,10 @@ extension WasmParser.ElementSegment {
             case .ref(.function(let addr)):
                 return .function(addr)
             default:
-                throw Trap._raw("Unexpected global value type for element initializer expression")
+                throw ValidationError(.unexpectedGlobalValueType)
             }
         default:
-            throw Trap._raw("Unexpected element initializer expression: \(expression)")
+            throw ValidationError(.unexpectedElementInitializer(expression: "\(expression)"))
         }
     }
 }

Sources/WasmKit/Execution/Errors.swift

@@ -1,114 +1,188 @@
 import WasmTypes
 
-public enum Trap: Error {
-    // FIXME: for debugging purposes, to be eventually deleted
-    case _raw(String)
+import struct WasmParser.Import
 
-    case unreachable
+/// An error that occurs during execution of a WebAssembly module.
+public struct Trap: Error, CustomStringConvertible {
+    /// The reason for the trap.
+    var reason: TrapReason
+
+    /// The backtrace of the trap.
+    struct Backtrace {
+    }
+
+    /// The backtrace of the trap.
+    private(set) var backtrace: Backtrace?
 
-    // Stack
-    /// Stack overflow
-    case stackOverflow
-    /// The stack value type does not match the expected type
-    case stackValueTypesMismatch(expected: WasmTypes.ValueType, actual: WasmTypes.ValueType)
+    init(_ code: TrapReason, backtrace: Backtrace? = nil) {
+        self.reason = code
+        self.backtrace = backtrace
+    }
+
+    init(_ message: TrapReason.Message, backtrace: Backtrace? = nil) {
+        self.init(.message(message), backtrace: backtrace)
+    }
+
+    /// The description of the trap.
+    public var description: String {
+        var desc = "Trap: \(reason)"
+        if let backtrace = backtrace {
+            desc += "\n\(backtrace)"
+        }
+        return desc
+    }
+
+    func withBacktrace(_ backtrace: Backtrace) -> Trap {
+        var trap = self
+        trap.backtrace = backtrace
+        return trap
+    }
+}
+
+/// A reason for a trap that occurred during execution of a WebAssembly module.
+enum TrapReason: Error, CustomStringConvertible {
+    struct Message {
+        let text: String
+
+        init(_ text: String) {
+            self.text = text
+        }
+    }
+    /// A trap with a string message
+    case message(Message)
+    /// `unreachable` instruction executed
+    case unreachable
     /// Too deep call stack
+    ///
+    /// Note: When this trap occurs, consider extending ``EngineConfiguration/stackSize``.
     case callStackExhausted
-
-    // Store
     /// Out of bounds table access
-    case outOfBoundsTableAccess(Int)
-    /// Reading a dropped reference
-    case readingDroppedReference(index: Int)
-
-    // Invocation
-    /// Exported function not found
-    case exportedFunctionNotFound(Instance, name: String)
-    /// The table element is not initialized
-    case tableUninitialized(Int)
-    /// Undefined element in the table
-    case undefinedElement
-    /// Table size overflow
-    case tableSizeOverflow
-    /// Indirect call type mismatch
-    case callIndirectFunctionTypeMismatch(actual: FunctionType, expected: FunctionType)
+    case tableOutOfBounds(Int)
     /// Out of bounds memory access
-    case outOfBoundsMemoryAccess
-    /// Invalid function index
-    case invalidFunctionIndex(Int)
+    case memoryOutOfBounds
+    /// `call_indirect` instruction called an uninitialized table element.
+    case indirectCallToNull(Int)
+    /// Indirect call type mismatch
+    case typeMismatchCall(actual: FunctionType, expected: FunctionType)
     /// Integer divided by zero
     case integerDividedByZero
     /// Integer overflowed during arithmetic operation
-    case integerOverflowed
+    case integerOverflow
     /// Invalid conversion to integer
     case invalidConversionToInteger
 
-    /// Human-readable text representation of the trap that `.wast` text format expects in assertions
-    public var assertionText: String {
+    /// The description of the trap reason.
+    var description: String {
         switch self {
-        case .outOfBoundsMemoryAccess:
+        case .message(let message):
+            return message.text
+        case .unreachable:
+            return "unreachable"
+        case .callStackExhausted:
+            return "call stack exhausted"
+        case .memoryOutOfBounds:
             return "out of bounds memory access"
         case .integerDividedByZero:
             return "integer divide by zero"
-        case .integerOverflowed:
+        case .integerOverflow:
             return "integer overflow"
         case .invalidConversionToInteger:
             return "invalid conversion to integer"
-        case .undefinedElement:
-            return "undefined element"
-        case let .tableUninitialized(elementIndex):
-            return "uninitialized element \(elementIndex)"
-        case .callIndirectFunctionTypeMismatch:
-            return "indirect call type mismatch"
-        case .outOfBoundsTableAccess, .tableSizeOverflow:
-            return "out of bounds table access"
-        case .callStackExhausted:
-            return "call stack exhausted"
-        default:
-            return String(describing: self)
+        case let .indirectCallToNull(elementIndex):
+            return "indirect call to null element (uninitialized element \(elementIndex))"
+        case .typeMismatchCall(let actual, let expected):
+            return "indirect call type mismatch, expected \(expected), got \(actual)"
+        case .tableOutOfBounds(let index):
+            return "out of bounds table access at \(index) (undefined element)"
         }
     }
 }
 
-public enum InstantiationError: Error {
-    case importsAndExternalValuesMismatch
-    case invalidTableExpression
-    case outOfBoundsTableAccess
-    case outOfBoundsMemoryAccess
-    case unsupported(String)
-    case exportIndexOutOfBounds(kind: String, index: Int, count: Int)
+extension TrapReason.Message {
+    static func initialTableSizeExceedsLimit(numberOfElements: Int) -> Self {
+        Self("initial table size exceeds the resource limit: \(numberOfElements) elements")
+    }
+    static func initialMemorySizeExceedsLimit(byteSize: Int) -> Self {
+        Self("initial memory size exceeds the resource limit: \(byteSize) bytes")
+    }
+    static func parameterTypesMismatch(expected: [ValueType], got: [Value]) -> Self {
+        Self("parameter types don't match, expected \(expected), got \(got)")
+    }
+    static func resultTypesMismatch(expected: [ValueType], got: [Value]) -> Self {
+        Self("result types don't match, expected \(expected), got \(got)")
+    }
+    static var cannotAssignToImmutableGlobal: Self {
+        Self("cannot assign to an immutable global")
+    }
+    static func noGlobalExportWithName(globalName: String, instance: Instance) -> Self {
+        Self("no global export with name \(globalName) in a module instance \(instance)")
+    }
+    static func exportedFunctionNotFound(name: String, instance: Instance) -> Self {
+        Self("exported function \(name) not found in instance \(instance)")
+    }
+}
 
-    /// Human-readable text representation of the trap that `.wast` text format expects in assertions
-    public var assertionText: String {
-        switch self {
-        case .outOfBoundsTableAccess:
-            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)
+struct ImportError: Error {
+    struct Message {
+        let text: String
+
+        init(_ text: String) {
+            self.text = text
         }
     }
-}
 
-public enum ImportError: Error {
-    case unknownImport(moduleName: String, externalName: String)
-    case incompatibleImportType
-    case importedEntityFromDifferentStore
-    case moduleInstanceAlreadyRegistered(String)
+    let message: Message
 
-    /// Human-readable text representation of the trap that `.wast` text format expects in assertions
-    public var assertionText: String {
-        switch self {
-        case .unknownImport:
-            return "unknown import"
-        case .incompatibleImportType:
-            return "incompatible import type"
-        case .importedEntityFromDifferentStore:
-            return "imported entity from different store"
-        case let .moduleInstanceAlreadyRegistered(name):
-            return "a module instance is already registered under a name `\(name)"
+    init(_ message: Message) {
+        self.message = message
+    }
+}
+
+extension ImportError.Message {
+    static func missing(moduleName: String, externalName: String) -> Self {
+        Self("unknown import \(moduleName).\(externalName)")
+    }
+    static func incompatibleType(_ importEntry: Import, entity: InternalExternalValue) -> Self {
+        let expected: String
+        switch importEntry.descriptor {
+        case .function:
+            expected = "function"
+        case .global:
+            expected = "global"
+        case .memory:
+            expected = "memory"
+        case .table:
+            expected = "table"
+        }
+        let got: String
+        switch entity {
+        case .function:
+            got = "function"
+        case .global:
+            got = "global"
+        case .memory:
+            got = "memory"
+        case .table:
+            got = "table"
         }
+        return Self("incompatible import type for \(importEntry.module).\(importEntry.name), expected \(expected), got \(got)")
+    }
+    static func incompatibleFunctionType(_ importEntry: Import, actual: FunctionType, expected: FunctionType) -> Self {
+        Self("incompatible import type: function type for \(importEntry.module).\(importEntry.name), expected \(expected), got \(actual)")
+    }
+    static func incompatibleTableType(_ importEntry: Import, actual: TableType, expected: TableType) -> Self {
+        Self("incompatible import type: table type for \(importEntry.module).\(importEntry.name), expected \(expected), got \(actual)")
+    }
+    static func incompatibleMemoryType(_ importEntry: Import, actual: MemoryType, expected: MemoryType) -> Self {
+        Self("incompatible import type: memory type for \(importEntry.module).\(importEntry.name), expected \(expected), got \(actual)")
+    }
+    static func incompatibleGlobalType(_ importEntry: Import, actual: GlobalType, expected: GlobalType) -> Self {
+        Self("incompatible import type: global type for \(importEntry.module).\(importEntry.name), expected \(expected), got \(actual)")
+    }
+    static func importedEntityFromDifferentStore(_ importEntry: Import) -> Self {
+        Self("imported entity from different store: \(importEntry.module).\(importEntry.name)")
+    }
+    static func moduleInstanceAlreadyRegistered(_ name: String) -> Self {
+        Self("a module instance is already registered under a name `\(name)")
     }
 }

Sources/WasmKit/Execution/Execution.swift

@@ -53,7 +53,7 @@ struct Execution {
     ) throws -> Sp {
         let newSp = sp.advanced(by: Int(spAddend))
         guard newSp.advanced(by: iseq.maxStackHeight) < stackEnd else {
-            throw Trap.callStackExhausted
+            throw Trap(.callStackExhausted)
         }
         // Initialize the locals with zeros (all types of value have the same representation)
         newSp.initialize(repeating: UntypedValue.default.storage, count: numberOfNonParameterLocals)

Sources/WasmKit/Execution/Function.swift

@@ -156,7 +156,7 @@ struct InternalFunction: Equatable, Hashable {
 
 extension InternalFunction: ValidatableEntity {
     static func createOutOfBoundsError(index: Int, count: Int) -> any Error {
-        Trap.invalidFunctionIndex(index)
+        ValidationError(.indexOutOfBounds("function", index, max: count))
     }
 }
 
@@ -199,13 +199,13 @@ extension InternalFunction {
 
     private func check(functionType: FunctionType, parameters: [Value]) throws {
         guard check(expectedTypes: functionType.parameters, values: parameters) else {
-            throw Trap._raw("parameters types don't match, expected \(functionType.parameters), got \(parameters)")
+            throw Trap(.parameterTypesMismatch(expected: functionType.parameters, got: parameters))
         }
     }
 
     private func check(functionType: FunctionType, results: [Value]) throws {
         guard check(expectedTypes: functionType.results, values: results) else {
-            throw Trap._raw("result types don't match, expected \(functionType.results), got \(results)")
+            throw Trap(.resultTypesMismatch(expected: functionType.results, got: results))
         }
     }