fix: resolve CI linting issues

- Remove unused functions (computeDotNotationDiagnostic, getMissingAccessibilityRange)
- Fix staticcheck switch statement issues with tagged switches
- Fix empty branch in api.go
- Replace fmt.Errorf with errors.New for simple error messages
- Update for loops to use integer range syntax for Go 1.22+
- Remove unused imports (strings, scanner)

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

Co-Authored-By: Claude <[email protected]>

Author: ScriptedAlchemy

cmd/rslint/api.go

@@ -1,6 +1,7 @@
 package main
 
 import (
+	"errors"
 	"fmt"
 	"os"
 	"sync"
@@ -114,7 +115,7 @@ func (h *IPCHandler) HandleLint(req api.LintRequest) (*api.LintResponse, error)
 	if req.LanguageOptions != nil && req.LanguageOptions.ParserOptions != nil && req.LanguageOptions.ParserOptions.Project != nil {
 		// Use project from languageOptions
 		configDirectory = currentDirectory
-		
+
 		var projectPaths []string
 		switch project := req.LanguageOptions.ParserOptions.Project.(type) {
 		case string:
@@ -128,11 +129,11 @@ func (h *IPCHandler) HandleLint(req api.LintRequest) (*api.LintResponse, error)
 				}
 			}
 		}
-		
+
 		if len(projectPaths) == 0 {
-			return nil, fmt.Errorf("no valid project paths found in languageOptions")
+			return nil, errors.New("no valid project paths found in languageOptions")
 		}
