fix(validation): inherited-attr edges in identity accessors + filterable/discriminator validation (#56 follow-up)

Addresses the UNSURE items from the #56 audit — own-only reads that break under
attr-level (ADR-0029) inheritance, where the codegen counterpart already reads effective:

- C# MetaIdentity: Fields/Unique/Generation/References/Enforce switched OwnAttr → Attr.
  Same ADR-0029 identity edge fixed in TS (#57) — an identity that inherits @fields via
  node-level extends without restating it now resolves its key (was: empty → no PK).
  + a regression gate (InheritWithoutRestateGateTests) mirroring the TS pk-resolver gate.

- Python validation: validate_discriminator @values and validation_passes
  @filterable/@db.indexed reads switched attr() → attrs().get() — an inherited enum's
  members no longer false-reject a discriminator value, and an inherited @filterable field
  is validated consistently with the (already-effective) codegen.

- Java ValidationPhase: @filterable/@db.indexed field reads and the warnFilterableWithoutIndex
  index-collection identity @fields read switched (.., false) → (.., true). (validateIdentityNode
  was already FR-024-correct — conditional effective-when-super-present — and is left as-is.)

Left own-only deliberately: the validation reference-walk (validate-at-declaration) and the
M:N junction identity.reference reads (the junction must declare its references locally).

Verified, no regressions: Java metadata 1058, C# conformance 665 + codegen 12 (+1 gate),
Python 1207.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: dmealing

server/csharp/MetaObjects.Codegen.Tests/InheritWithoutRestateGateTests.cs

@@ -0,0 +1,40 @@
+using System.Linq;
+using MetaObjects.Loader;
+using MetaObjects.Meta;
+using Xunit;
+
+namespace MetaObjects.Codegen.Tests;
+
+/// <summary>
+/// Regression gate for #56 (the ADR-0029 identity edge): an identity that inherits
+/// @fields via node-level <c>extends</c> without restating it must resolve those fields
+/// via the EFFECTIVE accessor. <see cref="MetaIdentity.Fields"/> reads <c>Attr</c>, not
+/// <c>OwnAttr</c>; before that fix the inherited @fields was invisible → empty key → no PK.
+/// Parity with the TS pk-resolver gate.
+/// </summary>
+public class InheritWithoutRestateGateTests
+{
+    private const string Model = """
+    { "metadata.root": { "package": "test", "children": [
+      { "object.entity": { "name": "BaseEntity", "abstract": true, "children": [
+        { "field.long": { "name": "id" } },
+        { "identity.primary": { "name": "primary", "@fields": ["id"], "@generation": "increment" } }
+      ] } },
+      { "object.entity": { "name": "Widget", "children": [
+        { "source.rdb": { "@table": "widgets" } },
+        { "field.long": { "name": "id" } },
+        { "identity.primary": { "name": "primary", "extends": "test::BaseEntity.primary" } }
+      ] } }
+    ] } }
+    """;
+
+    [Fact]
+    public void Inherited_identity_fields_resolve_via_effective_accessor()
+    {
+        var root = new MetaDataLoader().Load([new InMemoryStringSource(Model, id: "g.json")]).Root;
+        var widget = root.Objects().First(o => o.Name == "Widget");
+        var primary = widget.PrimaryIdentity();
+        Assert.NotNull(primary);
+        Assert.Equal(new[] { "id" }, primary!.Fields);
+    }
+}

server/csharp/MetaObjects/Meta/MetaIdentity.cs

@@ -16,7 +16,7 @@ public IReadOnlyList<string> Fields
     {
         get
         {
-            var f = OwnAttr(IDENTITY_ATTR_FIELDS);
+            var f = Attr(IDENTITY_ATTR_FIELDS);
             return f is IReadOnlyList<string> list ? list : [];
         }
     }
@@ -25,7 +25,7 @@ public IReadOnlyList<string> Fields
     /// Whether the identity enforces uniqueness.
     /// Defaults to <see langword="true"/>; explicit <c>@unique: false</c> makes it a non-unique index.
     /// </summary>
-    public bool Unique => OwnAttr(IDENTITY_ATTR_UNIQUE) is not false;
+    public bool Unique => Attr(IDENTITY_ATTR_UNIQUE) is not false;
 
     /// <summary>True when this identity's subtype is <c>primary</c>.</summary>
     public bool IsPrimary() => SubType == IDENTITY_SUBTYPE_PRIMARY;
@@ -51,7 +51,7 @@ public string? Generation
     {
         get
         {
-            var v = OwnAttr(IDENTITY_ATTR_GENERATION);
+            var v = Attr(IDENTITY_ATTR_GENERATION);
             return v is string s ? s : null;
         }
     }
@@ -73,7 +73,7 @@ public class MetaReferenceIdentity(TypeId typeId, string name) : MetaIdentity(ty
 {
     /// <summary>Raw <c>@references</c> value, unparsed.</summary>
     public string? ReferencesRaw =>
-        OwnAttr(IDENTITY_REFERENCE_ATTR_REFERENCES) is string s ? s : null;
+        Attr(IDENTITY_REFERENCE_ATTR_REFERENCES) is string s ? s : null;
 
     /// <summary>Target entity name (the part before the dot, or the whole bare value).</summary>
     public string? TargetEntity
@@ -104,5 +104,5 @@ public IReadOnlyList<string> TargetFields
     }
 
     /// <summary>Whether the reference is physically enforced (default true; <c>@enforce: false</c> = logical-only).</summary>
-    public bool Enforce => OwnAttr(IDENTITY_REFERENCE_ATTR_ENFORCE) is not false;
+    public bool Enforce => Attr(IDENTITY_REFERENCE_ATTR_ENFORCE) is not false;
 }

server/java/metadata/src/main/java/com/metaobjects/loader/ValidationPhase.java

@@ -1662,8 +1662,8 @@ private static void validateDataGridLayout(MetaObject obj, DataGridLayout grid)
         java.util.Set<String> filterable = new java.util.HashSet<>();
         for (MetaField f : obj.getChildren(MetaField.class, true)) {
             fieldsByName.put(f.getShortName(), f);
-            if (f.hasMetaAttr(ATTR_FILTERABLE, false)) {
-                Object v = f.getMetaAttr(ATTR_FILTERABLE, false).getValue();
+            if (f.hasMetaAttr(ATTR_FILTERABLE, true)) {
+                Object v = f.getMetaAttr(ATTR_FILTERABLE, true).getValue();
                 boolean isFilterable =
                     (v instanceof Boolean) ? (Boolean) v
                     : (v instanceof String) ? "true".equalsIgnoreCase((String) v)
@@ -1780,14 +1780,17 @@ private static void checkFilterableFields(MetaObject obj, MetaDataLoader loader)
         for (MetaData child : obj.getChildren(MetaData.class, true)) {
             if (!(child instanceof MetaIdentity)) continue;
             MetaIdentity identity = (MetaIdentity) child;
-            if (!identity.hasMetaAttr(MetaIdentity.ATTR_FIELDS, false)) continue;
-            Object raw = identity.getMetaAttr(MetaIdentity.ATTR_FIELDS, false).getValue();
+            // Effective (#56): a secondary index that inherits @fields via extends must
+            // still contribute its indexed columns, or a filterable field gets a spurious
+            // "without index" warning.
+            if (!identity.hasMetaAttr(MetaIdentity.ATTR_FIELDS, true)) continue;
+            Object raw = identity.getMetaAttr(MetaIdentity.ATTR_FIELDS, true).getValue();
             collectIdentityFields(raw, indexed);
         }
 
         for (MetaField field : fields) {
-            if (!field.hasMetaAttr(ATTR_FILTERABLE, false)) continue;
-            Object v = field.getMetaAttr(ATTR_FILTERABLE, false).getValue();
+            if (!field.hasMetaAttr(ATTR_FILTERABLE, true)) continue;
+            Object v = field.getMetaAttr(ATTR_FILTERABLE, true).getValue();
             boolean filterable =
                 (v instanceof Boolean) ? (Boolean) v
                 : (v instanceof String) ? "true".equalsIgnoreCase((String) v)
@@ -1796,8 +1799,8 @@ private static void checkFilterableFields(MetaObject obj, MetaDataLoader loader)
             // @db.indexed: true is an explicit escape hatch — author asserts a
             // backing index exists (or will, when supported). Mirrors TS
             // validation-passes.ts:155.
-            if (field.hasMetaAttr(ATTR_DB_INDEXED, false)) {
-                Object iv = field.getMetaAttr(ATTR_DB_INDEXED, false).getValue();
+            if (field.hasMetaAttr(ATTR_DB_INDEXED, true)) {
+                Object iv = field.getMetaAttr(ATTR_DB_INDEXED, true).getValue();
                 boolean dbIndexed =
                     (iv instanceof Boolean) ? (Boolean) iv
                     : (iv instanceof String) ? "true".equalsIgnoreCase((String) iv)
@@ -1848,8 +1851,8 @@ private static void validateFilterableHasSupportedOps(MetaRoot root) {
             MetaObject obj = (MetaObject) rootChild;
             // Effective fields (includes inherited via extends:/super:).
             for (MetaField field : obj.getChildren(MetaField.class, true)) {
-                if (!field.hasMetaAttr(ATTR_FILTERABLE, false)) continue;
-                Object v = field.getMetaAttr(ATTR_FILTERABLE, false).getValue();
+                if (!field.hasMetaAttr(ATTR_FILTERABLE, true)) continue;
+                Object v = field.getMetaAttr(ATTR_FILTERABLE, true).getValue();
                 boolean filterable =
                     (v instanceof Boolean) ? (Boolean) v
                     : (v instanceof String) ? "true".equalsIgnoreCase((String) v)

server/python/src/metaobjects/loader/validate_discriminator.py

@@ -106,7 +106,7 @@ def validate_discriminator(root: MetaData, errors: list[MetaError]) -> None:
             continue  # root's own ERR_DISCRIMINATOR_FIELD_NOT_FOUND already fires
 
         if field.sub_type == FIELD_SUBTYPE_ENUM:
-            enum_values = field.attr(FIELD_ATTR_VALUES)
+            enum_values = field.attrs().get(FIELD_ATTR_VALUES)
             members = [str(v) for v in enum_values] if isinstance(enum_values, (list, tuple)) else []
             if value not in members:
                 errors.append(

server/python/src/metaobjects/loader/validation_passes.py

@@ -791,7 +791,7 @@ def _validate_datagrid_filter_values(
         filterable: dict[str, frozenset[str]] = {
             f.name: ops_for_subtype(f.sub_type)
             for f in node.fields()
-            if f.attr("filterable") is True
+            if f.attrs().get("filterable") is True
         }
 
         for child in node.children():
@@ -1435,11 +1435,11 @@ def _validate_filterable_has_index(
         covered = _identity_field_names(node)
 
         for field in node.fields():
-            if field.attr("filterable") is not True:
+            if field.attrs().get("filterable") is not True:
                 continue
             if field.name in covered:
                 continue
-            if field.attr("db.indexed") is True:
+            if field.attrs().get("db.indexed") is True:
                 continue
             warnings.append(
                 f'[filterable-without-index] field "{node.name}.{field.name}" has @filterable: true '
@@ -1465,7 +1465,7 @@ def _validate_filterable_has_supported_ops(
         if node.type != TYPE_OBJECT or not isinstance(node, MetaObject):
             continue
         for field in node.fields():
-            if field.attr("filterable") is not True:
+            if field.attrs().get("filterable") is not True:
                 continue
             if ops_for_subtype(field.sub_type):
                 continue