Feature/fix issues

[Picazsoo]

PR checklist

• Read the contribution guidelines.
• Run the following to build the project and update samples:

  ./mvnw clean package || exit
  ./bin/generate-samples.sh ./bin/configs/*.yaml || exit
  ./bin/utils/export_docs_generators.sh || exit
  

  (For Windows users, please run the script in WSL)
  Commit all changed files.
  This is important, as CI jobs will verify all generator outputs of your HEAD commit as it would merge with master.
  These must match the expectations made by your contribution.
  You may regenerate an individual generator by passing the relevant config(s) as an argument to the script, for example ./bin/generate-samples.sh bin/configs/java*.
  IMPORTANT: Do NOT purge/delete any folders/files (e.g. tests) when regenerating the samples as manually written tests may be removed.
• If your PR is targeting a particular programming language, @mention the technical committee members, so they are more likely to review the pull request.

---

Summary by cubic

Fixes compile-breaking Kotlin output for allOf/discriminator inheritance hierarchies in the kotlin-spring generator, and adds an opt-in fixPolymorphicInheritance flag that promotes non-discriminated allOf parents to interface so subtypes can legally extend them. Also fixes three pre-existing, always-on compile regressions found in real-world specs.

Bug Fixes

• Subtypes re-declaring a property inherited through an allOf-composed parent now get the required override modifier.
• Discriminator properties narrowed to a per-subtype enum are normalized back to the parent's String type for allOf children.
• Free-form/map-typed schemas with a discriminator now render as open class instead of interface : HashMap<...>(), which Kotlin forbids.
• Self-mapped discriminator roots get a synthetic concrete <Schema>Impl leaf so Jackson can construct them.
• anyOf single-refs to a discriminated schema no longer emit override without a real Kotlin parent.
• oneOf/discriminator grouping interfaces with no own properties now synthesize a computed override for their abstract discriminator property.
• Inherited enum properties are typed via the model that actually declares the nested enum, not the composing child.
• fixPolymorphicInheritance interfaces used in deduction-based oneOf unions now redirect @JsonSubTypes to the synthetic Impl leaf.

New Features

• fixPolymorphicInheritance (default false) renders a non-discriminated allOf parent as an interface instead of a final data class, so affected schemas can no longer be instantiated directly.
• Interfaces used as discriminator mapping values get a synthetic <Schema>Impl data class in its own file, named collision-free (Impl, Impl2, ...), suppressible via schemaMapping.

^{Written for commit 5c8412a. Summary will update on new commits.}

[cubic-dev-ai]

11 issues found across 23 files

Prompt for AI agents (unresolved issues)

Check if these issues are valid — if so, understand the root cause of each and fix them. If appropriate, use sub-agents to investigate and fix each issue separately.


<file name="modules/openapi-generator/src/main/resources/kotlin-spring/oneof_interface.mustache">

<violation number="1" location="modules/openapi-generator/src/main/resources/kotlin-spring/oneof_interface.mustache:11">
P1: When a deduction `oneOf` member’s synthetic implementation is supplied through `schemaMapping`, this emits the bare `FooImpl::class` even though `FooImpl.kt` is suppressed. Resolve the synthetic name through the mapping and add the external type import before rendering, or generated Kotlin cannot compile.</violation>
</file>

<file name="modules/openapi-generator/src/main/resources/kotlin-spring/implDataClass.mustache">

<violation number="1" location="modules/openapi-generator/src/main/resources/kotlin-spring/implDataClass.mustache:10">
P1: When a synthetic discriminator target has no properties, this renders `data class FooImpl()`, which Kotlin rejects because a data class needs a primary-constructor property. Emit `data` only when `hasVars` is true so empty synthetic implementations are regular classes.</violation>

<violation number="2" location="modules/openapi-generator/src/main/resources/kotlin-spring/implDataClass.mustache:16">
P2: This template opens and closes two nested Mustache sections over the same list `vendorExtensions.x-kotlin-poly-synthetic-discriminator-overrides` (the outer one wrapping the `{`, the override block, and the closing `}`; the inner one wrapping just the override declaration). Mustache iterates a list once per element for each section, so when the list contains more than one override, every override is emitted once per outer iteration and the whole `{ … }` body is repeated once per element. A model that implements two `oneOf`+`discriminator` interfaces with distinct discriminator properties produces a broken file with duplicated `override val` declarations and a stray ` {` (compile error). `KotlinSpringServerCodegen.java` builds this extension as an `ArrayList` and adds one entry per distinct discriminator base name, so multi-element lists are reachable. `dataClass.mustache` renders the same extension with a single section and is not affected — drop the redundant inner section here.</violation>
</file>

<file name="modules/openapi-generator/src/main/resources/kotlin-spring/implClassOptVar.mustache">

<violation number="1" location="modules/openapi-generator/src/main/resources/kotlin-spring/implClassOptVar.mustache:9">
P1: When a synthetic implementation inherits an optional enum property from an allOf parent, this template emits an invalid enum qualifier. Use `x-kotlin-enum-owner` with `parent` as the fallback, matching `dataClassOptVar.mustache`, so the generated implementation references the model that actually declares the nested enum.</violation>

<violation number="2" location="modules/openapi-generator/src/main/resources/kotlin-spring/implClassOptVar.mustache:10">
P1: When a user enables `openApiNullable`, `postProcessModelsEnum` marks every optional+nullable var with `x-is-jackson-optional-nullable`, and this Impl template then declares `override val x: JsonNullable<T>`. The parent interface, however, declares the same property (from `interfaceOptVar.mustache`, which never wraps in JsonNullable) as a plain `val x: T?`. Overriding a `T?` member with a `JsonNullable<T>` member is a Kotlin override type mismatch and fails to compile. Because `buildSyntheticImplModelsMap` shares the same `CodegenProperty` instances with the interface model, the flag is present on the synthetic leaf whenever it is present on the interface. Match the interface declaration and drop the JsonNullable branch.</violation>
</file>

<file name="modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/AbstractKotlinCodegen.java">

<violation number="1" location="modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/AbstractKotlinCodegen.java:1130">
P2: When an `allOf` parent is a `$ref` alias (or an alias points through more than one component), this traversal stops at the alias and misses the parent's properties. Follow resolved references recursively before collecting properties, otherwise valid child redefinitions still generate Kotlin without the required `override` modifier.</violation>
</file>

<file name="docs/generators/kotlin-spring.md">

<violation number="1" location="docs/generators/kotlin-spring.md:36">
P3: The description says a promoted schema is generated as an `interface` and 'can no longer be instantiated directly', but that is not true for free-form/map-typed parents: KotlinSpringServerCodegen sets x-kotlin-poly-open-map for wouldBeInterface && isMap models, and dataClass.mustache renders them as an `open class` (still directly instantiable). Users with a map-typed allOf parent will get an instantiable open class, not the non-instantiable interface the docs promise. Consider adding a short caveat (e.g., 'free-form/map-typed schemas are emitted as an open class instead').</violation>
</file>

<file name="modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/KotlinSpringServerCodegen.java">

<violation number="1" location="modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/KotlinSpringServerCodegen.java:1600">
P2: The identity-based `ownVars` guard can't tell an own-declared enum property from an inherited one, so the retarget can repoint a model's own enum property at the parent's enum. `CodegenModel.removeAllDuplicatedProperty()` (line 1173) clones every entry via `removeDuplicatedProperty` (`newList.add(cp.clone())`, line 1189), so `m.vars`, `m.requiredVars`, `m.optionalVars` and `m.allVars` hold independent clone objects for the same logical property — the same PR's comment in `AbstractKotlinCodegen.fromModel` states this explicitly. `Collections.newSetFromMap(new IdentityHashMap<>())` therefore only matches the exact instances currently in `cm.vars`; the clones of an own-declared enum property sitting in `requiredVars`/`optionalVars`/`allVars` still pass `.filter(p -> p.isEnum && !ownVars.contains(p))`, and `retargetInheritedEnumPropertyType` (which matches only on `baseName` + `isEnum`, not `isInherited`) then rewrites `dataType`/`datatypeWithEnum` and sets `x-kotlin-enum-owner` to the owner's classname for them. This contradicts the method's own contract ("A no-op if the child redeclares its own enum property under the same name") and, when the child's nested enum differs from the parent's, silently binds the generated property to the wrong enum type; when they are structurally identical the child's nested enum becomes dead code. Use baseName-based exclusion (and/or the documented `isInherited` check) instead of reference identity.</violation>

<violation number="2" location="modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/KotlinSpringServerCodegen.java:1604">
P1: For a multi-level allOf chain, this lookup misses enums inherited by an intermediate composed parent because it examines only `owner.vars`. Traverse the parent/allOf ancestry to find the model that actually declares the enum before retargeting the leaf.</violation>

<violation number="3" location="modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/KotlinSpringServerCodegen.java:2136">
P1: When a synthetic leaf implements an interface inheriting an enum from an allOf ancestor, its enum property points at the immediate interface instead of `x-kotlin-enum-owner`. Make synthetic enum properties use the same declaring-owner qualifier as the interface.</violation>
</file>

<file name="modules/openapi-generator/src/test/java/org/openapitools/codegen/kotlin/spring/KotlinSpringServerCodegenTest.java">

<violation number="1" location="modules/openapi-generator/src/test/java/org/openapitools/codegen/kotlin/spring/KotlinSpringServerCodegenTest.java:7900">
P3: After the schemaMapping suppresses ServiceQualificationImpl.kt, the test only asserts that ServiceQualification.kt still contains the unqualified reference `ServiceQualificationImpl::class` — it never checks how that reference is resolved. DefaultGenerator uses schemaMapping values only as a suppression key (containsKey at DefaultGenerator.java:471/553), and the test-blessed redirect must compile against `com.example.custom.ServiceQualificationImpl`, so ServiceQualification.kt needs `import com.example.custom.ServiceQualificationImpl` (or a fully-qualified @JsonSubTypes value). If the import-emission path uses `modelPackage + name` (org.openapitools.model.ServiceQualificationImpl), the generated file no longer compiles and this test would pass on broken output. Assert the mapped import (e.g. `import com.example.custom.ServiceQualificationImpl`) in ServiceQualification.kt to lock in the compile-usable redirect.</violation>
</file>

<sub>Reply with feedback, questions, or to request a fix.

Re-trigger cubic</sub>

[cubic-dev-ai]

P1: When a deduction oneOf member’s synthetic implementation is supplied through schemaMapping, this emits the bare FooImpl::class even though FooImpl.kt is suppressed. Resolve the synthetic name through the mapping and add the external type import before rendering, or generated Kotlin cannot compile.

Prompt for AI agents

Check if this issue is valid — if so, understand the root cause and fix it. At modules/openapi-generator/src/main/resources/kotlin-spring/oneof_interface.mustache, line 11:

<comment>When a deduction `oneOf` member’s synthetic implementation is supplied through `schemaMapping`, this emits the bare `FooImpl::class` even though `FooImpl.kt` is suppressed. Resolve the synthetic name through the mapping and add the external type import before rendering, or generated Kotlin cannot compile.</comment>

<file context>
@@ -8,7 +8,7 @@
 @JsonSubTypes(
   {{#interfaceModels}}
-    JsonSubTypes.Type(value = {{classname}}::class){{^-last}},{{/-last}}
+    JsonSubTypes.Type(value = {{#vendorExtensions.x-kotlin-poly-impl-needed}}{{vendorExtensions.x-kotlin-poly-impl-name}}{{/vendorExtensions.x-kotlin-poly-impl-needed}}{{^vendorExtensions.x-kotlin-poly-impl-needed}}{{classname}}{{/vendorExtensions.x-kotlin-poly-impl-needed}}::class){{^-last}},{{/-last}}
   {{/interfaceModels}}
 )
</file context>

[cubic-dev-ai]

P1: When a synthetic discriminator target has no properties, this renders data class FooImpl(), which Kotlin rejects because a data class needs a primary-constructor property. Emit data only when hasVars is true so empty synthetic implementations are regular classes.

Prompt for AI agents

Check if this issue is valid — if so, understand the root cause and fix it. At modules/openapi-generator/src/main/resources/kotlin-spring/implDataClass.mustache, line 10:

<comment>When a synthetic discriminator target has no properties, this renders `data class FooImpl()`, which Kotlin rejects because a data class needs a primary-constructor property. Emit `data` only when `hasVars` is true so empty synthetic implementations are regular classes.</comment>

<file context>
@@ -0,0 +1,22 @@
+ * (rather than "{{parent}}Impl") if that default name collides with another schema
+ * already declared in the document.
+ */
+data class {{classname}}(
+{{#requiredVars}}
+{{>implClassReqVar}}{{^-last}},
</file context>

Suggested change

	data class {{classname}}(
	{{#hasVars}}data {{/hasVars}}class {{classname}}(

[cubic-dev-ai]

P1: When a synthetic implementation inherits an optional enum property from an allOf parent, this template emits an invalid enum qualifier. Use x-kotlin-enum-owner with parent as the fallback, matching dataClassOptVar.mustache, so the generated implementation references the model that actually declares the nested enum.

Prompt for AI agents

Check if this issue is valid — if so, understand the root cause and fix it. At modules/openapi-generator/src/main/resources/kotlin-spring/implClassOptVar.mustache, line 9:

<comment>When a synthetic implementation inherits an optional enum property from an allOf parent, this template emits an invalid enum qualifier. Use `x-kotlin-enum-owner` with `parent` as the fallback, matching `dataClassOptVar.mustache`, so the generated implementation references the model that actually declares the nested enum.</comment>

<file context>
@@ -0,0 +1,10 @@
+    @field:JsonInclude(JsonInclude.Include.{{{vendorExtensions.x-jackson-json-include-policy}}}){{/vendorExtensions.x-jackson-json-include-policy}}{{#vendorExtensions.x-has-json-setter-nulls-skip}}
+    @field:JsonSetter(nulls = Nulls.SKIP){{/vendorExtensions.x-has-json-setter-nulls-skip}}{{#vendorExtensions.x-has-json-setter-nulls-fail}}
+    @field:JsonSetter(nulls = Nulls.FAIL){{/vendorExtensions.x-has-json-setter-nulls-fail}}
+    @param:JsonProperty("{{{baseName}}}")
+    @get:JsonProperty("{{{baseName}}}") override {{>modelMutable}} {{{name}}}: {{#vendorExtensions.x-is-jackson-optional-nullable}}JsonNullable<{{#isEnum}}{{#isArray}}{{baseType}}<{{/isArray}}{{parent}}.{{{nameInPascalCase}}}{{#isArray}}>{{/isArray}}{{/isEnum}}{{^isEnum}}{{{dataType}}}{{/isEnum}}>{{/vendorExtensions.x-is-jackson-optional-nullable}}{{^vendorExtensions.x-is-jackson-optional-nullable}}{{#isEnum}}{{#isArray}}{{baseType}}<{{/isArray}}{{parent}}.{{{nameInPascalCase}}}{{#isArray}}>{{/isArray}}{{/isEnum}}{{^isEnum}}{{{dataType}}}{{/isEnum}}?{{/vendorExtensions.x-is-jackson-optional-nullable}} = {{#vendorExtensions.x-is-jackson-optional-nullable}}JsonNullable.undefined(){{/vendorExtensions.x-is-jackson-optional-nullable}}{{^vendorExtensions.x-is-jackson-optional-nullable}}{{^defaultValue}}null{{/defaultValue}}{{#defaultValue}}{{^isNumber}}{{{defaultValue}}}{{/isNumber}}{{#isNumber}}{{{dataType}}}("{{{defaultValue}}}"){{/isNumber}}{{/defaultValue}}{{/vendorExtensions.x-is-jackson-optional-nullable}}
\ No newline at end of file
</file context>

Suggested change

	@param:JsonProperty("{{{baseName}}}")
	@param:JsonProperty("{{{baseName}}}")
	@get:JsonProperty("{{{baseName}}}") override {{>modelMutable}} {{{name}}}: {{#vendorExtensions.x-is-jackson-optional-nullable}}JsonNullable<{{#isEnum}}{{#isArray}}{{baseType}}<{{/isArray}}{{#vendorExtensions.x-kotlin-enum-owner}}{{vendorExtensions.x-kotlin-enum-owner}}{{/vendorExtensions.x-kotlin-enum-owner}}{{^vendorExtensions.x-kotlin-enum-owner}}{{parent}}{{/vendorExtensions.x-kotlin-enum-owner}}.{{{nameInPascalCase}}}{{#isArray}}>{{/isArray}}{{/isEnum}}{{^isEnum}}{{{dataType}}}{{/isEnum}}>{{/vendorExtensions.x-is-jackson-optional-nullable}}{{^vendorExtensions.x-is-jackson-optional-nullable}}{{#isEnum}}{{#isArray}}{{baseType}}<{{/isArray}}{{#vendorExtensions.x-kotlin-enum-owner}}{{vendorExtensions.x-kotlin-enum-owner}}{{/vendorExtensions.x-kotlin-enum-owner}}{{^vendorExtensions.x-kotlin-enum-owner}}{{parent}}{{/vendorExtensions.x-kotlin-enum-owner}}.{{{nameInPascalCase}}}{{#isArray}}>{{/isArray}}{{/isEnum}}{{^isEnum}}{{{dataType}}}{{/isEnum}}?{{/vendorExtensions.x-is-jackson-optional-nullable}} = {{#vendorExtensions.x-is-jackson-optional-nullable}}JsonNullable.undefined(){{/vendorExtensions.x-is-jackson-optional-nullable}}{{^vendorExtensions.x-is-jackson-optional-nullable}}{{^defaultValue}}null{{/defaultValue}}{{#defaultValue}}{{^isNumber}}{{{defaultValue}}}{{/isNumber}}{{#isNumber}}{{{dataType}}}("{{{defaultValue}}}"){{/isNumber}}{{/defaultValue}}{{/vendorExtensions.x-is-jackson-optional-nullable}}

[cubic-dev-ai]

P1: When a synthetic leaf implements an interface inheriting an enum from an allOf ancestor, its enum property points at the immediate interface instead of x-kotlin-enum-owner. Make synthetic enum properties use the same declaring-owner qualifier as the interface.

Prompt for AI agents

Check if this issue is valid — if so, understand the root cause and fix it. At modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/KotlinSpringServerCodegen.java, line 2136:

<comment>When a synthetic leaf implements an interface inheriting an enum from an allOf ancestor, its enum property points at the immediate interface instead of `x-kotlin-enum-owner`. Make synthetic enum properties use the same declaring-owner qualifier as the interface.</comment>

<file context>
@@ -1700,6 +2106,88 @@ public ModelsMap postProcessModelsEnum(ModelsMap objs) {
+        implModel.classname = implName;
+        implModel.classFilename = implName;
+        implModel.parent = interfaceModel.classname;
+        implModel.requiredVars = interfaceModel.requiredVars;
+        implModel.optionalVars = interfaceModel.optionalVars;
+        implModel.vars = interfaceModel.vars;
</file context>

[cubic-dev-ai]

P1: For a multi-level allOf chain, this lookup misses enums inherited by an intermediate composed parent because it examines only owner.vars. Traverse the parent/allOf ancestry to find the model that actually declares the enum before retargeting the leaf.

Prompt for AI agents

Check if this issue is valid — if so, understand the root cause and fix it. At modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/KotlinSpringServerCodegen.java, line 1604:

<comment>For a multi-level allOf chain, this lookup misses enums inherited by an intermediate composed parent because it examines only `owner.vars`. Traverse the parent/allOf ancestry to find the model that actually declares the enum before retargeting the leaf.</comment>

<file context>
@@ -1507,6 +1526,282 @@ public Map<String, ModelsMap> postProcessAllModels(Map<String, ModelsMap> objs)
+                    .forEach(p -> {
+                        for (String ownerName : candidateOwners) {
+                            CodegenModel owner = allModelsMap.get(ownerName);
+                            if (owner == null || owner.vars == null) {
+                                continue;
+                            }
</file context>

[cubic-dev-ai]

P2: When an allOf parent is a $ref alias (or an alias points through more than one component), this traversal stops at the alias and misses the parent's properties. Follow resolved references recursively before collecting properties, otherwise valid child redefinitions still generate Kotlin without the required override modifier.

Prompt for AI agents

Check if this issue is valid — if so, understand the root cause and fix it. At modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/AbstractKotlinCodegen.java, line 1130:

<comment>When an `allOf` parent is a `$ref` alias (or an alias points through more than one component), this traversal stops at the alias and misses the parent's properties. Follow resolved references recursively before collecting properties, otherwise valid child redefinitions still generate Kotlin without the required `override` modifier.</comment>

<file context>
@@ -1090,6 +1111,38 @@ public CodegenModel fromModel(String name, Schema schema) {
+     */
+    private Set<String> collectAllOfPropertyNames(Schema<?> schema, Set<Schema<?>> visited) {
+        Set<String> propertyNames = new HashSet<>();
+        if (schema == null || !visited.add(schema)) {
+            return propertyNames;
+        }
</file context>

Suggested change

	if (schema == null || !visited.add(schema)) {
	return propertyNames;
	}
	if (schema == null) {
	return propertyNames;
	}
	if (!visited.add(schema)) {
	return propertyNames;
	}
	Schema<?> resolvedSchema = ModelUtils.getReferencedSchema(this.openAPI, schema);
	if (resolvedSchema != schema) {
	propertyNames.addAll(collectAllOfPropertyNames(resolvedSchema, visited));
	return propertyNames;
	}

[cubic-dev-ai]

P2: This template opens and closes two nested Mustache sections over the same list vendorExtensions.x-kotlin-poly-synthetic-discriminator-overrides (the outer one wrapping the {, the override block, and the closing }; the inner one wrapping just the override declaration). Mustache iterates a list once per element for each section, so when the list contains more than one override, every override is emitted once per outer iteration and the whole { … } body is repeated once per element. A model that implements two oneOf+discriminator interfaces with distinct discriminator properties produces a broken file with duplicated override val declarations and a stray { (compile error). KotlinSpringServerCodegen.java builds this extension as an ArrayList and adds one entry per distinct discriminator base name, so multi-element lists are reachable. dataClass.mustache renders the same extension with a single section and is not affected — drop the redundant inner section here.

Prompt for AI agents

Check if this issue is valid — if so, understand the root cause and fix it. At modules/openapi-generator/src/main/resources/kotlin-spring/implDataClass.mustache, line 16:

<comment>This template opens and closes two nested Mustache sections over the same list `vendorExtensions.x-kotlin-poly-synthetic-discriminator-overrides` (the outer one wrapping the `{`, the override block, and the closing `}`; the inner one wrapping just the override declaration). Mustache iterates a list once per element for each section, so when the list contains more than one override, every override is emitted once per outer iteration and the whole `{ … }` body is repeated once per element. A model that implements two `oneOf`+`discriminator` interfaces with distinct discriminator properties produces a broken file with duplicated `override val` declarations and a stray ` {` (compile error). `KotlinSpringServerCodegen.java` builds this extension as an `ArrayList` and adds one entry per distinct discriminator base name, so multi-element lists are reachable. `dataClass.mustache` renders the same extension with a single section and is not affected — drop the redundant inner section here.</comment>

<file context>
@@ -0,0 +1,22 @@
+{{/-last}}{{/requiredVars}}{{#hasRequired}}{{#hasOptional}},
+{{/hasOptional}}{{/hasRequired}}{{#optionalVars}}{{>implClassOptVar}}{{^-last}},
+{{/-last}}{{/optionalVars}}
+) : {{parent}}{{#vendorExtensions.x-kotlin-poly-synthetic-discriminator-overrides}} {
+{{#vendorExtensions.x-kotlin-poly-synthetic-discriminator-overrides}}
+    override val {{name}}: {{{type}}}
</file context>

Suggested change

	) : {{parent}}{{#vendorExtensions.x-kotlin-poly-synthetic-discriminator-overrides}} {
	{{#vendorExtensions.x-kotlin-poly-synthetic-discriminator-overrides}}
	override val {{name}}: {{{type}}}
	get() = {{{value}}}
	{{/vendorExtensions.x-kotlin-poly-synthetic-discriminator-overrides}}
	}
	) : {{parent}}{{#vendorExtensions.x-kotlin-poly-synthetic-discriminator-overrides}} {
	override val {{name}}: {{{type}}}
	get() = {{{value}}}
	}
	{{/vendorExtensions.x-kotlin-poly-synthetic-discriminator-overrides}}

[cubic-dev-ai]

P2: The identity-based ownVars guard can't tell an own-declared enum property from an inherited one, so the retarget can repoint a model's own enum property at the parent's enum. CodegenModel.removeAllDuplicatedProperty() (line 1173) clones every entry via removeDuplicatedProperty (newList.add(cp.clone()), line 1189), so m.vars, m.requiredVars, m.optionalVars and m.allVars hold independent clone objects for the same logical property — the same PR's comment in AbstractKotlinCodegen.fromModel states this explicitly. Collections.newSetFromMap(new IdentityHashMap<>()) therefore only matches the exact instances currently in cm.vars; the clones of an own-declared enum property sitting in requiredVars/optionalVars/allVars still pass .filter(p -> p.isEnum && !ownVars.contains(p)), and retargetInheritedEnumPropertyType (which matches only on baseName + isEnum, not isInherited) then rewrites dataType/datatypeWithEnum and sets x-kotlin-enum-owner to the owner's classname for them. This contradicts the method's own contract ("A no-op if the child redeclares its own enum property under the same name") and, when the child's nested enum differs from the parent's, silently binds the generated property to the wrong enum type; when they are structurally identical the child's nested enum becomes dead code. Use baseName-based exclusion (and/or the documented isInherited check) instead of reference identity.

Prompt for AI agents

Check if this issue is valid — if so, understand the root cause and fix it. At modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/KotlinSpringServerCodegen.java, line 1600:

<comment>The identity-based `ownVars` guard can't tell an own-declared enum property from an inherited one, so the retarget can repoint a model's own enum property at the parent's enum. `CodegenModel.removeAllDuplicatedProperty()` (line 1173) clones every entry via `removeDuplicatedProperty` (`newList.add(cp.clone())`, line 1189), so `m.vars`, `m.requiredVars`, `m.optionalVars` and `m.allVars` hold independent clone objects for the same logical property — the same PR's comment in `AbstractKotlinCodegen.fromModel` states this explicitly. `Collections.newSetFromMap(new IdentityHashMap<>())` therefore only matches the exact instances currently in `cm.vars`; the clones of an own-declared enum property sitting in `requiredVars`/`optionalVars`/`allVars` still pass `.filter(p -> p.isEnum && !ownVars.contains(p))`, and `retargetInheritedEnumPropertyType` (which matches only on `baseName` + `isEnum`, not `isInherited`) then rewrites `dataType`/`datatypeWithEnum` and sets `x-kotlin-enum-owner` to the owner's classname for them. This contradicts the method's own contract ("A no-op if the child redeclares its own enum property under the same name") and, when the child's nested enum differs from the parent's, silently binds the generated property to the wrong enum type; when they are structurally identical the child's nested enum becomes dead code. Use baseName-based exclusion (and/or the documented `isInherited` check) instead of reference identity.</comment>

<file context>
@@ -1507,6 +1526,282 @@ public Map<String, ModelsMap> postProcessAllModels(Map<String, ModelsMap> objs)
+                    .filter(Objects::nonNull)
+                    .flatMap(List::stream)
+                    .distinct()
+                    .filter(p -> p.isEnum && !ownVars.contains(p))
+                    .forEach(p -> {
+                        for (String ownerName : candidateOwners) {
</file context>

[cubic-dev-ai]

P3: The description says a promoted schema is generated as an interface and 'can no longer be instantiated directly', but that is not true for free-form/map-typed parents: KotlinSpringServerCodegen sets x-kotlin-poly-open-map for wouldBeInterface && isMap models, and dataClass.mustache renders them as an open class (still directly instantiable). Users with a map-typed allOf parent will get an instantiable open class, not the non-instantiable interface the docs promise. Consider adding a short caveat (e.g., 'free-form/map-typed schemas are emitted as an open class instead').

Prompt for AI agents

Check if this issue is valid — if so, understand the root cause and fix it. At docs/generators/kotlin-spring.md, line 36:

<comment>The description says a promoted schema is generated as an `interface` and 'can no longer be instantiated directly', but that is not true for free-form/map-typed parents: KotlinSpringServerCodegen sets x-kotlin-poly-open-map for wouldBeInterface && isMap models, and dataClass.mustache renders them as an `open class` (still directly instantiable). Users with a map-typed allOf parent will get an instantiable open class, not the non-instantiable interface the docs promise. Consider adding a short caveat (e.g., 'free-form/map-typed schemas are emitted as an open class instead').</comment>

<file context>
@@ -33,6 +33,7 @@ These options may be applied as additional-properties (cli) or configOptions (pl
 |documentationProvider|Select the OpenAPI documentation provider.|<dl><dt>**none**</dt><dd>Do not publish an OpenAPI specification.</dd><dt>**source**</dt><dd>Publish the original input OpenAPI specification.</dd><dt>**springdoc**</dt><dd>Generate an OpenAPI 3 specification using SpringDoc.</dd></dl>|springdoc|
 |enumPropertyNaming|Naming convention for enum properties: 'camelCase', 'PascalCase', 'snake_case', 'UPPERCASE', 'original', and 'bestEffortBacktick' (like 'original' but tries to wrap values in backticks before falling back to sanitizing, e.g. `name,asc` stays `name,asc` rather than becoming nameCommaAsc; useful for sort/order enums)| |original|
 |exceptionHandler|generate default global exception handlers (not compatible with reactive. enabling reactive will disable exceptionHandler )| |true|
+|fixPolymorphicInheritance|Fix compile-breaking Kotlin output for `allOf`/`discriminator` inheritance hierarchies where a schema is used as an `allOf` parent by other schemas but has no `discriminator` of its own. When enabled, such a schema is generated as an `interface` (like a genuinely polymorphic root) instead of a `data class`, which Kotlin does not allow extending. This changes the generated type shape for affected schemas (they can no longer be instantiated directly), so it is opt-in. If a schema promoted to `interface` this way (or a genuinely-discriminated root) is itself named as a value in some `discriminator.mapping` (including a root that maps to itself), a synthetic concrete `&lt;Schema&gt;Impl` data class implementing the interface is also generated (in its own file, named after the resolved class) and substituted into the corresponding `@JsonSubTypes` entry, so Jackson can still construct a concrete instance for that discriminator value. Being a genuinely separate model, this synthetic class can be suppressed via the standard `--schema-mappings` mechanism if you want to substitute your own implementation.| |false|
 |generateJsonIncludeAnnotations|Whether to generate policy @JsonInclude annotations on model properties. When true, emits spec-honest annotations (required-field protection and the optional non-nullable policy from optionalNonNullPropertyJsonInclude). When false, none are generated and the global ObjectMapper owns inclusion. When left unset it defaults to false (7.23.0-equivalent output) and logs a warning; set it explicitly to silence the warning. A per-property override set via the `x-jackson-json-include-policy` vendor extension is always honored regardless of this flag.| |false|
 |generateJsonSetterNullsAnnotations|Whether to generate @JsonSetter(nulls = ...) annotations on optional non-nullable model properties. When true, emits @JsonSetter (Nulls.FAIL when openApiNullable is true, otherwise Nulls.SKIP) so an explicit null in the payload is handled explicitly. When false, none are generated and deserialization null-handling defers to the global ObjectMapper. When left unset it defaults to false (7.23.0-equivalent output) and logs a warning; set it explicitly to silence the warning.| |false|
</file context>

[cubic-dev-ai]

P3: After the schemaMapping suppresses ServiceQualificationImpl.kt, the test only asserts that ServiceQualification.kt still contains the unqualified reference ServiceQualificationImpl::class — it never checks how that reference is resolved. DefaultGenerator uses schemaMapping values only as a suppression key (containsKey at DefaultGenerator.java:471/553), and the test-blessed redirect must compile against com.example.custom.ServiceQualificationImpl, so ServiceQualification.kt needs import com.example.custom.ServiceQualificationImpl (or a fully-qualified @JsonSubTypes value). If the import-emission path uses modelPackage + name (org.openapitools.model.ServiceQualificationImpl), the generated file no longer compiles and this test would pass on broken output. Assert the mapped import (e.g. import com.example.custom.ServiceQualificationImpl) in ServiceQualification.kt to lock in the compile-usable redirect.

Prompt for AI agents

Check if this issue is valid — if so, understand the root cause and fix it. At modules/openapi-generator/src/test/java/org/openapitools/codegen/kotlin/spring/KotlinSpringServerCodegenTest.java, line 7900:

<comment>After the schemaMapping suppresses ServiceQualificationImpl.kt, the test only asserts that ServiceQualification.kt still contains the unqualified reference `ServiceQualificationImpl::class` — it never checks how that reference is resolved. DefaultGenerator uses schemaMapping values only as a suppression key (containsKey at DefaultGenerator.java:471/553), and the test-blessed redirect must compile against `com.example.custom.ServiceQualificationImpl`, so ServiceQualification.kt needs `import com.example.custom.ServiceQualificationImpl` (or a fully-qualified @JsonSubTypes value). If the import-emission path uses `modelPackage + name` (org.openapitools.model.ServiceQualificationImpl), the generated file no longer compiles and this test would pass on broken output. Assert the mapped import (e.g. `import com.example.custom.ServiceQualificationImpl`) in ServiceQualification.kt to lock in the compile-usable redirect.</comment>

<file context>
@@ -7800,4 +7800,354 @@ public void extraImportsDedupAgainstGeneratedImports() throws IOException {
+        Path serviceQualification = files.get("ServiceQualification.kt").toPath();
+        assertFileContains(serviceQualification,
+                "interface ServiceQualification",
+                "JsonSubTypes.Type(value = ServiceQualificationImpl::class, name = \"ServiceQualification\")");
+        assertFileNotContains(serviceQualification, "data class ServiceQualificationImpl(");
+
</file context>