fix: preserve config paths for aliased lint targets

Author: fansenze

cmd/rslint/api.go

@@ -15,6 +15,7 @@ import (
 	"github.com/microsoft/typescript-go/shim/core"
 	"github.com/microsoft/typescript-go/shim/scanner"
 	"github.com/microsoft/typescript-go/shim/tspath"
+	"github.com/microsoft/typescript-go/shim/vfs"
 	"github.com/microsoft/typescript-go/shim/vfs/cachedvfs"
 	"github.com/microsoft/typescript-go/shim/vfs/osvfs"
 	api "github.com/web-infra-dev/rslint/internal/api"
@@ -87,17 +88,16 @@ func (h *IPCHandler) HandleLint(req api.LintRequest) (*api.LintResponse, error)
 		}
 	}
 	// Apply file contents if provided
+	var fileContents map[string]string
 	if len(req.FileContents) > 0 {
 		if allowedFiles == nil {
 			allowedFiles = make([]string, 0, len(req.FileContents))
 		}
-		fileContents := make(map[string]string, len(req.FileContents))
+		fileContents = make(map[string]string, len(req.FileContents))
 		for k, v := range req.FileContents {
 			normalizedPath := addAllowedFile(k)
 			fileContents[normalizedPath] = v
 		}
-		fs = utils.NewOverlayVFS(fs, fileContents)
-
 	}
 
 	// Initialize rule registry with all available rules
@@ -121,6 +121,10 @@ func (h *IPCHandler) HandleLint(req api.LintRequest) (*api.LintResponse, error)
 		configDirectory = currentDirectory
 	}
 	configDirectory = tspath.NormalizePath(configDirectory)
+	if len(fileContents) > 0 {
+		addEquivalentFileContentPaths(fileContents, configDirectory, currentDirectory, fs)
+		fs = utils.NewOverlayVFS(fs, fileContents)
+	}
 	var gitignoreGlobs []string
 	if len(allowedFiles) > 0 {
 		gitignoreGlobs = rslintconfig.ReadGitignoreAsGlobsForFiles(configDirectory, fs, allowedFiles)
@@ -166,10 +170,10 @@ func (h *IPCHandler) HandleLint(req api.LintRequest) (*api.LintResponse, error)
 	// list).
 	// The --api path never runs the type-check phase (RunLinterOptions.TypeCheck
 	// stays false), so there is no per-program type-check skip mask to build.
-	programs, typeInfoFiles, _, _, targetsByProgram := buildProgramsWithLintTargets(
+	programs, typeInfoFiles, _, _, targetsByProgram, configPathBySourcePath := buildProgramsWithLintTargets(
 		programs, nil, rslintConfig, configDirectory, nil, nil, fs, allowedFiles, nil, parseCache, false,
 	)
-	fileConfigResolver := rslintconfig.NewFileConfigResolver(rslintConfig, configDirectory, true)
+	fileConfigResolver := newLintConfigResolver(nil, rslintConfig, configDirectory, true, typeInfoFiles, configPathBySourcePath)
 
 	// Collect diagnostics and source files
 	var diagnostics []api.Diagnostic
@@ -337,7 +341,7 @@ func (h *IPCHandler) HandleLint(req api.LintRequest) (*api.LintResponse, error)
 			// so a rule carrying a plugin prefix runs only when its plugin is
 			// declared in the config's `plugins` — matching CLI and ESLint
 			// semantics (a rule whose plugin is not declared is skipped).
-			return fileConfigResolver.ActiveRulesForFile(sourceFile.FileName(), typeInfoFiles)
+			return fileConfigResolver.ActiveRulesForFile(sourceFile.FileName())
 		},
 		OnDiagnostic: diagnosticCollector,
 	})
@@ -435,6 +439,56 @@ func (h *IPCHandler) HandleLint(req api.LintRequest) (*api.LintResponse, error)
 	return response, nil
 }
 
