Ios swift – "Cannot Synthesize" — Why is this class not ready to be declared "@Model" for use with SwiftData?

The reason this happens is that the synthesis of the Codable implementation happens after the macros have expanded.

After the macros have expanded, all the properties you declared become computed properties, and the macros add an additional _$backingData property, as well as an underscored-prefixed version of each property you declared, of type _SwiftDataNoType (just an empty struct, acting as a placeholder), among other things.

Basically, @Model turns this:

class Foo {
    var foo: Int
    var bar: String
}

into:

class Foo: PersisrentModel {
    var foo: Int { get { ... } set { ... } }
    var bar: String { get { ... } set { ... } }
    private var _foo: _SwiftDataNoType
    private var _bar: _SwiftDataNoType

    private var _$backingData: any SwiftData.BackingData<Foo>
}

No wonder the Codable synthesis fails!

I recommend checking out the actual code that it generates (the above is only a simplified version) with Xcode’s "Inline Macro" and "Expand Macro" context menu items.

You can conform to Codable manually, like this article shows. See also workingdog’s answer.

Alternatively, try writing a macro that generates a Codable implementation. Your macro would receive the same syntax tree as @Model, so you will have access to the class’ members before the macro expansion. You’d use it like this:

@Model
@CodableModel
final class Landmark: Hashable, Identifiable {
    var id: Int
    var name: String
    ...
}

Here is a rough sketch of such a CodableModel:

@attached(member, names: named(init(from:)), named(encode(to:)), named(CodingKeys))
@attached(extension, conformances: Codable)
public macro CodableModel() = #externalMacro(module: "...", type: "CodableModel")

// ...

public struct CodableModel: MemberMacro, ExtensionMacro {
    public static func expansion(
      of node: AttributeSyntax,
      providingMembersOf declaration: some DeclGroupSyntax,
      in context: some MacroExpansionContext
    ) throws -> [DeclSyntax] {
        var properties = [(type: TypeSyntax, name: TokenSyntax)]()
        let members = declaration.memberBlock.members
        for member in members {
            guard let propertyDecl = member.decl.as(VariableDeclSyntax.self) else { continue }
            guard propertyDecl.bindingSpecifier.text == "var" else { continue } // ignore lets
            guard let binding = propertyDecl.bindings.first else { continue }
            guard binding.accessorBlock == nil else { continue } // ignore computed properties
            guard let type = binding.typeAnnotation?.type else { continue }
            guard let name = binding.pattern.as(IdentifierPatternSyntax.self)?.identifier else { continue }
            properties.append((type, name))
        }
        let codingKeys = try EnumDeclSyntax("enum CodingKeys: String, CodingKey") {
            for (_, name) in properties {
                "case (name)"
            }
        }
        
        let initialiser = try InitializerDeclSyntax("init(from decoder: Decoder) throws") {
            "let container = try decoder.container(keyedBy: CodingKeys.self)"
            for (type, name) in properties {
                "(name) = try container.decode((type).self, forKey: .(name))"
                // TODO: use decodeIfPresent if the type is optional
            }
        }
        
        let encodeMethod = try FunctionDeclSyntax("func encode(to encoder: Encoder) throws") {
            "var container = encoder.container(keyedBy: CodingKeys.self)"
            for (_, name) in properties {
                "try container.encode((name), forKey: .(name))"
            }
        }
        
        return [
            DeclSyntax(codingKeys),
            DeclSyntax(initialiser),
            DeclSyntax(encodeMethod),
        ]
    }
    
    public static func expansion(
        of node: AttributeSyntax,
        attachedTo declaration: some DeclGroupSyntax,
        providingExtensionsOf type: some TypeSyntaxProtocol,
        conformingTo protocols: [TypeSyntax],
        in context: some MacroExpansionContext
    ) throws -> [ExtensionDeclSyntax] {
        [try ExtensionDeclSyntax("extension (type): Codable") {}]
     }
}