SplitRS 0.3.5 Released — Eight Correctness Fixes Found Splitting a Real SQLite Parser

The best fuzzer for a refactoring tool isn’t a fixture file — it’s a real, gnarly codebase. Splitting the oxisqlite-core/oxisql sqlite3-parser crate found eight distinct ways SplitRS’s generated code could fail to compile.

Today we released SplitRS 0.3.5 — another pure correctness release, and like 0.3.4 it has an empty Added section. Every one of its eight fixes traces back to a real compiler error hit while splitting a real crate, and every one of them is fixed.

SplitRS is the AST-based Rust refactoring tool that splits oversized source files into clean, compilable modules: it parses with syn, clusters methods and types, infers visibility, and writes the imports and mod.rs facades for you. No C, no external formatter shelling out to system tools — it links prettyplease in-process and compiles to a single static binary.

Why 0.3.5 matters

Running a splitter against a large, real-world parser crate exercises code shapes a hand-written test suite doesn’t always think to cover — file-backed submodules, cross-chunk method calls, macro-defined types, trait-bound imports. 0.3.5 fixes the eight failure modes that dogfooding on sqlite3-parser actually found:

• File-backed mod x; declarations stay put. A real pub mod check;/mod fmt; line with no inline body used to get swept into a generated bucket file like any other item. New FileAnalyzer::file_backed_mods keeps it declared verbatim in the regenerated root mod.rs, and rewrite_pinned_mod_refs_in_use rewrites any forwarded use that pointed at it with a super:: prefix — closing E0583 (wrong sibling-file lookup) and E0432 (broken absolute-path references).
• Cross-chunk method calls under --split-impl-blocks resolve again. When one impl-block chunk called a private method that only lived in a sibling method_group chunk, the generator didn’t recognize that sibling as the method’s definition site. FileAnalyzer::module_defined_callables now does, fixing E0624 (and a false unconditional_recursion lint in some cases) — while a narrower free_fn_to_module map still stops such methods from being emitted as an invalid use super::<mod>::<method>; import.
• Cross-module const/static references trigger the right imports. A static TABLE: [u8; 256] = build_table(); initializer that calls a helper function now correctly upgrades that helper’s visibility, and an extracted tests.rs that names a sibling module’s const/static by name now gets the use super::<module>::<NAME>; it needs. Previously this only surfaced as E0425 under cargo test/nextest — invisible to a plain cargo check.
• bitflags::bitflags! { ... } invocations are recognized. The type(s) a bitflags! macro call defines are now registered by name (bitflags_defined_idents/bitflags_defines_pub_type, scanning the raw token stream), fixing E0425/E0433 on cross-module references and making sure such types are re-exported through the module’s public facade.
• Type::from_str(...) and write!/writeln! keep their trait imports. Import pruning no longer strips std::str::FromStr or std::fmt::Write/std::io::Write out from under a call site that still needs them, fixing E0599.
• use a::b::{self, *} pruning stopped over-keeping self. The self leaf now tracks the usage of its own enclosing path segment instead of automatically surviving alongside any kept sibling leaf, eliminating spurious unused_imports warnings.
• Grouped-import detection was rewritten on sturdier ground. already_imported used to be a string-based scan that only looked inside the first {...} group; it’s now AST-based via collect_use_bound_names, fixing E0252 (“the name … is defined multiple times”) on multi-segment nested grouped imports like std::{borrow::Cow, collections::{HashMap, VecDeque}}.
• Comments survive visibility upgrades in more places. Byte-verbatim slicing now covers extracted test modules and any impl-block/standalone item that needs a pub(super) bump, via new upgrade_verbatim_item_visibility, which text-patches the prefix onto the original source instead of round-tripping through prettyplease — a path that was silently dropping inline comments.

None of this changes the CLI surface — every flag works exactly as documented in 0.3.4. This release makes the code SplitRS generates compile (and keep its comments) more often.

Technical Deep Dive

1. FileAnalyzer::file_backed_mods scans the source for mod x; items with no inline body (content: None) before chunking begins, producing a pinned set the chunker must never place into a generated bucket file.
2. rewrite_pinned_mod_refs_in_use walks every forwarded use tree the generator writes and, for any path segment matching a pinned file-backed mod, inserts the super:: prefix so the reference still resolves from its new location.
3. FileAnalyzer::module_defined_callables extends the “who defines this callable” analysis to look inside individual method_group chunks, not just whole impl blocks, so a call from a sibling chunk resolves to the correct definition site instead of being assumed private-and-inaccessible.
4. free_fn_to_module is a narrower, free-function-only companion map: it stops the (invalid) use super::<mod>::<method>; shape from ever being emitted for a method, since only free functions can legally be imported that way.
5. bitflags_defined_idents / bitflags_defines_pub_type scan the raw macro token stream of every bitflags::bitflags! { ... } invocation — rather than trying to expand the macro — to recover the type name(s) it defines, feeding them into the same cross-module import/re-export machinery as an ordinary struct/enum.
6. collect_use_bound_names replaces a first-{...}-only string scan inside already_imported with a real AST walk, so nested multi-segment grouped imports are parsed correctly instead of pattern-matched.
7. upgrade_verbatim_item_visibility text-patches a pub(super) prefix directly onto a byte-verbatim-sliced item — correctly skipping past leading attributes and ////* */ comments to find the insertion point — so a visibility upgrade no longer forces a prettyplease round-trip that drops comments.
8. generate_tests_rs_full / generate_tests_rs_with_imports_deep, plus test_module_splitter::generate_per_test_file/generate_fallback_tests_rs, all gained an original_source: Option<&str> parameter, threading the original file text down to wherever verbatim slicing needs it.

