如果你不介意使用宏，你可以写一个独立的表达式宏，如下所示：

public struct PrintWithVariableName: ExpressionMacro {
    public static func expansion(
        of node: some FreestandingMacroExpansionSyntax,
        in context: some MacroExpansionContext
    ) throws -> ExprSyntax {
        let argExpressions = node.argumentList.map(\.expression)
        let printArgs = LabeledExprListSyntax {
            for expression in argExpressions {
                LabeledExprSyntax(
                    expression: StringLiteralExprSyntax(content: expression.trimmedDescription + ":")
                )
                LabeledExprSyntax(expression: expression)
            }
        }
        return "print(\(printArgs))"
    }

    /*
    // an alternative implementation that expands to a closure that is invoked immediately,
    // containing a print call for each expression, so that they are printed on separate lines
    public static func expansion(
        of node: some FreestandingMacroExpansionSyntax,
        in context: some MacroExpansionContext
    ) throws -> ExprSyntax {
        let argExpressions = node.argumentList.map(\.expression)
        let block = CodeBlockItemListSyntax {
            for expression in argExpressions {
                "print(\(literal: expression.trimmedDescription + ":"), \(expression))"
            }
        }
        return """
        {
            \(block)
        }()
        """
    }
    */
}

字符串
将其添加到providingMacros列表中，并像这样声明：

@freestanding(expression)
public macro printWithNames(_ args: Any...) = 
    #externalMacro(module: "...", type: "PrintWithVariableName")

型
使用方法：

#printWithNames(x, y)
// expands to:
print("x:", x, "y:", y)

型