BinaryParseKit/Sources/BinaryParseKitMacros/Macros/ParseStruct/ConstructParseStructMacro.swift at 9450e3dda5fc30ad1a6dfbf41686ccf9ba92937a · FlickerSoul/BinaryParseKit · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
//
//  ConstructParseStructMacro.swift
//  BinaryParseKit
//
//  Created by Larry Zeng on 7/15/25.
//
import BinaryParsing
import SwiftSyntax
import SwiftSyntaxBuilder
import SwiftSyntaxMacros

public struct ConstructStructParseMacro: ExtensionMacro {
    public static func expansion(
        of attributeNode: SwiftSyntax.AttributeSyntax,
        attachedTo declaration: some SwiftSyntax.DeclGroupSyntax,
        providingExtensionsOf type: some SwiftSyntax.TypeSyntaxProtocol,
        conformingTo _: [SwiftSyntax.TypeSyntax],
        in context: some SwiftSyntaxMacros.MacroExpansionContext,
    ) throws -> [SwiftSyntax.ExtensionDeclSyntax] {
        guard let structDeclaration = declaration.as(StructDeclSyntax.self) else {
            throw ParseStructMacroError.onlyStructsAreSupported
        }

        let accessorInfo = try extractAccessor(
            from: attributeNode,
            attachedTo: structDeclaration,
            in: context,
        )

        let structFieldInfo = ParseStructField(context: context)
        structFieldInfo.walk(structDeclaration)
        try structFieldInfo.validate(for: structDeclaration)

        let type = TypeSyntax(type)

        let extensionSyntax =
            try ExtensionDeclSyntax("extension \(type): \(raw: Constants.Protocols.parsableProtocol)") {
                try InitializerDeclSyntax(
                    "\(accessorInfo.parsingAccessor) init(parsing span: inout \(raw: Constants.BinaryParsing.parserSpan)) throws(\(raw: Constants.BinaryParsing.thrownParsingError))",
                ) {
                    for (variableName, variableInfo) in structFieldInfo.variables {
                        for action in variableInfo.parseActions {
                            switch action {
                            case let .parse(fieldParseInfo):
                                generateParseBlock(
                                    variableName: variableName,
                                    variableType: variableInfo.type,
                                    fieldParseInfo: fieldParseInfo,
                                    useSelf: true,
                                )
                            case let .skip(skipInfo):
                                generateSkipBlock(variableName: variableName, skipInfo: skipInfo)
                            }
                        }
                    }
                }
            }

        let printerExtension =
            try ExtensionDeclSyntax("extension \(type): \(raw: Constants.Protocols.printableProtocol)") {
                try FunctionDeclSyntax("\(accessorInfo.printingAccessor) func printerIntel() throws -> PrinterIntel") {
                    var parseSkipMacroInfo: [PrintableFieldInfo] = []

                    for (variableName, variableInfo) in structFieldInfo.variables {
                        for parseAction in variableInfo.parseActions {
                            switch parseAction {
                            case let .parse(parseInfo):
                                // swiftformat:disable:next redundantLet swiftlint:disable:next redundant_discardable_let
                                let _ = parseSkipMacroInfo.append(
                                    .init(
                                        binding: variableName,
                                        byteCount: parseInfo.byteCount.toExprSyntax()
                                            .map { "\(raw: Constants.Swift.byteCountType)(\($0))" },
                                        endianness: parseInfo.endianness,
                                    ),
                                )
                            case let .skip(skipInfo):
                                // swiftformat:disable:next redundantLet swiftlint:disable:next redundant_discardable_let
                                let _ = parseSkipMacroInfo.append(
                                    .init(
                                        binding: nil,
                                        byteCount: "\(raw: Constants.Swift.byteCountType)(\(raw: skipInfo.byteCount))",
                                        endianness: nil,
                                    ),
                                )
                            }
                        }
                    }

                    let fields = ArrayExprSyntax(elements: generatePrintableFields(parseSkipMacroInfo))

                    #"""
                    return .struct(
                        .init(
                            fields: \#(fields)
                        )
                    )
                    """#
                }
            }

        return [extensionSyntax, printerExtension]
    }
}