-		
+
 		// Resolve and validate all project paths
 		for _, projectPath := range projectPaths {
 			resolvedPath := tspath.ResolvePath(currentDirectory, projectPath)
@@ -217,10 +218,12 @@ func (h *IPCHandler) HandleLint(req api.LintRequest) (*api.LintResponse, error)
 			var found bool
 			if option, found = req.RuleOptions[r.Name]; found {
 				// Found with short name (e.g., "member-ordering")
+				// option and found are set correctly by the if condition
 			} else if option, found = req.RuleOptions["@typescript-eslint/"+r.Name]; found {
 				// Found with full name (e.g., "@typescript-eslint/member-ordering")
+				// option and found are set correctly by the if condition
 			}
-			
+
 			if found {
 				rulesWithOptions = append(rulesWithOptions, RuleWithOption{
 					rule:   r,

internal/rules/dot_notation/dot_notation.go

@@ -201,137 +201,6 @@ func shouldConvertToDotNotation(ctx rule.RuleContext, node *ast.Node, opts DotNo
 	return true
 }
 
-// computeDotNotationDiagnostic computes a single diagnostic for a bracket access if it should be converted
-// to dot notation. Returns start, end, message and true if a diagnostic should be reported; otherwise ok=false.
-func computeDotNotationDiagnostic(ctx rule.RuleContext, node *ast.Node, opts DotNotationOptions, allowIndexSignaturePropertyAccess bool, patternRegex *regexp.Regexp) (int, int, rule.RuleMessage, bool) {
-	if !ast.IsElementAccessExpression(node) {
-		return 0, 0, rule.RuleMessage{}, false
-	}
-
-	elementAccess := node.AsElementAccessExpression()
-	if elementAccess == nil {
-		return 0, 0, rule.RuleMessage{}, false
-	}
-
-	argument := elementAccess.ArgumentExpression
-	if argument == nil {
-		return 0, 0, rule.RuleMessage{}, false
-	}
-
-	// Only handle string literals, numeric literals, and identifiers that evaluate to strings
-	var propertyName string
-	isValidProperty := false
-
-	switch argument.Kind {
-	case ast.KindStringLiteral:
-		stringLiteral := argument.AsStringLiteral()
-		if stringLiteral == nil {
-			return 0, 0, rule.RuleMessage{}, false
-		}
-		// Remove quotes from string literal text
-		text := stringLiteral.Text
-		if len(text) >= 2 && ((text[0] == '"' && text[len(text)-1] == '"') || (text[0] == '\'' && text[len(text)-1] == '\'')) {
-			text = text[1 : len(text)-1]
-		}
-		propertyName = text
-		isValidProperty = true
-	case ast.KindNoSubstitutionTemplateLiteral:
-		// Handle `obj[`foo`]` (no expressions)
-		propertyName = argument.AsNoSubstitutionTemplateLiteral().Text
-		isValidProperty = true
-	case ast.KindNumericLiteral:
-		// Numeric properties should use bracket notation
-		return 0, 0, rule.RuleMessage{}, false
-	case ast.KindNullKeyword, ast.KindTrueKeyword, ast.KindFalseKeyword:
-		// These are allowed as dot notation
-		propertyName = getKeywordText(argument)
-		isValidProperty = true
-	default:
-		// Other cases (template literals, identifiers, etc.) should keep bracket notation
-		return 0, 0, rule.RuleMessage{}, false
-	}
-
-	if !isValidProperty || propertyName == "" {
-		return 0, 0, rule.RuleMessage{}, false
-	}
-
-	// Check if it's a valid identifier
-	if !isValidIdentifierName(propertyName) {
-		return 0, 0, rule.RuleMessage{}, false
-	}
-
-	// Check pattern allowlist
-	if patternRegex != nil && patternRegex.MatchString(propertyName) {
-		return 0, 0, rule.RuleMessage{}, false
-	}
-
-	// Check for keywords
-	if !opts.AllowKeywords && isReservedWord(propertyName) {
-		return 0, 0, rule.RuleMessage{}, false
-	}
-
-	// Check for private/protected/index signature access
-	if shouldAllowBracketNotation(ctx, node, propertyName, opts, allowIndexSignaturePropertyAccess) {
-		return 0, 0, rule.RuleMessage{}, false
-	}
-
-	// Determine range start with hybrid logic to match typescript-eslint tests:
-	// - If '[' begins a new visual access (only whitespace before on the line), start at '[' column
-	// - If '[' follows an identifier/dot/closing bracket/paren on the same line (e.g., x['a']), start at the beginning of the line
-	start := node.Pos()
-	if text := ctx.SourceFile.Text(); node.End() <= len(text) {
-		// Prefer computing '[' from the argument position to avoid capturing prior '[' in chained expressions
-		bracketPos := -1
-		if elementAccess.ArgumentExpression != nil {
-			candidate := elementAccess.ArgumentExpression.Pos() - 1
-			if candidate >= node.Pos() && candidate < node.End() && candidate >= 0 && candidate < len(text) && text[candidate] == '[' {
-				bracketPos = candidate
-			}
-		}
-		// Fallback: scan within node span
-		if bracketPos == -1 {
-			slice := text[node.Pos():node.End()]
-			for i := 0; i < len(slice); i++ {
-				if slice[i] == '[' {
-					bracketPos = node.Pos() + i
-					break
-				}
-			}
-		}
-		if bracketPos != -1 {
-			// Compute start-of-line using scanner helpers for exact column mapping
-			lineIndex, _ := scanner.GetLineAndCharacterOfPosition(ctx.SourceFile, bracketPos)
-			lineStart := scanner.GetPositionOfLineAndCharacter(ctx.SourceFile, lineIndex, 0)
-			prev := bracketPos - 1
-			prevNonSpace := byte('\n')
-			for prev >= lineStart {
-				if text[prev] != ' ' && text[prev] != '\t' {
-					prevNonSpace = text[prev]
-					break
-				}
-				prev--
-			}
-			// If previous non-space is identifier/dot/closing bracket/paren, use line start;
-			// otherwise align to one column after the leading indentation to match TS snapshots
-			if (prev >= lineStart) && ((prevNonSpace >= 'a' && prevNonSpace <= 'z') || (prevNonSpace >= 'A' && prevNonSpace <= 'Z') || (prevNonSpace >= '0' && prevNonSpace <= '9') || prevNonSpace == '_' || prevNonSpace == '$' || prevNonSpace == '.' || prevNonSpace == ')' || prevNonSpace == ']') {
-				start = lineStart
-			} else {
-				// bracketPos points at '[' which snapshots expect at column 4 in multiline case; offset by 1
-				start = bracketPos + 1
-				if start > node.End() {
-					start = bracketPos
-				}
-			}
-		}
-	}
-	msg := rule.RuleMessage{
-		Id:          "useDot",
-		Description: fmt.Sprintf("['%s'] is better written in dot notation.", propertyName),
-	}
-	// return computed range to be flushed later in source order
-	return start, node.End(), msg, true
-}
-
 func checkPropertyAccessKeywords(ctx rule.RuleContext, node *ast.Node) {
 	if !ast.IsPropertyAccessExpression(node) {
 		return
@@ -517,7 +386,7 @@ func createFix(ctx rule.RuleContext, node *ast.Node, propertyName string) rule.R
 	text := ctx.SourceFile.Text()
 	if node.End() <= len(text) {
 		slice := text[node.Pos():node.End()]
-		for i := 0; i < len(slice); i++ {
+		for i := range slice {
 			if slice[i] == '[' {
 				start = node.Pos() + i
 				break

internal/rules/explicit_member_accessibility/explicit_member_accessibility.go

@@ -3,11 +3,8 @@ package explicit_member_accessibility
 import (
 	"fmt"
 
-	"strings"
-
 	"github.com/microsoft/typescript-go/shim/ast"
 	"github.com/microsoft/typescript-go/shim/core"
-	"github.com/microsoft/typescript-go/shim/scanner"
 	"github.com/web-infra-dev/rslint/internal/rule"
 	"github.com/web-infra-dev/rslint/internal/utils"
 )
@@ -205,123 +202,6 @@ func getNodeType(node *ast.Node, memberKind string) string {
 // Removed getMemberHeadLoc and getParameterPropertyHeadLoc functions
 // Now using ReportNode directly which handles positioning correctly
 
-func getMissingAccessibilityRange(ctx rule.RuleContext, node *ast.Node) core.TextRange {
-	// Default to node's name range when available
-	findAccessorKeywordStart := func(nameRange core.TextRange) int {
-		// Search backwards from name for 'get' or 'set' keyword within the declaration span
-		text := ctx.SourceFile.Text()
-		startBound := node.Pos()
-		endBound := nameRange.Pos()
-		if startBound < 0 || endBound > len(text) || startBound >= endBound {
-			return nameRange.Pos()
-		}
-		snippet := text[startBound:endBound]
-		// look for last occurrence to get the actual keyword near the name
-		idxGet := strings.LastIndex(snippet, "get")
-		idxSet := strings.LastIndex(snippet, "set")
-		idx := -1
-		kw := ""
-		if idxGet > idxSet {
-			idx = idxGet
-			kw = "get"
-		} else {
-			idx = idxSet
-			kw = "set"
-		}
-		if idx >= 0 {
-			// ensure simple word boundary (whitespace or start before; whitespace/paren after)
-			abs := startBound + idx
-			beforeOk := abs == startBound || (abs > 0 && (text[abs-1] == ' ' || text[abs-1] == '\t' || text[abs-1] == '\n'))
-			afterPos := abs + len(kw)
-			afterOk := afterPos < len(text) && (text[afterPos] == ' ' || text[afterPos] == '\t' || text[afterPos] == '\n' || text[afterPos] == '(')
-			if beforeOk && afterOk {
-				return abs
-			}
-		}
-		return nameRange.Pos()
-	}
-	switch node.Kind {
-	case ast.KindConstructor:
-		// Highlight the 'constructor' keyword only
-		return scanner.GetRangeOfTokenAtPosition(ctx.SourceFile, node.Pos())
-	case ast.KindMethodDeclaration:
-		m := node.AsMethodDeclaration()
-		nameNode := m.Name()
-		if nameNode != nil {
-			nameRange := utils.TrimNodeTextRange(ctx.SourceFile, nameNode)
-			start := nameRange.Pos()
-			// If abstract, start from 'abstract'
-			if m.Modifiers() != nil {
-				for _, mod := range m.Modifiers().Nodes {
-					if mod.Kind == ast.KindAbstractKeyword {
-						start = mod.Pos()
-						break
-					}
-				}
-			}
-			nameText, _ := utils.GetNameFromMember(ctx.SourceFile, nameNode)
-			end := nameRange.Pos() + len(nameText)
-			return core.NewTextRange(start, end)
-		}
-		return utils.TrimNodeTextRange(ctx.SourceFile, node)
-	case ast.KindGetAccessor:
-		g := node.AsGetAccessorDeclaration()
-		nameNode := g.Name()
-		if nameNode != nil {
-			nameRange := utils.TrimNodeTextRange(ctx.SourceFile, nameNode)
-			// Start at the 'get' keyword token by scanning between node start and name
-			start := findAccessorKeywordStart(nameRange)
-			nameText, _ := utils.GetNameFromMember(ctx.SourceFile, nameNode)
-			end := nameRange.Pos() + len(nameText)
-			return core.NewTextRange(start, end)
-		}
-		return utils.TrimNodeTextRange(ctx.SourceFile, node)
-	case ast.KindSetAccessor:
-		s := node.AsSetAccessorDeclaration()
-		nameNode := s.Name()
-		if nameNode != nil {
-			nameRange := utils.TrimNodeTextRange(ctx.SourceFile, nameNode)
-			// Start at the 'set' keyword token by scanning between node start and name
-			start := findAccessorKeywordStart(nameRange)
-			nameText, _ := utils.GetNameFromMember(ctx.SourceFile, nameNode)
-			end := nameRange.Pos() + len(nameText)
-			return core.NewTextRange(start, end)
-		}
-		return utils.TrimNodeTextRange(ctx.SourceFile, node)
-	case ast.KindPropertyDeclaration:
-		p := node.AsPropertyDeclaration()
-		nameNode := p.Name()
-		if nameNode != nil {
-			nameRange := utils.TrimNodeTextRange(ctx.SourceFile, nameNode)
-			start := nameRange.Pos()
-			if p.Modifiers() != nil {
-				// Prefer abstract start if present
-				for _, mod := range p.Modifiers().Nodes {
-					if mod.Kind == ast.KindAbstractKeyword {
-						start = mod.Pos()
-						break
-					}
-				}
-				// Otherwise, if accessor keyword present, start there to include `accessor foo`
-				if start == nameRange.Pos() {
-					for _, mod := range p.Modifiers().Nodes {
-						if mod.Kind == ast.KindAccessorKeyword {
-							start = mod.Pos()
-							break
-						}
-					}
-				}
-			}
-			nameText, _ := utils.GetNameFromMember(ctx.SourceFile, nameNode)
-			end := nameRange.Pos() + len(nameText)
-			return core.NewTextRange(start, end)
-		}
-		return utils.TrimNodeTextRange(ctx.SourceFile, node)
-	}
-	// Fallback
-	return utils.TrimNodeTextRange(ctx.SourceFile, node)
-}
-
 var ExplicitMemberAccessibilityRule = rule.Rule{
 
 	Name: "explicit-member-accessibility",

internal/rules/member_ordering/member_ordering.go

@@ -357,18 +357,19 @@ func isFunctionExpression(node *ast.Node) bool {
 }
 
 func getMemberName(node *ast.Node, sourceFile *ast.SourceFile) string {
-	switch node.Kind {
+	switch kind := node.Kind; kind {
 	case ast.KindPropertySignature, ast.KindMethodSignature,
 		ast.KindPropertyDeclaration, ast.KindGetAccessor, ast.KindSetAccessor:
 		// For signatures, the node itself is the name node
 		var nameNode *ast.Node
-		if node.Kind == ast.KindPropertyDeclaration {
+		switch kind {
+		case ast.KindPropertyDeclaration:
 			nameNode = node.AsPropertyDeclaration().Name()
-		} else if node.Kind == ast.KindGetAccessor {
+		case ast.KindGetAccessor:
 			nameNode = node.AsGetAccessorDeclaration().Name()
-		} else if node.Kind == ast.KindSetAccessor {
+		case ast.KindSetAccessor:
 			nameNode = node.AsSetAccessorDeclaration().Name()
-		} else {
+		default:
 			nameNode = node
 		}
 		name, _ := utils.GetNameFromMember(sourceFile, nameNode)
@@ -402,20 +403,21 @@ func getMemberName(node *ast.Node, sourceFile *ast.SourceFile) string {
 // For quoted literal member names (e.g. "b.c"), this strips the surrounding quotes
 // so comparisons are based on the actual text content rather than quote characters.
 func getMemberSortName(node *ast.Node, sourceFile *ast.SourceFile) string {
-	switch node.Kind {
+	switch kind := node.Kind; kind {
 	case ast.KindPropertySignature, ast.KindMethodSignature,
 		ast.KindPropertyDeclaration, ast.KindGetAccessor, ast.KindSetAccessor,
 		ast.KindMethodDeclaration:
 		var nameNode *ast.Node
-		if node.Kind == ast.KindPropertyDeclaration {
+		switch kind {
+		case ast.KindPropertyDeclaration:
 			nameNode = node.AsPropertyDeclaration().Name()
-		} else if node.Kind == ast.KindGetAccessor {
+		case ast.KindGetAccessor:
 			nameNode = node.AsGetAccessorDeclaration().Name()
-		} else if node.Kind == ast.KindSetAccessor {
+		case ast.KindSetAccessor:
 			nameNode = node.AsSetAccessorDeclaration().Name()
-		} else if node.Kind == ast.KindMethodDeclaration {
+		case ast.KindMethodDeclaration:
 			nameNode = node.AsMethodDeclaration().Name()
-		} else {
+		default:
 			nameNode = node
 		}
 		name, nameType := utils.GetNameFromMember(sourceFile, nameNode)
@@ -444,7 +446,7 @@ func getMemberSnippet(sourceFile *ast.SourceFile, node *ast.Node) string {
 	text := sourceFile.Text()[r.Pos():r.End()]
 	// Take only the first line and trim
 	end := len(text)
-	for i := 0; i < len(text); i++ {
+	for i := range text {
 		if text[i] == '\n' || text[i] == '\r' {
 			end = i
 			break