REF: simplify resolvable pattern usage

Author: georgetchelidze

Sources/Resolvable/Resolvable.swift

@@ -7,16 +7,13 @@ public enum ResolvableDefault {
     case overridable   // All properties are overridable unless marked @Identity
 }
 
-/// Which nested types the @Resolvable macro should generate.
-public struct ResolvableParts: OptionSet, Hashable, Codable, Sendable {
-    public let rawValue: UInt8
-    public init(rawValue: UInt8) { self.rawValue = rawValue }
+/// Defines the pattern of code generation for a @Resolvable type.
+public enum ResolvablePattern {
+    /// Generates `.Definition`, `.Instance`, and `.Override`.
+    case full
 
-    public static let definition = ResolvableParts(rawValue: 1 << 0)
-    public static let instance   = ResolvableParts(rawValue: 1 << 1)
-    public static let overrides  = ResolvableParts(rawValue: 1 << 2)
-
-    public static let all: ResolvableParts = [.definition, .instance, .overrides]
+    /// Generates only `.Definition` and `.Override`.
+    case nonInstantiable
 }
 
 /// The `@Resolvable` macro generates all the necessary boilerplate for the
@@ -35,7 +32,7 @@ public struct ResolvableParts: OptionSet, Hashable, Codable, Sendable {
 @attached(memberAttribute)
 public macro Resolvable(
     default: ResolvableDefault = .optIn,
-    generate: ResolvableParts = .all
+    pattern: ResolvablePattern = .full
 ) = #externalMacro(module: "ResolvableMacros", type: "ResolvableMacro")
 
 /// A property wrapper to mark which properties of a model can be

Sources/ResolvableMacros/ResolvableMacro.swift

@@ -13,14 +13,16 @@ public struct ResolvableMacro: MemberMacro, MemberAttributeMacro {
     }
 
     // Generate flags parsed from `generate:` option set
+    private enum ResolvablePattern {
+        case full
+        case nonInstantiable
+    }
+    
     private struct GenerateFlags {
-        var hasDefinition = true
-        var hasInstance   = true
-        // Whether override fields should be generated + applied.
-        // The Override type still exists whenever hasDefinition is true.
-        var includeOverrideFields = true
-
-        var hasAnySource: Bool { hasDefinition || hasInstance }
+        var hasDefinition: Bool
+        var hasInstance: Bool
+        // This can be simplified. If a definition exists, overrides should be included.
+        var includeOverrideFields: Bool
     }
 
     public static func expansion(
@@ -43,31 +45,15 @@ public struct ResolvableMacro: MemberMacro, MemberAttributeMacro {
             }
         }
 
-        // Parse @Resolvable(generate: <ResolvableParts>)
-        let generateFlags = parseGenerateFlags(from: node)
-
-        // If nothing to resolve from
-        if !generateFlags.hasAnySource {
-            context.diagnose(Diagnostic(
-                node: Syntax(node),
-                message: ResolvableMessage(
-                    id: "noSourcesSelected",
-                    message: "At least one of '.definition' or '.instance' must be included in 'generate:' to produce 'Source', 'Resolved', and 'Resolver'.",
-                    severity: .error
-                )
-            ))
-        }
-        // If override fields requested but no definitions exist
-        if generateFlags.includeOverrideFields && !generateFlags.hasDefinition {
-            context.diagnose(Diagnostic(
-                node: Syntax(node),
-                message: ResolvableMessage(
-                    id: "overridesWithoutDefinition",
-                    message: "'.overrides' has no effect without '.definition'. The resolver will ignore overrides.",
-                    severity: .warning
-                )
-            ))
-        }
+         let pattern = parsePattern(from: node)
+
+         let generateFlags: GenerateFlags
+         switch pattern {
+         case .full:
+             generateFlags = GenerateFlags(hasDefinition: true, hasInstance: true, includeOverrideFields: true)
+         case .nonInstantiable:
+             generateFlags = GenerateFlags(hasDefinition: true, hasInstance: false, includeOverrideFields: true)
+         }
 
         var allProperties: [VariableDeclSyntax] = []
         var fullOverrides: [VariableDeclSyntax] = []
@@ -217,7 +203,7 @@ public struct ResolvableMacro: MemberMacro, MemberAttributeMacro {
             decls.append(createInstanceStruct(baseName: baseName, properties: allProperties))
         }
 
-        if generateFlags.hasAnySource {
+        if generateFlags.hasDefinition || generateFlags.hasInstance {
             decls.append(createSourceEnum(baseName: baseName,
                                           hasDefinition: generateFlags.hasDefinition,
                                           hasInstance: generateFlags.hasInstance))
@@ -519,30 +505,21 @@ public struct ResolvableMacro: MemberMacro, MemberAttributeMacro {
         }
         return text
     }
-
-    // Parse generate flags from the attribute's `generate:` argument.
-    private static func parseGenerateFlags(from node: AttributeSyntax) -> GenerateFlags {
-        var flags = GenerateFlags() // default == .all
+    
+    private static func parsePattern(from node: AttributeSyntax) -> ResolvablePattern {
         guard let args = node.arguments?.as(LabeledExprListSyntax.self),
-              let generateArg = args.first(where: { $0.label?.text == "generate" })
-        else { return flags }
-
-        let text = generateArg.expression.trimmedDescription
-
-        if text.contains(".all") {
-            return flags
+              let patternArg = args.first(where: { $0.label?.text == "pattern" })
+        else {
+            // If the `pattern` argument is omitted, default to `.full`.
+            return .full
         }
 
-        // Reset and enable selectively
-        flags.hasDefinition = false
-        flags.hasInstance = false
-        flags.includeOverrideFields = false
-
-        if text.contains(".definition") { flags.hasDefinition = true }
-        if text.contains(".instance")   { flags.hasInstance = true }
-        if text.contains(".overrides")  { flags.includeOverrideFields = true }
+        let text = patternArg.expression.trimmedDescription
+        if text.contains("nonInstantiable") {
+            return .nonInstantiable
+        }
 
-        return flags
+        return .full
     }
 }