register BuilderFactory for nested additionalProperties shapes

For a property like
`{ additionalProperties: { type: array, items: { $ref: ... } } }` the
generator emits `Map<String, BuiltList<X>>` in the Dart class but never
registers the `BuiltList<X>` BuilderFactory. The only
factory-registration path that ran for additionalProperties looked at
`items.getAdditionalProperties()`, which is null for this very common
shape (a region map of arrays of $ref). built_value then fails at
runtime with `Bad state: No builder factory for BuiltList<X>` on the
first deserialization that touches the property.

Fix:
- `postProcessModelProperty` now also calls `registerNestedBuilderFactories`,
  which walks the property's `items` tree top-down and registers a
  factory for every container layer. Three small helpers
  (`renderInnerFullType`, `renderDartType`, `renderBuilderFactory`)
  compute the corresponding `FullType(...)` argument list and the
  matching `XBuilder<...>` instantiation for arbitrary nesting:
  `Map<String, List<X>>`, `List<Map<String, X>>`,
  `Map<String, Map<String, X>>`, `List<List<X>>`, `Set<...>`, etc.
- `BuiltValueSerializer` gets a new `composite(fullTypeArgs,
  builderInstantiation)` constructor that carries the pre-rendered
  expressions. The existing `(isArray, uniqueItems, isMap,
  isNullable, dataType)` form is unchanged -- needed because the
  original model can't represent something like
  `BuiltMap<String, BuiltList<X>>` (the `FullType` argument is
  recursive and isn't expressible with a single `dataType` string).
  `equals`/`hashCode` are extended so composite serializers dedup on
  `(fullTypeArgs, builderInstantiation)` and never collide with simple
  ones.
- `serializers.mustache` gets a new branch that emits the composite
  fields verbatim when present; otherwise the existing
  `isArray`/`isMap` dispatch runs unchanged.

Existing simple cases (direct return / parameter container types,
single-level additionalProperties already handled by the prior
branch) keep producing byte-identical output.

A new fixture `built_value_additional_properties_factory.yaml`
exercises the canonical `Map<String, List<$ref>>` shape, and a new
test
`DartDioClientCodegenTest.testNestedAdditionalPropertiesGetBuilderFactories`
asserts both the inner `BuiltList<WatchProviderEntry>` and the outer
`BuiltMap<String, BuiltList<WatchProviderEntry>>` factories appear in
the generated `serializers.dart`.

Full Dart suite: 115 tests, 0 failures, 0 regressions.

Author: a-ledu

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

@@ -660,10 +660,121 @@ public void postProcessModelProperty(CodegenModel model, CodegenProperty propert
                             items.getAdditionalProperties().dataType
                     ));
                 }
+
+                // Recursively register builder factories for every nested
+                // container reachable from this property. Without this step,
+                // shapes like Map<String, List<X>> (e.g. an OpenAPI object
+                // with `additionalProperties: { type: array, items: ...}`)
+                // never get a `BuiltList<X>` factory registered, and
+                // built_value throws "No builder factory for BuiltList<X>"
+                // at deserialization time.
+                registerNestedBuilderFactories(property);
             }
         }
     }
 
