@swiftbrowser/swift 0.0.0-stage → 0.2.0

package/Sources/SwiftDataMacros/ModelMacro.swift

@@ -0,0 +1,260 @@
+// `@Model` and its helpers, expanded the way Apple's SwiftData expands them
+// (docs/ops-protocol.md, "Phase 18"):
+//
+// - every stored `var` of the class that is not `@Transient` gets
+//   `@_PersistedProperty`, which turns it into a computed property over the
+//   model's backing data (an `init` accessor, so `self.title = title` in the
+//   class's own initializer and a property's initial value still work), with
+//   Observation's `access` / `withMutation` around each read and write, and a
+//   `_SwiftDataNoType` peer that definite initialization tracks in its place;
+// - the class gains its backing data, an observation registrar, the schema
+//   metadata (each persisted property's name, key path, initial value and
+//   `@Attribute` / `@Relationship` options) and `init(backingData:)`, which a
+//   context uses to materialize a model from the store;
+// - an extension makes it a `PersistentModel` (and so `Observable`,
+//   `Hashable` and `Identifiable`).
+
+import SwiftDiagnostics
+import SwiftSyntax
+import SwiftSyntaxBuilder
+import SwiftSyntaxMacros
+
+/// A persisted property of a `@Model` class, as the macros see it.
+struct PersistedProperty {
+    let name: String
+    let initialValue: ExprSyntax?
+    let attribute: AttributeSyntax?
+    let relationship: AttributeSyntax?
+}
+
+enum ModelSyntax {
+    static let markerAttributes: Set<String> = ["Transient", "_PersistedProperty", "ObservationIgnored"]
+
+    static func attributeName(_ attribute: AttributeSyntax) -> String {
+        let name = attribute.attributeName.trimmedDescription
+        // `@SwiftData.Transient` names the same macro.
+        if let dot = name.lastIndex(of: ".") { return String(name[name.index(after: dot)...]) }
+        return name
+    }
+
+    static func attributes(of variable: VariableDeclSyntax) -> [AttributeSyntax] {
+        variable.attributes.compactMap { $0.as(AttributeSyntax.self) }
+    }
+
+    static func hasAttribute(_ variable: VariableDeclSyntax, named names: Set<String>) -> Bool {
+        attributes(of: variable).contains { names.contains(attributeName($0)) }
+    }
+
+    /// Whether the declaration is a stored `var` of the instance that `@Model`
+    /// persists: not static or lazy, no accessor block (computed or observed),
+    /// one simple name, and not marked `@Transient`.
+    static func isPersisted(_ variable: VariableDeclSyntax) -> Bool {
+        guard variable.bindingSpecifier.tokenKind == .keyword(.var) else { return false }
+        for modifier in variable.modifiers {
+            switch modifier.name.tokenKind {
+            case .keyword(.static), .keyword(.class), .keyword(.lazy): return false
+            default: break
+            }
+        }
+        if hasAttribute(variable, named: markerAttributes) { return false }
+        guard variable.bindings.count == 1, let binding = variable.bindings.first,
+              binding.pattern.is(IdentifierPatternSyntax.self) else { return false }
+        if binding.accessorBlock != nil { return false }
+        return true
+    }
+
+    static func name(of variable: VariableDeclSyntax) -> String? {
+        variable.bindings.first?.pattern.as(IdentifierPatternSyntax.self)?.identifier.trimmedDescription
+    }
+
+    static func persistedProperties(of members: MemberBlockItemListSyntax) -> [PersistedProperty] {
+        members.compactMap { item -> PersistedProperty? in
+            guard let variable = item.decl.as(VariableDeclSyntax.self), isPersisted(variable),
+                  let name = name(of: variable) else { return nil }
+            let attributes = attributes(of: variable)
+            return PersistedProperty(
+                name: name,
+                initialValue: variable.bindings.first?.initializer?.value,
+                attribute: attributes.first { attributeName($0) == "Attribute" },
+                relationship: attributes.first { attributeName($0) == "Relationship" }
+            )
+        }
+    }
+
+    /// `public ` when the class is public or open, so the members that
+    /// satisfy `PersistentModel` are as visible as the conformance.
+    static func accessPrefix(of declaration: some DeclGroupSyntax) -> String {
+        for modifier in declaration.modifiers {
+            switch modifier.name.tokenKind {
+            case .keyword(.public), .keyword(.open): return "public "
+            default: break
+            }
+        }
+        return ""
+    }
+
+    /// The arguments of an attribute as source (`.cascade, inverse: \Job.owner`).
+    static func arguments(of attribute: AttributeSyntax) -> String {
+        guard case .argumentList(let list)? = attribute.arguments else { return "" }
+        return list.trimmedDescription
+    }
+}
+
+struct ModelDiagnostic: DiagnosticMessage {
+    let message: String
+    let diagnosticID = MessageID(domain: "SwiftDataMacros", id: "Model")
+    let severity = DiagnosticSeverity.error
+}
+
+public struct ModelMacro: MemberMacro, MemberAttributeMacro, ExtensionMacro {
+    // MARK: Members
+
+    public static func expansion(
+        of node: AttributeSyntax,
+        providingMembersOf declaration: some DeclGroupSyntax,
+        conformingTo protocols: [TypeSyntax],
+        in context: some MacroExpansionContext
+    ) throws -> [DeclSyntax] {
+        guard let classDecl = declaration.as(ClassDeclSyntax.self) else {
+            context.diagnose(Diagnostic(node: Syntax(node), message: ModelDiagnostic(message: "@Model can only be applied to a class")))
+            return []
+        }
+        let typeName = classDecl.name.trimmedDescription
+        let access = ModelSyntax.accessPrefix(of: classDecl)
+        let properties = ModelSyntax.persistedProperties(of: classDecl.memberBlock.members)
+
+        let metadata = properties.map { property -> String in
+            var arguments = "name: \(literal(property.name)), keyPath: \\\(typeName).\(property.name)"
+            if let initial = property.initialValue { arguments += ", defaultValue: \(initial.trimmedDescription)" }
+            if let relationship = property.relationship {
+                arguments += ", metadata: SwiftData.Schema.Relationship(\(ModelSyntax.arguments(of: relationship)))"
+            } else if let attribute = property.attribute {
+                arguments += ", metadata: SwiftData.Schema.Attribute(\(ModelSyntax.arguments(of: attribute)))"
+            }
+            return "SwiftData.Schema.PropertyMetadata(\(arguments))"
+        }
+        let metadataList = metadata.isEmpty ? "[]" : "[\n        " + metadata.joined(separator: ",\n        ") + "\n    ]"
+        let peerInits = properties.map { "    _\($0.name) = SwiftData._SwiftDataNoType()\n" }.joined()
+
+        return [
+            "@SwiftData.Transient private var _$backingData: SwiftData._ModelBacking = SwiftData._ModelBacking(for: \(raw: typeName).self)",
+            """
+            \(raw: access)var persistentBackingData: SwiftData._ModelBacking {
+                get { _$backingData }
+                set { _$backingData = newValue }
+            }
+            """,
+            """
+            \(raw: access)static var schemaMetadata: [SwiftData.Schema.PropertyMetadata] {
+                \(raw: metadataList)
+            }
+            """,
+            """
+            \(raw: access)required init(backingData: SwiftData._ModelBacking) {
+            \(raw: peerInits)    self._$backingData = backingData
+            }
+            """,
+            "@SwiftData.Transient \(raw: access)let _$observationRegistrar = Observation.ObservationRegistrar()",
+        ]
+    }
+
+    // MARK: Member attributes
+
+    public static func expansion(
+        of node: AttributeSyntax,
+        attachedTo declaration: some DeclGroupSyntax,
+        providingAttributesFor member: some DeclSyntaxProtocol,
+        in context: some MacroExpansionContext
+    ) throws -> [AttributeSyntax] {
+        guard let variable = member.as(VariableDeclSyntax.self), ModelSyntax.isPersisted(variable) else { return [] }
+        return ["@SwiftData._PersistedProperty"]
+    }
+
+    // MARK: Conformance
+
+    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(ClassDeclSyntax.self) else { return [] }
+        let decl: DeclSyntax = "extension \(type.trimmed): SwiftData.PersistentModel {}"
+        return [decl.cast(ExtensionDeclSyntax.self)]
+    }
+
+    /// A property name as a string literal (identifiers need no escaping,
+    /// but backquoted ones carry their backquotes).
+    private static func literal(_ text: String) -> String {
+        "\"" + text.filter { $0 != "`" } + "\""
+    }
+}
+
+/// A persisted property: reads and writes go to the model's backing data,
+/// observed like an `@Observable` property.
+public struct PersistedPropertyMacro: AccessorMacro, PeerMacro {
+    public static func expansion(
+        of node: AttributeSyntax,
+        providingAccessorsOf declaration: some DeclSyntaxProtocol,
+        in context: some MacroExpansionContext
+    ) throws -> [AccessorDeclSyntax] {
+        guard let variable = declaration.as(VariableDeclSyntax.self), let name = ModelSyntax.name(of: variable) else { return [] }
+        let key = "\"" + name.filter { $0 != "`" } + "\""
+        return [
+            """
+            @storageRestrictions(accesses: _$backingData, initializes: _\(raw: name))
+            init(initialValue) {
+                _$backingData._setInitialValue(initialValue, forKey: \(raw: key))
+                _\(raw: name) = SwiftData._SwiftDataNoType()
+            }
+            """,
+            """
+            get {
+                _$observationRegistrar.access(self, keyPath: \\.\(raw: name))
+                return self._$getValue(forKey: \(raw: key))
+            }
+            """,
+            """
+            set {
+                _$observationRegistrar.withMutation(of: self, keyPath: \\.\(raw: name)) {
+                    self._$setValue(newValue, forKey: \(raw: key))
+                }
+            }
+            """,
+        ]
+    }
+
+    public static func expansion(
+        of node: AttributeSyntax,
+        providingPeersOf declaration: some DeclSyntaxProtocol,
+        in context: some MacroExpansionContext
+    ) throws -> [DeclSyntax] {
+        guard let variable = declaration.as(VariableDeclSyntax.self), let name = ModelSyntax.name(of: variable) else { return [] }
+        return ["@SwiftData.Transient private var _\(raw: name): SwiftData._SwiftDataNoType"]
+    }
+}
+
+/// `@Attribute`, `@Relationship` and `@Transient` only mark a property; `@Model`
+/// reads them.
+public struct MarkerMacro: PeerMacro {
+    public static func expansion(
+        of node: AttributeSyntax,
+        providingPeersOf declaration: some DeclSyntaxProtocol,
+        in context: some MacroExpansionContext
+    ) throws -> [DeclSyntax] {
+        []
+    }
+}
+
+/// `#Unique` and `#Index` (iOS 18) declare constraints and indexes inside a
+/// model. The store keeps every record in memory, so an index adds nothing;
+/// uniqueness is declared with `@Attribute(.unique)`.
+public struct ConstraintMacro: DeclarationMacro {
+    public static func expansion(
+        of node: some FreestandingMacroExpansionSyntax,
+        in context: some MacroExpansionContext
+    ) throws -> [DeclSyntax] {
+        []
+    }
+}

package/Sources/SwiftDataMacros/Plugin.swift

@@ -0,0 +1,18 @@
+import SwiftCompilerPlugin
+import SwiftSyntaxMacros
+
+@main
+struct SwiftDataMacrosPlugin: CompilerPlugin {
+    let providingMacros: [Macro.Type] = [
+        ModelMacro.self,
+        ModelActorMacro.self,
+        PersistedPropertyMacro.self,
+        MarkerMacro.self,
+        ConstraintMacro.self,
+        PredicateMacro.self,
+        ExpressionMacro.self,
+        EntryMacro.self,
+        GenerableMacro.self,
+        GuideMacro.self,
+    ]
+}