Migrate to Heap Type with some failing tests

Author: iainsmith

Sources/WAT/Encoder.swift

@@ -127,11 +127,9 @@ extension ValueType: WasmEncodable {
 
 extension ReferenceType: WasmEncodable {
     func encode(to encoder: inout Encoder) {
-        switch self {
-        case .funcRef: encoder.output.append(0x70)
-        case .funcRefNonNull: encoder.output.append(0x71)
+        switch self.heapType {
+        case .funcRef: encoder.output.append(isNullable ? 0x70 : 0x71)
         case .externRef: encoder.output.append(0x6F)
-        case .externRefNonNull: encoder.output.append(0x6E) // Is this correct
         }
     }
 }

Sources/WAT/Parser/WastParser.swift

@@ -63,13 +63,11 @@ struct WastParser {
         mutating func visitRefFunc(functionIndex: UInt32) throws {
             addValue(.ref(.function(FunctionAddress(functionIndex))))
         }
-        mutating func visitRefNull(type: ReferenceType) throws {
+        mutating func visitRefNull(type: HeapType) throws {
             let value: Reference
             switch type {
             case .externRef: value = .extern(nil)
-            case .externRefNonNull: value = .function(nil) // non null
             case .funcRef: value = .function(nil)
-            case .funcRefNonNull: value = .function(nil) // non null
             }
             addValue(.ref(value))
         }

Sources/WAT/Parser/WatParser.swift

@@ -650,8 +650,8 @@ struct WatParser {
         switch keyword {
         case "funcref": return .funcRef
         case "externref": return .externRef
-        case "func": return isNullable ? .funcRef : .funcRefNonNull
-        case "extern": return isNullable ? .externRef : .externRefNonNull
+        case "func": return ReferenceType(isNullable: isNullable, heapType: .funcRef)
+        case "extern": return ReferenceType(isNullable: isNullable, heapType: .funcRef)
         default: return nil
         }
     }

Sources/WasmKit/Execution/ConstEvaluation.swift

@@ -62,8 +62,10 @@ extension ConstExpression {
             return try context.globalValue(globalIndex)
         case .refNull(let type):
             switch type {
-            case .externRef, .externRefNonNull: return .ref(.extern(nil))
-            case .funcRef, .funcRefNonNull: return .ref(.function(nil))
+            case .externRef: return .ref(.extern(nil))
+            case .funcRef: return .ref(.function(nil))
+            default:
+                throw ValidationError(.illegalConstExpressionInstruction(constInst))
             }
         case .refFunc(let functionIndex):
             return try .ref(context.functionRef(functionIndex))

Sources/WasmKit/Execution/Instances.swift

@@ -274,15 +274,11 @@ struct TableEntity /* : ~Copyable */ {
 
     init(_ tableType: TableType, resourceLimiter: any ResourceLimiter) throws {
         let emptyElement: Reference
-        switch tableType.elementType {
+        switch tableType.elementType.heapType {
         case .funcRef:
             emptyElement = .function(nil)
-        case .funcRefNonNull:
-            emptyElement = .function(nil) // shouldn't be null
         case .externRef:
             emptyElement = .extern(nil)
-        case .externRefNonNull:
-            emptyElement = .extern(nil) // shouldn't be null
         }
 
         let numberOfElements = Int(tableType.limits.min)

Sources/WasmKit/Execution/Instructions/InstructionSupport.swift

@@ -105,11 +105,11 @@ extension Int32: InstructionImmediate {
 
 extension Instruction.RefNullOperand {
     init(result: VReg, type: ReferenceType) {
-        self.init(result: result, rawType: type.rawValue)
+        self.init(result: result, rawType: 0) // need to figure out rawType here
     }
 
     var type: ReferenceType {
-        ReferenceType(rawValue: rawType).unsafelyUnwrapped
+        ReferenceType(isNullable: true, heapType: .funcRef) // is this still a valid conversion?
     }
 }
 

Sources/WasmKit/Execution/Instructions/Misc.swift

@@ -22,10 +22,12 @@ extension Execution {
     mutating func refNull(sp: Sp, immediate: Instruction.RefNullOperand) {
         let value: Value
         switch immediate.type {
-        case .externRef, .externRefNonNull:
+        case .externRef:
             value = .ref(.extern(nil))
-        case .funcRef, .funcRefNonNull:
+        case .funcRef:
             value = .ref(.function(nil))
+        default:
+            fatalError()
         }
         sp[immediate.result] = UntypedValue(value)
     }

Sources/WasmKit/Execution/UntypedValue.swift

@@ -117,14 +117,10 @@ struct UntypedValue: Equatable, Hashable {
         switch type {
         case .funcRef:
             return .function(decodeOptionalInt())
-        case .funcRefNonNull:
-            // can skip optional check
-            return .function(decodeOptionalInt())
         case .externRef:
             return .extern(decodeOptionalInt())
-        case .externRefNonNull:
-            // can skip optional check
-            return .extern(decodeOptionalInt())
+        default:
+            fatalError()
         }
     }
 

Sources/WasmKit/Execution/Value.swift

@@ -1,4 +1,4 @@
-import enum WasmTypes.ReferenceType
+import struct WasmTypes.ReferenceType
 import enum WasmTypes.ValueType
 
 /// > Note:

Sources/WasmKit/Validator.swift

@@ -337,9 +337,7 @@ extension WasmTypes.Reference {
         // Should we validate nonNull variants have associated values present?
         switch (self, type) {
         case (.function, .funcRef): return
-        case (.function, .funcRefNonNull): return
         case (.extern, .externRef): return
-        case (.extern, .externRefNonNull): return
         default:
             throw ValidationError(.expectTypeButGot(expected: "\(type)", got: "\(self)"))
         }