Function Reference: Add explicit nonNull references & call_ref

instruction

Author: iainsmith

README.md

@@ -69,6 +69,8 @@ and should work on the following platforms:
 |                      | [Non-trapping float-to-int conversions](https://github.com/WebAssembly/nontrapping-float-to-int-conversions/blob/main/proposals/nontrapping-float-to-int-conversion/Overview.md) | ✅ Implemented |
 |                      | [Memory64](https://github.com/WebAssembly/memory64/blob/main/proposals/memory64/Overview.md) | ✅ Implemented |
 |                      | [Threads and atomics](https://github.com/WebAssembly/threads/blob/master/proposals/threads/Overview.md) | 🚧 Parser implemented |
+|                      | [Typed Function References](https://github.com/WebAssembly/function-references/blob/main/proposals/function-references/Overview.md) | 📋 Todo  |
+|                      | [Garbage Collection](https://github.com/WebAssembly/gc/blob/main/proposals/gc/Overview.md) |  📋 Todo |
 | WASI | WASI Preview 1 | ✅ Implemented |
 
 

Sources/WAT/BinaryInstructionEncoder.swift

@@ -384,4 +384,8 @@ extension BinaryInstructionEncoder {
         try encodeInstruction([0xFC, 0x10])
         try encodeImmediates(table: table)
     }
+    mutating func visitCallRef(functionIndex: UInt32) throws {
+        try encodeInstruction([0x14])
+        try encodeImmediates(functionIndex: functionIndex)
+    }
 }

Sources/WAT/Encoder.swift

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

Sources/WAT/ParseTextInstruction.swift

@@ -326,6 +326,9 @@ func parseTextInstruction<V: InstructionVisitor>(keyword: String, expressionPars
     case "i64.trunc_sat_f32_u": return { return try $0.visitConversion(.i64TruncSatF32U) }
     case "i64.trunc_sat_f64_s": return { return try $0.visitConversion(.i64TruncSatF64S) }
     case "i64.trunc_sat_f64_u": return { return try $0.visitConversion(.i64TruncSatF64U) }
+    case "call_ref":
+        let (functionIndex) = try expressionParser.visitCallRef(wat: &wat)
+        return { return try $0.visitCallRef(functionIndex: functionIndex) }
     default: return nil
     }
 }

Sources/WAT/Parser/ExpressionParser.swift

@@ -362,7 +362,9 @@ struct ExpressionParser<Visitor: InstructionVisitor> {
     }
 
     private mutating func refKind() throws -> ReferenceType {
-        if try parser.takeKeyword("func") {
+        if try parser.take(.id) {
+            return .funcRef // not sure about this.
+        } else if try parser.takeKeyword("func") {
             return .funcRef
         } else if try parser.takeKeyword("extern") {
             return .externRef
@@ -439,6 +441,10 @@ extension ExpressionParser {
         let use = try parser.expectIndexOrId()
         return UInt32(try wat.functionsMap.resolve(use: use).index)
     }
+    mutating func visitCallRef(wat: inout Wat) throws -> UInt32 {
+        let use = try parser.expectIndexOrId()
+        return UInt32(try wat.types.resolve(use: use).index)
+    }
     mutating func visitCallIndirect(wat: inout Wat) throws -> (typeIndex: UInt32, tableIndex: UInt32) {
         let tableIndex: UInt32
         if let tableId = try parser.takeIndexOrId() {

Sources/WAT/Parser/WastParser.swift

@@ -67,7 +67,9 @@ struct WastParser {
             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

@@ -606,29 +606,59 @@ struct WatParser {
     }
 
     mutating func valueType() throws -> ValueType {
+        if try parser.peek(.leftParen) != nil {
+            return try _referenceValueType()
+        } else {
+            return try _valueType()
+        }
+    }
+
+    // must consume right paren
+    mutating func _referenceValueType() throws -> ValueType {
+        var isNullable = false
+        _ = try parser.takeParenBlockStart("ref")
+        if try parser.peekKeyword() == "null" {
+            _ = try parser.takeKeyword("null")
+            isNullable = true
+        }
+
+        if try parser.takeId() != nil {
+            _ = try parser.take(.rightParen)
+            return .ref(refType(keyword: "func", isNullable: isNullable)!)
+        }
+
+        let keyword = try parser.expectKeyword()
+        _ = try parser.take(.rightParen)
+        if let refType = refType(keyword: keyword, isNullable: isNullable) { return .ref(refType) }
+        throw WatParserError("unexpected value type \(keyword)", location: parser.lexer.location())
+    }
+
+    mutating func _valueType() throws -> ValueType {
         let keyword = try parser.expectKeyword()
         switch keyword {
         case "i32": return .i32
         case "i64": return .i64
         case "f32": return .f32
         case "f64": return .f64
         default:
-            if let refType = refType(keyword: keyword) { return .ref(refType) }
+            if let refType = refType(keyword: keyword, isNullable: true) { return .ref(refType) }
             throw WatParserError("unexpected value type \(keyword)", location: parser.lexer.location())
         }
     }
 
-    mutating func refType(keyword: String) -> ReferenceType? {
+    mutating func refType(keyword: String, isNullable: Bool) -> ReferenceType? {
         switch keyword {
         case "funcref": return .funcRef
         case "externref": return .externRef
+        case "func": return isNullable ? .funcRef : .funcRefNonNull
+        case "extern": return isNullable ? .externRef : .externRefNonNull
         default: return nil
         }
     }
 
     mutating func refType() throws -> ReferenceType {
         let keyword = try parser.expectKeyword()
-        guard let refType = refType(keyword: keyword) else {
+        guard let refType = refType(keyword: keyword, isNullable: true) else {
             throw WatParserError("unexpected ref type \(keyword)", location: parser.lexer.location())
         }
         return refType

Sources/WasmKit/Execution/ConstEvaluation.swift

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

Sources/WasmKit/Execution/Instances.swift

@@ -277,8 +277,12 @@ struct TableEntity /* : ~Copyable */ {
         switch tableType.elementType {
         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/Misc.swift

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