Merge branch 'feat/own-sweep-jvm' into feat/own-sweep

Author: claude

server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/Fr019SharedEnum.kt

@@ -61,7 +61,11 @@ internal object Fr019SharedEnum {
         return sup
     }
 
-    /** Own-only read of `@provided` on an enum declaration. */
+    /**
+     * Read `@provided` on an enum declaration. ADR-0039: `@provided` is a
+     * declaration-layer marker (like `@isAbstract`) — describes THIS declaration,
+     * never inherited through extends. KEPT own-only.
+     */
     fun isProvided(decl: EnumField): Boolean {
         if (!decl.hasMetaAttr(EnumField.ATTR_PROVIDED, false)) return false
         val raw = runCatching { decl.getMetaAttr(EnumField.ATTR_PROVIDED, false).value }.getOrNull()

server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/KotlinExposedTableGenerator.kt

@@ -843,8 +843,9 @@ open class KotlinExposedTableGenerator : MultiFileDirectGeneratorBase<MetaObject
 
         for (entity in loader.metaObjects) {
             if (entity.subType != MetaObject.SUBTYPE_ENTITY) continue
-            for (child in entity.children) {
-                if (child !is MetaRelationship) continue
+            // ADR-0039: relationships are inheritable — RESOLVE via entity.relationships;
+            // entity.children (own-only) would miss an inherited relationship.
+            for (child in entity.relationships) {
                 if (child.subType != CompositionRelationship.SUBTYPE_COMPOSITION) continue
 
                 val objectRef = child.objectRef ?: continue
@@ -1016,7 +1017,9 @@ open class KotlinExposedTableGenerator : MultiFileDirectGeneratorBase<MetaObject
         val acc = linkedMapOf<String, MutableMap<String, RefDecoration>>()
         for (entity in loader.metaObjects) {
             if (entity.subType != MetaObject.SUBTYPE_ENTITY) continue
-            for (child in entity.children) {
+            // ADR-0039: identity.reference children are inheritable — RESOLVE via
+            // getIdentities(true); entity.children (own-only) would miss inherited FK refs.
+            for (child in entity.getIdentities(true)) {
                 if (child !is ReferenceIdentity) continue
                 val fields = child.fields
                 if (fields.size != 1) {

server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/KotlinExtractorGenerator.kt

@@ -71,8 +71,8 @@ open class KotlinExtractorGenerator : MultiFileDirectGeneratorBase<MetaObject>()
         val outRoot = Paths.get(outDir.absolutePath)
 
         // Stable name order — matches the sibling generators' deterministic emission.
-        val outputs = loader.root.children
-            .filterIsInstance<OutputTemplate>()
+        // ADR-0039: root-scan discipline — resolving children accessor.
+        val outputs = loader.root.getChildren(OutputTemplate::class.java, true)
             .sortedBy { it.name }
 
         for (tmpl in outputs) {

server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/KotlinGenUtil.kt

@@ -52,11 +52,12 @@ internal object KotlinGenUtil {
     }
 
     /**
-     * True if [obj] has an own `@isAbstract` attribute set to boolean-true. Reads only the
-     * own attribute (not inherited) — matches the ValidationPhase convention so concrete
-     * subtypes extending an abstract base still emit. Shared by every instance/write
-     * generator so the "never emit write artifacts for an abstract entity" invariant has a
-     * single definition.
+     * True if [obj] has an own `@isAbstract` attribute set to boolean-true. ADR-0039:
+     * `@isAbstract` is a declaration-layer marker — it describes THIS declaration and must
+     * NOT be inherited (a concrete subtype extending an abstract base is itself concrete
+     * and MUST emit). KEPT own-only, matching the ValidationPhase / GeneratorUtil.isAbstract
+     * convention. Shared by every instance/write generator so the "never emit write
+     * artifacts for an abstract entity" invariant has a single definition.
      */
     fun isAbstractEntity(obj: MetaObject): Boolean {
         if (!obj.hasMetaAttr(MetaData.ATTR_IS_ABSTRACT, false)) return false

server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/KotlinM2mSupport.kt

@@ -108,7 +108,9 @@ object KotlinM2mSupport {
 
     /** The single primary-key field name of an entity (defaults to `id`). */
     private fun primaryKeyField(entity: MetaObject): String {
-        val pk = entity.children
+        // ADR-0039: identities are inheritable — RESOLVE via getIdentities(true);
+        // entity.children (own-only) would miss an inherited primary identity.
+        val pk = entity.getIdentities(true)
             .filterIsInstance<com.metaobjects.identity.MetaIdentity>()
             .firstOrNull { it.isPrimary }
         return pk?.fields?.firstOrNull() ?: "id"

server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/KotlinOutputParserGenerator.kt

@@ -81,8 +81,8 @@ open class KotlinOutputParserGenerator : MultiFileDirectGeneratorBase<MetaObject
         val outRoot = Paths.get(outDir.absolutePath)
 
         // Stable name order — matches TS/C#/Python deterministic emission.
-        val outputs = loader.root.children
-            .filterIsInstance<OutputTemplate>()
+        // ADR-0039: root-scan discipline — resolving children accessor.
+        val outputs = loader.root.getChildren(OutputTemplate::class.java, true)
             .sortedBy { it.name }
 
         for (tmpl in outputs) {

server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/KotlinOutputPromptGenerator.kt

@@ -74,8 +74,8 @@ open class KotlinOutputPromptGenerator : MultiFileDirectGeneratorBase<MetaObject
         val outRoot = Paths.get(outDir.absolutePath)
 
         // Stable name order — matches TS/C#/Python/Java deterministic emission.
-        val outputs = loader.root.children
-            .filterIsInstance<OutputTemplate>()
+        // ADR-0039: root-scan discipline — resolving children accessor.
+        val outputs = loader.root.getChildren(OutputTemplate::class.java, true)
             .sortedBy { it.name }
 
         for (tmpl in outputs) {

server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/KotlinPayloadGenerator.kt

@@ -63,8 +63,8 @@ open class KotlinPayloadGenerator : MultiFileDirectGeneratorBase<MetaObject>() {
         // typed as its generated enum class (reusing the entity enum scheme); two fields sharing an
         // abstract enum super collapse onto ONE emitted file.
         val emittedEnumFqns = mutableSetOf<String>()
-        for (md in loader.root.children) {
-            if (md !is MetaTemplate) continue
+        // ADR-0039: root-scan discipline — resolving children accessor.
+        for (md in loader.root.getChildren(MetaTemplate::class.java, true)) {
             emit(md, loader, outRoot, emittedNestedFqns, emittedEnumFqns)
         }
     }
@@ -148,6 +148,8 @@ open class KotlinPayloadGenerator : MultiFileDirectGeneratorBase<MetaObject>() {
         emittedNestedFqns: MutableSet<String>,
         emittedEnumFqns: MutableSet<String>,
     ): TypeName {
+        // ADR-0039/ADR-0029: origin.* NEVER inherits — a derived field's origin is
+        // declared-here, so read OWN children (field.children), not resolving.
         val origin = field.children.filterIsInstance<MetaOrigin>().firstOrNull()
 
         if (origin != null) {
@@ -300,8 +302,9 @@ open class KotlinPayloadGenerator : MultiFileDirectGeneratorBase<MetaObject>() {
         val via = origin.via ?: return fallbackType()
         val (parentName, relName) = KotlinGenUtil.splitDottedRef(via) ?: return fallbackType()
         val parent = KotlinGenUtil.resolveObjectByShortOrFqn(loader, parentName) ?: return fallbackType()
-        val relationship = parent.children
-            .filterIsInstance<MetaRelationship>()
+        // ADR-0039: relationships are inheritable — RESOLVE via parent.relationships;
+        // parent.children (own-only) would miss a relationship inherited via extends.
+        val relationship = parent.relationships
             .firstOrNull { it.name == relName || it.name.substringAfterLast("::") == relName }
             ?: return fallbackType()
         val targetRef = relationship.objectRef ?: return fallbackType()

server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/KotlinRelationsGenerator.kt

@@ -70,8 +70,9 @@ open class KotlinRelationsGenerator : MultiFileDirectGeneratorBase<MetaObject>()
             // ADR-0039: resolving (an inherited source.rdb still means the entity is persisted).
             if (!KotlinGenUtil.hasRdbSource(entity)) continue
 
-            val manyRels = entity.children
-                .filterIsInstance<MetaRelationship>()
+            // ADR-0039: relationships are inheritable — RESOLVE via entity.relationships;
+            // entity.children (own-only) would miss an inherited relationship.
+            val manyRels = entity.relationships
                 .filter {
                     it.subType == CompositionRelationship.SUBTYPE_COMPOSITION &&
                         it.cardinality == MetaRelationship.CARDINALITY_MANY
@@ -233,7 +234,9 @@ open class KotlinRelationsGenerator : MultiFileDirectGeneratorBase<MetaObject>()
      */
     protected open fun reverseFksFor(entity: MetaObject): List<ReverseFk> {
         val out = mutableListOf<ReverseFk>()
-        for (child in entity.children) {
+        // ADR-0039: identity.reference children are inheritable — RESOLVE via
+        // getIdentities(true); entity.children (own-only) would miss inherited FK refs.
+        for (child in entity.getIdentities(true)) {
             if (child !is ReferenceIdentity) continue
             val fields = child.fields
             if (fields.size != 1) continue // single-column FKs only
@@ -258,7 +261,9 @@ open class KotlinRelationsGenerator : MultiFileDirectGeneratorBase<MetaObject>()
      * metadata.
      */
     protected open fun primaryKeyKotlinType(entity: MetaObject): TypeName {
-        val primary = entity.children
+        // ADR-0039: identities are inheritable — RESOLVE via getIdentities(true);
+        // entity.children (own-only) would miss an inherited primary identity.
+        val primary = entity.getIdentities(true)
             .filterIsInstance<MetaIdentity>()
             .firstOrNull { it.isPrimary } ?: return LONG
         val pkFieldName = primary.fields.firstOrNull() ?: return LONG

server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/KotlinRenderHelperGenerator.kt

@@ -79,8 +79,8 @@ open class KotlinRenderHelperGenerator : MultiFileDirectGeneratorBase<MetaObject
         val provider = FilesystemProvider(Paths.get(templateRoot))
 
         // Stable name order — matches the other ports' deterministic emission.
-        val outputs = loader.root.children
-            .filterIsInstance<OutputTemplate>()
+        // ADR-0039: root-scan discipline — resolving children accessor.
+        val outputs = loader.root.getChildren(OutputTemplate::class.java, true)
             .sortedBy { it.name }
 
         for (tmpl in outputs) {
@@ -254,6 +254,9 @@ open class KotlinRenderHelperGenerator : MultiFileDirectGeneratorBase<MetaObject
      * `object.value` is found.
      */
     private fun resolveNestedObjectRef(loader: MetaDataLoader, field: ObjectField): MetaObject? {
+        // ADR-0039: @objectRef is an inheritable effective field property — RESOLVE
+        // (includeParentData=true) so a field.object inheriting @objectRef via extends
+        // still resolves its target VO.
         if (!field.hasMetaAttr(MetaObject.ATTR_OBJECT_REF, true)) return null
         val ref = field.getMetaAttr(MetaObject.ATTR_OBJECT_REF, true).valueAsString
         if (ref.isNullOrEmpty()) return null
@@ -294,19 +297,23 @@ open class KotlinRenderHelperGenerator : MultiFileDirectGeneratorBase<MetaObject
     // Local helpers
     // -------------------------------------------------------------------------
 
-    /** Resolve `@kind` (own attr), defaulting to `document`. */
+    // ADR-0039: template.* attrs RESOLVE through extends (includeParentData=true, the
+    // default) — a template is a registered type that can be an `extends` target, so its
+    // refs inherit. Matches the TS reference + C#.
+
+    /** Resolve `@kind` (RESOLVING attr — ADR-0039), defaulting to `document`. */
     private fun kindOf(template: MetaTemplate): String {
-        if (template is OutputTemplate && template.hasMetaAttr(TemplateConstants.ATTR_KIND, false)) {
-            val v = template.getMetaAttr(TemplateConstants.ATTR_KIND, false).valueAsString
+        if (template is OutputTemplate && template.hasMetaAttr(TemplateConstants.ATTR_KIND)) {
+            val v = template.getMetaAttr(TemplateConstants.ATTR_KIND).valueAsString
             if (!v.isNullOrEmpty()) return v
         }
         return TemplateConstants.KIND_DEFAULT
     }
 
-    /** Read an own attr value, or null if absent. */
+    /** Read a template attr value (RESOLVING — ADR-0039), or null if absent. */
     private fun attr(template: MetaTemplate, attr: String): String? =
-        if (template.hasMetaAttr(attr, false))
-            template.getMetaAttr(attr, false).valueAsString
+        if (template.hasMetaAttr(attr))
+            template.getMetaAttr(attr).valueAsString
         else null
 
     /** Resolve a `@payloadRef` to its `object.value` (rejects entities — payloads must be VOs). */