feat: implement prefer-nullish-coalescing TypeScript rule

AGENTS.md

@@ -61,3 +61,12 @@ This document summarizes how to work on rslint effectively and consistently.
 - Icons: use `lucide-react` for consistent iconography (e.g., import `{ Share2Icon, CheckIcon } from 'lucide-react'`).
 - Keep layout simple: compose shadcn primitives and flex utilities for alignment instead of bespoke CSS blocks.
 - Only add custom CSS for domain‑specific visuals that primitives can’t express (e.g., AST tree expanders), and keep it scoped.
+
+## Submodule Policy: typescript-go (DO NOT EDIT)
+
+- Never edit files inside the `typescript-go/` directory directly. It is a Git submodule that tracks the upstream TypeScript-Go shim.
+- If behavior changes are required, prefer upstreaming fixes or using our patch script rather than local edits.
+  - Keep the submodule commit pinned to match the commit used on `upstream/main` unless the change is intentional.
+  - To sync: `git submodule update --init --recursive` and verify `git ls-tree HEAD typescript-go` matches `git ls-tree upstream/main typescript-go`.
+  - To apply our maintained patches, run: `./scripts/apply-tsgo-patch.sh` after updating the submodule.
+  - Do not commit arbitrary changes inside `typescript-go/`; any modifications must come from submodule updates or scripted patches.

cmd/rslint/api.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"os"
 	"sync"
+    "strings"
 
 	"github.com/microsoft/typescript-go/shim/ast"
 	"github.com/microsoft/typescript-go/shim/bundled"
@@ -43,73 +44,121 @@ func (h *IPCHandler) HandleLint(req api.LintRequest) (*api.LintResponse, error)
 	}
 	currentDirectory = tspath.NormalizePath(currentDirectory)
 
-	// Create filesystem
-	fs := bundled.WrapFS(cachedvfs.From(osvfs.FS()))
-	allowedFiles := []string{}
-	// Apply file contents if provided
-	if len(req.FileContents) > 0 {
-		fileContents := make(map[string]string, len(req.FileContents))
-		for k, v := range req.FileContents {
-			normalizePath := tspath.NormalizePath(k)
-			fileContents[normalizePath] = v
-			allowedFiles = append(allowedFiles, normalizePath)
-		}
-		fs = utils.NewOverlayVFS(fs, fileContents)
-
-	}
+    // Create filesystem
+    fs := bundled.WrapFS(cachedvfs.From(osvfs.FS()))
+    allowedFiles := []string{}
+    // Apply file contents if provided (support remapping to tsconfigRootDir when specified)
+    if len(req.FileContents) > 0 {
+        fileContents := make(map[string]string, len(req.FileContents))
+        var remapRoot string
+        if req.LanguageOptions != nil && req.LanguageOptions.ParserOptions != nil && req.LanguageOptions.ParserOptions.TsconfigRootDir != "" {
+            remapRoot = tspath.ResolvePath(currentDirectory, req.LanguageOptions.ParserOptions.TsconfigRootDir)
+        }
+        for k, v := range req.FileContents {
+            original := tspath.NormalizePath(k)
+            target := original
+            if remapRoot != "" {
+                // Remap to tsconfigRootDir while preserving the file name
+                base := tspath.GetBaseFileName(original)
+                target = tspath.ResolvePath(remapRoot, base)
+            }
+            fileContents[target] = v
+            allowedFiles = append(allowedFiles, target)
+        }
+        fs = utils.NewOverlayVFS(fs, fileContents)
+    }
 
 	// Initialize rule registry with all available rules
 	rslintconfig.RegisterAllRules()
 
