⚠️ Potential issue | 🟠 Major

# First, let's explore the file structure and locate the file
find . -name "pymodule.rs" -type f

# Read the context around lines 85-90 in the file to understand the code
cat -n crates/derive-impl/src/pymodule.rs | sed -n '75,100p'

# Search for any cfg-gated module_exec definitions in the entire codebase
rg --type=rust -B5 'fn\s+module_exec' --multiline-dotted

# Search for where def.slots.exec is set or assigned
rg --type=rust 'def\.slots\.exec|slots\.exec\s*=' -B2 -A2

# Search for module_exec with surrounding context, checking for #[cfg(...)]
rg --type=rust -B10 'fn\s+module_exec' | head -50

# Search specifically for cfg-gated module_exec
rg --type=rust '#\[cfg' -A10 | rg -A10 'module_exec'

# Find where context.has_module_exec is used
rg --type=rust 'has_module_exec' -B2 -A2

# Find where def.slots.exec = Some(module_exec) is generated with more context
rg --type=rust 'def\.slots\.exec\s*=\s*Some' -B10 -A5 crates/derive-impl/src/pymodule.rs

# Also search for where the module definition is generated to understand full flow
rg --type=rust 'gen_module_def|ModuleDef' crates/derive-impl/src/pymodule.rs | head -20

# Search for any actual cfg-gated module_exec definitions that might have caused issues
rg --type=rust -B3 '#\[cfg' -A3 | rg -B3 -A3 'fn\s+module_exec'

# Read the full context around where has_module_exec is used to understand the code generation
cat -n crates/derive-impl/src/pymodule.rs | sed -n '110,150p'

# Check if there's any conditional generation based on has_module_exec
rg --type=rust 'has_module_exec' -B5 -A10 crates/derive-impl/src/pymodule.rs

Reject cfg‑gated module_exec to prevent build failures.

When a user defines module_exec with a #[cfg(...)] attribute, the code checks for its presence (line 87) and sets context.has_module_exec = true. However, the code generation at line 142 unconditionally generates def.slots.exec = Some(module_exec); regardless of whether module_exec is cfg-gated. In builds where the cfg condition is false, the function won't exist but the code still references it, causing a hard compile error.

The suggested diagnostic check is appropriate: detect cfg-gated module_exec and emit an error, directing users to either move the cfg to the containing module or provide an explicit fallback.

In `@crates/derive-impl/src/pymodule.rs` around lines 85 - 90, The derive
currently marks context.has_module_exec = true when it sees an Item::Fn named
module_exec but doesn't handle cfg-gated declarations, which leads to emitting
def.slots.exec = Some(module_exec) unconditionally; update the visitor in
pymodule.rs to detect if the function/item named module_exec has any #[cfg(...)]
attributes (inspect func.attrs for a Meta path "cfg") and, if so, emit a
compile_error (or return a syn::Error) rejecting cfg‑gated module_exec with a
clear message that the cfg must be moved to the containing module or a non-gated
fallback provided, instead of setting context.has_module_exec = true and
generating def.slots.exec = Some(module_exec).

⚠️ Potential issue | 🟡 Minor

Return value of __module_exec is discarded; otherwise LGTM.

The module_exec function properly:

• Sets up error codes with ? propagation (line 853)
• Configures exceptions via setup_module_exceptions
• Initializes converters/adapters
• Uses ? for set_attr calls (lines 863-864)

However, line 848 discards the return value of __module_exec(vm, module). Consider propagating any potential errors.

     pub(crate) fn module_exec(vm: &VirtualMachine, module: &Py<PyModule>) -> PyResult<()> {
-        __module_exec(vm, module);
+        __module_exec(vm, module)?;
 
         for (name, code) in ERROR_CODES {

In `@crates/stdlib/src/_sqlite3.rs` around lines 847 - 867, The call to
__module_exec(vm, module) in module_exec currently discards its Result; change
the invocation to propagate errors (e.g., use __module_exec(vm, module)? or
otherwise handle its PyResult) so that any error returned by __module_exec is
forwarded from module_exec; ensure module_exec still returns PyResult<()> and
that subsequent initialization (ERROR_CODES loop, setup_module_exceptions,
CONVERTERS/ADAPTERS/USER_FUNCTION_EXCEPTION/ENABLE_TRACEBACK setup, and
module.set_attr calls) only runs after successful __module_exec.

__module_exec returns ()

@youknowone, thank you for the clarification! You're correct—if __module_exec returns () (unit type) rather than PyResult<()>, then the current code is correct as written. The call on line 848 doesn't need the ? operator since there's no Result to propagate.

The module_exec wrapper properly:

1. Invokes the infallible __module_exec(vm, module)
2. Performs additional fallible setup (error code registration, module attributes) with proper ? propagation
3. Returns PyResult<()> to handle any errors from the subsequent operations

The implementation correctly separates the auto-generated initialization (__module_exec) from the module-specific setup that can fail.