Getting Started

Install the latest SplitRS:

cargo install splitrs

Two of this release’s fixes (cross-chunk method calls, cross-module const/static imports) show up specifically under impl-block splitting, so it’s worth running with that flag on:

splitrs \
  --input src/large_file.rs \
  --output src/large_file/ \
  --split-impl-blocks \
  --max-impl-lines 200

If you hit E0583, E0624, E0425, E0433, E0599, or E0252 against generated output on 0.3.4 or earlier, upgrading to 0.3.5 and re-running the same command should resolve it without any config changes.

What’s New in 0.3.5

• File-backed mod x; declarations: no longer bucketed into a generated file; stay pinned to the root mod.rs, fixing E0583/E0432.
• --split-impl-blocks cross-chunk calls: private methods defined only in a sibling chunk now resolve, fixing E0624.
• Cross-module const/static references: helper calls inside initializers, and sibling-module constants referenced from extracted tests.rs, now get the imports they need, fixing E0425.
• bitflags! type exports: bitflags-defined types are now recognized for cross-module imports and public-facade re-exports, fixing E0425/E0433.
• FromStr/Write trait imports: no longer pruned out from under Type::from_str(...), write!, and writeln! call sites, fixing E0599.
• use a::b::{self, *} pruning: self no longer survives spuriously alongside a kept sibling glob, removing false unused_imports warnings.
• Grouped-import detection rewrite: already_imported is now AST-based via collect_use_bound_names, fixing E0252 on nested multi-segment grouped imports.
• Byte-verbatim comment preservation: extended to extracted test modules and any visibility-upgraded item, via upgrade_verbatim_item_visibility.
• Test suite grew to 608 tests passing with --all-features (537 with default features, 1 skipped), up from 570 in 0.3.4 — new regression coverage in tests/cross_module_visibility_tests.rs reproduces the real failures found while splitting the oxisqlite-core/oxisql sqlite3-parser crates.

Tips

• Hitting E0252 (“the name … is defined multiple times”) in a generated mod.rs? That’s the exact grouped-import bug this release fixes — upgrade and re-run. The AST-based collect_use_bound_names rewrite correctly handles nested multi-segment groups like std::{borrow::Cow, collections::{HashMap, VecDeque}}.
• If your crate declares real file-backed submodules (mod check;/mod fmt;, body in a sibling file, not inline) alongside the code you’re splitting, 0.3.5 is the first version safe to point at that file — earlier versions could bucket the declaration itself, breaking both E0583 sibling-file lookup and any absolute path referencing it.
• Using --split-impl-blocks on a type whose impls call each other’s methods? This release is required — 0.3.4 and earlier could wrongly mark those cross-chunk calls private (E0624) or emit an invalid use super::<mod>::<method>; import.
• Splitting a file that uses bitflags::bitflags! { ... }? Upgrade first — earlier versions didn’t know the macro defined a type at all, so any cross-module reference to it failed with E0425/E0433.
• Losing inline comments on visibility-upgraded items in extracted test modules? Fixed here — upgrade_verbatim_item_visibility text-patches pub(super) onto the original source instead of reformatting through prettyplease.
• Always run cargo test/nextest after a split, not just cargo check. The cross-module const/static fix in this release exists precisely because that import gap only showed up once test code exercised the split modules.

This is the foundation

SplitRS remains the development workhorse behind the COOLJAPAN policy of keeping every file under 2,000 lines, used across the ecosystem’s Rust codebases — OxiZ, NumRS2, SciRS2, and dozens of oxi* crates — whenever a module outgrows its budget. Fittingly, 0.3.5’s entire fix list came from dogfooding: splitting the oxisqlite-core/oxisql sqlite3-parser crate for real is what surfaced all eight of these bugs, not a synthetic test fixture.

Repository: https://github.com/cool-japan/splitrs

Star the repo if you want a refactoring tool that treats its own real-world failures as bugs worth a dedicated release. Pure Rust refactoring is here — fast, safe, and getting more battle-tested with every crate it splits.

— KitaSan at COOLJAPAN OÜ July 14, 2026