+func addEquivalentFileContentPaths(fileContents map[string]string, configDirectory string, currentDirectory string, fs vfs.FS) {
+	if len(fileContents) == 0 || fs == nil {
+		return
+	}
+
+	type fileContentEntry struct {
+		path    string
+		content string
+	}
+	entries := make([]fileContentEntry, 0, len(fileContents))
+	for filePath, content := range fileContents {
+		entries = append(entries, fileContentEntry{path: filePath, content: content})
+	}
+
+	comparePathOptions := tspath.ComparePathsOptions{
+		CurrentDirectory:          currentDirectory,
+		UseCaseSensitiveFileNames: fs.UseCaseSensitiveFileNames(),
+	}
+	addAlias := func(alias string, content string) {
+		if alias == "" {
+			return
+		}
+		if _, exists := fileContents[alias]; exists {
+			return
+		}
+		fileContents[alias] = content
+	}
+	addDirectoryAlias := func(fromDir string, toDir string, filePath string, content string) {
+		if fromDir == "" || toDir == "" || !tspath.ContainsPath(fromDir, filePath, comparePathOptions) {
+			return
+		}
+		relativePath := tspath.GetRelativePathFromDirectory(fromDir, filePath, comparePathOptions)
+		if relativePath == "" {
+			return
+		}
+		addAlias(tspath.ResolvePath(toDir, relativePath), content)
+	}
+
+	realConfigDirectory := fs.Realpath(configDirectory)
+	for _, entry := range entries {
+		if realPath := fs.Realpath(entry.path); realPath != "" && realPath != entry.path {
+			addAlias(realPath, entry.content)
+		}
+		if realConfigDirectory != "" && tspath.ComparePaths(configDirectory, realConfigDirectory, comparePathOptions) != 0 {
+			addDirectoryAlias(configDirectory, realConfigDirectory, entry.path, entry.content)
+			addDirectoryAlias(realConfigDirectory, configDirectory, entry.path, entry.content)
+		}
+	}
+}
+
 // HandleGetAstInfo handles get AST info requests in IPC mode
 func (h *IPCHandler) HandleGetAstInfo(req api.GetAstInfoRequest) (*api.GetAstInfoResponse, error) {
 	// Fixed user file name for program creation

cmd/rslint/api_test.go

@@ -635,6 +635,51 @@ func TestHandleLint_NoConfigEnablesNoRules(t *testing.T) {
 	}
 }
 
+func TestHandleLint_FileContentsKeepTypeInfoWhenProgramUsesSymlinkSource(t *testing.T) {
+	realDir := t.TempDir()
+	linkDir := filepath.Join(filepath.Dir(realDir), filepath.Base(realDir)+"-link")
+	if err := os.Symlink(realDir, linkDir); err != nil {
+		t.Skipf("symlink unavailable: %v", err)
+	}
+	defer os.Remove(linkDir)
+
+	srcDir := filepath.Join(realDir, "src")
+	if err := os.MkdirAll(srcDir, 0o755); err != nil {
+		t.Fatalf("mkdir src: %v", err)
+	}
+	if err := os.WriteFile(filepath.Join(srcDir, "a.ts"), []byte("const clean = 1;\n"), 0o644); err != nil {
+		t.Fatalf("write source: %v", err)
+	}
+	if err := os.WriteFile(filepath.Join(realDir, "tsconfig.json"), []byte(`{"include":["src/a.ts"]}`), 0o644); err != nil {
+		t.Fatalf("write tsconfig: %v", err)
+	}
+
+	config := json.RawMessage(`[{
+		"languageOptions": { "parserOptions": { "project": ["./tsconfig.json"] } },
+		"plugins": ["@typescript-eslint"],
+		"rules": { "@typescript-eslint/no-unsafe-member-access": "error" }
+	}]`)
+	realTarget := filepath.Join(realDir, "src", "a.ts")
+
+	handler := &IPCHandler{}
+	response, err := handler.HandleLint(api.LintRequest{
+		Config:           config,
+		ConfigDirectory:  linkDir,
+		WorkingDirectory: linkDir,
+		Files:            []string{realTarget},
+		FileContents:     map[string]string{realTarget: "let b: any = 10;\nb.c = 20;\n"},
+	})
+	if err != nil {
+		t.Fatalf("HandleLint returned error: %v", err)
+	}
+	if len(response.Diagnostics) != 1 {
+		t.Fatalf("expected one type-aware overlay diagnostic, got %d: %+v", len(response.Diagnostics), response.Diagnostics)
+	}
+	if got := response.Diagnostics[0].RuleName; got != "@typescript-eslint/no-unsafe-member-access" {
+		t.Fatalf("expected no-unsafe-member-access diagnostic from typed overlay content, got %q", got)
+	}
+}
+
 // scenario b (in-memory file命门): a requested file outside every tsconfig
 // Program (a "gap" file) must still be linted by non-type-aware rules via the
 // fallback Program — it must NOT be silently skipped with 0 diagnostics.

