Swift: How to access the value of a static variable in a Macros declaration

Question

I’m trying to create a custom macro that receives a static variable as a parameter. However, I can’t directly access the value of baseURL from the expansion method of my macro.

Here is my code:

enum AppAPI {
    static var baseURL: URL = URL(string: "https://myBaseURL.com")!

    @RouteAPI("users", baseURL: baseURL)
    enum User {
        @HTTP(.post, path: "login") case login(LoginReq) 
        @HTTP(.post, path: "register") case register(RegisterReq) 
        @HTTP(.get, path: .join(["me", "profile"])) case myProfile 
        @HTTP(.get, path: .join(["profile", .parameter("id"), .parameter("second")])) case profile2(id: Int, second: String)
    }
}

Here is the syntax tree:

Optional(LabeledExprListSyntax
├─[0]: LabeledExprSyntax
│ ├─expression: StringLiteralExprSyntax
│ │ ├─openingQuote: stringQuote
│ │ ├─segments: StringLiteralSegmentListSyntax
│ │ │ ╰─[0]: StringSegmentSyntax
│ │ │   ╰─content: stringSegment("users")
│ │ ╰─closingQuote: stringQuote
│ ╰─trailingComma: comma
╰─[1]: LabeledExprSyntax
  ├─label: identifier("baseURL")
  ├─colon: colon
  ╰─expression: DeclReferenceExprSyntax
    ╰─baseName: identifier("baseURL"))

I can only see the name of the variable baseURL but not its value.

@attached(extension, conformances: APIRoute, names: arbitrary)
public macro RouteAPI(_ controller: String, baseURL: URL) = #externalMacro(module: "MyMacroMacros", type: "RouteAPI")

How can I access the value of baseURL instead of its name in my macro?

Answer 1

Macros only have access to the things in the syntax tree. You must change your design.

One possible design is a usage like this:

enum AppAPI {
    #BaseURL("https://google.com") {
        @RouteAPI("users")
        enum User {
            
        }

        // other @RouteAPIs with the same base URL...
    }
}

BaseURL is a declaration macro. For each declaration in the closure, it generates the same declaration, except for declarations that has the @RouteAPI attribute. For declarations that have the @RouteAPI attribute with only one parameter, it "replaces" the attribute with a @RouteAPI attribute that also has a baseURL: parameter. Macros can't normally "replace" things, but since this is in a closure passed to a declaration macro, you can generate any declaration you want. It can also generate the baseURL property in your original design.

The one-parameter @RouteAPI does nothing. You can even throw an error in its expansion method, so that users cannot use it outside of #BaseURL { ... }. It can be any type of macro except an extension macro.

The above code expands to:

enum AppAPI {
    static var baseURL: URL = URL(string: "https://google.com")!

    @RouteAPI("users", baseURL: URL(string: "https://google.com")!)
    enum User {
        
    }
}

And only after that does the two-parameter @RouteAPI expand.

Here are the declarations for all 3 macros. Notice that the one-parameter RouteAPI is implemented by a different type from the two-parameter RouteAPI.

@freestanding(declaration, names: named(baseURL), arbitrary)
public macro BaseURL(_ url: String, _ block: () -> Void) = #externalMacro(module: "MyMacroMacros", type: "BaseURL")

@attached(extension, names: arbitrary)
public macro RouteAPI(_ name: String, baseURL: URL) = #externalMacro(module: "MyMacroMacros", type: "ActualRouteAPI")

@attached(member) // this doesn't have to be member - could also be peer, memberAttribute etc
public macro RouteAPI(_ name: String) = #externalMacro(module: "MyMacroMacros", type: "RouteAPI")

Here is an example implementation of BaseURL that does not output any diagnostic messages. Consider adding those in in your actual implementation

enum BaseURL: DeclarationMacro {
    static func expansion(of node: some FreestandingMacroExpansionSyntax, in context: some MacroExpansionContext) throws -> [DeclSyntax] {
        guard let baseURLParameter = node.argumentList.first?.expression,
              let baseURL = baseURLParameter.as(StringLiteralExprSyntax.self)?.representedLiteralValue,
              let block = node.trailingClosure else {
            return []
        }
        let decls = block.statements.compactMap { $0.item.asProtocol(DeclGroupSyntax.self) }
        return decls.map { replacingRouteAPIAttribute(of: $0, baseURL: baseURL) } + [
            "static let baseURL = URL(string: \(literal: baseURL))!"
        ]
    }
    
    static func replacingRouteAPIAttribute(of decl: DeclGroupSyntax, baseURL: String) -> DeclSyntax {
        var newDecl = decl
        for i in newDecl.attributes.indices {
            guard case var .attribute(attr) = newDecl.attributes[i],
                  let attrName = attr.attributeName.as(IdentifierTypeSyntax.self)?.name.text,
                  attrName == "RouteAPI" ,
                  case let .argumentList(argsList) = attr.arguments,
                  argsList.count == 1
            else {
                continue
            }
            let expr: ExprSyntax = "URL(string: \(literal: baseURL))!"
            let newArgsList = LabeledExprListSyntax {
                argsList
                LabeledExprSyntax(label: "baseURL", expression: expr)
            }
            attr.arguments = .argumentList(newArgsList)
            newDecl.attributes[i] = .attribute(attr)
        }
        return newDecl.as(DeclSyntax.self)!
    }
}

---

A caveat is that #BaseURL cannot be used at the top level because it introduces arbitrary names, but this is not that much of a problem in this particular context.