refactor(pyo3): move DTO-coercion emission into wire_schema, stay under file cap

The #1165 schema/helper emission grew gen_bindings/mod.rs to 1021 lines, over the
1000-line file-modularization cap. Move the classification + emission orchestration
(coercible_dto_names, emit_dto_coercion_section) into wire_schema.rs, where the
schema generation already lives; mod.rs now calls them in a few lines. Generated
output is byte-identical. mod.rs 1021 -> 998; wire_schema.rs 164 -> 205.

Author: tobocop2

src/backends/pyo3/gen_bindings/mod.rs

@@ -603,38 +603,15 @@ impl Backend for Pyo3Backend {
             opaque_types.is_empty(),
         );
 
-        // Classify which config-DTO types are dataclass-backed: their public name resolves to a
-        // `@dataclass`/`dict` (via options.py), not the compiled `#[pyclass]`. Enum-variant payload
-        // fields of these types must accept the public wrapper or a dict — coerced into the core
-        // type — for parity with struct-field `_to_rust_*` coercion. Native-return types stay
-        // compiled and are left untouched. Same source of truth as `gen_init_py`'s import routing.
-        let dto_output_style = config.dto.python_output_style();
-        let reexported_dto_names: ahash::AHashSet<&str> = config
-            .python
-            .as_ref()
-            .map(|p| p.reexported_types.iter().map(String::as_str).collect())
-            .unwrap_or_default();
-        let coercible_dto_names: ahash::AHashSet<&str> = api
-            .types
-            .iter()
-            .filter(|t| errors::is_dataclass_backed_config(t, dto_output_style, &reexported_dto_names))
-            .map(|t| t.name.as_str())
-            .collect();
-        // Emit the runtime coercion helper once when any data-enum variant constructor needs it
-        // (gated on serde availability — the helper deserializes the coerced JSON into the core type),
-        // followed by the per-DTO `__ALEF_WIRE_*` rename-schema consts that give the helper full
-        // serde-rename fidelity (handling `#[serde(rename)]`/`#[serde(rename_all)]` and nesting).
-        if has_serde
-            && api
-                .enums
-                .iter()
-                .any(|e| generators::data_enum_needs_dto_coercion(e, &coercible_dto_names))
-        {
-            builder.add_item(generators::PYO3_DTO_COERCE_HELPER);
-            let wire_schema_consts = wire_schema::gen_wire_schema_consts(api, &coercible_dto_names);
-            if !wire_schema_consts.is_empty() {
-                builder.add_item(&wire_schema_consts);
-            }
+        // Classify which config-DTO types are dataclass-backed (their public name is a
+        // `@dataclass`/`dict`, not the compiled `#[pyclass]`) so enum-variant payloads of those
+        // types are coerced rather than required as compiled instances. Then emit the runtime
+        // coercion helper plus the per-DTO `__ALEF_WIRE_*` rename-schema consts (both live in
+        // `wire_schema`). `coercible_dto_names` is reused below to drive the variant constructors.
+        let coercible_dto_names = wire_schema::coercible_dto_names(api, config);
+        let coercion_section = wire_schema::emit_dto_coercion_section(api, has_serde, &coercible_dto_names);
+        if !coercion_section.is_empty() {
+            builder.add_item(&coercion_section);
         }
 
         for e in &api.enums {

src/backends/pyo3/gen_bindings/wire_schema.rs

@@ -9,14 +9,55 @@
 //! same single source of truth the Python `_to_rust_*` converters use) and recurses through nested
 //! DTOs, sequences, maps, and optionals so renamed fields at any depth survive the round-trip.
 
+use super::errors::is_dataclass_backed_config;
 use crate::codegen::generators::{
-    coercible_payload, collect_variant_constructors, enum_has_data_variants, pyo3_wire_schema_const_name,
+    PYO3_DTO_COERCE_HELPER, coercible_payload, collect_variant_constructors, data_enum_needs_dto_coercion,
+    enum_has_data_variants, pyo3_wire_schema_const_name,
 };
 use crate::codegen::naming::wire_field_name;
 use crate::codegen::shared::binding_fields;
+use crate::core::config::ResolvedCrateConfig;
 use crate::core::ir::{ApiSurface, TypeDef};
 use ahash::{AHashMap, AHashSet};
 
+/// Classify the dataclass-backed config-DTO type names: their public name resolves to a
+/// `@dataclass`/`dict` (via `options.py`), not the compiled `#[pyclass]`. Enum-variant payload
+/// fields of these types must accept the public wrapper or a dict — coerced into the core type —
+/// for parity with struct-field `_to_rust_*` coercion. Native-return types stay compiled and are
+/// left untouched. Same source of truth as `gen_init_py`'s import routing.
+pub(super) fn coercible_dto_names<'a>(api: &'a ApiSurface, config: &ResolvedCrateConfig) -> AHashSet<&'a str> {
+    let output_style = config.dto.python_output_style();
+    let reexported: AHashSet<&str> = config
+        .python
+        .as_ref()
+        .map(|p| p.reexported_types.iter().map(String::as_str).collect())
+        .unwrap_or_default();
+    api.types
+        .iter()
+        .filter(|t| is_dataclass_backed_config(t, output_style, &reexported))
+        .map(|t| t.name.as_str())
+        .collect()
+}
+
+/// Emit the data-enum DTO-coercion section for the generated pyo3 module: the runtime coercion
+/// helper ([`PYO3_DTO_COERCE_HELPER`]) followed by the per-DTO `__ALEF_WIRE_*` rename-schema consts.
+/// Returns an empty string when no data-enum variant constructor needs coercion (or `serde` is
+/// unavailable — the helper deserializes the coerced JSON into the core type). The helper and the
+/// schema consts are joined the same way `RustFileBuilder` joins items (`"\n\n"`), so emitting this
+/// as a single item is byte-identical to emitting them separately.
+pub(super) fn emit_dto_coercion_section(api: &ApiSurface, has_serde: bool, coercible: &AHashSet<&str>) -> String {
+    let needed = has_serde && api.enums.iter().any(|e| data_enum_needs_dto_coercion(e, coercible));
+    if !needed {
+        return String::new();
+    }
+    let schema_consts = gen_wire_schema_consts(api, coercible);
+    if schema_consts.is_empty() {
+        PYO3_DTO_COERCE_HELPER.to_string()
+    } else {
+        format!("{PYO3_DTO_COERCE_HELPER}\n\n{schema_consts}")
+    }
+}
+
 /// One emitted `__AlefAlias` row.
 struct AliasEntry {
     rust: String,