@swiftbrowser/swift 0.0.0-stage → 0.2.0

package/Sources/SwiftData/StringPredicates.swift

@@ -0,0 +1,125 @@
+// The string comparisons `#Predicate` accepts on Apple platforms. swift-foundation
+// compiles them only into Apple's Foundation (`FOUNDATION_FRAMEWORK`), so
+// corelibs Foundation on WASI and Linux lacks them; SwiftData's copy of the
+// predicate macro (Sources/SwiftDataMacros/PredicateMacro.swift) builds these.
+// Adapted from swift-foundation's FoundationInternationalization/Predicate/
+// LocalizedString.swift and FoundationEssentials/Predicate/Expressions/
+// StringComparison.swift (Apache License v2.0 with Runtime Library Exception;
+// see https://swift.org/LICENSE.txt).
+
+import Foundation
+
+extension PredicateExpressions {
+    public struct StringLocalizedStandardContains<Root: PredicateExpression, Other: PredicateExpression>: PredicateExpression
+    where Root.Output: StringProtocol, Other.Output: StringProtocol {
+        public typealias Output = Bool
+
+        public let root: Root
+        public let other: Other
+
+        public init(root: Root, other: Other) {
+            self.root = root
+            self.other = other
+        }
+
+        public func evaluate(_ bindings: PredicateBindings) throws -> Bool {
+            try root.evaluate(bindings).localizedStandardContains(try other.evaluate(bindings))
+        }
+    }
+
+    public static func build_localizedStandardContains<Root, Other>(_ root: Root, _ other: Other) -> StringLocalizedStandardContains<Root, Other> {
+        StringLocalizedStandardContains(root: root, other: other)
+    }
+
+    public struct StringLocalizedCompare<Root: PredicateExpression, Other: PredicateExpression>: PredicateExpression
+    where Root.Output: StringProtocol, Other.Output: StringProtocol {
+        public typealias Output = ComparisonResult
+
+        public let root: Root
+        public let other: Other
+
+        public init(root: Root, other: Other) {
+            self.root = root
+            self.other = other
+        }
+
+        public func evaluate(_ bindings: PredicateBindings) throws -> ComparisonResult {
+            try root.evaluate(bindings).localizedCompare(other.evaluate(bindings))
+        }
+    }
+
+    public static func build_localizedCompare<Root, Other>(_ root: Root, _ other: Other) -> StringLocalizedCompare<Root, Other> {
+        StringLocalizedCompare(root: root, other: other)
+    }
+
+    public struct StringCaseInsensitiveCompare<Root: PredicateExpression, Other: PredicateExpression>: PredicateExpression
+    where Root.Output: StringProtocol, Other.Output: StringProtocol {
+        public typealias Output = ComparisonResult
+
+        public let root: Root
+        public let other: Other
+
+        public init(root: Root, other: Other) {
+            self.root = root
+            self.other = other
+        }
+
+        public func evaluate(_ bindings: PredicateBindings) throws -> ComparisonResult {
+            try root.evaluate(bindings).caseInsensitiveCompare(try other.evaluate(bindings))
+        }
+    }
+
+    public static func build_caseInsensitiveCompare<Root, Other>(_ root: Root, _ other: Other) -> StringCaseInsensitiveCompare<Root, Other> {
+        StringCaseInsensitiveCompare(root: root, other: other)
+    }
+}
+
+extension PredicateExpressions.StringLocalizedStandardContains: StandardPredicateExpression where Root: StandardPredicateExpression, Other: StandardPredicateExpression {}
+extension PredicateExpressions.StringLocalizedCompare: StandardPredicateExpression where Root: StandardPredicateExpression, Other: StandardPredicateExpression {}
+extension PredicateExpressions.StringCaseInsensitiveCompare: StandardPredicateExpression where Root: StandardPredicateExpression, Other: StandardPredicateExpression {}
+
+extension PredicateExpressions.StringLocalizedStandardContains: Sendable where Root: Sendable, Other: Sendable {}
+extension PredicateExpressions.StringLocalizedCompare: Sendable where Root: Sendable, Other: Sendable {}
+extension PredicateExpressions.StringCaseInsensitiveCompare: Sendable where Root: Sendable, Other: Sendable {}
+
+extension PredicateExpressions.StringLocalizedStandardContains: Codable where Root: Codable, Other: Codable {
+    public func encode(to encoder: any Encoder) throws {
+        var container = encoder.unkeyedContainer()
+        try container.encode(root)
+        try container.encode(other)
+    }
+
+    public init(from decoder: any Decoder) throws {
+        var container = try decoder.unkeyedContainer()
+        root = try container.decode(Root.self)
+        other = try container.decode(Other.self)
+    }
+}
+
+extension PredicateExpressions.StringLocalizedCompare: Codable where Root: Codable, Other: Codable {
+    public func encode(to encoder: any Encoder) throws {
+        var container = encoder.unkeyedContainer()
+        try container.encode(root)
+        try container.encode(other)
+    }
+
+    public init(from decoder: any Decoder) throws {
+        var container = try decoder.unkeyedContainer()
+        root = try container.decode(Root.self)
+        other = try container.decode(Other.self)
+    }
+}
+
+extension PredicateExpressions.StringCaseInsensitiveCompare: Codable where Root: Codable, Other: Codable {
+    public func encode(to encoder: any Encoder) throws {
+        var container = encoder.unkeyedContainer()
+        try container.encode(root)
+        try container.encode(other)
+    }
+
+    public init(from decoder: any Decoder) throws {
+        var container = try decoder.unkeyedContainer()
+        root = try container.decode(Root.self)
+        other = try container.decode(Other.self)
+    }
+}

