Add error tests

Author: FlickerSoul

Sources/BinaryParseKit/BinaryParseKit.swift

@@ -306,3 +306,27 @@ public macro match(bytes: [UInt8]) = #externalMacro(
     module: "BinaryParseKitMacros",
     type: "EmptyPeerMacro",
 )
+
+@attached(peer)
+public macro matchAndTake() = #externalMacro(
+    module: "BinaryParseKitMacros",
+    type: "EmptyPeerMacro",
+)
+
+@attached(peer)
+public macro matchAndTake(byte: UInt8) = #externalMacro(
+    module: "BinaryParseKitMacros",
+    type: "EmptyPeerMacro",
+)
+
+@attached(peer)
+public macro matchAndTake(bytes: [UInt8]) = #externalMacro(
+    module: "BinaryParseKitMacros",
+    type: "EmptyPeerMacro",
+)
+
+@attached(peer)
+public macro matchDefault() = #externalMacro(
+    module: "BinaryParseKitMacros",
+    type: "EmptyPeerMacro",
+)

Sources/BinaryParseKit/EnumParseUtils.swift

@@ -6,19 +6,20 @@
 //
 import BinaryParsing
 
+/// Matches the given bytes in the input parser span.
 /// - Warning: This function is used to `@parseEnum` macro and should not be used directly.
 @inlinable
