2 | 
3 | 
4 | 
5 | 
6 | 
7 | 
10 |
11 |
119 |
--------------------------------------------------------------------------------
/Sources/SFSymbolsMacro/SFSymbol.swift:
--------------------------------------------------------------------------------
1 | //
2 | // SFSymbol.swift
3 | // SFSymbolsMacro/SFSymbolsMacro
4 | //
5 | // Created by Lukas Pistrol on 14.06.23.
6 | //
7 |
8 | /**
9 | A Swift macro for *"type-safe"* SF Symbols.
10 |
11 | ## Initialization
12 | ```swift
13 | @SFSymbol
14 | enum Symbols: String {
15 | case globe
16 | case circleFill = "circle.fill"
17 | }
18 | ```
19 |
20 | ## Usage
21 | ```swift
22 | var body: some View {
23 | Symbols.circleFill.image // ~= Image(systemName: "circle.fill")
24 | Label("Globe", systemImage: Symbols.globe.name) // ~= Label("Globe", systemImage: "globe")
25 | // the above can also be written as
26 | Label("Globe", systemImage: Symbols.globe())
27 | }
28 | ```
29 | */
30 | @attached(member, names: arbitrary)
31 | public macro SFSymbol() = #externalMacro(module: "SFSymbolsMacroImpl", type: "SFSymbolMacro")
32 |
--------------------------------------------------------------------------------
/Sources/SFSymbolsMacroImpl/SFSymbolsDiagnostic.swift:
--------------------------------------------------------------------------------
1 | //
2 | // SFSymbolsDiagnostic.swift
3 | // SFSymbolsMacro/SFSymbolsMacroImpl
4 | //
5 | // Created by Lukas Pistrol on 14.06.23.
6 | //
7 |
8 | import SwiftDiagnostics
9 |
10 | enum SFSymbolDiagnostic: DiagnosticMessage {
11 | case notAnEnum
12 | case missingStringProtocolConformance(symbol: String)
13 | case noValidSFSymbol(symbol: String)
14 |
15 | var severity: DiagnosticSeverity { return .error }
16 |
17 | var message: String {
18 | switch self {
19 | case .noValidSFSymbol(let symbol):
20 | "\"\(symbol)\" is not a valid SF Symbol."
21 | case .notAnEnum:
22 | "Macro \"@SFSymbol\" can only be applied to enums."
23 | case .missingStringProtocolConformance(let symbol):
24 | "Enum \"\(symbol)\" must declare a raw value type of String."
25 | }
26 | }
27 |
28 | var diagnosticID: MessageID {
29 | MessageID(domain: "SFSymbolMacro", id: self.message)
30 | }
31 | }
32 |
--------------------------------------------------------------------------------
/Sources/SFSymbolsMacroImpl/SFSymbolsMacro.swift:
--------------------------------------------------------------------------------
1 | //
2 | // SFSymbolsMacro.swift
3 | // SFSymbolsMacro/SFSymbolsMacroImpl
4 | //
5 | // Created by Lukas Pistrol on 14.06.23.
6 | //
7 |
8 | import SwiftDiagnostics
9 | import SwiftSyntax
10 | import SwiftSyntaxMacros
11 | import SwiftUI
12 |
13 | public struct SFSymbolMacro: MemberMacro {
14 |
15 | private typealias SymbolPair = (id: String, node: Syntax)
16 |
17 | public static func expansion<
18 | Declaration: DeclGroupSyntax, Context: MacroExpansionContext
19 | >(
20 | of node: AttributeSyntax,
21 | providingMembersOf declaration: Declaration,
22 | in context: Context
23 | ) throws -> [DeclSyntax] {
24 | try validate(declaration)
25 | let accessLevel = try getAccessLevel(declaration)
26 |
27 | return [
28 | """
29 | \(raw: accessLevel)var image: Image {
30 | Image(systemName: self.rawValue)
31 | }
32 | """,
33 | """
34 | \(raw: accessLevel)var name: String {
35 | self.rawValue
36 | }
37 | """,
38 | """
39 | #if canImport(UIKit)
40 | \(raw: accessLevel)func uiImage(configuration: UIImage.Configuration? = nil) -> UIImage {
41 | UIImage(systemName: self.rawValue, withConfiguration: configuration)!
42 | }
43 | #else
44 | \(raw: accessLevel)func nsImage(accessibilityDescription: String? = nil) -> NSImage {
45 | return NSImage(systemSymbolName: self.rawValue, accessibilityDescription: accessibilityDescription)!
46 | }
47 | #endif
48 | """,
49 | """
50 | \(raw: accessLevel)func callAsFunction() -> String {
51 | return self.rawValue
52 | }
53 | """
54 | ]
55 | }
56 |
57 | // MARK: Helper Methods
58 |
59 | private static func validate(_ declaration: DeclGroupSyntax) throws {
60 | try validateStringProtocolInheritance(declaration)
61 | let members = declaration.memberBlock.members
62 | let cases = members.compactMap { $0.decl.as(EnumCaseDeclSyntax.self) }
63 | let ids = getIdentifiers(from: cases)
64 | try ids.forEach { id throws in
65 | try assertUINSImage(for: id)
66 | }
67 | }
68 |
69 | private static func validateStringProtocolInheritance(_ declaration: DeclGroupSyntax) throws {
70 | guard let enumDecl = declaration.as(EnumDeclSyntax.self) else {
71 | throw DiagnosticsError(diagnostics: [
72 | .init(node: Syntax(declaration), message: SFSymbolDiagnostic.notAnEnum)
73 | ])
74 | }
75 | let identifier = enumDecl.name
76 | guard enumDecl.inheritanceClause?.inheritedTypes.contains(where: {
77 | $0.type.as(IdentifierTypeSyntax.self)?.name.text == "String"
78 | }) ?? false else {
79 | throw DiagnosticsError(diagnostics: [
80 | .init(node: Syntax(identifier), message: SFSymbolDiagnostic.missingStringProtocolConformance(symbol: identifier.text))
81 | ])
82 | }
83 | }
84 |
85 | /// Gets either the rawValue (if available) or the identifier of the enum case.
86 | private static func getIdentifiers(from cases: [EnumCaseDeclSyntax]) -> [SymbolPair] {
87 | return cases.flatMap { enumCase in
88 | let a = enumCase.elements.map {
89 | let idNode = $0.rawValue?.value.as(StringLiteralExprSyntax.self)?.segments.first {
90 | $0.as(StringSegmentSyntax.self) != nil
91 | }
92 | let id = idNode?.as(StringSegmentSyntax.self)?.content.text ?? $0.name.text
93 | let syntax = Syntax(enumCase)
94 | return (id: id, node: syntax)
95 | }
96 | return a
97 | }
98 | }
99 |
100 | private static func assertUINSImage(for id: (SymbolPair)) throws {
101 | #if canImport(UIKit)
102 | if let _ = UIImage(systemName: id.id) { return }
103 | #else
104 | if let _ = NSImage(systemSymbolName: id.id, accessibilityDescription: nil) { return }
105 | #endif
106 | throw DiagnosticsError(diagnostics: [
107 | .init(node: id.node, message: SFSymbolDiagnostic.noValidSFSymbol(symbol: id.0))
108 | ])
109 | }
110 |
111 | /// Gets access level
112 | private static func getAccessLevel(_ declaration: DeclGroupSyntax) throws -> String {
113 | guard let enumdeclaration = declaration.as(EnumDeclSyntax.self) else {
114 | throw DiagnosticsError(diagnostics: [
115 | .init(node: Syntax(declaration), message: SFSymbolDiagnostic.notAnEnum)
116 | ])
117 | }
118 | guard let accessLevel = enumdeclaration.modifiers.first(where: \.isNeededAccessLevelModifier)?.name.trimmed else {
119 | return ""
120 | }
121 | return "\(accessLevel.text) "
122 | }
123 | }
124 |
125 | extension DeclModifierSyntax {
126 | var isNeededAccessLevelModifier: Bool {
127 | switch self.name.tokenKind {
128 | case .keyword(.public): return true
129 | case .keyword(.internal): return true
130 | case .keyword(.fileprivate): return true
131 | case .keyword(.private): return true
132 | default: return false
133 | }
134 | }
135 | }
136 |
--------------------------------------------------------------------------------
/Sources/SFSymbolsMacroImpl/SFSymbolsMacroPlugin.swift:
--------------------------------------------------------------------------------
1 | //
2 | // SFSymbolsMacroPlugin.swift
3 | // SFSymbolsMacro/SFSymbolsMacroImpl
4 | //
5 | // Created by Lukas Pistrol on 14.06.23.
6 | //
7 |
8 | import SwiftCompilerPlugin
9 | import SwiftSyntaxMacros
10 |
11 | @main
12 | struct SFSymbolsMacroPlugin: CompilerPlugin {
13 | let providingMacros: [Macro.Type] = [
14 | SFSymbolMacro.self
15 | ]
16 | }
17 |
--------------------------------------------------------------------------------
/Tests/SFSymbolsMacroTests/SFSymbolsMacroTests.swift:
--------------------------------------------------------------------------------
1 | import SwiftSyntaxMacros
2 | import SwiftSyntaxMacrosTestSupport
3 | import XCTest
4 | import SFSymbolsMacroImpl
5 |
6 | let testMacros: [String: Macro.Type] = [
7 | "SFSymbol": SFSymbolMacro.self,
8 | ]
9 |
10 | final class SFSymbolsMacroTests: XCTestCase {
11 |
12 | func testSFSymbolMacro() {
13 | assertMacroExpansion(
14 | """
15 | @SFSymbol
16 | enum Symbols: String {
17 | case globe
18 | case circleFill = "circle.fill"
19 | }
20 | """,
21 | expandedSource:
22 | """
23 |
24 | enum Symbols: String {
25 | case globe
26 | case circleFill = "circle.fill"
27 |
28 | var image: Image {
29 | Image(systemName: self.rawValue)
30 | }
31 |
32 | var name: String {
33 | self.rawValue
34 | }
35 |
36 | #if canImport(UIKit)
37 | func uiImage(configuration: UIImage.Configuration? = nil) -> UIImage {
38 | UIImage(systemName: self.rawValue, withConfiguration: configuration)!
39 | }
40 | #else
41 | func nsImage(accessibilityDescription: String? = nil) -> NSImage {
42 | return NSImage(systemSymbolName: self.rawValue, accessibilityDescription: accessibilityDescription)!
43 | }
44 | #endif
45 |
46 | func callAsFunction() -> String {
47 | return self.rawValue
48 | }
49 | }
50 | """,
51 | macros: testMacros
52 | )
53 | }
54 |
55 | func testPublicSFSymbolMacro() {
56 | assertMacroExpansion(
57 | """
58 | @SFSymbol
59 | public enum Symbols: String {
60 | case globe
61 | case circleFill = "circle.fill"
62 | }
63 | """,
64 | expandedSource:
65 | """
66 |
67 | public enum Symbols: String {
68 | case globe
69 | case circleFill = "circle.fill"
70 |
71 | public var image: Image {
72 | Image(systemName: self.rawValue)
73 | }
74 |
75 | public var name: String {
76 | self.rawValue
77 | }
78 |
79 | #if canImport(UIKit)
80 | public func uiImage(configuration: UIImage.Configuration? = nil) -> UIImage {
81 | UIImage(systemName: self.rawValue, withConfiguration: configuration)!
82 | }
83 | #else
84 | public func nsImage(accessibilityDescription: String? = nil) -> NSImage {
85 | return NSImage(systemSymbolName: self.rawValue, accessibilityDescription: accessibilityDescription)!
86 | }
87 | #endif
88 |
89 | public func callAsFunction() -> String {
90 | return self.rawValue
91 | }
92 | }
93 | """,
94 | macros: testMacros
95 | )
96 | }
97 |
98 | func testInternalSFSymbolMacro() {
99 | assertMacroExpansion(
100 | """
101 | @SFSymbol
102 | internal enum Symbols: String {
103 | case globe
104 | case circleFill = "circle.fill"
105 | }
106 | """,
107 | expandedSource:
108 | """
109 |
110 | internal enum Symbols: String {
111 | case globe
112 | case circleFill = "circle.fill"
113 |
114 | internal var image: Image {
115 | Image(systemName: self.rawValue)
116 | }
117 |
118 | internal var name: String {
119 | self.rawValue
120 | }
121 |
122 | #if canImport(UIKit)
123 | internal func uiImage(configuration: UIImage.Configuration? = nil) -> UIImage {
124 | UIImage(systemName: self.rawValue, withConfiguration: configuration)!
125 | }
126 | #else
127 | internal func nsImage(accessibilityDescription: String? = nil) -> NSImage {
128 | return NSImage(systemSymbolName: self.rawValue, accessibilityDescription: accessibilityDescription)!
129 | }
130 | #endif
131 |
132 | internal func callAsFunction() -> String {
133 | return self.rawValue
134 | }
135 | }
136 | """,
137 | macros: testMacros
138 | )
139 | }
140 |
141 | func testFilePrivateSFSymbolMacro() {
142 | assertMacroExpansion(
143 | """
144 | @SFSymbol
145 | fileprivate enum Symbols: String {
146 | case globe
147 | case circleFill = "circle.fill"
148 | }
149 | """,
150 | expandedSource:
151 | """
152 |
153 | fileprivate enum Symbols: String {
154 | case globe
155 | case circleFill = "circle.fill"
156 |
157 | fileprivate var image: Image {
158 | Image(systemName: self.rawValue)
159 | }
160 |
161 | fileprivate var name: String {
162 | self.rawValue
163 | }
164 |
165 | #if canImport(UIKit)
166 | fileprivate func uiImage(configuration: UIImage.Configuration? = nil) -> UIImage {
167 | UIImage(systemName: self.rawValue, withConfiguration: configuration)!
168 | }
169 | #else
170 | fileprivate func nsImage(accessibilityDescription: String? = nil) -> NSImage {
171 | return NSImage(systemSymbolName: self.rawValue, accessibilityDescription: accessibilityDescription)!
172 | }
173 | #endif
174 |
175 | fileprivate func callAsFunction() -> String {
176 | return self.rawValue
177 | }
178 | }
179 | """,
180 | macros: testMacros
181 | )
182 | }
183 |
184 | func testPrivateSFSymbolMacro() {
185 | assertMacroExpansion(
186 | """
187 | @SFSymbol
188 | private enum Symbols: String {
189 | case globe
190 | case circleFill = "circle.fill"
191 | }
192 | """,
193 | expandedSource:
194 | """
195 |
196 | private enum Symbols: String {
197 | case globe
198 | case circleFill = "circle.fill"
199 |
200 | private var image: Image {
201 | Image(systemName: self.rawValue)
202 | }
203 |
204 | private var name: String {
205 | self.rawValue
206 | }
207 |
208 | #if canImport(UIKit)
209 | private func uiImage(configuration: UIImage.Configuration? = nil) -> UIImage {
210 | UIImage(systemName: self.rawValue, withConfiguration: configuration)!
211 | }
212 | #else
213 | private func nsImage(accessibilityDescription: String? = nil) -> NSImage {
214 | return NSImage(systemSymbolName: self.rawValue, accessibilityDescription: accessibilityDescription)!
215 | }
216 | #endif
217 |
218 | private func callAsFunction() -> String {
219 | return self.rawValue
220 | }
221 | }
222 | """,
223 | macros: testMacros
224 | )
225 | }
226 |
227 | func testInvalidSFSymbolError() {
228 | assertMacroExpansion(
229 | """
230 | @SFSymbol
231 | enum Symbols: String {
232 | case circleFill
233 | }
234 | """,
235 | expandedSource:
236 | """
237 |
238 | enum Symbols: String {
239 | case circleFill
240 | }
241 | """,
242 | diagnostics: [
243 | .init(message: "\"circleFill\" is not a valid SF Symbol.", line: 3, column: 5)
244 | ],
245 | macros: testMacros
246 | )
247 | }
248 |
249 | func testInvalidSFSymbolErrorExplicit() {
250 | assertMacroExpansion(
251 | """
252 | @SFSymbol
253 | enum Symbols: String {
254 | case xyz = "xyz"
255 | }
256 | """,
257 | expandedSource:
258 | """
259 |
260 | enum Symbols: String {
261 | case xyz = "xyz"
262 | }
263 | """,
264 | diagnostics: [
265 | .init(message: "\"xyz\" is not a valid SF Symbol.", line: 3, column: 5)
266 | ],
267 | macros: testMacros
268 | )
269 | }
270 |
271 | func testInvalidEnum() {
272 | assertMacroExpansion(
273 | """
274 | @SFSymbol
275 | enum Symbols {
276 | case globe
277 | }
278 | """,
279 | expandedSource:
280 | """
281 |
282 | enum Symbols {
283 | case globe
284 | }
285 | """,
286 | diagnostics: [
287 | .init(message: "Enum \"Symbols\" must declare a raw value type of String.", line: 2, column: 6)
288 | ],
289 | macros: testMacros
290 | )
291 | }
292 |
293 | func testInvalidType() {
294 | assertMacroExpansion(
295 | """
296 | @SFSymbol
297 | struct Symbols {
298 | let xyz = "xyz"
299 | }
300 | """,
301 | expandedSource:
302 | """
303 |
304 | struct Symbols {
305 | let xyz = "xyz"
306 | }
307 | """,
308 | diagnostics: [
309 | .init(message: "Macro \"@SFSymbol\" can only be applied to enums.", line: 1, column: 1)
310 | ],
311 | macros: testMacros
312 | )
313 | }
314 |
315 | func testInvalidModifier() {
316 | assertMacroExpansion(
317 | """
318 | @SFSymbol
319 | struct Symbols {
320 | let xyz = "xyz"
321 | }
322 | """,
323 | expandedSource:
324 | """
325 |
326 | struct Symbols {
327 | let xyz = "xyz"
328 | }
329 | """,
330 | diagnostics: [
331 | .init(message: "Macro \"@SFSymbol\" can only be applied to enums.", line: 1, column: 1)
332 | ],
333 | macros: testMacros
334 | )
335 | }
336 | }
337 |
--------------------------------------------------------------------------------