Support validate exact for non-optional raw defaults

fatbobman · fatbobman · commit 7a969d61202f · 2026-03-19T21:31:08.000+08:00
diff --git a/Sources/CoreDataEvolutionToolingCore/Config/ToolingConfigValidation.swift b/Sources/CoreDataEvolutionToolingCore/Config/ToolingConfigValidation.swift
@@ -89,11 +89,13 @@ private func validateResolvedToolingSchemaConfig(
   context: String,
   entitiesByName: [String: NSEntityDescription]
 ) throws {
+  let allowNonOptionalRawStorageWithModelDefault = context == "validate"
   try validateToolingModelConstraints(
     entitiesByName: entitiesByName,
     attributeRules: config.attributeRules,
     relationshipRules: config.relationshipRules,
-    context: context
+    context: context,
+    allowNonOptionalRawStorageWithModelDefault: allowNonOptionalRawStorageWithModelDefault
   )
   try validateAttributeRules(
     config.attributeRules,
@@ -125,7 +127,8 @@ private func validateToolingModelConstraints(
   entitiesByName: [String: NSEntityDescription],
   attributeRules: ToolingAttributeRules,
   relationshipRules: ToolingRelationshipRules,
-  context: String
+  context: String,
+  allowNonOptionalRawStorageWithModelDefault: Bool
 ) throws {
   for (entityName, entity) in entitiesByName {
     let rules = attributeRules[entity: entityName]
@@ -148,6 +151,12 @@ private func validateToolingModelConstraints(
         )
       }
       if storageMethod != .default, attribute.isOptional == false {
+        if allowNonOptionalRawStorageWithModelDefault,
+          storageMethod == .raw,
+          attribute.defaultValue != nil
+        {
+          continue
+        }
         throw configValidationFailure(
           """
           \(context) does not support non-optional custom storage for '\(entityName).\(fieldName)'. \
diff --git a/Sources/CoreDataEvolutionToolingCore/Generate/ToolingSourceRenderer.swift b/Sources/CoreDataEvolutionToolingCore/Generate/ToolingSourceRenderer.swift
@@ -512,8 +512,8 @@ public enum ToolingSourceRenderer {
   }
 
   // V1 generation follows model defaults exactly. It does not invent code-side defaults for
-  // required fields, and it does not convert persistent defaults into custom storage values such
-  // as enums, codable payloads, or compositions.
+  // required fields. For `.raw` storage, validate exact mode can still render a stable source
+  // default by wrapping the persistent literal in `RawRepresentable(rawValue:)!`.
   private static func renderDefaultValue(
     for attribute: ToolingAttributeIR,
     storageMethod: ToolingAttributeStorageRule,
@@ -526,7 +526,25 @@ public enum ToolingSourceRenderer {
     switch storageMethod {
     case .default:
       return attribute.modelDefaultValueLiteral
-    case .raw, .codable, .composition, .transformed:
+    case .raw:
+      guard let rawType = attribute.storage.nonOptionalSwiftType else {
+        throw ToolingFailure.user(
+          .configInvalid,
+          "generate could not resolve a Swift type for non-optional raw attribute '\(attribute.swiftName)'."
+        )
+      }
+      guard let rawValueLiteral = attribute.modelDefaultValueLiteral else {
+        throw ToolingFailure.user(
+          .configInvalid,
+          """
+          generate cannot derive a non-optional default for raw storage '\(storageMethod.rawValue)' \
+          on '\(attribute.swiftName)' without a model default. Make the field optional or keep \
+          default storage for required fields.
+          """
+        )
+      }
+      return "\(rawType)(rawValue: \(rawValueLiteral))!"
+    case .codable, .composition, .transformed:
       throw ToolingFailure.user(
         .configInvalid,
         """
diff --git a/Sources/CoreDataEvolutionToolingCore/Validation/ToolingValidateComparator.swift b/Sources/CoreDataEvolutionToolingCore/Validation/ToolingValidateComparator.swift
@@ -417,7 +417,27 @@ public enum ToolingValidateComparator {
           )
         )
       }
-    case .raw, .codable, .composition, .transformed:
+    case .raw:
+      guard attribute.hasModelDefaultValue else {
+        diagnostics.append(
+          error(
+            "validate does not support non-optional raw storage without a model default for '\(entityName).\(expectedPropertyName)'."
+          )
+        )
+        return
+      }
+
+      guard let actualDefault = sourceProperty.defaultValueLiteral,
+        normalizeLiteral(actualDefault) != "nil"
+      else {
+        diagnostics.append(
+          error(
+            "validate requires non-optional raw storage for '\(entityName).\(expectedPropertyName)' to declare an explicit non-nil Swift default."
+          )
+        )
+        return
+      }
+    case .codable, .composition, .transformed:
       diagnostics.append(
         error(
           "validate does not support non-optional \(attribute.storage.method.rawValue) storage for '\(entityName).\(expectedPropertyName)'."
diff --git a/Tests/CoreDataEvolutionToolingCoreTests/ConfigValidationTests.swift b/Tests/CoreDataEvolutionToolingCoreTests/ConfigValidationTests.swift
@@ -624,6 +624,25 @@ struct ConfigValidationTests {
     }
   }
 
+  @Test("validate accepts non-optional raw storage when model provides default")
+  func validateAcceptsNonOptionalRawStorageWithModelDefault() throws {
+    let model = makeModelWithCustomStorageCandidate()
+    let template = makeValidateValidationTemplate(
+      attributeRules: .init(
+        entities: [
+          "Item": [
+            "status_raw": .init(
+              swiftType: "ItemStatus",
+              storageMethod: .raw
+            )
+          ]
+        ]
+      )
+    )
+
+    try validateToolingConfigTemplate(template, against: model)
+  }
+
   @Test("generate rejects transient attribute with custom storage")
   func generateRejectsTransientAttributeWithCustomStorage() throws {
     let model = makeModelWithTransientAttribute()
@@ -727,6 +746,38 @@ struct ConfigValidationTests {
     )
   }
 
+  private func makeValidateValidationTemplate(
+    attributeRules: ToolingAttributeRules? = nil
+  ) -> ToolingConfigTemplate {
+    ToolingConfigTemplate(
+      schemaVersion: toolingSupportedSchemaVersion,
+      generate: nil,
+      validate: .init(
+        modelPath: "Models/AppModel.xcdatamodeld",
+        modelVersion: nil,
+        momcBin: nil,
+        sourceDir: "Sources/AppModels",
+        moduleName: "AppModels",
+        typeMappings: nil,
+        attributeRules: attributeRules,
+        relationshipRules: nil,
+        compositionRules: nil,
+        accessLevel: .internal,
+        singleFile: false,
+        splitByEntity: true,
+        headerTemplate: nil,
+        generateInit: false,
+        defaultDecodeFailurePolicy: .fallbackToDefaultValue,
+        include: [],
+        exclude: [],
+        level: .conformance,
+        report: .text,
+        failOnWarning: false,
+        maxIssues: 200
+      )
+    )
+  }
+
   private func makeModel() -> NSManagedObjectModel {
     let nameAttribute = NSAttributeDescription()
     nameAttribute.name = "name"
diff --git a/Tests/CoreDataEvolutionToolingCoreTests/ToolingSourceRendererTests.swift b/Tests/CoreDataEvolutionToolingCoreTests/ToolingSourceRendererTests.swift
@@ -308,6 +308,58 @@ struct ToolingSourceRendererTests {
     }
   }
 
+  @Test("renderer emits non-optional raw storage using model default literal")
+  func rendererEmitsNonOptionalRawStorageDefault() throws {
+    let modelIR = ToolingModelIR(
+      source: .init(
+        originalPath: "/virtual/AppModel.xcdatamodeld",
+        selectedSourcePath: "/virtual/AppModel.xcdatamodeld/V1.xcdatamodel",
+        compiledModelPath: "/virtual/AppModel.momd",
+        inputKind: .xcdatamodeld,
+        selectedVersionName: "V1.xcdatamodel"
+      ),
+      generationPolicy: .init(
+        accessLevel: .internal,
+        singleFile: false,
+        splitByEntity: true,
+        generateInit: false,
+        defaultDecodeFailurePolicy: .fallbackToDefaultValue
+      ),
+      entities: [
+        .init(
+          name: "Item",
+          managedObjectClassName: "NSManagedObject",
+          representedClassName: "Item",
+          attributes: [
+            .init(
+              persistentName: "status_raw",
+              swiftName: "status",
+              coreDataAttributeType: "Integer 32",
+              coreDataPrimitiveType: "Int32",
+              isOptional: false,
+              hasModelDefaultValue: true,
+              modelDefaultValueLiteral: "0",
+              storage: .init(
+                method: .raw,
+                swiftType: "ItemStatus",
+                nonOptionalSwiftType: "ItemStatus",
+                transformerName: nil,
+                decodeFailurePolicy: .fallbackToDefaultValue,
+                isResolved: true
+              )
+            )
+          ],
+          relationships: [],
+          compositions: []
+        )
+      ]
+    )
+
+    let source = try #require(ToolingSourceRenderer.renderSources(from: modelIR).first?.contents)
+
+    #expect(source.contains(#"var status: ItemStatus = ItemStatus(rawValue: 0)!"#))
+  }
+
   @Test(
     "renderer emits required default storage without an initializer when model default is absent")
   func rendererEmitsRequiredDefaultStorageWithoutInitializer() throws {
diff --git a/Tests/CoreDataEvolutionToolingCoreTests/ToolingValidateComparatorTests.swift b/Tests/CoreDataEvolutionToolingCoreTests/ToolingValidateComparatorTests.swift
@@ -549,6 +549,53 @@ struct ToolingValidateComparatorTests {
     )
     #expect(diagnosticsWithIgnore.isEmpty)
   }
+
+  @Test("comparator accepts non-optional raw storage when model default exists")
+  func comparatorAcceptsNonOptionalRawStorageWithModelDefault() {
+    let diagnostics = ToolingValidateComparator.compareQuick(
+      expected: requiredRawStorageModelIR(),
+      actual: .init(
+        sourceDirectory: "/virtual/Sources",
+        entities: [
+          .init(
+            filePath: "/virtual/Sources/Item.swift",
+            className: "Item",
+            objcEntityName: "Item",
+            persistentModelArguments: .init(generateInit: false),
+            properties: [
+              .init(
+                filePath: "/virtual/Sources/Item.swift",
+                name: "status",
+                typeName: "ItemStatus",
+                nonOptionalTypeName: "ItemStatus",
+                declarationRange: dummyRange(0, 0),
+                declarationIndent: "  ",
+                isOptional: false,
+                defaultValueLiteral: ".draft",
+                defaultValueRange: dummyRange(0, 0),
+                isStored: true,
+                isStatic: false,
+                hasIgnore: false,
+                attribute: .init(
+                  range: dummyRange(0, 0),
+                  persistentName: "status_raw",
+                  storageMethod: .raw,
+                  transformerName: nil,
+                  transformerTypeName: nil,
+                  decodeFailurePolicy: nil
+                ),
+                relationshipShape: nil
+              )
+            ],
+            customMembers: []
+          )
+        ]
+      ),
+      level: .conformance
+    )
+
+    #expect(diagnostics.isEmpty)
+  }
 }
 
 private func ambiguousRelationshipModelIR() -> ToolingModelIR {
@@ -650,6 +697,55 @@ private func requiredDefaultStorageModelIR() -> ToolingModelIR {
   )
 }
 
+private func requiredRawStorageModelIR() -> ToolingModelIR {
+  .init(
+    source: .init(
+      originalPath: "/virtual/AppModel.xcdatamodeld",
+      selectedSourcePath: "/virtual/AppModel.xcdatamodeld/V1.xcdatamodel",
+      compiledModelPath: "/virtual/AppModel.momd",
+      inputKind: .xcdatamodeld,
+      selectedVersionName: "V1.xcdatamodel"
+    ),
+    generationPolicy: .init(
+      accessLevel: .internal,
+      singleFile: false,
+      splitByEntity: true,
+      generateInit: false,
+      defaultDecodeFailurePolicy: .fallbackToDefaultValue
+    ),
+    entities: [
+      .init(
+        name: "Item",
+        managedObjectClassName: "NSManagedObject",
+        representedClassName: "Item",
+        attributes: [
+          .init(
+            persistentName: "status_raw",
+            swiftName: "status",
+            coreDataAttributeType: "Integer 32",
+            coreDataPrimitiveType: "Int32",
+            isUnique: false,
+            isTransient: false,
+            isOptional: false,
+            hasModelDefaultValue: true,
+            modelDefaultValueLiteral: "0",
+            storage: .init(
+              method: .raw,
+              swiftType: "ItemStatus",
+              nonOptionalSwiftType: "ItemStatus",
+              transformerName: nil,
+              decodeFailurePolicy: .fallbackToDefaultValue,
+              isResolved: true
+            )
+          )
+        ],
+        relationships: [],
+        compositions: []
+      )
+    ]
+  )
+}
+
 private func dummyRange(_ start: Int, _ end: Int) -> ToolingTextRange {
   .init(startUTF8Offset: start, endUTF8Offset: end)
 }
diff --git a/Tests/CoreDataEvolutionToolingCoreTests/ValidateServiceTests.swift b/Tests/CoreDataEvolutionToolingCoreTests/ValidateServiceTests.swift
