Distinguish default match action

Author: FlickerSoul

Sources/BinaryParseKitMacros/Macros/ParseEnum/ConstructParseEnumMacro.swift

@@ -53,6 +53,9 @@ public struct ConstructEnumParseMacro: ExtensionMacro {
                             } else if let toBeMatched = caseParseInfo.bytesToMatch(of: type) {
                                 // Byte-array-based matching: use __matchBytes with inout span
                                 ExprSyntax("\(raw: Constants.UtilityFunctions.matchBytes)(\(toBeMatched), in: &span)")
+                            } else if caseParseInfo.matchAction.target.isDefaultMatch {
+                                // Default matching: always true
+                                ExprSyntax("true")
                             } else {
                                 // Otherwise, it's a failure on our side
                                 throw ParseEnumMacroError.unexpectedError(
@@ -61,9 +64,7 @@ public struct ConstructEnumParseMacro: ExtensionMacro {
                             }
                         }
 
-                        try IfExprSyntax(
-                            "if \(matchCondition)",
-                        ) {
+                        try IfExprSyntax("if \(matchCondition)") {
                             if caseParseInfo.matchAction.matchPolicy == .matchAndTake {
                                 if let toBeMatched = caseParseInfo.bytesToMatch(of: type) {
                                     "try span.seek(toRelativeOffset: \(toBeMatched).count)"
@@ -204,7 +205,8 @@ public struct ConstructEnumParseMacro: ExtensionMacro {
                             let caseCodeBlock = try CodeBlockItemListSyntax {
                                 let bytesTakenInMatching = context.makeUniqueName("bytesTakenInMatching")
 
-                                if caseParseInfo.matchAction.isLengthMatch {
+                                if caseParseInfo.matchAction.target.isLengthMatch
+                                    || caseParseInfo.matchAction.target.isDefaultMatch {
                                     // For length-based matching, use empty bytes array (similar to matchDefault)
                                     "let \(bytesTakenInMatching): [UInt8] = []"
                                 } else if let bytesToMatch = caseParseInfo.bytesToMatch(of: type) {

Sources/BinaryParseKitMacros/Macros/ParseEnum/EnumCaseParseInfo.swift

@@ -52,47 +52,56 @@ enum EnumMatchTarget {
     // @matchAndTake() -> .bytes(nil)
     // @matchAndTake(byte: byte) -> .byte([byte])
     // @matchAndTake(bytes: bytes) -> .bytes(bytes)
-    // @matchDefault() -> .bytes([])
     case bytes(ExprSyntax?)
     // @match(length: length) -> .length(length)
     case length(ExprSyntax)
-}
-
-struct EnumCaseMatchAction {
-    let target: EnumMatchTarget
-    let matchPolicy: EnumCaseMatchPolicy
+    // @matchDefault
+    case `default`
 
     var matchBytes: ExprSyntax?? {
-        if case let .bytes(bytes) = target {
+        if case let .bytes(bytes) = self {
             bytes
         } else {
             nil
         }
     }
 
     var matchLength: ExprSyntax? {
-        if case let .length(length) = target {
+        if case let .length(length) = self {
             length
         } else {
             nil
         }
     }
 
     var isLengthMatch: Bool {
-        if case .length = target {
+        if case .length = self {
             true
         } else {
             false
         }
     }
 
     var isByteMatch: Bool {
-        if case .bytes = target {
+        if case .bytes = self {
+            true
+        } else {
+            false
+        }
+    }
+
+    var isDefaultMatch: Bool {
+        if case .default = self {
             true
         } else {
             false
         }
     }
+}
+
+struct EnumCaseMatchAction {
+    let target: EnumMatchTarget
+    let matchPolicy: EnumCaseMatchPolicy
 
     static func match(bytes: ExprSyntax?) -> EnumCaseMatchAction {
         EnumCaseMatchAction(target: .bytes(bytes), matchPolicy: .match)
@@ -103,7 +112,7 @@ struct EnumCaseMatchAction {
     }
 
     static func matchDefault() -> EnumCaseMatchAction {
-        EnumCaseMatchAction(target: .bytes("[]"), matchPolicy: .matchDefault)
+        EnumCaseMatchAction(target: .default, matchPolicy: .matchDefault)
     }
 
     static func matchAndTake(bytes: ExprSyntax?) -> EnumCaseMatchAction {
@@ -189,7 +198,7 @@ struct EnumCaseParseInfo {
     }
 
     func bytesToMatch(of type: some TypeSyntaxProtocol) -> ExprSyntax? {
-        matchAction.matchBytes.map { matchBytes in
+        matchAction.target.matchBytes.map { matchBytes in
             if let matchBytes {
                 matchBytes
             } else {
@@ -201,7 +210,7 @@ struct EnumCaseParseInfo {
     }
 
     func lengthToMatch() -> ExprSyntax? {
-        matchAction.matchLength
+        matchAction.target.matchLength
     }
 }
 

Sources/BinaryParseKitMacros/Macros/ParseEnum/ParseEnumCase.swift

@@ -111,7 +111,7 @@ class ParseEnumCase: SyntaxVisitor {
             }
 
             // Track matching strategy for mutual exclusivity validation
-            if matchAction.isLengthMatch {
+            if matchAction.target.isLengthMatch {
                 if hasByteMatch {
                     errors.append(
                         .init(
@@ -121,7 +121,7 @@ class ParseEnumCase: SyntaxVisitor {
                     )
                 }
                 hasLengthMatch = true
-            } else if matchAction.isByteMatch {
+            } else if matchAction.target.isByteMatch {
                 if hasLengthMatch {
                     errors.append(
                         .init(