- Remember Lambda IR is the core optimization layer

- All`lam_*.ml` files process this representation

- Use`lam_print.ml` for debugging lambda expressions

- Test both with and without optimization passes

- Test both with and without optimization passes

Rewatch is the modern build system written in Rust that replaces the legacy bsb (BuckleScript) build system. It provides faster incremental builds, better error messages, and improved developer experience.

1.**Initialization** (`build::initialize_build`)

- Parse`rescript.json` configuration

- Discover packages and dependencies

- Set up compiler information

- Create initial`BuildState`

2.**AST Generation** (`build::parse`)

- Generate AST files using`bsc -bs-ast`

- Handle PPX transformations

- Process JSX

3.**Dependency Analysis** (`build::deps`)

- Analyze module dependencies from AST files

- Build dependency graph

- Detect circular dependencies

4.**Compilation** (`build::compile`)

- Generate`bsc` compiler arguments

- Compile modules in dependency order

- Handle warnings and errors

- Generate JavaScript output

5.**Incremental Updates** (`watcher.rs`)

- Watch for file changes

- Determine dirty modules

- Recompile only affected modules

1.**CLI Arguments**: Add to`cli.rs` in`BuildArgs` and`WatchArgs`

2.**Configuration**: Extend`config.rs` for new`rescript.json` fields

3.**Build Logic**: Modify appropriate`build/*.rs` modules

4.**Thread Parameters**: Pass new parameters through the build system chain

5.**Add Tests**: Include unit tests for new functionality

-**Parameter Threading**: New CLI flags need to be passed through:

-`main.rs` →`build::build()` →`initialize_build()` →`BuildState`

-`main.rs` →`watcher::start()` →`async_watch()` →`initialize_build()`

-**Configuration Precedence**: Command-line flags override`rescript.json` config

-**Error Handling**: Use`anyhow::Result` for error propagation

-**Logging**: Use`log::debug!` for development debugging

cargotest --manifest-path rewatch/Cargo.toml

cargotest --manifest-path rewatch/Cargo.toml config::tests::test_get_warning_args

cargo clippy --manifest-path rewatch/Cargo.toml --all-targets --all-features

cargo fmt --check --manifest-path rewatch/Cargo.toml

cargo build --manifest-path rewatch/Cargo.toml --release

make rewatch# Build rewatch

make test-rewatch# Run integration tests

**Note**: The rewatch project is located in the`rewatch/` directory with its own`Cargo.toml` file. All cargo commands should be run from the project root using the`--manifest-path rewatch/Cargo.toml` flag, as shown in the CI workflow.

**Integration Tests**: The`make test-rewatch` command runs bash-based integration tests located in`rewatch/tests/suite-ci.sh`. These tests use the`rewatch/testrepo/` directory as a test workspace with various package configurations to verify rewatch's behavior across different scenarios.

-**Build State**: Use`log::debug!` to inspect`BuildState` contents

-**Compiler Args**: Check generated`bsc` arguments in`compile.rs`

-**Dependencies**: Inspect module dependency graph in`deps.rs`

-**File Watching**: Monitor file change events in`watcher.rs`

-**Incremental Builds**: Only recompile dirty modules

-**Parallel Compilation**: Use`rayon` for parallel processing

-**Memory Usage**: Be mindful of`BuildState` size in large projects

-**File I/O**: Minimize file system operations

When clippy suggests refactoring that could impact performance, consider the trade-offs:

-**Parameter Structs vs Many Arguments**: While clippy prefers parameter structs for functions with many arguments, sometimes the added complexity isn't worth it. Use`#[allow(clippy::too_many_arguments)]` for functions that legitimately need many parameters and where a struct would add unnecessary complexity.

-**Cloning vs Borrowing**: Sometimes cloning is necessary due to Rust's borrow checker rules. If the clone is:

- Small and one-time (e.g.,`Vec<String>` with few elements)

- Necessary for correct ownership semantics

- Not in a hot path

Then accept the clone rather than over-engineering the solution.

-**When to Optimize**: Profile before optimizing. Most "performance concerns" in build systems are negligible compared to actual compilation time.

-**Avoid Unnecessary Type Conversions**: When threading parameters through multiple function calls, use consistent types (e.g.,`String` throughout) rather than converting between`String` and`&str` at each boundary. This eliminates unnecessary allocations and conversions.