-	// Load rslint configuration and determine which tsconfig files to use
-	rslintConfig, tsConfigs, configDirectory := rslintconfig.LoadConfigurationWithFallback(req.Config, currentDirectory, fs)
-
-	// Merge languageOptions from request with config file if provided
-	if req.LanguageOptions != nil && len(rslintConfig) > 0 {
-		// Convert API LanguageOptions to config LanguageOptions
-		configLanguageOptions := &rslintconfig.LanguageOptions{}
-		if req.LanguageOptions.ParserOptions != nil {
-			configLanguageOptions.ParserOptions = &rslintconfig.ParserOptions{
-				ProjectService: req.LanguageOptions.ParserOptions.ProjectService,
-				Project:        rslintconfig.ProjectPaths(req.LanguageOptions.ParserOptions.Project),
-			}
-		}
-
-		// Override languageOptions for the first config entry
-		rslintConfig[0].LanguageOptions = configLanguageOptions
-
-		// Re-extract tsconfig files with updated languageOptions
-		overrideTsconfigs := []string{}
-		for _, entry := range rslintConfig {
-			if entry.LanguageOptions != nil && entry.LanguageOptions.ParserOptions != nil {
-				for _, config := range entry.LanguageOptions.ParserOptions.Project {
-					tsconfigPath := tspath.ResolvePath(configDirectory, config)
-					if fs.FileExists(tsconfigPath) {
-						overrideTsconfigs = append(overrideTsconfigs, tsconfigPath)
-					}
-				}
-			}
-		}
-		if len(overrideTsconfigs) > 0 {
-			tsConfigs = overrideTsconfigs
-		}
-	}
+    // Load rslint configuration and determine which tsconfig files to use
+    rslintConfig, tsConfigs, configDirectory := rslintconfig.LoadConfigurationWithFallback(req.Config, currentDirectory, fs)
+
+    // Merge languageOptions from request with config file if provided
+    if req.LanguageOptions != nil && len(rslintConfig) > 0 {
+        // Merge into existing languageOptions rather than replacing wholesale
+        var baseLang *rslintconfig.LanguageOptions
+        if len(rslintConfig) > 0 && rslintConfig[0].LanguageOptions != nil {
+            baseLang = rslintConfig[0].LanguageOptions
+        } else {
+            baseLang = &rslintconfig.LanguageOptions{}
+        }
+        if baseLang.ParserOptions == nil {
+            baseLang.ParserOptions = &rslintconfig.ParserOptions{}
+        }
+        if req.LanguageOptions.ParserOptions != nil {
+            baseLang.ParserOptions.ProjectService = req.LanguageOptions.ParserOptions.ProjectService
+            // Only override project paths if present on the request; otherwise keep config file values
+            if len(req.LanguageOptions.ParserOptions.Project) > 0 {
+                baseLang.ParserOptions.Project = rslintconfig.ProjectPaths(req.LanguageOptions.ParserOptions.Project)
+            }
+        }
+        // Write back merged options
+        rslintConfig[0].LanguageOptions = baseLang
+
+        // If a tsconfigRootDir is provided, override the configDirectory used to resolve tsconfigs
+        if req.LanguageOptions.ParserOptions != nil && req.LanguageOptions.ParserOptions.TsconfigRootDir != "" {
+            // Resolve relative to current working directory
+            configDirectory = tspath.ResolvePath(currentDirectory, req.LanguageOptions.ParserOptions.TsconfigRootDir)
+        }
+
+        // Re-extract tsconfig files with the possibly-updated languageOptions and/or configDirectory
+        // Prefer explicit project entries from the (possibly overridden) config entry above.
+        recomputedTsConfigs := []string{}
+        for _, entry := range rslintConfig {
+            if entry.LanguageOptions == nil || entry.LanguageOptions.ParserOptions == nil {
+                continue
+            }
+            for _, cfg := range entry.LanguageOptions.ParserOptions.Project {
+                tsconfigPath := tspath.ResolvePath(configDirectory, cfg)
+                if fs.FileExists(tsconfigPath) {
+                    recomputedTsConfigs = append(recomputedTsConfigs, tsconfigPath)
+                }
+            }
+        }
+        if len(recomputedTsConfigs) > 0 {
+            tsConfigs = recomputedTsConfigs
+        }
+    }
 	type RuleWithOption struct {
 		rule   rule.Rule
 		option interface{}
 	}
-	rulesWithOptions := []RuleWithOption{}
-	// filter rule based on request.RuleOptions
-	if len(req.RuleOptions) > 0 {
-		for _, r := range rslintconfig.GlobalRuleRegistry.GetAllRules() {
-			if option, ok := req.RuleOptions[r.Name]; ok {
-				rulesWithOptions = append(rulesWithOptions, RuleWithOption{
-					rule:   r,
-					option: option,
-				})
-			}
-		}
-	}
+    rulesWithOptions := []RuleWithOption{}
+    // filter rule based on request.RuleOptions (accept both prefixed and unprefixed names)
+    if len(req.RuleOptions) > 0 {
+        for _, r := range rslintconfig.GlobalRuleRegistry.GetAllRules() {
+            // Build candidate keys to match more flexibly
+            name := r.Name // may already be prefixed (e.g., @typescript-eslint/xxx)
+            unprefixed := name
+            if strings.HasPrefix(name, "@typescript-eslint/") {
+                unprefixed = strings.TrimPrefix(name, "@typescript-eslint/")
+            }
+            prefixed := name
+            if !strings.HasPrefix(name, "@typescript-eslint/") {
+                prefixed = "@typescript-eslint/" + name
+            }
+
+            var (
+                option interface{}
+                ok bool
+            )
+            // Try exact name first
+            if option, ok = req.RuleOptions[name]; !ok {
+                // Try prefixed form
+                if option, ok = req.RuleOptions[prefixed]; !ok {
+                    // Try unprefixed form
+                    option, ok = req.RuleOptions[unprefixed]
+                }
+            }
+            if ok {
+                rulesWithOptions = append(rulesWithOptions, RuleWithOption{
+                    rule:   r,
+                    option: option,
+                })
+            }
+        }
+    }
 
 	// Create compiler host
 	host := utils.CreateCompilerHost(configDirectory, fs)

