# IDL→Rust codegen: a reopened IDL module emits a second pub mod block at the same scope, which Rust rejects (E0428), so any multi-module or multi-file IDL produces uncompilable output

[swarm59]

IDL→Rust codegen: a reopened IDL module emits a second pub mod block at the same scope, which Rust rejects (E0428), so any multi-module or multi-file IDL produces uncompilable output

Crate: zerodds-idl-rust
Version: 1.0.0-rc.6 (source clone at commit b0033675f5, 2026-07-23)
Component: module emission (emitter.rs:131)

Type and module names in the reproducer below are illustrative reduced cases, not real-world names.

Summary

Reopening a module is legal and idiomatic IDL — the same module name may be declared more than once, and the declarations merge. The generator emits one pub mod <name> { … } block per declaration, all at the same scope. Rust does not allow an inline module to be redeclared:

error[E0428]: the name `Demo` is defined multiple times

Since #include produces exactly this pattern (each included file contributes its own module <name> { … } to the expanded translation unit), any IDL set that shares a common module across files generates code that cannot compile.

This is the root cause of a large cascade: every subsequent reference to a path inside the module fails as well. In one of our files, 108 of 108 E0433 errors are use of undeclared type <module>, all downstream of this single E0428.

Root cause

crates/idl-rust/src/emitter.rs:131:

out.push_str("pub mod ");

Each Definition::Module in the AST is emitted as a fresh inline module. There is no merge step that groups declarations sharing a name before emission.

Reproduction

A single file, no includes needed:

module Demo { struct A { long a; }; };
module Demo { struct B { long b; }; };

Codegen succeeds (225 lines) and emits:

L10:  pub mod Demo {
L118: pub mod Demo {

Both at brace depth 0. Compiling the result:

error[E0428]: the name `Demo` is defined multiple times
   --> src\lib.rs:118:1
    |
 10 | pub mod Demo {
    | ------------ previous definition of the module `Demo` here
...
118 | pub mod Demo {
    | ^^^^^^^^^^^^ `Demo` redefined here

Confirmed against a minimal rustc case, to rule out any misreading on our side:

pub mod A { pub struct X { pub a: u32 } }
pub mod A { pub struct Y { pub b: u32 } }

error[E0428]: the name `A` is defined multiple times
 = note: `A` must be defined only once in the type namespace of this module

Scale on a real IDL set

We generated and compiled a mid-size IDL set of five files, preprocessed with includes expanded. The number of emitted top-level pub mod blocks equals the number of files in the translation unit, and the E0428 count is exactly (blocks − 1):

Files in translation unit	Blocks emitted	E0428	Compiles
1 (includes nothing)	1	0	yes
2	2	1	no
3	3	2	no
4	4	3	no

The only file that compiles is the only one that includes nothing.

Impact

Any IDL using #include, or reopening a module within one file, yields output that does not compile. Since #include is the normal way to share common types across an IDL set, we expect this to affect most non-trivial users. Single-file, single-module IDL is unaffected.

Suggested fix

Group Definition::Module entries by name before emission and emit one pub mod block per distinct name, concatenating the members — mirroring the merge semantics IDL itself gives to a reopened module. Nested modules need the same treatment recursively.

A downstream post-processing step that merges the duplicate blocks textually is possible and is what we would fall back to, but it is fragile and we would rather not carry it.

We have not attempted a patch against the real codebase, preferring to test the unmodified published artefact. Reduced reproducer available on request.

[SandraK82]

Thank you, @swarm59, for the clear report and reproducer. You were right: reopening an IDL module could leave multiple module nodes in the generated representation, and the Rust backend then emitted duplicate pub mod declarations that failed with E0428.

The direct failure is fixed on main in bd7e592. Reopened modules are now merged into one semantic scope while preserving all declarations and their source information.

Your report also led us considerably deeper than the original Rust compiler error. During the cross-backend audit, we found that ten code-generation backends had incomplete or missing handling for Definition::Module. Instead of producing a visible duplicate, they could silently omit structs, enums, typedefs, or other declarations wrapped in a module. Those paths have now been corrected as well.

A second pass then uncovered another related problem: simply flattening module contents could make identically named types from different modules collide, or make a reference resolve to the type from the wrong module. The affected backends now use module-qualified, injective generated names and resolve cross-module references against the correct lexical scope. Tests cover nested and reopened modules, same-named types in different modules, and references crossing module boundaries.

The complete public main build, including the expanded adversarial and generated-code regression suite, is green:
https://github.com/zero-objects/zero-dds/actions/runs/30556000574

I am closing this discussion as fixed. If you still encounter duplicate modules, missing declarations, or an incorrect cross-module type reference on current main, please let us know here — we will be very happy to reopen the discussion and investigate further.

Thank you again for providing the entry point to a much broader module and scope audit across the IDL compiler.