Xcode Question posted in
Whether you're new to Xcode or an experienced developer, our archive has everything you need to know about this integrated development environment (IDE). From basic functionalities to advanced features, our archive covers a wide range of Xcode-related questions and answers. Browse our archive now and find solutions to your Xcode questions, and take your app development skills to the next level

Xcode – Using special literals in a function

I’m trying to write a wrapper for the print() function which also includes the current line number. I have something like this:

//  wrapper around print:
    func dbug(_ things: Any...) {
        print("(#line): ",  things.map {"($0)"}.joined(separator: ", "))
    }

//  elsewhere:
    dbug("hello", 23)

The only problem is that the #line literal prints the line number within the function, not the line number where it’s called, which is a bit of a waste of time.

Short of adding #line at the source, is there a way of getting the line number where the function is called?

Tags:

3

Answers


  1. 0

    You could try something like this example code to achieve what you want.

    Example SwiftUI code:

    struct ContentView: View {
    
    var body: some View {
        VStack {
            Button("click me") {
                dbug("(#line): ","hello", 23) //<--- here
            }
        }
    }

    func dbug(_ line: String, _ things: Any...) { //<--- here
        print(line, things.map {"($0)"}.joined(separator: ", "))
    }
}
    Login or Signup to reply.
  2. 0

    To get rid of passing #line as parameter to dbug function from @workingdog support Ukraine’s answer, you can use Swift Macro. Here is an example:

    @freestanding(expression)
public macro dbug(_ value: Any...) -> Void = #externalMacro(module: "MyMacroMacros", type: "DbugMacro")

public func dbug(_ line: String, _ things: Any...) {
    print("(line): ",  things.map {"($0)"}.joined(separator: ", "))
}

public struct DbugMacro: ExpressionMacro {
    public static func expansion(
        of node: some FreestandingMacroExpansionSyntax,
        in context: some MacroExpansionContext
    ) -> ExprSyntax {
        return "dbug("\(#line): ", (node.arguments))"
    }
        
}

@main
struct MyMacroPlugin: CompilerPlugin {
    let providingMacros: [Macro.Type] = [
        DbugMacro.self,
    ]
}

    Now you only have to call #dbug("hello", 23)

    Login or Signup to reply.
  3. 0

    Instead of using the #line macro in the function body, add an extra parameter and use #line as the default value of that parameter.

    func dbug(_ things: Any..., line: UInt = #line) {
    print("(line): ",  things.map {"($0)"}.joined(separator: ", "))
}

// usage:
dbug("hello", "something else") // don't pass the 'line' parameter!

    Then this works out of the box, because macros that are used as default values expand on the caller’s side.

    You can see the same pattern used in many built-in functions, like preconditionFailure, fatalError, etc.

    Login or Signup to reply.
Please signup or login to give your own answer.

Back To Top
Search