cmd/rslint/cmd.go

@@ -1203,7 +1203,7 @@ func executeLintPipeline(args lintArgs, ctx context.Context, dispatch linter.Esl
 	// then bind selected files to existing Programs or an AST-only fallback
 	// Program. Shared with the --api path via buildProgramsWithLintTargets, so
 	// target discovery, fallback creation, and type-aware gating stay aligned.
-	programs, typeInfoFiles, capturedGapFiles, targetFiles, targetsByProgram := buildProgramsWithLintTargets(
+	programs, typeInfoFiles, capturedGapFiles, targetFiles, targetsByProgram, configPathBySourcePath := buildProgramsWithLintTargets(
 		programs,
 		targetConfigMap,
 		targetRslintConfig,
@@ -1285,6 +1285,7 @@ func executeLintPipeline(args lintArgs, ctx context.Context, dispatch linter.Esl
 		currentDirectory,
 		enforcePlugins,
 		typeInfoFiles,
+		configPathBySourcePath,
 	)
 	getRulesForFile := func(sourceFile *ast.SourceFile) []linter.ConfiguredRule {
 		return fileConfigResolver.ActiveRulesForFile(sourceFile.FileName())
@@ -1413,24 +1414,43 @@ func executeLintPipeline(args lintArgs, ctx context.Context, dispatch linter.Esl
 
 			// Re-lint: collect remaining diagnostics.
 			fixProgramIndex := buildProgramFileIndex(newPrograms, fs, singleThreaded)
-			fixTargetsByProgram := assignLintTargetsToPrograms(newPrograms, targetConfigMap, newProgramConfigDirs, targetFiles, fixProgramIndex)
+			fixTargetsByProgram, fixConfigPathBySourcePath := assignLintTargetsToPrograms(newPrograms, targetConfigMap, newProgramConfigDirs, targetFiles, fixProgramIndex, fs)
 			fixSkipMask := buildTypeCheckSkipMask(newPrograms)
+			fixTypeInfoFiles := buildTypeInfoFilesForPrograms(newPrograms, fixSkipMask, fs, singleThreaded)
+			fixConfigResolver := newLintConfigResolver(
+				configMap,
+				rslintConfig,
+				currentDirectory,
+				enforcePlugins,
+				fixTypeInfoFiles,
+				fixConfigPathBySourcePath,
+			)
+			fixGetRulesForFile := func(sourceFile *ast.SourceFile) []linter.ConfiguredRule {
+				return fixConfigResolver.ActiveRulesForFile(sourceFile.FileName())
+			}
+			var fixRulesForFile linter.RuleHandler
+			if !typeCheckOnly {
+				fixRulesForFile = fixGetRulesForFile
+			}
+			fixShouldReportLintSyntax := func(filePath string) bool {
+				return fixConfigResolver.ConfigForFile(filePath) != nil
+			}
 			var passDiags []rule.RuleDiagnostic
 			passDiags = append(passDiags, collectTargetSyntacticDiagnostics(
 				newPrograms,
 				fixTargetsByProgram,
 				fixSkipMask,
 				typeCheck,
 				typeCheckOnly,
-				shouldReportLintSyntax,
+				fixShouldReportLintSyntax,
 			)...)
 			fixRunOpts := linter.RunLinterOptions{
 				Programs:              newPrograms,
 				SingleThreaded:        singleThreaded,
 				Scope:                 linter.FileScope{Files: allowFiles, Dirs: allowDirs},
 				TargetFiles:           fixTargetsByProgram,
-				GetRulesForFile:       getRulesForFile,
-				TypeInfoFiles:         typeInfoFiles,
+				GetRulesForFile:       fixRulesForFile,
+				TypeInfoFiles:         fixTypeInfoFiles,
 				TypeCheck:             typeCheck,
 				SkipTypeCheckPrograms: fixSkipMask,
 				OnDiagnostic: func(d rule.RuleDiagnostic) {
@@ -1444,7 +1464,10 @@ func executeLintPipeline(args lintArgs, ctx context.Context, dispatch linter.Esl
 			// plugin diagnostics from being lost when allDiags is replaced.
 			var fixPluginCh <-chan []rule.RuleDiagnostic
 			if hasEslintPlugins {
-				fixPluginInputs := buildPluginFileInputs(fixRunOpts, pluginResolver)
+				fixPluginInputs := buildPluginFileInputs(fixRunOpts, pluginConfigResolver{
+					lintResolver:      fixConfigResolver,
+					originalConfigDir: originalConfigDir,
+				})
 				fixPluginCh = dispatchPluginLintAsync(ctx, dispatch, fixPluginInputs, fix, pluginSuggestionsMode(fix))
 			}
 			passResult, _ := linter.RunLinter(fixRunOpts)

cmd/rslint/cmd_test.go

@@ -1119,7 +1119,7 @@ func TestCLIRuleOverlayDoesNotWidenTargetDiscovery(t *testing.T) {
 	if exitCode != 0 {
 		t.Fatalf("createProgramsForConfig exit code = %d", exitCode)
 	}
-	programs, typeInfoFiles, _, targetFiles, targetsByProgram := buildProgramsWithLintTargets(
+	programs, typeInfoFiles, _, targetFiles, targetsByProgram, _ := buildProgramsWithLintTargets(
 		programs, nil, targetConfig, dir, nil, nil, fs, nil, []string{tspath.NormalizePath(dir)}, parseCache, true,
 	)
 	if len(targetFiles) != 1 || !strings.HasSuffix(targetFiles[0], "/a.ts") {

cmd/rslint/eslint_plugin.go

@@ -29,15 +29,16 @@ func (r pluginConfigResolver) resolve(filePath string) (wireKey string, merged *
 	if r.lintResolver == nil {
 		return "", nil
 	}
-	cfgDir, resolver, ok := r.lintResolver.resolverForFile(filePath)
+	configPath := r.lintResolver.configPathFor(filePath)
+	cfgDir, resolver, ok := r.lintResolver.resolverForFile(configPath)
 	if !ok {
 		return "", nil
 	}
 	wireKey = cfgDir
 	if raw, ok := r.originalConfigDir[cfgDir]; ok {
 		wireKey = raw
 	}
-	return wireKey, resolver.ConfigForFile(filePath)
+	return wireKey, resolver.ConfigForFile(configPath)
 }
 
 // buildPluginFileInputs collects, from RunLinter's lint targets, the files that

cmd/rslint/eslint_plugin_test.go

@@ -28,7 +28,7 @@ func TestPluginConfigResolver_NormalizedMatchRawWireKey(t *testing.T) {
 
 	// Windows: file matches on the normalized key, wire key is the RAW string.
 	r := pluginConfigResolver{
-		lintResolver:      newLintConfigResolver(p.ConfigMap, nil, "", false, nil),
+		lintResolver:      newLintConfigResolver(p.ConfigMap, nil, "", false, nil, nil),
 		originalConfigDir: p.OriginalConfigDir,
 	}
 	wireKey, merged := r.resolve(norm + "/src/a.ts")
@@ -47,6 +47,7 @@ func TestPluginConfigResolver_NormalizedMatchRawWireKey(t *testing.T) {
 			"",
 			false,
 			nil,
+			nil,
 		),
 	}
 	if wk, m := posix.resolve("/posix/proj/a.ts"); wk != "/posix/proj" || m == nil {
@@ -120,7 +121,7 @@ func TestPluginConfigResolver_Branches(t *testing.T) {
 
 	// Multi-config, file under no config -> ("", nil).
 	r := pluginConfigResolver{
-		lintResolver:      newLintConfigResolver(p.ConfigMap, nil, "", false, nil),
+		lintResolver:      newLintConfigResolver(p.ConfigMap, nil, "", false, nil, nil),
 		originalConfigDir: p.OriginalConfigDir,
 	}
 	if wk, m := r.resolve("/elsewhere/a.ts"); wk != "" || m != nil {
@@ -129,7 +130,7 @@ func TestPluginConfigResolver_Branches(t *testing.T) {
 
 	// Single-config (configMap==nil): wireKey is currentDirectory; merged from rslintConfig.
 	single := pluginConfigResolver{
-		lintResolver: newLintConfigResolver(nil, p.ConfigMap["/proj"], "/proj", false, nil),
+		lintResolver: newLintConfigResolver(nil, p.ConfigMap["/proj"], "/proj", false, nil, nil),
 	}
 	if wk, m := single.resolve("/proj/a.ts"); wk != "/proj" || m == nil {
 		t.Errorf("single-config -> (currentDirectory, merged), got (%q, nil=%v)", wk, m == nil)
@@ -155,7 +156,7 @@ func TestLintConfigResolver_NearestConfigAndTypeInfoGate(t *testing.T) {
 	typeInfoFiles := map[string]struct{}{
 		"/repo/packages/app/src/typed.ts": {},
 	}
-	resolver := newLintConfigResolver(configMap, nil, "", false, typeInfoFiles)
+	resolver := newLintConfigResolver(configMap, nil, "", false, typeInfoFiles, nil)
 
 	gapRules := configuredRuleNameSet(resolver.ActiveRulesForFile("/repo/packages/app/src/gap.ts"))
 	if gapRules["@typescript-eslint/require-await"] {
@@ -183,6 +184,39 @@ func TestLintConfigResolver_NearestConfigAndTypeInfoGate(t *testing.T) {
 	}
 }
 
+func TestLintConfigResolver_UsesConfigPathAliasForRulesAndGlobals(t *testing.T) {
+	rslintconfig.RegisterAllRules()
+
+	cfg := rslintconfig.RslintConfig{{
+		Files: []string{"src/**/*.ts"},
+		LanguageOptions: &rslintconfig.LanguageOptions{Raw: map[string]any{
+			"globals": map[string]any{
+				"aliasedGlobal": "readonly",
+			},
+		}},
+		Rules: rslintconfig.Rules{"no-console": "error"},
+	}}
+	resolver := newLintConfigResolver(
+		nil,
+		cfg,
+		"/repo",
+		false,
+		map[string]struct{}{"/outside/real-a.ts": {}},
+		map[string]string{"/outside/real-a.ts": "/repo/src/a.ts"},
+	)
+
+	rules := resolver.ActiveRulesForFile("/outside/real-a.ts")
+	if len(rules) != 1 || rules[0].Name != "no-console" {
+		t.Fatalf("expected aliased source path to use config path rules, got %v", configuredRuleNameSet(rules))
+	}
+	if !rules[0].Globals["aliasedGlobal"] {
+		t.Fatalf("expected aliased source path to carry globals from config path")
+	}
+	if resolver.ConfigForFile("/outside/real-a.ts") == nil {
+		t.Fatalf("expected aliased source path to resolve merged config")
+	}
+}
+
 func configuredRuleNameSet(rules []linter.ConfiguredRule) map[string]bool {
 	names := make(map[string]bool, len(rules))
 	for _, r := range rules {