revert default-resolution related changes as the behavior is unspecified and therefore dangerous

Author: Picazsoo

modules/openapi-generator/src/main/java/org/openapitools/codegen/OpenAPINormalizer.java

@@ -1932,14 +1932,8 @@ protected void ensureInheritanceForDiscriminatorMapping(Schema parent, Schema ch
                 // already done, so no need to add
                 return;
             }
-            // Prepend at position 0 so the parent ref is the FIRST item in the child's allOf.
-            // resolveDefault() uses last-writer-wins semantics, so anything the child already
-            // expressed in its allOf (including its own defaults) must come after the base in
-            // order to win. Appending at the end would make the parent the last — and therefore
-            // the winning — default, which is wrong: the normalizer is injecting structural
-            // inheritance here, not overriding child-specified defaults.
             Schema refToParent = new Schema<>().$ref(reference);
-            allOf.add(0, refToParent);
+            allOf.add(refToParent);
         } else {
             allOf = new ArrayList<>();
             child.setAllOf(allOf);

modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/SpringPageableScanUtils.java

@@ -535,10 +535,13 @@ public static Map<String, PageableDefaultsData> scanPageableDefaults(
                     if (schema == null) {
                         continue;
                     }
-                    Object defaultValue = ModelUtils.resolveDefault(openAPI, schema);
-                    if (defaultValue == null) {
+                    if (schema.get$ref() != null) {
+                        schema = ModelUtils.getReferencedSchema(openAPI, schema);
+                    }
+                    if (schema == null || schema.getDefault() == null) {
                         continue;
                     }
+                    Object defaultValue = schema.getDefault();
                     switch (param.getName()) {
                         case PAGE:
                             if (defaultValue instanceof Number) {

modules/openapi-generator/src/main/java/org/openapitools/codegen/utils/ModelUtils.java

@@ -1020,78 +1020,6 @@ public static ResolvedMinBound resolveMinimumBound(OpenAPI openAPI, Schema<?> sc
                   .reduce(result, ResolvedMinBound::getLargerMinBound);
     }
 
-    /**
-     * Returns the effective {@code default} for the given schema using
-     * <em>last-writer-wins</em> semantics across the flattened {@code allOf} chain.
-     *
-     * <h3>Resolution algorithm</h3>
-     * <ol>
-     *   <li>Resolve any top-level {@code $ref} to obtain the concrete schema.</li>
-     *   <li>If the schema has a direct {@code default} (i.e. the {@code default:} key at
-     *       the same level as {@code allOf:}), return it immediately — no traversal needed.</li>
-     *   <li>Otherwise walk the {@code allOf} array <strong>top-to-bottom</strong>.  Each
-     *       item is itself fully resolved (recursing into nested {@code allOf} chains), and
-     *       its result — if non-null — overwrites the current candidate (last-writer-wins).</li>
-     * </ol>
-     *
-     * <h3>Example</h3>
-     * <pre>{@code
-     * # Base1: default = "base_1"   → Step 1: candidate = "base_1"
-     * # Base2: default = "base_2"   → Step 2: candidate = "base_2"  (overwrites Step 1)
-     * #
-     * # Intermediate:
-     * #   allOf: [$ref Base1, $ref Base2]
-     * #   → resolves to "base_2"  (Base2 is last, wins over Base1)
-     * #
-     * # Final:
-     * #   allOf:
-     * #     - $ref: Intermediate    → Step 3a: candidate = "base_2"
-     * #     - default: "final"      → Step 3b: candidate = "final"  (overwrites Step 3a)
-     * #   → resolves to "final"
-     * }</pre>
-     *
-     * @param openAPI the OpenAPI document used to resolve {@code $ref}s
-     * @param schema  the schema to inspect
-     * @return the effective default value, or {@code null} if none is defined
-     * @implNote The result depends on the {@code allOf} array ordering <em>as it exists when
-     *     this method is called</em> — i.e., after the OpenAPI normalizer has run.
-     *     Normalizer mutations (e.g. {@code ensureInheritanceForDiscriminatorMapping} prepending
-     *     a parent {@code $ref}) are therefore visible here and are accounted for by design.
-     */
-    public static Object resolveDefault(OpenAPI openAPI, Schema<?> schema) {
-        schema = getReferencedSchema(openAPI, schema);
-        if (schema == null) return null;
-
-        // Direct default short-circuits — no allOf traversal needed.
-        Object directDefault = schema.getDefault();
-        if (directDefault != null) {
-            return directDefault;
-        }
-
-        // Walk allOf top-to-bottom; each non-null result overwrites the previous candidate.
-        if (hasAllOf(schema)) {
-            return getLastNonNullDefault(openAPI, schema);
-        }
-        return null;
-    }
-
-    /**
-     * Walks {@code allOf} items top-to-bottom and returns the <em>last</em> non-null
-     * {@code default} value found (last-writer-wins).  Each item is fully resolved
-     * (including its own nested {@code allOf}) before the candidate is updated, so
-     * arbitrarily deep chains are flattened correctly.
-     */
-    private static Object getLastNonNullDefault(OpenAPI openAPI, Schema<?> schema) {
-        Object last = null;
-        for (Schema<?> item : schema.getAllOf()) {
-            Object resolved = resolveDefault(openAPI, item);
-            if (resolved != null) {
-                last = resolved;
-            }
-        }
-        return last;
-    }
-
     public static boolean hasValidation(Schema sc) {
         return (
                 sc.getMaxItems() != null ||

modules/openapi-generator/src/test/java/org/openapitools/codegen/OpenAPINormalizerTest.java

@@ -1844,62 +1844,4 @@ public void oneOf_issue_23276() {
         assertNotNull(payload.getOneOf());
     }
 
-    @Test
-    public void ensureInheritanceForDiscriminatorMapping_prependsParentRef_childDefaultWins() {
-        // When a child already has allOf items (e.g. a base schema carrying "base_default"),
-        // the normalizer must INSERT the parent $ref at position 0 — not append at the end.
-        // With last-writer-wins semantics in resolveDefault(), appending at the end would make
-        // the parent's default the winner, incorrectly overriding the child's own default.
-        OpenAPI openAPI = TestUtils.createOpenAPI();
-
-        Schema<?> parent = new StringSchema();
-        parent.setDefault("parent_default");
-
-        Schema<?> base = new StringSchema();
-        base.setDefault("base_default");
-        openAPI.getComponents().addSchemas("Base", base);
-
-        // Child: allOf → [Base]; no Parent ref yet — use mutable list (parser always produces ArrayList)
-        Schema<?> child = new Schema<>().allOf(new ArrayList<>(List.of(new Schema<>().$ref("#/components/schemas/Base"))));
-        openAPI.getComponents().addSchemas("Child", child);
-        openAPI.getComponents().addSchemas("Parent", parent);
-
-        OpenAPINormalizer normalizer = new OpenAPINormalizer(openAPI, Map.of());
-        normalizer.ensureInheritanceForDiscriminatorMapping(parent, child, "Parent", new HashSet<>());
-
-        // Parent ref must be prepended at index 0; Base ref stays at index 1
-        assertEquals(((Schema<?>) child.getAllOf().get(0)).get$ref(), "#/components/schemas/Parent");
-        assertEquals(((Schema<?>) child.getAllOf().get(1)).get$ref(), "#/components/schemas/Base");
-
-        // resolveDefault walks top-to-bottom, last non-null wins → "base_default"
-        assertEquals(ModelUtils.resolveDefault(openAPI, child), "base_default");
-    }
-
-    @Test
-    public void ensureInheritanceForDiscriminatorMapping_noExistingAllOf_noProperties_directDefaultPreserved() {
-        // When a child has no allOf and no properties but does have a direct default,
-        // the normalizer creates allOf with just the parent $ref. The child's direct default
-        // must NOT be cleared — resolveDefault() short-circuits on it before inspecting allOf.
-        OpenAPI openAPI = TestUtils.createOpenAPI();
-
-        Schema<?> parent = new StringSchema();
-        parent.setDefault("parent_default");
-        openAPI.getComponents().addSchemas("Parent", parent);
-
-        // Child: direct default only, no allOf, no properties
-        Schema<?> child = new StringSchema();
-        child.setDefault("child_direct_default");
-        openAPI.getComponents().addSchemas("Child", child);
-
-        OpenAPINormalizer normalizer = new OpenAPINormalizer(openAPI, Map.of());
-        normalizer.ensureInheritanceForDiscriminatorMapping(parent, child, "Parent", new HashSet<>());
-
-        // Child now has allOf (parent ref only), and still holds its direct default
-        assertNotNull(child.getAllOf());
-        assertEquals(child.getDefault(), "child_direct_default");
-
-        // resolveDefault short-circuits on the direct default — child wins
-        assertEquals(ModelUtils.resolveDefault(openAPI, child), "child_direct_default");
-    }
-
 }

modules/openapi-generator/src/test/java/org/openapitools/codegen/java/spring/SpringCodegenTest.java

@@ -7366,25 +7366,6 @@ public void generatePageableConstraintValidationResolvesMinimumFromAllOfRef() th
                 .containsWithNameAndAttributes("ValidPageable", Map.of("minSize", "5"));
     }
 
-    @Test
-    public void scanPageableDefaultsResolvesDefaultFromAllOfRef() throws IOException {
-        Map<String, Object> props = new HashMap<>();
-        props.put(SpringCodegen.INTERFACE_ONLY, "true");
-        props.put(SpringCodegen.SKIP_DEFAULT_INTERFACE, "true");
-        props.put(SpringCodegen.USE_TAGS, "true");
-        props.put(SpringCodegen.USE_SPRING_BOOT3, "true");
-
-        Map<String, File> files = generateFromContract(
-                "src/test/resources/3_0/spring/petstore-sort-validation.yaml", SPRING_BOOT, props);
-
-        // findPetsWithDefaultFromAllOfRef: default: 7 is on the referenced schema only
-        JavaFileAssert.assertThat(files.get("PetApi.java"))
-                .assertMethod("findPetsWithDefaultFromAllOfRef")
-                .assertParameter("pageable")
-                .assertParameterAnnotations()
-                .containsWithNameAndAttributes("PageableDefault", Map.of("size", "7"));
-    }
-
     // -------------------------------------------------------------------------
     // @PageableDefault / @SortDefault tests
     // -------------------------------------------------------------------------

modules/openapi-generator/src/test/java/org/openapitools/codegen/kotlin/spring/KotlinSpringServerCodegenTest.java

@@ -4312,20 +4312,6 @@ public void generatePageableConstraintValidationResolvesMinimumFromAllOfRef() th
                 "@ValidPageable(minSize = 5) should be resolved from allOf $ref schema");
     }
 
-    @Test
-    public void scanPageableDefaultsResolvesDefaultFromAllOfRef() throws Exception {
-        Map<String, Object> additionalProperties = new HashMap<>();
-        additionalProperties.put(USE_TAGS, "true");
-        additionalProperties.put(INTERFACE_ONLY, "true");
-        additionalProperties.put(SKIP_DEFAULT_INTERFACE, "true");
-
-        Map<String, File> files = generateFromContract("src/test/resources/3_0/spring/petstore-sort-validation.yaml", additionalProperties);
-
-        File petApi = files.get("PetApi.kt");
-        // findPetsWithDefaultFromAllOfRef: default: 7 is on the referenced schema only
-        assertFileContains(petApi.toPath(), "@PageableDefault(size = 7)");
-    }
-
     // ========== AUTO X-SPRING-PAGINATED TESTS ==========
 
     @Test

modules/openapi-generator/src/test/java/org/openapitools/codegen/utils/ModelUtilsTest.java

@@ -1181,167 +1181,4 @@ public void resolveMinimumBound_nestedAllOf_mostRestrictiveAcrossAllLevels() {
         assertEquals(bound.minBound, BigDecimal.valueOf(20));
     }
 
-    // -------------------------------------------------------------------------
-    // resolveDefault
-    // -------------------------------------------------------------------------
-
-    @Test
-    public void resolveDefault_nullSchema_returnsNull() {
-        assertNull(ModelUtils.resolveDefault(new OpenAPI(), null));
-    }
-
-    @Test
-    public void resolveDefault_noDefaultDefined_returnsNull() {
-        OpenAPI openAPI = TestUtils.createOpenAPI();
-        assertNull(ModelUtils.resolveDefault(openAPI, new IntegerSchema()));
-    }
-
-    @Test
-    public void resolveDefault_inlineDefault_returnsIt() {
-        OpenAPI openAPI = TestUtils.createOpenAPI();
-        Schema<?> schema = new IntegerSchema();
-        schema.setDefault(10);
-        assertEquals(ModelUtils.resolveDefault(openAPI, schema), 10);
-    }
-
-    @Test
-    public void resolveDefault_refToSchemaWithDefault_resolvesRef() {
-        OpenAPI openAPI = TestUtils.createOpenAPI();
-        Schema<?> refTarget = new IntegerSchema();
-        refTarget.setDefault(0);
-        openAPI.getComponents().addSchemas("MyInt", refTarget);
-
-        Schema<?> ref = new Schema<>().$ref("#/components/schemas/MyInt");
-        assertEquals(ModelUtils.resolveDefault(openAPI, ref), 0);
-    }
-
-    @Test
-    public void resolveDefault_allOfItemHasDefault_returnsIt() {
-        OpenAPI openAPI = TestUtils.createOpenAPI();
-        Schema<?> allOfItem = new IntegerSchema();
-        allOfItem.setDefault(20);
-        openAPI.getComponents().addSchemas("Base", allOfItem);
-
-        // Inline schema has no default; allOf item has default=20
-        Schema<?> schema = new Schema<>().allOf(List.of(new Schema<>().$ref("#/components/schemas/Base")));
-        assertEquals(ModelUtils.resolveDefault(openAPI, schema), 20);
-    }
-
-    @Test
-    public void resolveDefault_inlineDefaultTakesPrecedenceOverAllOf() {
-        OpenAPI openAPI = TestUtils.createOpenAPI();
-        Schema<?> allOfItem = new IntegerSchema();
-        allOfItem.setDefault(99);
-        openAPI.getComponents().addSchemas("Base", allOfItem);
-
-        // Inline schema default=5 should win over allOf item default=99
-        Schema<?> schema = new IntegerSchema();
-        schema.setDefault(5);
-        schema.setAllOf(List.of(new Schema<>().$ref("#/components/schemas/Base")));
-        assertEquals(ModelUtils.resolveDefault(openAPI, schema), 5);
-    }
-
-    @Test
-    public void resolveDefault_allOfItemsNoDefault_returnsNull() {
-        OpenAPI openAPI = TestUtils.createOpenAPI();
-        openAPI.getComponents().addSchemas("Base", new IntegerSchema()); // no default
-
-        Schema<?> schema = new Schema<>().allOf(List.of(new Schema<>().$ref("#/components/schemas/Base")));
-        assertNull(ModelUtils.resolveDefault(openAPI, schema));
-    }
-
-    @Test
-    public void resolveDefault_stringDefault_returnsIt() {
-        OpenAPI openAPI = TestUtils.createOpenAPI();
-        Schema<?> schema = new StringSchema();
-        schema.setDefault("hello");
-        assertEquals(ModelUtils.resolveDefault(openAPI, schema), "hello");
-    }
-
-    @Test
-    public void resolveDefault_nestedAllOf_findsDefaultInNestedItem() {
-        OpenAPI openAPI = TestUtils.createOpenAPI();
-        // base has default=99; mid allOf → base; top allOf → mid
-        Schema<?> base = new IntegerSchema();
-        base.setDefault(99);
-        openAPI.getComponents().addSchemas("Base", base);
-
-        Schema<?> mid = new Schema<>().allOf(List.of(new Schema<>().$ref("#/components/schemas/Base")));
-        openAPI.getComponents().addSchemas("Mid", mid);
-
-        Schema<?> top = new Schema<>().allOf(List.of(new Schema<>().$ref("#/components/schemas/Mid")));
-
-        assertEquals(ModelUtils.resolveDefault(openAPI, top), 99);
-    }
-
-    @Test
-    public void resolveDefault_allOf_lastDefaultWins() {
-        // allOf: [Base1(default="base_1"), Base2(default="base_2")]
-        // Base2 is last → wins
-        OpenAPI openAPI = TestUtils.createOpenAPI();
-        Schema<?> base1 = new StringSchema();
-        base1.setDefault("base_1");
-        openAPI.getComponents().addSchemas("Base1", base1);
-
-        Schema<?> base2 = new StringSchema();
-        base2.setDefault("base_2");
-        openAPI.getComponents().addSchemas("Base2", base2);
-
-        Schema<?> schema = new Schema<>().allOf(List.of(
-                new Schema<>().$ref("#/components/schemas/Base1"),
-                new Schema<>().$ref("#/components/schemas/Base2")
-        ));
-        assertEquals(ModelUtils.resolveDefault(openAPI, schema), "base_2");
-    }
-
-    @Test
-    public void resolveDefault_allOf_lastNonNullDefaultWins() {
-        // allOf: [Base1(default="base_1"), NoDefault] — trailing null item does not clear candidate
-        OpenAPI openAPI = TestUtils.createOpenAPI();
-        Schema<?> base1 = new StringSchema();
-        base1.setDefault("base_1");
-        openAPI.getComponents().addSchemas("Base1", base1);
-
-        Schema<?> schema = new Schema<>().allOf(List.of(
-                new Schema<>().$ref("#/components/schemas/Base1"),
-                new StringSchema() // no default
-        ));
-        assertEquals(ModelUtils.resolveDefault(openAPI, schema), "base_1");
-    }
-
-    @Test
-    public void resolveDefault_fullChain_lastWriterWins() {
-        // Mirrors the documented resolution example:
-        //   Base1: default="base_1"
-        //   Base2: default="base_2"
-        //   Intermediate: allOf: [Base1, Base2]  → resolves to "base_2" (Base2 is last)
-        //   Final: allOf: [Intermediate, {default:"final"}]  → resolves to "final" (inline patch is last)
-        OpenAPI openAPI = TestUtils.createOpenAPI();
-
-        Schema<?> base1 = new StringSchema();
-        base1.setDefault("base_1");
-        openAPI.getComponents().addSchemas("Base1", base1);
-
-        Schema<?> base2 = new StringSchema();
-        base2.setDefault("base_2");
-        openAPI.getComponents().addSchemas("Base2", base2);
-
-        Schema<?> intermediate = new Schema<>().allOf(List.of(
-                new Schema<>().$ref("#/components/schemas/Base1"),
-                new Schema<>().$ref("#/components/schemas/Base2")
-        ));
-        openAPI.getComponents().addSchemas("Intermediate", intermediate);
-
-        Schema<?> inlinePatch = new StringSchema();
-        inlinePatch.setDefault("final");
-        Schema<?> finalSchema = new Schema<>().allOf(List.of(
-                new Schema<>().$ref("#/components/schemas/Intermediate"),
-                inlinePatch
-        ));
-
-        // Intermediate alone resolves to "base_2"
-        assertEquals(ModelUtils.resolveDefault(openAPI, new Schema<>().$ref("#/components/schemas/Intermediate")), "base_2");
-        // Full chain resolves to "final"
-        assertEquals(ModelUtils.resolveDefault(openAPI, finalSchema), "final");
-    }
 }

samples/server/petstore/kotlin-springboot-sort-validation/src/main/kotlin/org/openapitools/api/PetApi.kt

@@ -110,7 +110,7 @@ interface PetApi {
         value = [PATH_FIND_PETS_WITH_DEFAULT_FROM_ALL_OF_REF],
         produces = ["application/json"]
     )
-    fun findPetsWithDefaultFromAllOfRef(@PageableDefault(size = 7) pageable: Pageable): ResponseEntity<List<Pet>> {
+    fun findPetsWithDefaultFromAllOfRef(pageable: Pageable): ResponseEntity<List<Pet>> {
         return ResponseEntity(HttpStatus.NOT_IMPLEMENTED)
     }