fix: prevent deadlock on tsconfig extends cycle by bypassing cache when cycle detected

When a tsconfig extends cycle is present (e.g., base.json extends itself),
the ExtendedConfigCache would deadlock because the same goroutine tried to
re-lock a mutex it already held. The fix checks the resolutionStack before
entering the cache - if the file is already in the stack, it bypasses the
cache and lets parseConfig handle the circularity error normally.

Agent-Logs-Url: https://github.com/microsoft/typescript-go/sessions/c02ab152-7feb-4028-b517-64facd33ddf4

Co-authored-by: jakebailey <5341706+jakebailey@users.noreply.github.com>

Author: Copilot

internal/execute/tsc/extendedconfigcache_test.go

@@ -0,0 +1,75 @@
+package tsc_test
+
+import (
+	"testing"
+
+	"github.com/microsoft/typescript-go/internal/execute/tsc"
+	"github.com/microsoft/typescript-go/internal/tsoptions"
+	"github.com/microsoft/typescript-go/internal/vfs"
+	"github.com/microsoft/typescript-go/internal/vfs/vfstest"
+)
+
+type testParseConfigHost struct {
+	fs  vfs.FS
+	cwd string
+}
+
+func (h *testParseConfigHost) FS() vfs.FS                 { return h.fs }
+func (h *testParseConfigHost) GetCurrentDirectory() string { return h.cwd }
+
+func TestExtendedConfigCacheExtendsCircularity(t *testing.T) {
+	t.Parallel()
+
+	t.Run("self-referencing extends", func(t *testing.T) {
+		t.Parallel()
+
+		// Regression test: a tsconfig extends cycle should produce an error,
+		// not a deadlock when using the tsc ExtendedConfigCache.
+		files := map[string]any{
+			"/project/tsconfig.json": `{"extends": "./base.json"}`,
+			"/project/base.json":    `{"extends": "./base.json"}`,
+			"/project/main.ts":      `// Hello World!`,
+		}
+
+		fs := vfstest.FromMap(files, false /*useCaseSensitiveFileNames*/)
+		host := &testParseConfigHost{fs: fs, cwd: "/project"}
+		cache := &tsc.ExtendedConfigCache{}
+
+		cmd, _ := tsoptions.GetParsedCommandLineOfConfigFile("/project/tsconfig.json", nil, nil, host, cache)
+		if cmd == nil {
+			t.Fatal("expected non-nil ParsedCommandLine")
+		}
+		assertHasCircularityDiagnostic(t, cmd)
+	})
+
+	t.Run("mutual extends cycle", func(t *testing.T) {
+		t.Parallel()
+
+		// Two config files that extend each other.
+		files := map[string]any{
+			"/project/tsconfig.json": `{"extends": "./other.json"}`,
+			"/project/other.json":    `{"extends": "./tsconfig.json"}`,
+			"/project/main.ts":       `// Hello World!`,
+		}
+
+		fs := vfstest.FromMap(files, false /*useCaseSensitiveFileNames*/)
+		host := &testParseConfigHost{fs: fs, cwd: "/project"}
+		cache := &tsc.ExtendedConfigCache{}
+
+		cmd, _ := tsoptions.GetParsedCommandLineOfConfigFile("/project/tsconfig.json", nil, nil, host, cache)
+		if cmd == nil {
+			t.Fatal("expected non-nil ParsedCommandLine")
+		}
+		assertHasCircularityDiagnostic(t, cmd)
+	})
+}
+
+func assertHasCircularityDiagnostic(t *testing.T, cmd *tsoptions.ParsedCommandLine) {
+	t.Helper()
+	for _, d := range cmd.Errors {
+		if d != nil && d.Code() == 18000 {
+			return
+		}
+	}
+	t.Error("expected circularity diagnostic (code 18000), but none was found")
+}

internal/tsoptions/tsconfigparsing.go

@@ -971,7 +971,11 @@ func getExtendedConfig(
 	extendedConfigPath := tspath.ToPath(extendedConfigFileName, host.GetCurrentDirectory(), host.FS().UseCaseSensitiveFileNames())
 
 	var cacheEntry *ExtendedConfigCacheEntry
-	if extendedConfigCache != nil {
+	// Bypass the cache when we detect a cycle in the resolution stack.
+	// The cache locks entries during parsing, and a cycle would cause the same goroutine
+	// to re-lock the same entry, resulting in a deadlock. Let parseConfig handle the
+	// circularity error via its own resolution stack check.
+	if extendedConfigCache != nil && !slices.Contains(resolutionStack, extendedConfigFileName) {
 		cacheEntry = extendedConfigCache.GetExtendedConfig(extendedConfigFileName, extendedConfigPath, resolutionStack, host)
 	} else {
 		cacheEntry = ParseExtendedConfig(extendedConfigFileName, extendedConfigPath, resolutionStack, host, extendedConfigCache)