fix: avoid crash when encountering tsconfig circular extends (#570)

sapphi-red · web-flow · commit 3cda38def286 · 2025-06-23T20:38:09.000+08:00
When there's a circular `tsconfig` extends, oxc-resolver crashed with
`Segmentation fault (core dumped)`.

This PR fixes that.

In this case, TypeScript outputs errors like:
```
$ pnpm tsc --noEmit -p tsconfig_self_reference.json
error TS18000: Circularity detected while resolving configuration: /home/green/workspace/oxc-resolver/tests/tsconfig_self_reference.json -&gt; /home/green/workspace/oxc-resolver/tests/tsconfig_self_reference.json
$ pnpm tsc --noEmit -p tsconfig_circular_reference_a.json 
error TS18000: Circularity detected while resolving configuration: /home/green/workspace/oxc-resolver/tests/tsconfig_circular_reference_a.json -&gt; /home/green/workspace/oxc-resolver/tests/tsconfig_circular_reference_b.json -&gt; /home/green/workspace/oxc-resolver/tests/tsconfig_circular_reference_a.json
```
diff --git a/src/error.rs b/src/error.rs
@@ -1,4 +1,9 @@
-use std::{io, path::PathBuf, sync::Arc};
+use std::{
+    fmt::{self, Debug, Display},
+    io,
+    path::PathBuf,
+    sync::Arc,
+};
 
 use thiserror::Error;
 
@@ -38,6 +43,10 @@ pub enum ResolveError {
     #[error("Tsconfig's project reference path points to this tsconfig {0}")]
     TsconfigSelfReference(PathBuf),
 
+    /// Occurs when tsconfig extends configs circularly
+    #[error("Tsconfig extends configs circularly: {0}")]
+    TsconfigCircularExtend(CircularPathBufs),
+
     #[error("{0}")]
     IOError(IOError),
 
@@ -162,6 +171,27 @@ impl From<io::Error> for ResolveError {
     }
 }
 
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct CircularPathBufs(Vec<PathBuf>);
+
+impl Display for CircularPathBufs {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        for (i, path) in self.0.iter().enumerate() {
+            if i != 0 {
+                write!(f, " -> ")?;
+            }
+            path.fmt(f)?;
+        }
+        Ok(())
+    }
+}
+
+impl From<Vec<PathBuf>> for CircularPathBufs {
+    fn from(value: Vec<PathBuf>) -> Self {
+        Self(value)
+    }
+}
+
 #[test]
 fn test_into_io_error() {
     use std::io::{self, ErrorKind};
diff --git a/src/lib.rs b/src/lib.rs
@@ -63,6 +63,7 @@ mod path;
 mod resolution;
 mod specifier;
 mod tsconfig;
+mod tsconfig_context;
 #[cfg(feature = "fs_cache")]
 mod tsconfig_serde;
 #[cfg(target_os = "windows")]
@@ -109,7 +110,10 @@ pub use crate::{
     resolution::{ModuleType, Resolution},
     tsconfig::{CompilerOptions, CompilerOptionsPathsMap, ProjectReference, TsConfig},
 };
-use crate::{context::ResolveContext as Ctx, path::SLASH_START, specifier::Specifier};
+use crate::{
+    context::ResolveContext as Ctx, path::SLASH_START, specifier::Specifier,
+    tsconfig_context::TsconfigResolveContext,
+};
 
 type ResolveResult<Cp> = Result<Option<Cp>, ResolveError>;
 
@@ -207,7 +211,12 @@ impl<C: Cache> ResolverGeneric<C> {
     /// * See [ResolveError]
     pub fn resolve_tsconfig<P: AsRef<Path>>(&self, path: P) -> Result<Arc<C::Tc>, ResolveError> {
         let path = path.as_ref();
-        self.load_tsconfig(true, path, &TsconfigReferences::Auto)
+        self.load_tsconfig(
+            true,
+            path,
+            &TsconfigReferences::Auto,
+            &mut TsconfigResolveContext::default(),
+        )
     }
 
     /// Resolve `specifier` at absolute `path` with [ResolveContext]
@@ -1224,23 +1233,36 @@ impl<C: Cache> ResolverGeneric<C> {
         root: bool,
         path: &Path,
         references: &TsconfigReferences,
+        ctx: &mut TsconfigResolveContext,
     ) -> Result<Arc<C::Tc>, ResolveError> {
         self.cache.get_tsconfig(root, path, |tsconfig| {
             let directory = self.cache.value(tsconfig.directory());
             tracing::trace!(tsconfig = ?tsconfig, "load_tsconfig");
 
+            if ctx.is_already_extended(tsconfig.path()) {
+                return Err(ResolveError::TsconfigCircularExtend(
+                    ctx.get_extended_configs_with(tsconfig.path().to_path_buf()).into(),
+                ));
+            }
+
             // Extend tsconfig
             let extended_tsconfig_paths = tsconfig
                 .extends()
                 .map(|specifier| self.get_extended_tsconfig_path(&directory, tsconfig, specifier))
                 .collect::<Result<Vec<_>, _>>()?;
-            for extended_tsconfig_path in extended_tsconfig_paths {
-                let extended_tsconfig = self.load_tsconfig(
-                    /* root */ false,
-                    &extended_tsconfig_path,
-                    &TsconfigReferences::Disabled,
-                )?;
-                tsconfig.extend_tsconfig(&extended_tsconfig);
+            if !extended_tsconfig_paths.is_empty() {
+                ctx.with_extended_file(tsconfig.path().to_owned(), |ctx| {
+                    for extended_tsconfig_path in extended_tsconfig_paths {
+                        let extended_tsconfig = self.load_tsconfig(
+                            /* root */ false,
+                            &extended_tsconfig_path,
+                            &TsconfigReferences::Disabled,
+                            ctx,
+                        )?;
+                        tsconfig.extend_tsconfig(&extended_tsconfig);
+                    }
+                    Result::Ok::<(), ResolveError>(())
+                })?;
             }
 
             if tsconfig.load_references(references) {
@@ -1280,6 +1302,7 @@ impl<C: Cache> ResolverGeneric<C> {
             /* root */ true,
             &tsconfig_options.config_file,
             &tsconfig_options.references,
+            &mut TsconfigResolveContext::default(),
         )?;
         let paths = tsconfig.resolve(cached_path.path(), specifier);
         for path in paths {
diff --git a/src/tsconfig_context.rs b/src/tsconfig_context.rs
@@ -0,0 +1,26 @@
+use std::path::{Path, PathBuf};
+
+#[derive(Default)]
+pub struct TsconfigResolveContext {
+    extended_configs: Vec<PathBuf>,
+}
+
+impl TsconfigResolveContext {
+    pub fn with_extended_file<R, T: FnOnce(&mut Self) -> R>(&mut self, path: PathBuf, cb: T) -> R {
+        self.extended_configs.push(path);
+        let result = cb(self);
+        self.extended_configs.pop();
+        result
+    }
+
+    pub fn is_already_extended(&self, path: &Path) -> bool {
+        self.extended_configs.iter().any(|config| config == path)
+    }
+
+    pub fn get_extended_configs_with(&self, path: PathBuf) -> Vec<PathBuf> {
+        let mut new_vec = Vec::with_capacity(self.extended_configs.len() + 1);
+        new_vec.extend_from_slice(&self.extended_configs);
+        new_vec.push(path);
+        new_vec
+    }
+}
diff --git a/tests/integration_test.rs b/tests/integration_test.rs
@@ -3,7 +3,7 @@
 use std::{env, path::PathBuf};
 
 use oxc_resolver::{
-    EnforceExtension, FileSystemOs, FsCache, PackageJson, Resolution, ResolveContext,
+    EnforceExtension, FileSystemOs, FsCache, PackageJson, Resolution, ResolveContext, ResolveError,
     ResolveOptions, Resolver,
 };
 
@@ -52,6 +52,39 @@ fn tsconfig() {
     assert_eq!(tsconfig.path, PathBuf::from("./tests/tsconfig.json"));
 }
 
+#[test]
+fn tsconfig_extends_self_reference() {
+    let resolver = Resolver::new(ResolveOptions::default());
+    let err = resolver.resolve_tsconfig("./tests/tsconfig_self_reference.json").unwrap_err();
+    assert_eq!(
+        err,
+        ResolveError::TsconfigCircularExtend(
+            vec![
+                "./tests/tsconfig_self_reference.json".into(),
+                "./tests/tsconfig_self_reference.json".into()
+            ]
+            .into()
+        )
+    );
+}
+
+#[test]
+fn tsconfig_extends_circular_reference() {
+    let resolver = Resolver::new(ResolveOptions::default());
+    let err = resolver.resolve_tsconfig("./tests/tsconfig_circular_reference_a.json").unwrap_err();
+    assert_eq!(
+        err,
+        ResolveError::TsconfigCircularExtend(
+            vec![
+                "./tests/tsconfig_circular_reference_a.json".into(),
+                "./tests/tsconfig_circular_reference_b.json".into(),
+                "./tests/tsconfig_circular_reference_a.json".into(),
+            ]
+            .into()
+        )
+    );
+}
+
 #[cfg(feature = "package_json_raw_json_api")]
 #[test]
 fn package_json_raw_json_api() {
diff --git a/tests/tsconfig_circular_reference_a.json b/tests/tsconfig_circular_reference_a.json
@@ -0,0 +1,3 @@
+{
+  "extends": "./tsconfig_circular_reference_b.json"
+}
diff --git a/tests/tsconfig_circular_reference_b.json b/tests/tsconfig_circular_reference_b.json
@@ -0,0 +1,3 @@
+{
+  "extends": "./tsconfig_circular_reference_a.json"
+}
diff --git a/tests/tsconfig_self_reference.json b/tests/tsconfig_self_reference.json
@@ -0,0 +1,3 @@
+{
+  "extends": "./tsconfig_self_reference.json"
+}

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+{`
	`2`	`+ "extends": "./tsconfig_circular_reference_b.json"`
	`3`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+{`
	`2`	`+ "extends": "./tsconfig_self_reference.json"`
	`3`	`+}`