feat(cli): Add --root-mode argument for .swcrc resolution (#11501)

## Summary

Adds `--root-mode` CLI argument to the `swc compile` command, matching
Babel's behavior for resolving `.swcrc` configuration files.

Closes #1801

### Modes

| Mode | Behavior |
|------|----------|
| `root` (default) | Only looks for `.swcrc` at the root directory |
| `upward` | Walks upward from the file directory, **throws error** if
no `.swcrc` is found |
| `upward-optional` | Walks upward from the file directory, **falls back
silently** if no `.swcrc` is found |

### Changes

- **compile.rs**: Add `--root-mode` argument with value parser
- **compile.rs**: Use `swcrc: default_swcrc()` in Options construction
for consistency with serde default
- **config/mod.rs**: Make `default_swcrc()` public so CLI can use it
- **lib.rs**: Canonicalize relative paths before calling `find_swcrc`
for proper parent traversal
- **lib.rs**: Add error when `upward` mode fails to find a `.swcrc`
- **issues.rs**: Add 5 CLI tests covering all root-mode behaviors

### Tests

| Test | Description |
|------|-------------|
| `root_mode_upward_finds_parent_config` | Verifies `upward` finds
`.swcrc` in parent directory |
| `root_mode_root_ignores_parent_config` | Verifies `root` mode does NOT
search parent directories |
| `root_mode_upward_fails_without_config` | Verifies `upward` fails when
no `.swcrc` exists |
| `root_mode_upward_optional_succeeds_without_config` | Verifies
`upward-optional` succeeds without `.swcrc` |
| `root_mode_upward_optional_finds_parent_config` | Verifies
`upward-optional` finds parent `.swcrc` |

### Note for maintainers

The `Options` struct derives `Default`, which sets `swcrc` to `false`
(Rust's bool default). However, the serde configuration uses
`#[serde(default = "default_swcrc")]` which returns `true`. To address
this discrepancy, the CLI now explicitly sets `swcrc: default_swcrc()`
when constructing Options, ensuring consistent behavior. Happy to tweak
the PR if you prefer some other approach here.

## Test plan

- [x] `cargo test -p swc_cli_impl` - all 9 tests pass
- [x] `cargo clippy -p swc_cli_impl --tests -- -D warnings` - no
warnings
- [x] `cargo fmt --all` - formatted

🤖 Generated with [Claude Code](https://claude.com/claude-code)

---------

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>

Author: leos

crates/swc/src/config/mod.rs

@@ -958,7 +958,7 @@ pub enum RootMode {
     UpwardOptional,
 }
 
-const fn default_swcrc() -> bool {
+pub const fn default_swcrc() -> bool {
     true
 }
 

crates/swc/src/lib.rs

@@ -491,7 +491,24 @@ impl Compiler {
                 _ => {
                     if *swcrc {
                         if let FileName::Real(ref path) = name {
-                            find_swcrc(path, root, *root_mode)
+                            // Canonicalize relative paths for proper parent traversal
+                            let abs_path = if path.is_relative() {
+                                root.join(path).canonicalize().ok()
+                            } else {
+                                path.canonicalize().ok()
+                            };
+                            let found = abs_path.and_then(|p| find_swcrc(&p, root, *root_mode));
+
+                            // "upward" mode requires a .swcrc to be found
+                            if found.is_none() && *root_mode == RootMode::Upward {
+                                bail!(
+                                    "Could not find .swcrc file while using rootMode \
+                                     \"upward\".\nSearched from: {}",
+                                    path.display()
+                                );
+                            }
+
+                            found
                         } else {
                             None
                         }

crates/swc_cli_impl/src/commands/compile.rs

@@ -13,7 +13,9 @@ use path_absolutize::Absolutize;
 use relative_path::RelativePath;
 use swc_core::{
     base::{
-        config::{Config, ConfigFile, Options, PluginConfig, SourceMapsConfig},
+        config::{
+            default_swcrc, Config, ConfigFile, Options, PluginConfig, RootMode, SourceMapsConfig,
+        },
         try_with_handler, Compiler, HandlerOpts, TransformOutput,
     },
     common::{
@@ -39,6 +41,11 @@ pub struct CompileOptions {
     #[clap(long)]
     config_file: Option<PathBuf>,
 
+    /// The mode to use for resolving the project root and .swcrc file.
+    /// Values: root (default), upward, upward-optional
+    #[clap(long, value_parser = parse_root_mode)]
+    root_mode: Option<RootMode>,
+
     /// Filename to use when reading from stdin - this will be used in
     /// source-maps, errors etc
     #[clap(long, short = 'f', group = "input")]
@@ -114,6 +121,17 @@ fn parse_config(s: &str) -> Result<Config, serde_json::Error> {
     serde_json::from_str(s)
 }
 
+fn parse_root_mode(s: &str) -> Result<RootMode, String> {
+    match s {
+        "root" => Ok(RootMode::Root),
+        "upward" => Ok(RootMode::Upward),
+        "upward-optional" => Ok(RootMode::UpwardOptional),
+        _ => Err(format!(
+            "Invalid root mode '{s}'. Valid values are: root, upward, upward-optional"
+        )),
+    }
+}
+
 static COMPILER: Lazy<Arc<Compiler>> = Lazy::new(|| {
     let cm = Arc::new(SourceMap::new(FilePathMapping::empty()));
 
@@ -296,6 +314,7 @@ impl CompileOptions {
         let mut options = Options {
             config: self.config.to_owned().unwrap_or_default(),
             config_file,
+            swcrc: default_swcrc(),
             ..Options::default()
         };
 
@@ -331,6 +350,10 @@ impl CompileOptions {
             options.env_name = env_name.to_string();
         }
 
+        if let Some(root_mode) = self.root_mode {
+            options.root_mode = root_mode;
+        }
+
         if let Some(source_maps) = &self.source_maps {
             options.source_maps = Some(match source_maps.as_str() {
                 "false" => SourceMapsConfig::Bool(false),

crates/swc_cli_impl/tests/issues.rs

@@ -158,6 +158,184 @@ fn issue_9559() -> Result<()> {
     Ok(())
 }
 
+/// Tests that `--root-mode upward` finds a `.swcrc` in a parent directory.
+#[test]
+fn root_mode_upward_finds_parent_config() -> Result<()> {
+    let tmp = TempDir::new()?;
+
+    let subdir = tmp.path().join("subdir");
+    create_dir_all(&subdir)?;
+
+    // target: es2022 keeps arrow functions (unlike default es5)
+    fs::write(
+        tmp.path().join(".swcrc"),
+        r#"{
+            "jsc": {
+                "parser": { "syntax": "ecmascript" },
+                "target": "es2022"
+            }
+        }"#,
+    )?;
+
+    fs::write(subdir.join("input.js"), "const arrow = () => 'hello';")?;
+
+    let mut cmd = cli()?;
+    cmd.current_dir(&subdir)
+        .arg("compile")
+        .arg("--root-mode")
+        .arg("upward")
+        .arg("--out-file")
+        .arg("output.js")
+        .arg("input.js");
+
+    cmd.assert().success();
+
+    // Verify the config was found: es2022 keeps arrow functions
+    let output = fs::read_to_string(subdir.join("output.js"))?;
+    assert!(
+        output.contains("=>"),
+        "Arrow should be kept with es2022 target from parent .swcrc. Got: {output}"
+    );
+
+    Ok(())
+}
+
+/// Tests that `--root-mode root` does NOT search parent directories for
+/// `.swcrc`.
+#[test]
+fn root_mode_root_ignores_parent_config() -> Result<()> {
+    let tmp = TempDir::new()?;
+
+    let subdir = tmp.path().join("subdir");
+    create_dir_all(&subdir)?;
+
+    // Parent has .swcrc with es2022 (keeps arrows)
+    fs::write(
+        tmp.path().join(".swcrc"),
+        r#"{
+            "jsc": {
+                "parser": { "syntax": "ecmascript" },
+                "target": "es2022"
+            }
+        }"#,
+    )?;
+
+    fs::write(subdir.join("input.js"), "const arrow = () => 'hello';")?;
+
+    let mut cmd = cli()?;
+    cmd.current_dir(&subdir)
+        .arg("compile")
+        .arg("--root-mode")
+        .arg("root")
+        .arg("--out-file")
+        .arg("output.js")
+        .arg("input.js");
+
+    cmd.assert().success();
+
+    // Parent .swcrc should be ignored, so default es5 transforms arrow to function
+    let output = fs::read_to_string(subdir.join("output.js"))?;
+    assert!(
+        output.contains("function"),
+        "Parent .swcrc should be ignored with root mode. Got: {output}"
+    );
+
+    Ok(())
+}
+
+/// Tests that `--root-mode upward` fails when no `.swcrc` is found.
+#[test]
+fn root_mode_upward_fails_without_config() -> Result<()> {
+    let tmp = TempDir::new()?;
+
+    // No .swcrc anywhere
+    fs::write(tmp.path().join("input.js"), "const arrow = () => 'hello';")?;
+
+    let mut cmd = cli()?;
+    cmd.current_dir(&tmp)
+        .arg("compile")
+        .arg("--root-mode")
+        .arg("upward")
+        .arg("--out-file")
+        .arg("output.js")
+        .arg("input.js");
+
+    cmd.assert().failure();
+
+    Ok(())
+}
+
+/// Tests that `--root-mode upward-optional` succeeds even without a `.swcrc`.
+#[test]
+fn root_mode_upward_optional_succeeds_without_config() -> Result<()> {
+    let tmp = TempDir::new()?;
+
+    // No .swcrc anywhere
+    fs::write(tmp.path().join("input.js"), "const arrow = () => 'hello';")?;
+
+    let mut cmd = cli()?;
+    cmd.current_dir(&tmp)
+        .arg("compile")
+        .arg("--root-mode")
+        .arg("upward-optional")
+        .arg("--out-file")
+        .arg("output.js")
+        .arg("input.js");
+
+    cmd.assert().success();
+
+    // Should compile with defaults (es5 transforms arrow to function)
+    let output = fs::read_to_string(tmp.path().join("output.js"))?;
+    assert!(
+        output.contains("function"),
+        "Should use default es5 target without .swcrc. Got: {output}"
+    );
+
+    Ok(())
+}
+
+/// Tests that `--root-mode upward-optional` uses parent `.swcrc` when found.
+#[test]
+fn root_mode_upward_optional_finds_parent_config() -> Result<()> {
+    let tmp = TempDir::new()?;
+
+    let subdir = tmp.path().join("subdir");
+    create_dir_all(&subdir)?;
+
+    // target: es2022 keeps arrow functions
+    fs::write(
+        tmp.path().join(".swcrc"),
+        r#"{
+            "jsc": {
+                "parser": { "syntax": "ecmascript" },
+                "target": "es2022"
+            }
+        }"#,
+    )?;
+
+    fs::write(subdir.join("input.js"), "const arrow = () => 'hello';")?;
+
+    let mut cmd = cli()?;
+    cmd.current_dir(&subdir)
+        .arg("compile")
+        .arg("--root-mode")
+        .arg("upward-optional")
+        .arg("--out-file")
+        .arg("output.js")
+        .arg("input.js");
+
+    cmd.assert().success();
+
+    // Verify the config was found: es2022 keeps arrow functions
+    let output = fs::read_to_string(subdir.join("output.js"))?;
+    assert!(
+        output.contains("=>"),
+        "Arrow should be kept with es2022 target from parent .swcrc. Got: {output}"
+    );
+
+    Ok(())
+}
+
 /// ln -s $a $b
 fn symlink(a: &Path, b: &Path) {
     #[cfg(unix)]