package/Sources/SwiftDataMacros/EntryMacro.swift

@@ -0,0 +1,82 @@
+// SwiftUI's `@Entry` (Sources/SwiftUI/API/Entry.swift), expanded the way
+// Apple's is: the property becomes computed over a private key type, its
+// peer, whose default value is the property's initial value (nil for an
+// optional without one).
+//
+//     extension EnvironmentValues { @Entry var isCompact: Bool = false }
+//
+// becomes
+//
+//     var isCompact: Bool {
+//         get { self[__Key_isCompact.self] }
+//         set { self[__Key_isCompact.self] = newValue }
+//     }
+//     private struct __Key_isCompact: SwiftUI.EnvironmentKey {
+//         typealias Value = Bool
+//         static var defaultValue: Value { false }
+//     }
+//
+// It lives in this macro target so that apps build one macro plugin.
+
+import SwiftDiagnostics
+import SwiftSyntax
+import SwiftSyntaxBuilder
+import SwiftSyntaxMacros
+
+public struct EntryMacro: AccessorMacro, PeerMacro {
+    struct Entry {
+        let name: String
+        let type: TypeSyntax?
+        let initialValue: ExprSyntax?
+    }
+
+    static func entry(of declaration: some DeclSyntaxProtocol, in context: some MacroExpansionContext) throws -> Entry {
+        guard let variable = declaration.as(VariableDeclSyntax.self), variable.bindings.count == 1,
+              let binding = variable.bindings.first,
+              let identifier = binding.pattern.as(IdentifierPatternSyntax.self),
+              binding.accessorBlock == nil else {
+            throw MacroExpansionErrorMessage("@Entry applies to a single stored `var` with an initial value or an optional type")
+        }
+        let entry = Entry(name: identifier.identifier.trimmedDescription,
+                          type: binding.typeAnnotation?.type.trimmed,
+                          initialValue: binding.initializer?.value.trimmed)
+        if entry.initialValue == nil && entry.type?.is(OptionalTypeSyntax.self) != true
+            && entry.type?.is(ImplicitlyUnwrappedOptionalTypeSyntax.self) != true {
+            throw MacroExpansionErrorMessage("@Entry needs an initial value (or an optional type, whose default is nil)")
+        }
+        if entry.type == nil && entry.initialValue == nil {
+            throw MacroExpansionErrorMessage("@Entry needs a type or an initial value")
+        }
+        return entry
+    }
+
+    public static func expansion(of node: AttributeSyntax, providingAccessorsOf declaration: some DeclSyntaxProtocol,
+                                 in context: some MacroExpansionContext) throws -> [AccessorDeclSyntax] {
+        let entry = try entry(of: declaration, in: context)
+        return [
+            "get { self[__Key_\(raw: entry.name).self] }",
+            "set { self[__Key_\(raw: entry.name).self] = newValue }",
+        ]
+    }
+
+    public static func expansion(of node: AttributeSyntax, providingPeersOf declaration: some DeclSyntaxProtocol,
+                                 in context: some MacroExpansionContext) throws -> [DeclSyntax] {
+        let entry = try entry(of: declaration, in: context)
+        let key: DeclSyntax
+        if let type = entry.type {
+            key = """
+            private struct __Key_\(raw: entry.name): SwiftUI.EnvironmentKey {
+                typealias Value = \(type)
+                static var defaultValue: Value { \(entry.initialValue ?? "nil") }
+            }
+            """
+        } else {
+            key = """
+            private struct __Key_\(raw: entry.name): SwiftUI.EnvironmentKey {
+                nonisolated(unsafe) static let defaultValue = \(entry.initialValue!)
+            }
+            """
+        }
+        return [key]
+    }
+}