+    /**
+     * Walk the CodegenProperty tree and register a built_value
+     * BuilderFactory for every container node, including the top one.
+     * Handles arbitrary nesting like {@code Map<String, List<X>>},
+     * {@code List<Map<String, X>>}, {@code List<List<X>>}, etc.
+     */
+    private void registerNestedBuilderFactories(CodegenProperty prop) {
+        if (prop == null || !prop.isContainer || prop.items == null) {
+            return;
+        }
+        // Recurse first so deeper containers are registered too. Order
+        // doesn't matter for correctness (built_value resolves factories
+        // by FullType lookup), but it keeps the emitted list intuitive.
+        registerNestedBuilderFactories(prop.items);
+
+        BuilderFactoryExpr expr = renderBuilderFactory(prop);
+        if (expr != null) {
+            addBuiltValueSerializer(BuiltValueSerializer.composite(
+                    expr.fullTypeArgs,
+                    expr.builderInstantiation));
+        }
+    }
+
+    /**
+     * Render the FullType argument list and the matching Builder
+     * instantiation for a container CodegenProperty.
+     *
+     * @return null if {@code prop} is not a container we can render.
+     */
+    private BuilderFactoryExpr renderBuilderFactory(CodegenProperty prop) {
+        if (prop == null || !prop.isContainer || prop.items == null) {
+            return null;
+        }
+        String innerFullType = renderInnerFullType(prop.items);
+        String innerDart = renderDartType(prop.items);
+
+        if (prop.isArray) {
+            String collection = prop.getUniqueItems() ? "BuiltSet" : "BuiltList";
+            String builder = prop.getUniqueItems() ? "SetBuilder" : "ListBuilder";
+            return new BuilderFactoryExpr(
+                    collection + ", [FullType(" + innerFullType + ")]",
+                    builder + "<" + innerDart + ">");
+        }
+        if (prop.isMap) {
+            return new BuilderFactoryExpr(
+                    "BuiltMap, [FullType(String), FullType(" + innerFullType + ")]",
+                    "MapBuilder<String, " + innerDart + ">");
+        }
+        return null;
+    }
+
+    /**
+     * What goes inside {@code FullType(...)} for this property:
+     * a leaf type name like {@code "Foo"}, or a nested expression like
+     * {@code "BuiltList, [FullType(Foo)]"}.
+     */
+    private String renderInnerFullType(CodegenProperty prop) {
+        if (prop == null) return "dynamic";
+        if (!prop.isContainer || prop.items == null) {
+            return prop.dataType;
+        }
+        String inner = renderInnerFullType(prop.items);
+        if (prop.isArray) {
+            String collection = prop.getUniqueItems() ? "BuiltSet" : "BuiltList";
+            return collection + ", [FullType(" + inner + ")]";
+        }
+        if (prop.isMap) {
+            return "BuiltMap, [FullType(String), FullType(" + inner + ")]";
+        }
+        return prop.dataType;
+    }
+
+    /**
+     * Render the Dart type literal (e.g. {@code BuiltMap<String, BuiltList<Foo>>})
+     * used inside the {@code () => XBuilder<...>()} lambda.
+     */
+    private String renderDartType(CodegenProperty prop) {
+        if (prop == null) return "dynamic";
+        if (!prop.isContainer || prop.items == null) {
+            return prop.dataType;
+        }
+        String inner = renderDartType(prop.items);
+        if (prop.isArray) {
+            String collection = prop.getUniqueItems() ? "BuiltSet" : "BuiltList";
+            return collection + "<" + inner + ">";
+        }
+        if (prop.isMap) {
+            return "BuiltMap<String, " + inner + ">";
+        }
+        return prop.dataType;
+    }
+
+    private static final class BuilderFactoryExpr {
+        final String fullTypeArgs;
+        final String builderInstantiation;
+
+        BuilderFactoryExpr(String fullTypeArgs, String builderInstantiation) {
+            this.fullTypeArgs = fullTypeArgs;
+            this.builderInstantiation = builderInstantiation;
+        }
+    }
+
     @Override
     public OperationsMap postProcessOperationsWithModels(OperationsMap objs, List<ModelMap> allModels) {
         super.postProcessOperationsWithModels(objs, allModels);
@@ -817,12 +928,45 @@ static class BuiltValueSerializer {
 
         @Getter final String dataType;
 
+        // When non-null, the serializer is rendered verbatim from these
+        // pre-computed strings instead of being dispatched through the
+        // isArray/isMap branches in serializers.mustache. Used for
+        // arbitrarily nested container types where dataType alone can't
+        // express the FullType expression (e.g. Map<String, List<X>>).
+        @Getter final String fullTypeArgs;
+
+        @Getter final String builderInstantiation;
+
         private BuiltValueSerializer(boolean isArray, boolean uniqueItems, boolean isMap, boolean isNullable, String dataType) {
             this.isArray = isArray;
             this.uniqueItems = uniqueItems;
             this.isMap = isMap;
             this.isNullable = isNullable;
             this.dataType = dataType;
+            this.fullTypeArgs = null;
+            this.builderInstantiation = null;
+        }
+
+        private BuiltValueSerializer(String fullTypeArgs, String builderInstantiation) {
+            this.isArray = false;
+            this.uniqueItems = false;
+            this.isMap = false;
+            this.isNullable = false;
+            this.dataType = "";
+            this.fullTypeArgs = fullTypeArgs;
+            this.builderInstantiation = builderInstantiation;
+        }
+
+        /**
+         * Build a serializer for a nested-container BuilderFactory whose
+         * type signature can't be expressed by the simple
+         * (isArray, isMap, dataType) form. {@code fullTypeArgs} is the
+         * argument list for {@code FullType(...)} (without the wrapping
+         * call) and {@code builderInstantiation} is the inside of
+         * {@code () => ...()}.
+         */
+        public static BuiltValueSerializer composite(String fullTypeArgs, String builderInstantiation) {
+            return new BuiltValueSerializer(fullTypeArgs, builderInstantiation);
         }
 
         public boolean isArray() {
@@ -842,11 +986,18 @@ public boolean equals(Object o) {
             if (this == o) return true;
             if (o == null || getClass() != o.getClass()) return false;
             BuiltValueSerializer that = (BuiltValueSerializer) o;
+            if (fullTypeArgs != null || that.fullTypeArgs != null) {
+                return Objects.equals(fullTypeArgs, that.fullTypeArgs)
+                        && Objects.equals(builderInstantiation, that.builderInstantiation);
+            }
             return isArray == that.isArray && uniqueItems == that.uniqueItems && isMap == that.isMap && isNullable == that.isNullable && dataType.equals(that.dataType);
         }
 
         @Override
         public int hashCode() {
+            if (fullTypeArgs != null) {
+                return Objects.hash(fullTypeArgs, builderInstantiation);
+            }
             return Objects.hash(isArray, uniqueItems, isMap, isNullable, dataType);
         }
     }

modules/openapi-generator/src/main/resources/dart/libraries/dio/serialization/built_value/serializers.mustache

@@ -23,6 +23,11 @@ part 'serializers.g.dart';
 ])
 Serializers serializers = (_$serializers.toBuilder(){{#builtValueSerializers}}
       ..addBuilderFactory(
+{{#fullTypeArgs}}
+        const FullType({{{fullTypeArgs}}}),
+        () => {{{builderInstantiation}}}(),
+{{/fullTypeArgs}}
+{{^fullTypeArgs}}
 {{#isArray}}
         const FullType(Built{{#uniqueItems}}Set{{/uniqueItems}}{{^uniqueItems}}List{{/uniqueItems}}, [FullType{{#isNullable}}.nullable{{/isNullable}}({{dataType}})]),
         () => {{#uniqueItems}}Set{{/uniqueItems}}{{^uniqueItems}}List{{/uniqueItems}}Builder<{{dataType}}>(),
@@ -31,6 +36,7 @@ Serializers serializers = (_$serializers.toBuilder(){{#builtValueSerializers}}
         const FullType(BuiltMap, [FullType(String), FullType{{#isNullable}}.nullable{{/isNullable}}({{dataType}})]),
         () => MapBuilder<String, {{dataType}}{{#isNullable}}?{{/isNullable}}>(),
 {{/isMap}}
+{{/fullTypeArgs}}
       ){{/builtValueSerializers}}
       {{#models}}{{#model}}{{#vendorExtensions.x-is-parent}}..add({{classname}}.serializer)
       {{/vendorExtensions.x-is-parent}}{{/model}}{{/models}}..add(const OneOfSerializer())

modules/openapi-generator/src/test/java/org/openapitools/codegen/dart/dio/DartDioClientCodegenTest.java

@@ -142,6 +142,50 @@ public void testImportMappingsInSerializersAndBarrelFile() throws IOException {
                 "package:my_api/src/model/custom_address.dart");
     }
 
+    /**
+     * Regression test for missing BuilderFactory entries on container
+     * types reachable only via {@code additionalProperties}.
+     *
+     * Before the fix, a property like
+     * {@code Map<String, List<Widget>>} (an object schema with
+     * {@code additionalProperties: { type: array, items: ... }}) ended
+     * up in the generated Dart class but no
+     * {@code addBuilderFactory(BuiltList<Widget>, ...)} call was
+     * emitted in {@code serializers.dart}. built_value then failed at
+     * runtime with
+     * {@code Bad state: No builder factory for BuiltList<Widget>}.
+     *
+     * The fix walks every model property's container tree and registers
+     * a factory for each nested layer.
+     */
+    @Test
+    public void testNestedAdditionalPropertiesGetBuilderFactories() throws IOException {
+        File output = Files.createTempDirectory("test").toFile();
+        output.deleteOnExit();
+
+        final CodegenConfigurator configurator = new CodegenConfigurator()
+                .setGeneratorName("dart-dio")
+                .setInputSpec("src/test/resources/3_0/dart-dio/built_value_additional_properties_factory.yaml")
+                .setOutputDir(output.getAbsolutePath().replace("\\", "/"));
+
+        ClientOptInput opts = configurator.toClientOptInput();
+        Generator generator = new DefaultGenerator().opts(opts);
+        List<File> files = generator.generate();
+        files.forEach(File::deleteOnExit);
+
+        Path serializers = output.toPath().resolve("lib/src/serializers.dart");
+
+        // Inner container: List<Widget>.
+        TestUtils.assertFileContains(serializers,
+                "const FullType(BuiltList, [FullType(Widget)]),",
+                "() => ListBuilder<Widget>(),");
+
+        // Outer container: Map<String, List<Widget>>.
+        TestUtils.assertFileContains(serializers,
+                "const FullType(BuiltMap, [FullType(String), FullType(BuiltList, [FullType(Widget)])]),",
+                "() => MapBuilder<String, BuiltList<Widget>>(),");
+    }
+
     @Test
     public void verifyDartDioGeneratorRuns() throws IOException {
         File output = Files.createTempDirectory("test").toFile();

modules/openapi-generator/src/test/resources/3_0/dart-dio/built_value_additional_properties_factory.yaml

@@ -0,0 +1,51 @@
+openapi: "3.0.0"
+info:
+  title: Built-value additionalProperties BuilderFactory test
+  version: "1.0.0"
+paths:
+  /catalog/{id}:
+    get:
+      operationId: getCatalog
+      parameters:
+        - name: id
+          in: path
+          required: true
+          schema: { type: integer }
+      responses:
+        "200":
+          description: OK
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/Catalog"
+components:
+  schemas:
+    Widget:
+      type: object
+      required:
+        - id
+        - name
+      properties:
+        id:
+          type: integer
+        name:
+          type: string
+    # `additionalProperties: { type: array, items: ... }` is the canonical
+    # "map of array of $ref" shape. Without the BuilderFactory walk,
+    # deserialization throws
+    #   Bad state: No builder factory for BuiltList<Widget>
+    WidgetsByCategory:
+      type: object
+      additionalProperties:
+        type: array
+        items:
+          $ref: "#/components/schemas/Widget"
+    Catalog:
+      type: object
+      required:
+        - id
+      properties:
+        id:
+          type: integer
+        widgetsByCategory:
+          $ref: "#/components/schemas/WidgetsByCategory"