WAT: Ban named param and check inline type consistency in block type

Author: kateinoigakukun

Sources/WAT/NameMapping.swift

@@ -169,8 +169,8 @@ struct TypesMap {
     /// Resolves a block type from a type use
     mutating func resolveBlockType(use: WatParser.TypeUse) throws -> BlockType {
         switch (use.index, use.inline) {
-        case let (indexOrId?, _):
-            let (type, index) = try resolve(use: indexOrId)
+        case let (indexOrId?, inline):
+            let (type, index) = try resolveAndCheck(use: indexOrId, inline: inline)
             return try resolveBlockType(signature: type.signature, resolveSignatureIndex: { _ in index })
         case (nil, let inline?):
             return try resolveBlockType(signature: inline.signature)
@@ -194,18 +194,22 @@ struct TypesMap {
         return (decl.type, index)
     }
 
+    private func resolveAndCheck(use indexOrId: Parser.IndexOrId, inline: WatParser.FunctionType?) throws -> (type: WatParser.FunctionType, index: Int) {
+        let (found, index) = try resolve(use: indexOrId)
+        if let inline {
+            // If both index and inline type, then they must match
+            guard found.signature == inline.signature else {
+                throw WatParserError("Type mismatch \(found) != \(inline)", location: indexOrId.location)
+            }
+        }
+        return (found, Int(index))
+    }
+
     /// Resolves a function type from a type use with an optional inline type
     mutating func resolve(use: WatParser.TypeUse) throws -> (type: WatParser.FunctionType, index: Int) {
         switch (use.index, use.inline) {
         case let (indexOrId?, inline):
-            let (found, index) = try resolve(use: indexOrId)
-            if let inline {
-                // If both index and inline type, then they must match
-                guard found.signature == inline.signature else {
-                    throw WatParserError("Type mismatch \(found) != \(inline)", location: indexOrId.location)
-                }
-            }
-            return (found, Int(index))
+            return try resolveAndCheck(use: indexOrId, inline: inline)
         case (nil, let inline):
             // If no index and no inline type, then it's a function type with no parameters or results
             let inline = inline ?? WatParser.FunctionType(signature: WasmTypes.FunctionType(parameters: [], results: []), parameterNames: [])

Sources/WAT/Parser/ExpressionParser.swift

@@ -352,7 +352,7 @@ struct ExpressionParser<Visitor: InstructionVisitor> {
         if !results.isEmpty {
             return try wat.types.resolveBlockType(results: results)
         }
-        let typeUse = try withWatParser { try $0.typeUse() }
+        let typeUse = try withWatParser { try $0.typeUse(mayHaveName: false) }
         return try wat.types.resolveBlockType(use: typeUse)
     }
 
@@ -455,7 +455,7 @@ extension ExpressionParser {
         } else {
             tableIndex = 0
         }
-        let typeUse = try withWatParser { try $0.typeUse() }
+        let typeUse = try withWatParser { try $0.typeUse(mayHaveName: true) }
         let (_, typeIndex) = try wat.types.resolve(use: typeUse)
         return (UInt32(typeIndex), tableIndex)
     }

Sources/WAT/Parser/WatParser.swift

@@ -196,7 +196,7 @@ struct WatParser {
             let importNames = try importNames()
             if try parser.takeParenBlockStart("func") {
                 let id = try parser.takeId()
-                kind = .function(FunctionDecl(id: id, exports: [], typeUse: try typeUse(), kind: .imported(importNames)))
+                kind = .function(FunctionDecl(id: id, exports: [], typeUse: try typeUse(mayHaveName: true), kind: .imported(importNames)))
             } else if try parser.takeParenBlockStart("table") {
                 let id = try parser.takeId()
                 kind = .table(TableDecl(id: id, exports: [], type: try tableType(), importNames: importNames))
@@ -215,7 +215,7 @@ struct WatParser {
             let id = try parser.takeId()
             let exports = try inlineExports()
             let importNames = try inlineImport()
-            let typeUse = try typeUse()
+            let typeUse = try typeUse(mayHaveName: true)
             let functionKind: FunctionKind
             if let importNames = importNames {
                 functionKind = .imported(importNames)
@@ -441,14 +441,14 @@ struct WatParser {
         return ImportNames(module: module, name: name)
     }
 
-    mutating func typeUse() throws -> TypeUse {
+    mutating func typeUse(mayHaveName: Bool) throws -> TypeUse {
         let location = parser.lexer.location()
         var index: Parser.IndexOrId?
         if try parser.takeParenBlockStart("type") {
             index = try parser.expectIndexOrId()
             try parser.expect(.rightParen)
         }
-        let inline = try optionalFunctionType()
+        let inline = try optionalFunctionType(mayHaveName: mayHaveName)
         return TypeUse(index: index, inline: inline, location: location)
     }
 
@@ -552,37 +552,39 @@ struct WatParser {
     mutating func funcType() throws -> FunctionType {
         try parser.expect(.leftParen)
         try parser.expectKeyword("func")
-        let (params, names) = try params()
+        let (params, names) = try params(mayHaveName: true)
         let results = try results()
         try parser.expect(.rightParen)
         return FunctionType(signature: WasmTypes.FunctionType(parameters: params, results: results), parameterNames: names)
     }
 
-    mutating func optionalFunctionType() throws -> FunctionType? {
-        let (params, names) = try params()
+    mutating func optionalFunctionType(mayHaveName: Bool) throws -> FunctionType? {
+        let (params, names) = try params(mayHaveName: mayHaveName)
         let results = try results()
         if results.isEmpty, params.isEmpty {
             return nil
         }
         return FunctionType(signature: WasmTypes.FunctionType(parameters: params, results: results), parameterNames: names)
     }
 
-    mutating func params() throws -> ([ValueType], [Name?]) {
+    mutating func params(mayHaveName: Bool) throws -> ([ValueType], [Name?]) {
         var types: [ValueType] = []
         var names: [Name?] = []
         while try parser.takeParenBlockStart("param") {
-            if let id = try parser.takeId() {
-                let valueType = try valueType()
-                types.append(valueType)
-                names.append(id)
-                try parser.expect(.rightParen)
-            } else {
-                while try !parser.take(.rightParen) {
+            if mayHaveName {
+                if let id = try parser.takeId() {
                     let valueType = try valueType()
                     types.append(valueType)
-                    names.append(nil)
+                    names.append(id)
+                    try parser.expect(.rightParen)
+                    continue
                 }
             }
+            while try !parser.take(.rightParen) {
+                let valueType = try valueType()
+                types.append(valueType)
+                names.append(nil)
+            }
         }
         return (types, names)
     }

Tests/WATTests/EncoderTests.swift

@@ -107,7 +107,6 @@ class EncoderTests: XCTestCase {
 
             var stats = CompatibilityTestStats()
             let excluded: [String] = [
-                "block.wast",
                 "call_indirect.wast",
                 "const.wast",
                 "float_literals.wast",