package/Sources/SwiftDataMacros/GenerableMacro.swift

@@ -0,0 +1,183 @@
+// FoundationModels' `@Generable` and `@Guide` (Sources/FoundationModels),
+// in this macro target so that apps build one macro plugin.
+//
+// `@Generable` makes a struct or an enum `Generable`: an extension with its
+// generation schema (a struct's stored properties with their `@Guide`
+// descriptions and guides, an enum's case names as choices), an
+// `init(_: GeneratedContent)` that reads each property by name, and
+// `generatedContent`, which writes them. The members are `nonisolated`, so
+// a type in a main-actor module still conforms without isolation.
+//
+//     @Generable struct Tags {
+//         @Guide(description: "Hashtags", .count(5)) let values: [String]
+//     }
+//
+// becomes, besides the struct,
+//
+//     extension Tags: FoundationModels.Generable {
+//         nonisolated static var generationSchema: FoundationModels.GenerationSchema {
+//             FoundationModels.GenerationSchema(type: Self.self, description: nil, properties: [
+//                 FoundationModels.GenerationSchema.Property(name: "values", description: "Hashtags",
+//                                                            type: [String].self, _guides: [.count(5)])])
+//         }
+//         nonisolated init(_ generatedContent: FoundationModels.GeneratedContent) throws {
+//             self.values = try generatedContent.value([String].self, forProperty: "values")
+//         }
+//         nonisolated var generatedContent: FoundationModels.GeneratedContent {
+//             FoundationModels.GeneratedContent(properties: ["values": values])
+//         }
+//     }
+//
+// Apple's macro also makes a `PartiallyGenerated` type with optional
+// properties for streaming; here `PartiallyGenerated` is the type itself.
+// `@Guide` adds nothing of its own: `@Generable` reads it.
+
+import SwiftDiagnostics
+import SwiftSyntax
+import SwiftSyntaxBuilder
+import SwiftSyntaxMacros
+
+public struct GenerableMacro: ExtensionMacro {
+    struct Property {
+        let name: String
+        let type: TypeSyntax
+        let description: ExprSyntax?
+        let guides: [ExprSyntax]
+    }
+
+    public static func expansion(
+        of node: AttributeSyntax,
+        attachedTo declaration: some DeclGroupSyntax,
+        providingExtensionsOf type: some TypeSyntaxProtocol,
+        conformingTo protocols: [TypeSyntax],
+        in context: some MacroExpansionContext
+    ) throws -> [ExtensionDeclSyntax] {
+        let access = ModelSyntax.accessPrefix(of: declaration)
+        let description = argument(named: "description", of: node)?.trimmedDescription ?? "nil"
+        let members: String
+        if let structDecl = declaration.as(StructDeclSyntax.self) {
+            members = try structMembers(structDecl, access: access, description: description)
+        } else if let enumDecl = declaration.as(EnumDeclSyntax.self) {
+            members = try enumMembers(enumDecl, access: access, description: description)
+        } else {
+            throw MacroExpansionErrorMessage("@Generable applies to a struct or an enum")
+        }
+        let conformance = protocols.isEmpty ? "" : ": FoundationModels.Generable"
+        let decl: DeclSyntax = "extension \(type.trimmed)\(raw: conformance) {\n\(raw: members)\n}"
+        return [decl.cast(ExtensionDeclSyntax.self)]
+    }
+
+    static func structMembers(_ decl: StructDeclSyntax, access: String, description: String) throws -> String {
+        let properties = try storedProperties(of: decl)
+        let schema = properties.map { property in
+            var arguments = "name: \(literal(property.name)), description: \(property.description?.trimmedDescription ?? "nil"), type: \(property.type.trimmedDescription).self"
+            if !property.guides.isEmpty {
+                arguments += ", _guides: [\(property.guides.map(\.trimmedDescription).joined(separator: ", "))]"
+            }
+            return "FoundationModels.GenerationSchema.Property(\(arguments))"
+        }
+        let reads = properties.map {
+            "        self.\($0.name) = try generatedContent.value(\($0.type.trimmedDescription).self, forProperty: \(literal($0.name)))"
+        }
+        let writes = properties.map { "\(literal($0.name)): \($0.name)" }
+        return """
+            nonisolated \(access)static var generationSchema: FoundationModels.GenerationSchema {
+                FoundationModels.GenerationSchema(type: Self.self, description: \(description), properties: [\(schema.joined(separator: ", "))])
+            }
+            nonisolated \(access)init(_ generatedContent: FoundationModels.GeneratedContent) throws {
+            \(reads.joined(separator: "\n"))
+            }
+            nonisolated \(access)var generatedContent: FoundationModels.GeneratedContent {
+                FoundationModels.GeneratedContent(properties: [\(writes.isEmpty ? ":" : writes.joined(separator: ", "))])
+            }
+            """
+    }
+
+    static func enumMembers(_ decl: EnumDeclSyntax, access: String, description: String) throws -> String {
+        var names: [String] = []
+        for member in decl.memberBlock.members {
+            guard let cases = member.decl.as(EnumCaseDeclSyntax.self) else { continue }
+            for element in cases.elements {
+                if element.parameterClause != nil {
+                    throw MacroExpansionErrorMessage("@Generable supports enums whose cases have no associated values")
+                }
+                names.append(element.name.trimmedDescription)
+            }
+        }
+        let choices = names.map { literal($0) }.joined(separator: ", ")
+        let reads = names.map { "        case \(literal($0)): self = .\($0)" }.joined(separator: "\n")
+        let writes = names.map { "        case .\($0): FoundationModels.GeneratedContent(kind: .string(\(literal($0))))" }.joined(separator: "\n")
+        return """
+            nonisolated \(access)static var generationSchema: FoundationModels.GenerationSchema {
+                FoundationModels.GenerationSchema(type: Self.self, description: \(description), anyOf: [\(choices)])
+            }
+            nonisolated \(access)init(_ generatedContent: FoundationModels.GeneratedContent) throws {
+                switch try generatedContent.value(String.self) {
+            \(reads)
+                default: throw FoundationModels.GeneratedContent._mismatch(generatedContent, Self.self)
+                }
+            }
+            nonisolated \(access)var generatedContent: FoundationModels.GeneratedContent {
+                switch self {
+            \(writes.isEmpty ? "        default: FoundationModels.GeneratedContent(kind: .null)" : writes)
+                }
+            }
+            """
+    }
+
+    /// The struct's stored instance properties, in order (a `let` with an
+    /// initial value is left out: it cannot be set from generated content).
+    static func storedProperties(of decl: StructDeclSyntax) throws -> [Property] {
+        var properties: [Property] = []
+        for member in decl.memberBlock.members {
+            guard let variable = member.decl.as(VariableDeclSyntax.self) else { continue }
+            if variable.modifiers.contains(where: { [.keyword(.static), .keyword(.class), .keyword(.lazy)].contains($0.name.tokenKind) }) {
+                continue
+            }
+            let guide = ModelSyntax.attributes(of: variable).first { ModelSyntax.attributeName($0) == "Guide" }
+            for binding in variable.bindings {
+                guard let identifier = binding.pattern.as(IdentifierPatternSyntax.self) else { continue }
+                if let accessors = binding.accessorBlock {
+                    // Computed properties are not generated; observed ones are stored.
+                    if case .accessors(let list) = accessors.accessors,
+                       list.allSatisfy({ ["willSet", "didSet"].contains($0.accessorSpecifier.text) }) {
+                    } else {
+                        continue
+                    }
+                }
+                if variable.bindingSpecifier.tokenKind == .keyword(.let), binding.initializer != nil { continue }
+                guard let type = binding.typeAnnotation?.type else {
+                    throw MacroExpansionErrorMessage("@Generable needs the type of '\(identifier.identifier.text)' written out")
+                }
+                var description: ExprSyntax?
+                var guides: [ExprSyntax] = []
+                if let guide, case .argumentList(let list)? = guide.arguments {
+                    for argument in list {
+                        if argument.label?.text == "description" { description = argument.expression.trimmed }
+                        else { guides.append(argument.expression.trimmed) }
+                    }
+                }
+                properties.append(Property(name: identifier.identifier.trimmedDescription, type: type.trimmed,
+                                           description: description, guides: guides))
+            }
+        }
+        return properties
+    }
+
+    static func argument(named label: String, of attribute: AttributeSyntax) -> ExprSyntax? {
+        guard case .argumentList(let list)? = attribute.arguments else { return nil }
+        return list.first { $0.label?.text == label }?.expression.trimmed
+    }
+
+    static func literal(_ text: String) -> String {
+        "\"" + text.filter { $0 != "`" } + "\""
+    }
+}
+
+/// `@Guide`: read by `@Generable`; adds nothing itself.
+public struct GuideMacro: PeerMacro {
+    public static func expansion(of node: AttributeSyntax, providingPeersOf declaration: some DeclSyntaxProtocol,
+                                 in context: some MacroExpansionContext) throws -> [DeclSyntax] {
+        []
+    }
+}