-public func __match(_ bytes: [UInt8], in input: inout BinaryParsing.ParserSpan) -> Bool {
-    // FIXME: right now, it's all `matchAndTake` semantic, implement a peak on ParserSpan??
-    (try? input.atomically { span in
-        let toMatchSpan = try span.sliceSpan(byteCount: bytes.count)
-        let toMatch: [UInt8] = unsafe toMatchSpan.withUnsafeBytes(Array.init)
-        if toMatch == bytes {
-            return true
-        } else {
-            throw BinaryParserKitError.failedToParse("Expected bytes \(bytes), found \(toMatch)")
-        }
-    }) ?? false
+public func __match(_ bytes: borrowing [UInt8], in input: inout BinaryParsing.ParserSpan) -> Bool {
+    if bytes.isEmpty { return true }
+
+    do {
+        try input._checkCount(minimum: bytes.count)
+    } catch {
+        return false
+    }
+
+    let toMatch = unsafe input.bytes.extracting(first: bytes.count).withUnsafeBytes(Array.init)
+    return toMatch == bytes
 }
 
 /// - Warning: This function is used to `@parse` macro and should not be used directly.

Sources/BinaryParseKitMacros/Macros/ParseEnum/ConsructParseEnumMacro.swift

@@ -48,6 +48,10 @@ public struct ConstructEnumParseMacro: ExtensionMacro {
                         try IfExprSyntax(
                             "if \(raw: Constants.UtilityFunctions.matchBytes)(\(toBeMatched), in: &span)",
                         ) {
+                            if caseParseInfo.matchAction.matchPolicy == .matchAndTake {
+                                "try input.seek(toRelativeOffset: \(toBeMatched).count)"
+                            }
+
                             var arguments: OrderedDictionary<TokenSyntax, EnumCaseParameterParseInfo> = [:]
 
                             for parseAction in caseParseInfo.parseActions {

Sources/BinaryParseKitMacros/Macros/ParseEnum/ParseEnumCase.swift

@@ -13,10 +13,12 @@ class ParseEnumCase<C: MacroExpansionContext>: SyntaxVisitor {
 
     private var workEnum: EnumDeclSyntax?
     private var currentParseMacroVisitor: StructFieldVisitor<C>?
-    private var currentCaseElement: EnumCaseElementSyntax?
+    private var currentCaseElements: EnumCaseElementListSyntax?
     private var caseParseInfo: [EnumCaseParseInfo] = []
     private(set) var parsedInfo: EnumParseInfo?
 
+    private var hasMatchDefault = false
+
     private var errors: [Diagnostic] = []
 
     init(context: C) {
@@ -33,30 +35,16 @@ class ParseEnumCase<C: MacroExpansionContext>: SyntaxVisitor {
         return .visitChildren
     }
 
-    override func visit(_ node: EnumCaseDeclSyntax) -> SyntaxVisitorContinueKind {
-        // has multiple declaration in the same `case`, reject
-        guard node.elements.count <= 1 else {
-            errors.append(.init(node: node, message: ParseEnumMacroError.onlyOneEnumDeclarationForEachCase))
-            return .skipChildren
-        }
-
-        return .visitChildren
-    }
-
     override func visit(_ node: AttributeListSyntax) -> SyntaxVisitorContinueKind {
         currentParseMacroVisitor = StructFieldVisitor(context: context)
         currentParseMacroVisitor?.walk(node)
-        do {
-            try currentParseMacroVisitor?.validate()
-        } catch {
-            errors.append(.init(node: node, message: error))
-        }
+        currentParseMacroVisitor?.validate(errors: &errors)
 
         return .skipChildren
     }
 
-    override func visit(_ node: EnumCaseElementSyntax) -> SyntaxVisitorContinueKind {
-        currentCaseElement = node
+    override func visit(_ node: EnumCaseElementListSyntax) -> SyntaxVisitorContinueKind {
+        currentCaseElements = node
         return .skipChildren
     }
 
@@ -71,7 +59,7 @@ class ParseEnumCase<C: MacroExpansionContext>: SyntaxVisitor {
         guard node.belongsTo(workEnum) else {
             return
         }
-        guard let currentCaseElement else {
+        guard let currentCaseElements, !currentCaseElements.isEmpty else {
             errors.append(.init(
                 node: node,
                 message: ParseEnumMacroError.unexpectedError(description: "No enum case declaration"),
@@ -98,33 +86,43 @@ class ParseEnumCase<C: MacroExpansionContext>: SyntaxVisitor {
             return
         }
 
-        let caseParameters = currentCaseElement.parameterClause?.parameters ?? []
+        if matchAction.matchPolicy == .matchDefault {
+            if hasMatchDefault {
+                errors.append(
+                    .init(
+                        node: node,
+                        message: ParseEnumMacroError.onlyOneMatchDefaultAllowed,
+                    ),
+                )
+                return
+            }
 
-        let enumParseActions: [EnumParseAction]
-        do {
-            enumParseActions = try currentParseMacroVisitor.parseActions.convertToEnumParseAction(with: caseParameters)
-        } catch {
-            errors.append(.init(node: caseParameters, message: error))
-            return
+            hasMatchDefault = true
+        } else {
+            if hasMatchDefault {
+                errors.append(
+                    .init(
+                        node: node,
+                        message: ParseEnumMacroError.defaultCaseMustBeLast,
+                    ),
+                )
+            }
         }
 
-        if caseParseInfo.last?.matchAction.matchPolicy == .matchDefault {
-            errors.append(
+        for currentCaseElement in currentCaseElements {
+            let enumParseActions = currentParseMacroVisitor.parseActions.convertToEnumParseAction(
+                with: currentCaseElement,
+                errors: &errors,
+            )
+
+            caseParseInfo.append(
                 .init(
-                    node: node,
-                    message: ParseEnumMacroError.defaultCaseMustBeLast,
+                    matchAction: matchAction,
+                    parseActions: enumParseActions,
+                    caseElementName: currentCaseElement.name,
                 ),
             )
-            return
         }
-
-        caseParseInfo.append(
-            .init(
-                matchAction: matchAction,
-                parseActions: enumParseActions,
-                caseElementName: currentCaseElement.name,
-            ),
-        )
     }
 
     override func visitPost(_ node: EnumDeclSyntax) {
@@ -139,11 +137,11 @@ class ParseEnumCase<C: MacroExpansionContext>: SyntaxVisitor {
     }
 
     func validate() throws {
-        for error in errors {
-            context.diagnose(error)
-        }
-
         if !errors.isEmpty {
+            for error in errors {
+                context.diagnose(error)
+            }
+
             throw ParseEnumMacroError.unexpectedError(description: "Enum macro parsing encountered errors")
         }
     }
@@ -167,8 +165,11 @@ private extension EnumCaseDeclSyntax {
 
 private extension [StructParseAction] {
     func convertToEnumParseAction(
-        with parameters: EnumCaseParameterListSyntax,
-    ) throws(ParseEnumMacroError) -> [EnumParseAction] {
+        with enumCase: EnumCaseElementSyntax,
+        errors: inout [Diagnostic],
+    ) -> [EnumParseAction] {
+        let arguments = enumCase.parameterClause?.parameters ?? []
+
         var result: [EnumParseAction] = []
         var parseActionIndex = 0
 
@@ -177,30 +178,68 @@ private extension [StructParseAction] {
             parseActionIndex += 1
         }
 
-        for parameter in parameters {
+        for argument in arguments {
             while parseActionIndex < count, case let .skip(skipInfo) = self[parseActionIndex] {
                 addAction(.skip(skipInfo))
             }
 
             guard parseActionIndex < count else {
-                throw ParseEnumMacroError.parameterParseNumberNotMatch
+                errors.append(
+                    .init(
+                        node: argument,
+                        message: ParseEnumMacroError.caseArgumentsMoreThanMacros,
+                    ),
+                )
+                break
             }
 
             guard case let .parse(parseInfo) = self[parseActionIndex] else {
-                throw ParseEnumMacroError.unexpectedError(description: "countered skip action")
+                fatalError("countered skip action")
             }
 
             addAction(
                 .parse(
                     .init(
                         parseInfo: parseInfo,
-                        firstName: parameter.firstName,
-                        type: parameter.type,
+                        firstName: argument.firstName,
+                        type: argument.type,
                     ),
                 ),
             )
         }
 
+        if parseActionIndex != count {
+            while parseActionIndex < count {
+                let parseAction = self[parseActionIndex]
+
+                errors.append(
+                    .init(
+                        node: parseAction.source,
+                        message: ParseEnumMacroError.macrosMoreThanCaseArguments,
+                        notes: [.init(
+                            node: Syntax(enumCase),
+                            message: MacrosMoreThanCaseArgumentsNote(enumCase: enumCase.description),
+                        )],
+                    ),
+                )
+
+                parseActionIndex += 1
+            }
+        }
+
         return result
     }
 }
+
+struct MacrosMoreThanCaseArgumentsNote: NoteMessage {
+    let enumCase: String
+
+    var message: String {
+        "The enum case `\(enumCase)` has less associated values than parse/skip macros."
+    }
+
+    let noteID: SwiftDiagnostics.MessageID = .init(
+        domain: "observer.universe.BinaryParseKit.MoreThanCaseArgumentsNote",
+        id: "macrosMoreThanCaseArguments",
+    )
+}

Sources/BinaryParseKitMacros/Macros/ParseEnum/ParseEnumMacroError.swift

@@ -8,22 +8,27 @@ import SwiftDiagnostics
 
 enum ParseEnumMacroError: Error, DiagnosticMessage {
     case onlyEnumsAreSupported
-    case onlyOneEnumDeclarationForEachCase
-    case parameterParseNumberNotMatch
-    case matchMustProceedParse
+    case caseArgumentsMoreThanMacros
+    case macrosMoreThanCaseArguments
+    case matchMustProceedParseAndSkip
     case missingCaseMatchMacro
     case defaultCaseMustBeLast
+    case onlyOneMatchDefaultAllowed
+    case matchDefaultShouldBeLast
     case unexpectedError(description: String)
 
     var message: String {
         switch self {
         case .onlyEnumsAreSupported: "Only enums are supported by this macro."
-        case .onlyOneEnumDeclarationForEachCase: "Only one enum declaration is allowed for each case."
-        case .parameterParseNumberNotMatch:
-            "The number of the parse macros does not match the number of cases in the enum."
-        case .matchMustProceedParse: "The `match` macro must proceed all `parse` macro."
+        case .caseArgumentsMoreThanMacros:
+            "The associated values in the enum case exceed the number of parse/skip macros."
+        case .macrosMoreThanCaseArguments:
+            "There are more parse/skip macros than the number of cases in the enum."
+        case .matchMustProceedParseAndSkip: "The `match` macro must proceed all `parse` and `skip` macro."
         case .missingCaseMatchMacro: "A `case` declaration must has a `match` macro."
         case .defaultCaseMustBeLast: "The `matchDefault` case must be the last case in the enum."
+        case .onlyOneMatchDefaultAllowed: "Only one `matchDefault` case is allowed in a enum."
+        case .matchDefaultShouldBeLast: "The `matchDefault` case should be the last case in the enum."
         case let .unexpectedError(description: description):
             "Unexpected error: \(description)"
         }

Sources/BinaryParseKitMacros/Macros/ParseSkip/ParseSkipInfo.swift

@@ -11,10 +11,12 @@ import SwiftSyntax
 struct ParseSkipInfo {
     let byteCount: ByteCount
     let reason: ExprSyntax
+    let source: Syntax
 
-    init(byteCount: ByteCount, reason: ExprSyntax) {
+    init(byteCount: ByteCount, reason: ExprSyntax, source: Syntax) {
         self.byteCount = byteCount
         self.reason = reason
+        self.source = source
     }
 
     init(from attribute: AttributeSyntax) throws(ParseStructMacroError) {
@@ -46,6 +48,6 @@ struct ParseSkipInfo {
             )
         }
 
-        self.init(byteCount: byteCountValue, reason: reasonArgument.expression)
+        self.init(byteCount: byteCountValue, reason: reasonArgument.expression, source: Syntax(attribute))
     }
 }