@swiftbrowser/swift 0.0.0-stage → 0.2.0

package/Sources/SwiftDataMacros/PredicateMacro.swift

@@ -0,0 +1,1244 @@
+// Vendored from swift-foundation (Sources/FoundationMacros/PredicateMacro.swift,
+// tag swift-6.4.x-DEVELOPMENT-SNAPSHOT-2026-09-26-a), Apache License v2.0 with
+// Runtime Library Exception; see https://swift.org/LICENSE.txt.
+//
+// SwiftBrowser's changes, so that `#Predicate` accepts what it does on Apple
+// platforms: `localizedStandardContains`, `localizedCompare` and
+// `caseInsensitiveCompare` are listed as supported functions (the open-source
+// build lists them only for Apple's Foundation, `FOUNDATION_FRAMEWORK`, whose
+// expressions corelibs Foundation lacks), and their `build_` functions are
+// SwiftData's (Sources/SwiftData/StringPredicates.swift). Apps that import SwiftData
+// get this macro in place of Foundation's through a declaration the CLI
+// generates in the app module (docs/ops-protocol.md, "Phase 18").
+
+
+import SwiftSyntax
+import SwiftSyntaxMacros
+import SwiftDiagnostics
+import SwiftSyntaxBuilder
+
+// A list of all functions supported by Predicate/Expression itself, any other functions called will be diagnosed as an error
+// This allows for checking the function name, the number of arguments, and the argument labels, but the types of the arguments will need to be validated by the post-expansion type checking pass
+// The closure specification is used to determine whether keypaths should be transformed/expanded into closures and whether dropping the final argument in favor of a trailing closure is allowed
+private let _knownSupportedFunctions: Set<FunctionStructure> = [
+    FunctionStructure("contains", arguments: [.unlabeled]),
+    FunctionStructure("contains", arguments: [.closure(labeled: "where")]),
+    FunctionStructure("allSatisfy", arguments: [.closure(labeled: nil)]),
+    FunctionStructure("flatMap", arguments: [.closure(labeled: nil)]),
+    FunctionStructure("filter", arguments: [.closure(labeled: nil)]),
+    FunctionStructure("subscript", arguments: [.unlabeled]),
+    FunctionStructure("subscript", arguments: [.unlabeled, "default"]),
+    FunctionStructure("starts", arguments: ["with"]),
+    FunctionStructure("min", arguments: []),
+    FunctionStructure("max", arguments: []),
+]
+
+private var knownSupportedFunctions: Set<FunctionStructure> {
+    var result = _knownSupportedFunctions
+    result.insert(FunctionStructure("localizedStandardContains", arguments: [.unlabeled]))
+    result.insert(FunctionStructure("localizedCompare", arguments: [.unlabeled]))
+    result.insert(FunctionStructure("caseInsensitiveCompare", arguments: [.unlabeled]))
+    return result
+}
+
+/// The functions whose `build_` SwiftData supplies (Sources/SwiftData/StringPredicates.swift).
+private let swiftDataFunctions: Set<String> = ["localizedStandardContains", "localizedCompare", "caseInsensitiveCompare"]
+
+private let _supportedFunctionSuggestions: [FunctionStructure : FunctionStructure] = [
+    FunctionStructure("hasPrefix", arguments: [.unlabeled]) : FunctionStructure("starts", arguments: ["with"]),
+]
+
+private var supportedFunctionSuggestions: [FunctionStructure : FunctionStructure] {
+    var result = _supportedFunctionSuggestions
+    result[FunctionStructure("localizedCaseInsensitiveContains", arguments: [.unlabeled])] = FunctionStructure("localizedStandardContains", arguments: [.unlabeled])
+    result[FunctionStructure("localizedCaseInsensitiveCompare", arguments: [.unlabeled])] = FunctionStructure("localizedCompare", arguments: [.unlabeled])
+    result[FunctionStructure("localizedStandardCompare", arguments: [.unlabeled])] = FunctionStructure("localizedCompare", arguments: [.unlabeled])
+    return result
+}
+
+extension Array where Element == FunctionStructure.Argument {
+    fileprivate func argumentsEqual(_ other: Self) -> Bool {
+        let currentPackIndex = self.firstIndex { $0.kind == .pack }
+        let otherPackIndex = other.firstIndex { $0.kind == .pack }
+
+        var full: [FunctionStructure.Argument]
+        var prefix: ArraySlice<FunctionStructure.Argument>
+        var suffix: ArraySlice<FunctionStructure.Argument>
+        switch (currentPackIndex, otherPackIndex) {
+        // If neither contains a pack or both contain a pack, just compare arguments as-is
+        case (nil, nil), (.some(_), .some(_)):
+            return self == other
+
+        // If one of them contains a pack, compare the prefix and suffix to allow the pack to lazily consume multiple arguments
+        case (let .some(idx), nil):
+            full = other
+            prefix = self[..<idx]
+            suffix = self[self.index(after: idx)...]
+        case (nil, let .some(idx)):
+            full = self
+            prefix = other[..<idx]
+            suffix = other[other.index(after: idx)...]
+        }
+        return full.starts(with: prefix) && full.reversed().starts(with: suffix.reversed())
+    }
+
+    fileprivate func expandingPackToMatchCount(_ otherCount: Int) -> Self {
+        let countDifference = otherCount - self.count
+        guard countDifference >= 0, let packIdx = self.firstIndex(where: { $0.kind == .pack }) else {
+            return self
+        }
+
+        var copy = self
+        copy[packIdx] = .init(label: copy[packIdx].label, kind: .standard)
+        if countDifference > 0 {
+            copy.insert(contentsOf: Array(repeating: .unlabeled, count: countDifference), at: packIdx + 1)
+        }
+        return copy
+    }
+}
+
+private struct FunctionStructure: Hashable {
+    struct Argument : Hashable, ExpressibleByStringLiteral {
+        enum Kind : Hashable {
+            case standard
+            case closure
+            case pack
+        }
+        
+        let label: String?
+        let kind: Kind
+        
+        init(stringLiteral: String) {
+            label = stringLiteral
+            kind = .standard
+        }
+        
+        init(label: String?, kind: Kind) {
+            self.label = label
+            self.kind = kind
+        }
+        
+        static func closure(labeled label: String?) -> Self {
+            Self(label: label, kind: .closure)
+        }
+        
+        static var unlabeled: Self {
+            Self(label: nil, kind: .standard)
+        }
+            
+        static func pack(labeled label: String?) -> Self {
+            Self(label: label, kind: .pack)
+        }
+        
+        static func ==(lhs: Self, rhs: Self) -> Bool {
+            lhs.label == rhs.label
+        }
+    }
+    let name: String
+    let arguments: [Argument]
+    let hasTrailingClosure: Bool
+    
+    var supportsTrailingClosure: Bool {
+        hasTrailingClosure || arguments.last?.kind == .closure
+    }
+    
+    var signature: String {
+        let args = arguments.map { ($0.label ?? "_") + ":" }.joined()
+        return "\(name)(\(args))"
+    }
+    
+    init(_ name: String, arguments: [Argument], trailingClosure: Bool = false) {
+        self.name = name
+        self.arguments = arguments
+        self.hasTrailingClosure = trailingClosure
+    }
+    
+    func matches(_ other: FunctionStructure) -> Bool {
+        guard self.name == other.name else { return false }
+        
+        switch (self.hasTrailingClosure, other.hasTrailingClosure) {
+        case (true, true), (false, false):
+            return self.arguments.argumentsEqual(other.arguments)
+        case (true, false):
+            guard let otherLast = other.arguments.last else { return false }
+            return self.arguments.argumentsEqual(other.arguments.dropLast()) && otherLast.kind == .closure
+        case (false, true):
+            guard let last = self.arguments.last else { return false }
+            return self.arguments.dropLast().argumentsEqual(other.arguments) && last.kind == .closure
+        }
+    }
+    
+    func fixItChanges(transformingFrom source: FunctionCallExprSyntax) -> [FixIt.Change]? {
+        let sourceHasTrailingClosure = source.trailingClosure != nil
+        if sourceHasTrailingClosure {
+            guard supportsTrailingClosure else { return nil }
+        }
+        let sourceArgumentTotalCount = source.arguments.count + (sourceHasTrailingClosure ? 1 : 0)
+        let argumentTotalCount = self.arguments.count + (hasTrailingClosure ? 1 : 0)
+        guard argumentTotalCount == sourceArgumentTotalCount,
+              let calledExpr = source.calledExpression.as(MemberAccessExprSyntax.self) else {
+            return nil
+        }
+        var newFunctionCall = source
+        newFunctionCall.calledExpression = ExprSyntax(calledExpr.with(\.declName, DeclReferenceExprSyntax(baseName: .identifier(name))))
+        newFunctionCall.arguments = LabeledExprListSyntax(zip(source.arguments, arguments).map {
+            if let newLabel = $1.label {
+                return $0.with(\.label, .identifier(newLabel)).with(\.colon, .colonToken()).with(\.expression, $0.expression.with(\.leadingTrivia, [.spaces(1)]))
+            } else {
+                return $0.with(\.label, nil).with(\.colon, nil).with(\.trailingTrivia, []).with(\.expression, $0.expression.with(\.leadingTrivia, []))
+            }
+        })
+        newFunctionCall.leadingTrivia = []
+        newFunctionCall.trailingTrivia = []
+        if self.hasTrailingClosure && source.trailingClosure == nil, let newTrailingClosure = source.arguments.last?.expression.as(ClosureExprSyntax.self) {
+            newFunctionCall.trailingClosure = newTrailingClosure
+        }
+        return [.replace(oldNode: Syntax(source), newNode: Syntax(newFunctionCall))]
+    }
+}
+
+private func _knownMatchingFunction(_ structure: FunctionStructure) -> FunctionStructure? {
+    knownSupportedFunctions.first {
+        $0.matches(structure)
+    }
+}
+
+private func _suggestionForUnknownFunction(_ structure: FunctionStructure) -> FunctionStructure? {
+    guard let key = supportedFunctionSuggestions.keys.first(where: { $0.matches(structure) }) else {
+        return nil
+    }
+    return supportedFunctionSuggestions[key]
+}
+
+private class ShorthandArgumentIdentifierDetector: SyntaxVisitor {
+    var found = false
+
+    override func visit(_ node: DeclReferenceExprSyntax) -> SyntaxVisitorContinueKind {
+        // Look for identifiers such as $0, $1, etc.
+        if case let .dollarIdentifier(identifier) = node.baseName.tokenKind, identifier.dropFirst().allSatisfy(\.isNumber) {
+            found = true
+            return .skipChildren
+        } else {
+            return .visitChildren
+        }
+    }
+}
+
+extension SyntaxProtocol {
+    var containsShorthandArgumentIdentifiers: Bool {
+        let visitor = ShorthandArgumentIdentifierDetector(viewMode: .all)
+        visitor.walk(self)
+        return visitor.found
+    }
+}
+
+private protocol PredicateSyntaxRewriter : SyntaxRewriter {
+    var success: Bool { get }
+    var ignorable: Bool { get }
+    var diagnostics: [Diagnostic] { get }
+}
+
+extension PredicateSyntaxRewriter {
+    var success: Bool { true }
+    var ignorable: Bool { false }
+    var diagnostics: [Diagnostic] { [] }
+}
+
+extension SyntaxProtocol {
+    fileprivate func rewrite(with rewriter: some PredicateSyntaxRewriter) throws -> Syntax {
+        let translated = rewriter.rewrite(self)
+        guard rewriter.success else {
+            throw DiagnosticsError(diagnostics: rewriter.diagnostics)
+        }
+        guard !rewriter.ignorable else {
+            return Syntax(self)
+        }
+        return translated
+    }
+}
+
+private class OptionalChainRewriter: SyntaxRewriter, PredicateSyntaxRewriter {
+    var withinValidChainingTreeStart = true
+    var withinChainingTree = false
+    var optionalInput: ExprSyntax? = nil
+    var ignorable = true
+    
+    private func _prePossibleTopOfTree() -> Bool {
+        if !withinChainingTree && withinValidChainingTreeStart {
+            withinChainingTree = true
+            return true
+        }
+        return false
+    }
+    
+    private func _postTopOfTree(_ node: ExprSyntax) -> ExprSyntax {
+        assert(withinChainingTree)
+        withinChainingTree = false
+        if let input = optionalInput {
+            optionalInput = nil
+            ignorable = false
+            let visited = self.visit(input)
+            let closure = ClosureExprSyntax(statements: [CodeBlockItemSyntax(item: CodeBlockItemSyntax.Item(node))])
+            let functionMember = MemberAccessExprSyntax(base: visited, name: "flatMap")
+            let functionCall = FunctionCallExprSyntax(calledExpression: functionMember, leftParen: .leftParenToken(), arguments: [], rightParen: .rightParenToken(), trailingClosure: closure)
+            return ExprSyntax(functionCall)
+        }
+        return node
+    }
+    
+    override func visit(_ node: ClosureExprSyntax) -> ExprSyntax {
+        guard withinChainingTree else {
+            // If we're not already in a chaining tree, just keep progressing with our current rewriter
+            return super.visit(node)
+        }
+        
+        // We're in the middle of a potential tree, so rewrite the closure with a fresh state
+        // This ensures potential chaining in the closure isn't rewritten outside of the closure
+        let nestedRewriter = OptionalChainRewriter()
+        guard let rewritten = (try? node.rewrite(with: nestedRewriter))?.as(ExprSyntax.self) else {
+            // If rewriting the closure failed, just leave the closure as-is
+            return ExprSyntax(node)
+        }
+        if ignorable {
+            ignorable = nestedRewriter.ignorable
+        }
+        return rewritten
+    }
+    
+    override func visit(_ node: FunctionCallExprSyntax) -> ExprSyntax {
+        let priorValidTreeStart = withinValidChainingTreeStart
+        defer { withinValidChainingTreeStart = priorValidTreeStart }
+        
+        if node.arguments.containsShorthandArgumentIdentifiers {
+            withinValidChainingTreeStart = false
+        }
+        
+        let topOfTree = _prePossibleTopOfTree()
+        let visited = super.visit(node)
+        if topOfTree {
+            return _postTopOfTree(visited)
+        } else {
+            return visited
+        }
+    }
+    
+    override func visit(_ node: MemberAccessExprSyntax) -> ExprSyntax {
+        let topOfTree = _prePossibleTopOfTree()
+        let visited = super.visit(node)
+        if topOfTree {
+            return _postTopOfTree(visited)
+        } else {
+            return visited
+        }
+    }
+    
+    override func visit(_ node: OptionalChainingExprSyntax) -> ExprSyntax {
+        guard withinChainingTree else {
+            return super.visit(node)
+        }
+        // Capture the optional input, and replace it in the output expression with a "$0"
+        optionalInput = node.expression
+        return .init(DeclReferenceExprSyntax(baseName: .dollarIdentifier("$0")))
+    }
+}
+
+extension CodeBlockItemListSyntax.Element.Item {
+    fileprivate var _expression: ExprSyntax? {
+        switch self {
+        case .expr(let expr): return expr
+        case .stmt(let stmt): return stmt.as(ExpressionStmtSyntax.self)?.expression
+        default: return nil
+        }
+    }
+}
+
+extension ConditionElementListSyntax {
+    fileprivate var optionalBindings: [OptionalBindingConditionSyntax]? {
+        var result = [OptionalBindingConditionSyntax]()
+        for element in self {
+            switch element.condition {
+            case let .optionalBinding(binding):
+                result.append(binding)
+            default:
+                return nil
+            }
+        }
+        return result
+    }
+}
+
+extension ClosureParameterListSyntax {
+    fileprivate var withVariableWrappedTypes: Self {
+        return Self(self.map {
+            if let type = $0.type {
+                $0.with(\.type, "PredicateExpressions.\(raw: moduleName())::Variable<\(type)>")
+            } else {
+                $0
+            }
+        })
+    }
+}
+
+extension KeyPathExprSyntax {
+    private enum KeyPathDirectExpressionRewritingError : Error {
+        case unknownKeypathComponentType
+    }
+    
+    fileprivate func asDirectExpression(on base: some ExprSyntaxProtocol) -> ExprSyntax? {
+        var result = ExprSyntax(base)
+        for item in components {
+            switch item.component {
+            case .property(let prop):
+                result = ExprSyntax(MemberAccessExprSyntax(base: result, declName: prop.declName))
+            case .optional(let opt):
+                if opt.questionOrExclamationMark.tokenKind == .exclamationMark {
+                    result = ExprSyntax(ForceUnwrapExprSyntax(expression: result))
+                } else {
+                    result = ExprSyntax(OptionalChainingExprSyntax(expression: result))
+                }
+            case .subscript(let sub):
+                result = ExprSyntax(SubscriptCallExprSyntax(calledExpression: result, arguments: sub.arguments))
+            @unknown default:
+                return nil
+            }
+        }
+        return result
+    }
+}
+
+private class PredicateQueryRewriter: SyntaxRewriter, PredicateSyntaxRewriter {
+    private let indentWidth: Trivia = .spaces(4)
+    private var indentLevel = 0
+    private var indent: Trivia {
+        Trivia(pieces: Array(repeating: .spaces(4), count: indentLevel))
+    }
+    var validOptionalChainingTree = true
+    var diagnostics: [Diagnostic] = []
+    var success: Bool { diagnostics.isEmpty }
+    let kind: ExpansionKind
+    
+    init(kind: ExpansionKind) {
+        self.kind = kind
+    }
+    
+    private func diagnose(node: SyntaxProtocol, message: PredicateExpansionDiagnostic, fixIts: [FixIt] = []) {
+        diagnostics.append(.init(node: Syntax(node), message: message, fixIts: fixIts))
+    }
+    
+    private func makeArgument(label: String?, _ expression: ExprSyntax, shouldVisit: Bool = true, shouldIndent: Bool = true) -> LabeledExprSyntax {
+        if shouldIndent {
+            indentLevel += 1
+        }
+        defer {
+            if shouldIndent {
+                indentLevel -= 1
+            }
+        }
+        
+        let labelSyntax = label.map {
+            TokenSyntax(.identifier($0), presence: .present)
+        }?.with(\.leadingTrivia, indent)
+        
+        let colonSyntax = label.map { _ in
+            TokenSyntax(.colon, presence: .present)
+        }
+        
+        var argument = shouldVisit ? visit(expression) : expression
+        
+        if shouldVisit && argument == expression {
+            argument = "PredicateExpressions.\(raw: moduleName())::build_Arg(\(expression.with(\.leadingTrivia, []).with(\.trailingTrivia, [])))"
+        }
+        
+        argument = argument.with(\.leadingTrivia, label == nil ? indent : .space)
+        return .init(label: labelSyntax,
+                     colon: colonSyntax,
+                     expression: argument,
+                     trailingComma: nil)
+    }
+    
+    override func visit(_ node: PrefixOperatorExprSyntax) -> ExprSyntax {
+        switch node.operator.text {
+        case "!":
+            let syntax: ExprSyntax =
+                """
+                \(raw: indent)PredicateExpressions.\(raw: moduleName())::build_Negation(
+                \(makeArgument(label: nil, node.expression))
+                \(raw: indent))
+                """
+            
+            return syntax
+        case "-":
+            let syntax: ExprSyntax =
+                """
+                \(raw: indent)PredicateExpressions.\(raw: moduleName())::build_UnaryMinus(
+                \(makeArgument(label: nil, node.expression))
+                \(raw: indent))
+                """
+            
+            return syntax
+        default:
+            diagnose(node: node.operator, message: "The '\(node.operator.text)' operator is not supported in this \(kind.keyword)")
+            return ExprSyntax(node)
+        }
+    }
+    
+    override func visit(_ node: InfixOperatorExprSyntax) -> ExprSyntax {
+        let lhsOp =  node.leftOperand
+        let rhsOp = node.rightOperand
+        let opExpr = node.operator
+        
+        guard let opSyntax = opExpr.as(BinaryOperatorExprSyntax.self) else {
+            diagnose(node: opExpr, message: "The '\(opExpr.description)' operator is not supported in this \(kind.keyword)")
+            return ExprSyntax(node)
+        }
+        
+        let (lhsLabel, rhsLabel) = switch opSyntax.operator.text {
+        case "...", "..<": ("lower", "upper")
+        default: ("lhs", "rhs")
+        }
+        
+        let lhsArgument = makeArgument(label: lhsLabel, lhsOp).with(\.trailingTrivia, [])
+        let rhsArgument = makeArgument(label: rhsLabel, rhsOp).with(\.trailingTrivia, [])
+        
+        switch (opSyntax.operator.text) {
+        case "==":
+            let syntax: ExprSyntax =
+                """
+                \(raw: indent)PredicateExpressions.\(raw: moduleName())::build_Equal(
+                \(lhsArgument),
+                \(rhsArgument)
+                \(raw: indent))
+                """
+            
+            return syntax
+        case "!=":
+            let syntax: ExprSyntax =
+                """
+                \(raw: indent)PredicateExpressions.\(raw: moduleName())::build_NotEqual(
+                \(lhsArgument),
+                \(rhsArgument)
+                \(raw: indent))
+                """
+            
+            return syntax
+        case "<":
+            let syntax: ExprSyntax =
+                """
+                \(raw: indent)PredicateExpressions.\(raw: moduleName())::build_Comparison(
+                \(lhsArgument),
+                \(rhsArgument),
+                \(raw: indent + indentWidth)op: .lessThan
+                \(raw: indent))
+                """
+            
+            return syntax
+        case "<=":
+            let syntax: ExprSyntax =
+                """
+                \(raw: indent)PredicateExpressions.\(raw: moduleName())::build_Comparison(
+                \(lhsArgument),
+                \(rhsArgument),
+                \(raw: indent + indentWidth)op: .lessThanOrEqual
+                \(raw: indent))
+                """
+            
+            return syntax
+        case ">":
+            let syntax: ExprSyntax =
+                """
+                \(raw: indent)PredicateExpressions.\(raw: moduleName())::build_Comparison(
+                \(lhsArgument),
+                \(rhsArgument),
+                \(raw: indent + indentWidth)op: .greaterThan
+                \(raw: indent))
+                """
+            
+            return syntax
+        case ">=":
+            let syntax: ExprSyntax =
+                """
+                \(raw: indent)PredicateExpressions.\(raw: moduleName())::build_Comparison(
+                \(lhsArgument),
+                \(rhsArgument),
+                \(raw: indent + indentWidth)op: .greaterThanOrEqual
+                \(raw: indent))
+                """
+            
+            return syntax
+        case "||":
+            let syntax: ExprSyntax =
+                """
+                \(raw: indent)PredicateExpressions.\(raw: moduleName())::build_Disjunction(
+                \(lhsArgument),
+                \(rhsArgument)
+                \(raw: indent))
+                """
+            
+            return syntax
+        case "&&":
+            let syntax: ExprSyntax =
+                """
+                \(raw: indent)PredicateExpressions.\(raw: moduleName())::build_Conjunction(
+                \(lhsArgument),
+                \(rhsArgument)
+                \(raw: indent))
+                """
+            
+            return syntax
+        case "+":
+            let syntax: ExprSyntax =
+                """
+                \(raw: indent)PredicateExpressions.\(raw: moduleName())::build_Arithmetic(
+                \(lhsArgument),
+                \(rhsArgument),
+                \(raw: indent + indentWidth)op: .add
+                \(raw: indent))
+                """
+            
+            return syntax
+        case "-":
+            let syntax: ExprSyntax =
+                """
+                \(raw: indent)PredicateExpressions.\(raw: moduleName())::build_Arithmetic(
+                \(lhsArgument),
+                \(rhsArgument),
+                \(raw: indent + indentWidth)op: .subtract
+                \(raw: indent))
+                """
+            
+            return syntax
+        case "*":
+            let syntax: ExprSyntax =
+                """
+                \(raw: indent)PredicateExpressions.\(raw: moduleName())::build_Arithmetic(
+                \(lhsArgument),
+                \(rhsArgument),
+                \(raw: indent + indentWidth)op: .multiply
+                \(raw: indent))
+                """
+            
+            return syntax
+        case "/":
+            let syntax: ExprSyntax =
+                """
+                \(raw: indent)PredicateExpressions.\(raw: moduleName())::build_Division(
+                \(lhsArgument),
+                \(rhsArgument)
+                \(raw: indent))
+                """
+            
+            return syntax
+        case "%":
+            let syntax: ExprSyntax =
+                """
+                \(raw: indent)PredicateExpressions.\(raw: moduleName())::build_Remainder(
+                \(lhsArgument),
+                \(rhsArgument)
+                \(raw: indent))
+                """
+            
+            return syntax
+        case "??":
+            let syntax: ExprSyntax =
+                """
+                \(raw: indent)PredicateExpressions.\(raw: moduleName())::build_NilCoalesce(
+                \(lhsArgument),
+                \(rhsArgument)
+                \(raw: indent))
+                """
+            
+            return syntax
+            
+        case "...":
+            let syntax: ExprSyntax =
+                """
+                \(raw: indent)PredicateExpressions.\(raw: moduleName())::build_ClosedRange(
+                \(lhsArgument),
+                \(rhsArgument)
+                \(raw: indent))
+                """
+            
+            return syntax
+            
+        case "..<":
+            let syntax: ExprSyntax =
+                """
+                \(raw: indent)PredicateExpressions.\(raw: moduleName())::build_Range(
+                \(lhsArgument),
+                \(rhsArgument)
+                \(raw: indent))
+                """
+            
+            return syntax
+        default:
+            diagnose(node: opSyntax, message: "The '\(opSyntax.operator.text)' operator is not supported in this \(kind.keyword)")
+            return ExprSyntax(node)
+        }
+    }
+    
+    // We only hit this if our OptionalChainingRewriter was unable to rewrite them out of the expression tree
+    override func visit(_ node: OptionalChainingExprSyntax) -> ExprSyntax {
+        diagnose(node: node.questionMark, message: "Optional chaining is not supported here in this \(kind.keyword). Use the flatMap(_:) function explicitly instead.")
+        return .init(node)
+    }
+    
+    override func visit(_ node: ForceUnwrapExprSyntax) -> ExprSyntax {
+        return """
+                \(raw: indent)PredicateExpressions.\(raw: moduleName())::build_ForcedUnwrap(
+                \(makeArgument(label: nil, node.expression))
+                \(raw: indent))
+                """
+    }
+    
+    override func visit(_ node: NilLiteralExprSyntax) -> ExprSyntax {
+        "PredicateExpressions.\(raw: moduleName())::build_NilLiteral()"
+    }
+    
+    override func visit(_ node: MemberAccessExprSyntax) -> ExprSyntax {
+        guard let base = node.base else {
+            diagnose(node: node, message: "Member access without an explicit base is not supported in this \(kind.keyword)")
+            return .init(node)
+        }
+        
+        let newPropertyComponent = KeyPathPropertyComponentSyntax(declName: node.declName)
+        let keyPath = KeyPathExprSyntax(components: [.init(period: TokenSyntax.periodToken(), component: .property(newPropertyComponent))])
+        return """
+                \(raw: indent)PredicateExpressions.\(raw: moduleName())::build_KeyPath(
+                \(makeArgument(label: "root", base)),
+                \(makeArgument(label: "keyPath", .init(keyPath), shouldVisit: false).with(\.trailingTrivia, []))
+                \(raw: indent))
+                """
+    }
+    
+    override func visit(_ node: FunctionCallExprSyntax) -> ExprSyntax {
+        let memberAccess = node.calledExpression.as(MemberAccessExprSyntax.self)
+        let base = memberAccess?.base
+        let funcName = memberAccess?.declName.baseName.with(\.leadingTrivia, []).with(\.trailingTrivia, []).text ?? node.calledExpression.as(DeclReferenceExprSyntax.self)!.baseName.text
+        return _processFunction(
+            base: base,
+            functionName: funcName,
+            argumentList: node.arguments,
+            trailingClosure: node.trailingClosure,
+            diagnosticPoint: .init(memberAccess?.declName) ?? .init(node),
+            functionCallExpr: node)
+        ?? .init(node)
+    }
+    
+    override func visit(_ node: SubscriptCallExprSyntax) -> ExprSyntax {
+        return _processFunction(
+            base: node.calledExpression,
+            functionName: "subscript",
+            argumentList: node.arguments,
+            trailingClosure: node.trailingClosure,
+            diagnosticPoint: .init(node.leftSquare))
+        ?? .init(node)
+    }
+    
+    private func _processFunction(base: ExprSyntax?, functionName: String, argumentList: LabeledExprListSyntax, trailingClosure: ClosureExprSyntax?, diagnosticPoint: Syntax, functionCallExpr: FunctionCallExprSyntax? = nil) -> ExprSyntax? {
+        // The provided base is nil when calling global functions functions
+        guard let base else {
+            diagnose(node: diagnosticPoint, message: "Global functions are not supported in this \(kind.keyword)")
+            return nil
+        }
+        
+        // Check this function against our known list to provide rich diagnostics for functions we know we don't support
+        let name = TokenSyntax(.identifier(functionName), presence: .present).with(\.leadingTrivia, []).with(\.trailingTrivia, [])
+        let args = argumentList.map {
+            let isClosure = $0.expression.is(ClosureExprSyntax.self) || $0.expression.is(KeyPathExprSyntax.self)
+            return FunctionStructure.Argument(label: $0.label?.text, kind: isClosure ? .closure : .standard)
+        }
+        let structure = FunctionStructure(name.text, arguments: args, trailingClosure: trailingClosure != nil)
+        guard let knownFunc = _knownMatchingFunction(structure) else {
+            let diagnostic = PredicateExpansionDiagnostic("The \(structure.signature) function is not supported in this \(kind.keyword)")
+            var fixIts = [FixIt]()
+            if let functionCallExpr,
+               let suggestion = _suggestionForUnknownFunction(structure),
+               let changes = suggestion.fixItChanges(transformingFrom: functionCallExpr) {
+                fixIts.append(FixIt(message: PredicateExpansionDiagnostic("Use \(suggestion.signature)", severity: .note), changes: changes))
+            }
+            diagnose(node: diagnosticPoint, message: diagnostic, fixIts: fixIts)
+            return nil
+        }
+        
+        var arguments: [LabeledExprSyntax] = []
+        func addArgument(_ argument: ExprSyntax, label: String?, withComma: Bool) {
+            arguments.append(
+                makeArgument(label: label, argument)
+                    .with(\.trailingComma, withComma ? TokenSyntax(.comma, presence: .present) : nil)
+                    .with(\.trailingTrivia, withComma ? .newline : [])
+            )
+        }
+        
+        // Function arguments can contain dollar sign identifiers that can't be nested inside of a new closure
+        // Prevent this function call from being placed inside of a flatMap due to optionalChaining
+        let oldValidOptionalChainingTree = validOptionalChainingTree
+        validOptionalChainingTree = false
+        addArgument(base, label: nil, withComma: !argumentList.isEmpty)
+        validOptionalChainingTree = oldValidOptionalChainingTree
+        
+        for (sourceArg, knownArgStructure) in zip(argumentList, knownFunc.arguments.expandingPackToMatchCount(argumentList.count)) {
+            var expression = sourceArg.expression
+            if knownArgStructure.kind == .closure, let kpExpr = sourceArg.expression.as(KeyPathExprSyntax.self) {
+                guard !kpExpr.containsShorthandArgumentIdentifiers,
+                      let memberAccess = kpExpr.asDirectExpression(on: DeclReferenceExprSyntax(baseName: .dollarIdentifier("$0"))),
+                      let preparedMemberAccess = try? memberAccess.rewrite(with: OptionalChainRewriter()) else {
+                    diagnose(node: kpExpr, message: "This key path is not supported here in this \(kind.keyword). Use an explicit closure instead.")
+                    return nil
+                }
+                expression = ExprSyntax(ClosureExprSyntax(statements: [CodeBlockItemSyntax(item: .expr(preparedMemberAccess.as(ExprSyntax.self)!))]))
+            }
+            addArgument(expression, label: sourceArg.label?.text, withComma: sourceArg.trailingComma != nil)
+        }
+        
+        // SwiftData's builders are found without a module selector.
+        let buildModule = swiftDataFunctions.contains(name.text) ? "" : "\(moduleName())::"
+        if let closure = trailingClosure {
+            // Don't indent, because closures already get indented
+            let closureArg = makeArgument(label: nil, ExprSyntax(closure), shouldIndent: false)
+            return """
+             \(raw: indent)PredicateExpressions.\(raw: buildModule)build_\(name.with(\.leadingTrivia, []).with(\.trailingTrivia, []))(
+             \(LabeledExprListSyntax(arguments))
+             \(raw: indent))\(raw: Trivia.space)\(closureArg.with(\.leadingTrivia, []).with(\.trailingTrivia, []))
+             """
+        } else {
+            return """
+             \(raw: indent)PredicateExpressions.\(raw: buildModule)build_\(name.with(\.leadingTrivia, []).with(\.trailingTrivia, []))(
+             \(LabeledExprListSyntax(arguments))
+             \(raw: indent))
+             """
+        }
+    }
+    
+    override func visit(_ node: TupleExprSyntax) -> ExprSyntax {
+        guard node.elements.count == 1, let element = node.elements.first else {
+            diagnose(node: node, message: "Tuples are not supported in this \(kind.keyword)")
+            return ExprSyntax(node)
+        }
+        
+        // Support expressions like "(input as? Bool) == true" where parantheses used for grouping are treated like a single element tuple expression
+        return visit(element.expression)
+    }
+    
+    // Processes a code block and guarantees that the returned code block only contains one item
+    func _processCodeBlock(_ statements: CodeBlockItemListSyntax, in node: Syntax, removeReturn: Bool = false) -> CodeBlockItemListSyntax? {
+        guard statements.count == 1 else {
+            diagnose(node: statements.isEmpty ? node : statements[statements.index(after: statements.startIndex)], message: "\(kind.capitalizedKeyword) body may only contain one expression")
+            return nil
+        }
+        
+        indentLevel += 1
+        var body = visit(statements)
+        if success && body == statements {
+            let wrapped: ExprSyntax =
+                """
+                \(raw: indent)PredicateExpressions.\(raw: moduleName())::build_Arg(
+                \(raw: indent + indentWidth)\(body.with(\.leadingTrivia, []).with(\.trailingTrivia, []))
+                \(raw: indent))
+                """
+            body = [.init(item: .expr(wrapped))]
+        }
+        indentLevel -= 1
+        
+        if removeReturn, let first = body.first, case .stmt(let statement) = first.item, let returnStmt = statement.as(ReturnStmtSyntax.self), let returnExpr = returnStmt.expression {
+            body = [.init(item: .expr(returnExpr.with(\.leadingTrivia, returnStmt.leadingTrivia)))]
+        }
+        return body
+    }
+    
+    override func visit(_ node: CodeBlockSyntax) -> CodeBlockSyntax {
+        guard let body = _processCodeBlock(node.statements, in: .init(node)) else {
+            return node
+        }
+        return node.with(\.statements, body)
+    }
+    
+    override func visit(_ node: ClosureExprSyntax) -> ExprSyntax {
+        guard let body = _processCodeBlock(node.statements, in: .init(node)) else {
+            return .init(node)
+        }
+        
+        var resultingSignature = node.signature
+        if let signature = node.signature {
+            var visited = signature
+            visited.returnClause = nil
+            if case .parameterClause(let paramClause) = signature.parameterClause {
+                let newParamClause = paramClause.with(\.parameters, paramClause.parameters.withVariableWrappedTypes)
+                visited.parameterClause = .parameterClause(newParamClause)
+            }
+            resultingSignature = visited
+        }
+        
+        return ExprSyntax(
+            node
+            .with(\.statements, body)
+            .with(\.leftBrace, node.leftBrace.with(\.trailingTrivia, node.signature == nil ? .newline : .space))
+            .with(\.signature, resultingSignature?.with(\.trailingTrivia, .newline))
+            .with(\.rightBrace, node.rightBrace.with(\.leadingTrivia, .newline + indent))
+        )
+    }
+    
+    override func visit(_ node: TernaryExprSyntax) -> ExprSyntax {
+        let condition = node.condition
+        let firstChoice = node.thenExpression
+        let secondChoice = node.elseExpression
+        
+        return """
+         \(raw: indent)PredicateExpressions.\(raw: moduleName())::build_Conditional(
+         \(makeArgument(label: nil, condition).with(\.trailingTrivia, [])),
+         \(makeArgument(label: nil, firstChoice).with(\.trailingTrivia, [])),
+         \(makeArgument(label: nil, secondChoice).with(\.trailingTrivia, []))
+         \(raw: indent))
+         """
+    }
+    
+    override func visit(_ node: IsExprSyntax) -> ExprSyntax {
+        return """
+         \(raw: indent)PredicateExpressions.\(raw: moduleName())::TypeCheck<_, \(node.type)>(
+         \(makeArgument(label: nil, node.expression).with(\.trailingTrivia, []))
+         \(raw: indent))
+         """
+    }
+    
+    override func visit(_ node: AsExprSyntax) -> ExprSyntax {
+        let castType: String
+        switch node.questionOrExclamationMark?.tokenKind {
+        case .none: fallthrough
+        case .some(.exclamationMark):
+            castType = "Force"
+        case .some(.postfixQuestionMark):
+            castType = "Conditional"
+        default:
+            fatalError("Unexpected question/exclamation mark token kind")
+        }
+        
+        return """
+         \(raw: indent)PredicateExpressions.\(raw: moduleName())::\(raw: castType)Cast<_, \(node.type)>(
+         \(makeArgument(label: nil, node.expression).with(\.trailingTrivia, []))
+         \(raw: indent))
+         """
+    }
+    
+    override func visit(_ node: ReturnStmtSyntax) -> StmtSyntax {
+        guard let expression = node.expression else {
+            // No expansion needed when returning Void
+            return StmtSyntax(node)
+        }
+        
+        let visited = visit(expression)
+        guard visited == expression else {
+            // No expansion needed when returning transformed expression
+            return StmtSyntax(node.with(\.expression, visited.with(\.leadingTrivia, [])).with(\.leadingTrivia, indent))
+        }
+        
+        // Wrap constant return expressions in a build_Arg call
+        let wrapped: ExprSyntax =
+            """
+            PredicateExpressions.\(raw: moduleName())::build_Arg(
+            \(visited.with(\.leadingTrivia, indent + indentWidth))
+            \(raw: indent))
+            """
+        return StmtSyntax(node.with(\.expression, wrapped).with(\.leadingTrivia, indent))
+    }
+    
+    override func visit(_ node: SwitchExprSyntax) -> ExprSyntax {
+        self.diagnose(node: node, message: "Switch expressions are not supported in this \(kind.keyword)")
+        return .init(node)
+    }
+    
+    private func _rewriteConditionsAsExpression<C: BidirectionalCollection<ConditionElementListSyntax.Element>>(_ collection: C, in expr: IfExprSyntax) -> ExprSyntax? {
+        guard let last = collection.last else {
+            self.diagnose(node: expr, message: "This list of conditionals is unsupported in this \(kind.keyword)")
+            return nil
+        }
+        guard case .expression(let lastExpr) = last.condition else {
+            let type: String
+            switch last.condition {
+            case .availability(_):
+                type = "Availability conditions"
+            case .matchingPattern(_):
+                type = "Matching pattern conditions"
+            case .optionalBinding(_):
+                self.diagnose(node: last, message: "Mixing optional bindings with other conditions is not supported in this \(kind.keyword)")
+                return nil
+            default:
+                type = "These types of conditions"
+            }
+            self.diagnose(node: last, message: "\(type) are not supported in this \(kind.keyword)")
+            return nil
+        }
+        let rest = collection.dropLast()
+        if rest.isEmpty {
+            return lastExpr
+        } else {
+            guard let restRewritten = _rewriteConditionsAsExpression(rest, in: expr) else {
+                return nil
+            }
+            return .init(InfixOperatorExprSyntax(leftOperand: restRewritten, operator: BinaryOperatorExprSyntax(operator: .binaryOperator("&&")), rightOperand: lastExpr))
+        }
+    }
+    
+    private func _rewriteIfAsFlatMap(bindings: [OptionalBindingConditionSyntax], body: ExprSyntax, else: ExprSyntax) -> ExprSyntax? {
+        indentLevel += bindings.count
+        
+        var prior: ExprSyntax = body
+        for binding in bindings.reversed() {
+            guard let identifier = binding.pattern.as(IdentifierPatternSyntax.self)?.identifier else {
+                self.diagnose(node: binding.pattern, message: "This optional binding condition is not supported in this \(kind.keyword)")
+                return nil
+            }
+            let initializer = binding.initializer?.value ?? ExprSyntax(DeclReferenceExprSyntax(baseName: identifier))
+            
+            prior = """
+             \(raw: indent)PredicateExpressions.\(raw: moduleName())::build_flatMap(
+             \(makeArgument(label: nil, initializer).with(\.trailingTrivia, []))
+             \(raw: indent)) { \(identifier.with(\.trailingTrivia, []).with(\.leadingTrivia, [])) in
+             \(makeArgument(label: nil, prior, shouldVisit: false).with(\.trailingTrivia, []))
+             \(raw: indent)}
+             """
+            indentLevel -= 1
+        }
+        
+        return """
+         \(raw: indent)PredicateExpressions.\(raw: moduleName())::build_NilCoalesce(
+         \(makeArgument(label: "lhs", prior, shouldVisit: false)),
+         \(makeArgument(label: "rhs", `else`, shouldVisit: false))
+         \(raw: indent))
+         """
+    }
+    
+    private func _processIfBody(_ node: IfExprSyntax) -> ExprSyntax? {
+        guard let visitedBody = _processCodeBlock(node.body.statements, in: .init(node.body), removeReturn: true) else {
+            return nil
+        }
+        
+        guard let bodyExpression = visitedBody.first?.item._expression else {
+            self.diagnose(node: node.body, message: "This if expression body is not supported in this \(kind.keyword)")
+            return nil
+        }
+        
+        return bodyExpression
+    }
+    
+    private func _processElseBody(_ node: IfExprSyntax) -> ExprSyntax? {
+        guard let elseBody = node.elseBody else {
+            self.diagnose(node: node, message: "If expressions without an else expression are not supported in this \(kind.keyword)")
+            return nil
+        }
+
+        let elseExpression: ExprSyntax
+        switch elseBody {
+        case .codeBlock(let codeBlock):
+            guard let visitedElseBody = _processCodeBlock(codeBlock.statements, in: .init(codeBlock), removeReturn: true) else {
+                return nil
+            }
+            guard let expr = visitedElseBody.first?.item._expression else {
+                self.diagnose(node: node.body, message: "This if expression else body is not supported in this \(kind.keyword)")
+                return nil
+            }
+            elseExpression = expr
+        case .ifExpr(let ifExpr):
+            elseExpression = visit(ifExpr)
+#if FOUNDATION_FRAMEWORK
+        @unknown default:
+            self.diagnose(node: elseBody, message: "This if expression else body is not supported in this \(kind.keyword)")
+            return nil
+#endif
+        }
+        
+        return elseExpression
+    }
+    
+    override func visit(_ node: IfExprSyntax) -> ExprSyntax {
+        if let bindings = node.conditions.optionalBindings {
+            indentLevel += bindings.count
+            guard let bodyExpression = _processIfBody(node) else {
+                return .init(node)
+            }
+            indentLevel -= bindings.count
+            guard let elseExpression = _processElseBody(node) else {
+                return .init(node)
+            }
+            return _rewriteIfAsFlatMap(bindings: bindings, body: bodyExpression, else: elseExpression) ?? .init(node)
+        }
+        
+        guard let ifExpression = _rewriteConditionsAsExpression(node.conditions, in: node),
+              let bodyExpression = _processIfBody(node),
+              let elseExpression = _processElseBody(node) else {
+            return .init(node)
+        }
+
+        return """
+         \(raw: indent)PredicateExpressions.\(raw: moduleName())::build_Conditional(
+         \(makeArgument(label: nil, ifExpression).with(\.trailingTrivia, [])),
+         \(makeArgument(label: nil, bodyExpression, shouldVisit: false).with(\.trailingTrivia, [])),
+         \(makeArgument(label: nil, elseExpression, shouldVisit: false).with(\.trailingTrivia, []))
+         \(raw: indent))
+         """
+    }
+    
+    override func visit(_ node: WhileStmtSyntax) -> StmtSyntax {
+        self.diagnose(node: node, message: "While loops are not supported in this \(kind.keyword)")
+        return .init(node)
+    }
+    
+    override func visit(_ node: ForStmtSyntax) -> StmtSyntax {
+        self.diagnose(node: node, message: "For-in loops are not supported in this \(kind.keyword)")
+        return .init(node)
+    }
+    
+    override func visit(_ node: DoStmtSyntax) -> StmtSyntax {
+        self.diagnose(node: node, message: "Do statements are not supported in this \(kind.keyword)")
+        return .init(node)
+    }
+    
+    override func visit(_ node: CatchClauseSyntax) -> CatchClauseSyntax {
+        self.diagnose(node: node, message: "Catch clauses are not supported in this \(kind.keyword)")
+        return node
+    }
+    
+    override func visit(_ node: RepeatStmtSyntax) -> StmtSyntax {
+        self.diagnose(node: node, message: "Repeat-while loops are not supported in this \(kind.keyword)")
+        return .init(node)
+    }
+    
+    override func visit(_ node: CodeBlockItemSyntax) -> CodeBlockItemSyntax {
+        // At this point, we know we're the only item in the code block because predicates only support single-expression code blocks
+        
+        // Diagnose any declarations
+        if case .decl(_) = node.item {
+            diagnose(node: node.item, message: "Declarations are not supported in this \(kind.keyword)")
+            return node
+        }
+        
+        if case let .stmt(statement) = node.item {
+            // Unwrap a do statement with valid expression bodies
+            if let doStatement = statement.as(DoStmtSyntax.self) {
+                if let catchClause = doStatement.catchClauses.first {
+                    diagnose(node: catchClause, message: "Catch clauses are not supported in this \(kind.keyword)")
+                    return node
+                }
+                indentLevel -= 1
+                let visitedBody = self.visit(doStatement.body)
+                indentLevel += 1
+                guard success else {
+                    return node
+                }
+                guard let innerExpr = visitedBody.statements.first else {
+                    diagnose(node: doStatement, message: "Do statement is not supported here in this \(kind.keyword)")
+                    return node
+                }
+                return innerExpr
+            }
+        }
+        
+        return super.visit(node)
+    }
+}
+
+private struct PredicateExpansionDiagnostic: DiagnosticMessage, FixItMessage, ExpressibleByStringLiteral, ExpressibleByStringInterpolation {
+    let message: String
+    let severity: DiagnosticSeverity
+    let diagnosticID: MessageID = .init(domain: "FoundationMacros", id: "PredicateDiagnostic")
+    var fixItID: MessageID { diagnosticID }
+    
+    init(_ message: String, severity: DiagnosticSeverity = .error) {
+        self.message = message
+        self.severity = severity
+    }
+    
+    init(stringLiteral value: String) {
+        self.init(value)
+    }
+}
+
+private func moduleName(internationalization: Bool = false) -> String {
+    #if FOUNDATION_FRAMEWORK
+    "Foundation"
+    #else
+    internationalization ? "FoundationInternationalization" : "FoundationEssentials"
+    #endif
+}
+
+private enum ExpansionKind {
+    case predicate
+    case expression
+    
+    var keyword: String {
+        switch self {
+        case .predicate:
+            "predicate"
+        case .expression:
+            "expression"
+        }
+    }
+    
+    var capitalizedKeyword: String {
+        let keyword = self.keyword
+        let first = keyword.first!.uppercased()
+        return "\(first)\(keyword.dropFirst())"
+    }
+    
+    var macroKeyword: String {
+        "#\(capitalizedKeyword)"
+    }
+
+    var qualifiedExpansionType: String {
+        "\(moduleName()).\(capitalizedKeyword)"
+    }
+}
+
+private func predicateExpansion(of node: some FreestandingMacroExpansionSyntax, in context: some MacroExpansionContext, kind: ExpansionKind) throws -> ExprSyntax {
+    guard let closure = node.trailingClosure else {
+        let fixIts: [FixIt]
+        if let argument = node.arguments.first?.expression.as(ClosureExprSyntax.self) {
+            var newNode = node.with(\.leftParen, nil)
+                .with(\.rightParen, nil)
+                .with(\.trailingClosure, argument.with(\.leadingTrivia, [.spaces(1)]).with(\.trailingTrivia, []))
+            newNode.arguments = []
+            fixIts = [
+                FixIt(message: PredicateExpansionDiagnostic("Use a trailing closure instead of a function parameter", severity: .note), changes: [
+                    .replace(oldNode: Syntax(node), newNode: Syntax(newNode))
+                ])
+            ]
+        } else {
+            fixIts = []
+        }
+        throw DiagnosticsError(diagnostics: [.init(
+            node: Syntax(node),
+            message: PredicateExpansionDiagnostic("\(kind.macroKeyword) macro expansion requires a trailing closure"),
+            fixIts: fixIts
+        )])
+    }
+    
+    let translatedClosure = try closure
+        .rewrite(with: OptionalChainRewriter())
+        .rewrite(with: PredicateQueryRewriter(kind: kind))
+        .with(\.leadingTrivia, [])
+        .with(\.trailingTrivia, [])
+    
+    if let genericArgs = node.genericArgumentClause {
+        let strippedGenericArgs = genericArgs
+            .with(\.leadingTrivia, [])
+            .with(\.trailingTrivia, [])
+        return "\(raw: kind.qualifiedExpansionType)\(strippedGenericArgs)(\(translatedClosure))"
+    } else {
+        // When the macro is specified without generic args (ex. "#Predicate { ... }") initialize a Predicate without generic args so they can be inferred from context
+        return "\(raw: kind.qualifiedExpansionType)(\(translatedClosure))"
+    }
+}
+
+public struct PredicateMacro: SwiftSyntaxMacros.ExpressionMacro, Sendable {
+    public static var formatMode: FormatMode { .disabled }
+    
+    public static func expansion(of node: some FreestandingMacroExpansionSyntax, in context: some MacroExpansionContext) throws -> ExprSyntax {
+        try predicateExpansion(of: node, in: context, kind: .predicate)
+    }
+}
+
+public struct ExpressionMacro: SwiftSyntaxMacros.ExpressionMacro, Sendable {
+    public static var formatMode: FormatMode { .disabled }
+    
+    public static func expansion(of node: some FreestandingMacroExpansionSyntax, in context: some MacroExpansionContext) throws -> ExprSyntax {
+        try predicateExpansion(of: node, in: context, kind: .expression)
+    }
+}