package/Sources/SwiftDataMacros/ModelActorMacro.swift

@@ -0,0 +1,46 @@
+// `@ModelActor`, expanded as Apple's SwiftData expands it: the actor gains
+// its container, an executor that holds a context of its own, and
+// `init(modelContainer:)`; an extension makes it a `ModelActor`, whose
+// `modelContext` is the executor's. It runs on the main actor's executor
+// (ModelActor.swift), where Apple's runs on the model executor.
+
+import SwiftDiagnostics
+import SwiftSyntax
+import SwiftSyntaxBuilder
+import SwiftSyntaxMacros
+
+public struct ModelActorMacro: MemberMacro, ExtensionMacro {
+    public static func expansion(
+        of node: AttributeSyntax,
+        providingMembersOf declaration: some DeclGroupSyntax,
+        conformingTo protocols: [TypeSyntax],
+        in context: some MacroExpansionContext
+    ) throws -> [DeclSyntax] {
+        guard declaration.is(ActorDeclSyntax.self) else {
+            context.diagnose(Diagnostic(node: Syntax(node), message: ModelDiagnostic(message: "@ModelActor can only be applied to an actor")))
+            return []
+        }
+        return [
+            "nonisolated let modelExecutor: any SwiftData.ModelExecutor",
+            "nonisolated let modelContainer: SwiftData.ModelContainer",
+            """
+            init(modelContainer: SwiftData.ModelContainer) {
+                let modelContext = SwiftData.ModelContext(modelContainer)
+                self.modelExecutor = SwiftData.DefaultSerialModelExecutor(modelContext: modelContext)
+                self.modelContainer = modelContainer
+            }
+            """,
+        ]
+    }
+
+    public static func expansion(
+        of node: AttributeSyntax,
+        attachedTo declaration: some DeclGroupSyntax,
+        providingExtensionsOf type: some TypeSyntaxProtocol,
+        conformingTo protocols: [TypeSyntax],
+        in context: some MacroExpansionContext
+    ) throws -> [ExtensionDeclSyntax] {
+        guard declaration.is(ActorDeclSyntax.self) else { return [] }
+        return [try ExtensionDeclSyntax("extension \(type.trimmed): SwiftData.ModelActor {}")]
+    }
+}