PrincipleMacros/Sources/PrincipleMacros/Syntax/Extensions/WithModifiersSyntax.swift at f1cccd4e9b6ef5d7570451dd3d017f8c24e217da · NSFatalError/PrincipleMacros · 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
//
//  WithModifiersSyntax.swift
//  PrincipleMacros
//
//  Created by Kamil Strzelecki on 12/01/2025.
//  Copyright © 2025 Kamil Strzelecki. All rights reserved.
//

import SwiftSyntax

extension WithModifiersSyntax {

    public var finalSpecifier: TokenSyntax? {
        modifiers.lazy.map(\.name).first { name in
            name.tokenKind == .keyword(.final)
        }
    }

    public var typeScopeSpecifier: TokenSyntax? {
        modifiers.lazy.map(\.name).first { name in
            TokenKind.typeScopeSpecifiers.contains(name.tokenKind)
        }
    }
}

extension WithModifiersSyntax {

    public var accessControlLevel: TokenSyntax? {
        accessControlLevel(detail: nil)
    }

    public var setterAccessControlLevel: TokenSyntax? {
        accessControlLevel(detail: .identifier("set")) ?? accessControlLevel
    }

    private func accessControlLevel(detail: TokenKind?) -> TokenSyntax? {
        modifiers.lazy
            .filter { $0.detail?.detail.tokenKind == detail }
            .map(\.name)
            .first { TokenKind.accessControlLevels.contains($0.tokenKind) }
    }
}

extension WithModifiersSyntax {

    public func inlinableAccessControlLevel(
        inheritedBy inheritingDeclaration: InheritingDeclaration,
        maxAllowed: Keyword
    ) -> TokenSyntax? {
        guard let accessControlLevel,
              let index = TokenKind.accessControlLevels.firstIndex(of: accessControlLevel.tokenKind),
              let maxAllowedIndex = Keyword.accessControlLevels.firstIndex(of: maxAllowed)
        else {
            return nil
        }

        guard index <= maxAllowedIndex else {
            let tokenKind = TokenKind.accessControlLevels[maxAllowedIndex]
            return TokenSyntax(tokenKind, presence: .present).withTrailingSpace
        }

        switch inheritingDeclaration {
        case .member:
            if let internalIndex = Keyword.accessControlLevels.firstIndex(of: .internal),
               index <= internalIndex {
                return nil
            }
        case .peer:
            break
        }

        return accessControlLevel.trimmed.withTrailingSpace
    }
}

extension TokenKind {

    fileprivate static let typeScopeSpecifiers = Keyword.typeScopeSpecifiers
        .map(TokenKind.keyword)

    fileprivate static let accessControlLevels = Keyword.accessControlLevels
        .map(TokenKind.keyword)
}

extension Keyword {

    fileprivate static let typeScopeSpecifiers: [Keyword] = [
        .static,
        .class
    ]

    fileprivate static let accessControlLevels: [Keyword] = [
        .private,
        .fileprivate,
        .internal,
        .package,
        .public,
        .open
    ]
}