internal/api/api.go

@@ -99,8 +99,10 @@ func (p *ProjectPaths) UnmarshalJSON(data []byte) error {
 
 // ParserOptions contains parser-specific configuration
 type ParserOptions struct {
-	ProjectService bool         `json:"projectService"`
-	Project        ProjectPaths `json:"project,omitempty"`
+    ProjectService bool         `json:"projectService"`
+    Project        ProjectPaths `json:"project,omitempty"`
+    // Optional root directory to resolve tsconfig paths against (matches @typescript-eslint tests)
+    TsconfigRootDir string      `json:"tsconfigRootDir,omitempty"`
 }
 type ByteArray []byte
 

internal/config/config.go

@@ -49,6 +49,7 @@ import (
 	"github.com/web-infra-dev/rslint/internal/plugins/typescript/rules/non_nullable_type_assertion_style"
 	"github.com/web-infra-dev/rslint/internal/plugins/typescript/rules/only_throw_error"
 	"github.com/web-infra-dev/rslint/internal/plugins/typescript/rules/prefer_as_const"
+	"github.com/web-infra-dev/rslint/internal/plugins/typescript/rules/prefer_nullish_coalescing"
 	"github.com/web-infra-dev/rslint/internal/plugins/typescript/rules/prefer_promise_reject_errors"
 	"github.com/web-infra-dev/rslint/internal/plugins/typescript/rules/prefer_reduce_type_parameter"
 	"github.com/web-infra-dev/rslint/internal/plugins/typescript/rules/prefer_return_this_type"
@@ -370,6 +371,7 @@ func registerAllTypeScriptEslintPluginRules() {
 	GlobalRuleRegistry.Register("@typescript-eslint/non-nullable-type-assertion-style", non_nullable_type_assertion_style.NonNullableTypeAssertionStyleRule)
 	GlobalRuleRegistry.Register("@typescript-eslint/only-throw-error", only_throw_error.OnlyThrowErrorRule)
 	GlobalRuleRegistry.Register("@typescript-eslint/prefer-as-const", prefer_as_const.PreferAsConstRule)
+	GlobalRuleRegistry.Register("@typescript-eslint/prefer-nullish-coalescing", prefer_nullish_coalescing.PreferNullishCoalescingRule)
 	GlobalRuleRegistry.Register("@typescript-eslint/prefer-promise-reject-errors", prefer_promise_reject_errors.PreferPromiseRejectErrorsRule)
 	GlobalRuleRegistry.Register("@typescript-eslint/prefer-reduce-type-parameter", prefer_reduce_type_parameter.PreferReduceTypeParameterRule)
 	GlobalRuleRegistry.Register("@typescript-eslint/prefer-return-this-type", prefer_return_this_type.PreferReturnThisTypeRule)

internal/plugins/typescript/rules/no_unnecessary_type_assertion/no_unnecessary_type_assertion.go

@@ -266,11 +266,31 @@ var NoUnnecessaryTypeAssertionRule = rule.CreateRule(rule.Rule{
 
 				t := utils.GetConstrainedTypeAtLocation(ctx.TypeChecker, expression)
 
+				// Special-case: when a non-null assertion appears within a JSX attribute initializer,
+				// do not mark it as unnecessary if the original expression type includes null/undefined.
+				// JSX attribute contextual typing can mask nullish constituents, but semantically the
+				// assertion is often required to satisfy the attribute's declared type.
+				isInJsxAttribute := func(n *ast.Node) bool {
+					for p := n.Parent; p != nil; p = p.Parent {
+						if p.Kind == ast.KindJsxAttribute {
+							return true
+						}
+					}
+					return false
+				}
+
 				var tFlags checker.TypeFlags
 				for _, part := range utils.UnionTypeParts(t) {
 					tFlags |= checker.Type_flags(part)
 				}
 
+				// In JSX attribute initializers, treat non-null assertions as necessary when the
+				// operand type can be null. Undefined alone is allowed for optional attributes,
+				// so do not suppress on undefined-only unions.
+				if isInJsxAttribute(node) && (tFlags&checker.TypeFlagsNull) != 0 {
+					return
+				}
+
 				if tFlags&(checker.TypeFlagsAny|checker.TypeFlagsUnknown|
 					checker.TypeFlagsNull|
 					checker.TypeFlagsUndefined|