-**Command-line Flags**: Maintain compatibility with bsb flags where possible

-**Configuration**: Support both old (`bs-*`) and new field names

-**Output Format**: Generate compatible build artifacts

-**Error Messages**: Provide clear migration guidance

1. Add to`BuildArgs` and`WatchArgs` in`cli.rs`

2. Update`From<BuildArgs> for WatchArgs` implementation

3. Pass through`main.rs` to build functions

4. Thread through build system to where it's needed

5. Add unit tests for the new functionality

1. Update`compiler_args()` in`build/compile.rs`

2. Consider both parsing and compilation phases

3. Handle precedence between CLI flags and config

4. Test with various`rescript.json` configurations

1. Use`packages.rs` for package discovery

2. Update`deps.rs` for dependency analysis

3. Handle both local and external dependencies

4. Consider dev dependencies vs regular dependencies

1. Modify`watcher.rs` for file change handling

2. Update`AsyncWatchArgs` for new parameters

3. Handle different file types (`.res`,`.resi`, etc.)

4. Consider performance impact of watching many files

- Option optimization: do not create redundant local vars.https://github.com/rescript-lang/rescript/pull/7915

- Js output: remove superfluous newline after every`if`.https://github.com/rescript-lang/rescript/pull/7920

- Rewatch: Traverse upwards for package resolution in single context projects.https://github.com/rescript-lang/rescript/pull/7896

- Rewatch: Add`--warn-error` flag to`build`.https://github.com/rescript-lang/rescript/pull/7916

&project_context.current_config,

relative_filename,

&contents,

)?;

let is_interface = filename.to_string_lossy().ends_with('i');

let has_interface =if is_interface{

is_type_dev,

)?;

let result = serde_json::to_string_pretty(&CompilerArgs{

) ->Result<BuildState>{

) ->Result<BuildCommandState>{

let project_context =ProjectContext::new(path)?;

let compiler =get_compiler_info(&project_context)?;

let _ =stdout().flush();

letmut build_state =BuildState::new(project_context, packages, compiler);

letmut build_state =BuildCommandState::new(project_context, packages, compiler, warn_error);

packages::parse_packages(&mut build_state);

let timing_source_files_elapsed = timing_source_files.elapsed();

let timing_deps =Instant::now();

deps::get_deps(build_state,&build_state.deleted_modules.to_owned());

let deleted_modules = build_state.deleted_modules.clone();

deps::get_deps(build_state,&deleted_modules);

let timing_deps_elapsed = timing_deps.elapsed();

current_step +=1;

mark_modules_with_expired_deps_dirty(build_state);

mark_modules_with_deleted_deps_dirty(build_state);

current_step +=1;

build_state.packages.iter().for_each(|(_, package)|{

if package.is_local_dep{

for packagein build_state.packages.values(){

letmut f =File::create(package.get_build_path().join("build.ninja")).expect("Unable to write file");

f.write_all(b"").expect("unable to write to ninja file");

filter:&Option<regex::Regex>,

) ->Result<BuildState>{

) ->Result<BuildCommandState>{

let default_timing:Option<std::time::Duration> =if no_timing{

Some(std::time::Duration::new(0.0asu64,0.0asu32))

path,

build_dev_deps,

snapshot_output,

warn_error,

.map_err(|e|anyhow!("Could not initialize build. Error: {e}"))?;

usecrate::project_context::ProjectContext;

use ahash::{AHashMap,AHashSet};

use blake3::Hash;

use std::{fmt::Display, path::PathBuf, time::SystemTime};

use std::{fmt::Display,ops::Deref,path::PathBuf, time::SystemTime};

pubfnget_module(&self,module_name:&str) ->Option<&Module>{

self.modules.get(module_name)

) ->Self{

build_state:BuildState::new(project_context, packages, compiler),

warn_error_override,

pubfnget_warn_error_override(&self) ->Option<String>{

pubfnmodule_name_package_pairs(&self) ->Vec<(String,String)>{

.map(|(name, module)|(name.clone(), module.package_name.clone()))

typeTarget =BuildState;

fnderef(&self) ->&Self::Target{

impl std::ops::DerefMutforBuildCommandState{

fnderef_mut(&mutself) ->&mutSelf::Target{