test: Enable test for ban-tslint-comment rule (#151)

## Summary
- Uncommented the test file for the `ban-tslint-comment` rule in
`rstest.config.mts` to enable testing
- Implemented the ban-tslint-comment rule in Go
- Registered the rule in the configuration

## Context
This PR is a follow-up to #149 which enabled the `ban-ts-comment` rule.
This PR enables the `ban-tslint-comment` rule which helps enforce
migration from deprecated TSLint to ESLint.

## Changes
1. **Test Configuration** (rstest.config.mts:36)
   - Uncommented the line enabling the ban-tslint-comment test file

2. **Implementation**
(internal/plugins/typescript/rules/ban_tslint_comment/ban_tslint_comment.go)
   - Created new Go implementation for the ban-tslint-comment rule
- Detects `tslint:disable` and `tslint:enable` comments in both
single-line (`//`) and multi-line (`/* */`) formats
   - Provides automatic fixes that remove tslint comments
- Handles various comment positions (standalone lines and inline
comments)
- Reports errors with messageId 'commentDetected' and appropriate
description

3. **Registration** (internal/config/config.go)
   - Added import for the ban_tslint_comment package
   - Registered the rule as `@typescript-eslint/ban-tslint-comment`

## Implementation Details
The rule implementation:
- Scans source text for tslint comment patterns
- Matches comments starting with `tslint:disable` or `tslint:enable`
- Creates fixes that intelligently remove comments:
- For standalone comment lines: removes the entire line including
newline
- For inline comments (e.g., `someCode(); // tslint:disable-line`):
removes just the comment
- Follows the pattern established by the ban-ts-comment rule

## Test Plan
- [x] Run `npm test` to verify all tests pass
- [ ] Check CI pipeline for any failures
- [ ] Fix any implementation issues if tests fail in CI

## TypeScript-ESLint Reference
The implementation follows the behavior of the TypeScript-ESLint
ban-tslint-comment rule:
https://typescript-eslint.io/rules/ban-tslint-comment/

TSLint was deprecated in favor of ESLint, and this rule helps enforce
the migration by detecting and removing TSLint directive comments.

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

---------

Co-authored-by: claude[bot] <41898282+claude[bot]@users.noreply.github.com>
Co-authored-by: Claude <noreply@anthropic.com>

Author: 3 people

internal/config/config.go

@@ -14,6 +14,7 @@ import (
 	"github.com/web-infra-dev/rslint/internal/plugins/typescript/rules/array_type"
 	"github.com/web-infra-dev/rslint/internal/plugins/typescript/rules/await_thenable"
 	"github.com/web-infra-dev/rslint/internal/plugins/typescript/rules/ban_ts_comment"
+	"github.com/web-infra-dev/rslint/internal/plugins/typescript/rules/ban_tslint_comment"
 	"github.com/web-infra-dev/rslint/internal/plugins/typescript/rules/ban_types"
 	"github.com/web-infra-dev/rslint/internal/plugins/typescript/rules/class_literal_property_style"
 	"github.com/web-infra-dev/rslint/internal/plugins/typescript/rules/consistent_generic_constructors"
@@ -365,6 +366,7 @@ func registerAllTypeScriptEslintPluginRules() {
 	GlobalRuleRegistry.Register("@typescript-eslint/array-type", array_type.ArrayTypeRule)
 	GlobalRuleRegistry.Register("@typescript-eslint/await-thenable", await_thenable.AwaitThenableRule)
 	GlobalRuleRegistry.Register("@typescript-eslint/ban-ts-comment", ban_ts_comment.BanTsCommentRule)
+	GlobalRuleRegistry.Register("@typescript-eslint/ban-tslint-comment", ban_tslint_comment.BanTslintCommentRule)
 	GlobalRuleRegistry.Register("@typescript-eslint/ban-types", ban_types.BanTypesRule)
 	GlobalRuleRegistry.Register("@typescript-eslint/class-literal-property-style", class_literal_property_style.ClassLiteralPropertyStyleRule)
 	GlobalRuleRegistry.Register("@typescript-eslint/consistent-generic-constructors", consistent_generic_constructors.ConsistentGenericConstructorsRule)

internal/linter/linter.go

@@ -99,6 +99,20 @@ func RunLinterInProgram(program *compiler.Program, allowFiles []string, skipFile
 							Severity:    r.Severity,
 						})
 					},
+					ReportRangeWithFixes: func(textRange core.TextRange, msg rule.RuleMessage, fixes ...rule.RuleFix) {
+						// Check if rule is disabled at this position
+						if disableManager.IsRuleDisabled(r.Name, textRange.Pos()) {
+							return
+						}
+						onDiagnostic(rule.RuleDiagnostic{
+							RuleName:   r.Name,
+							Range:      textRange,
+							Message:    msg,
+							FixesPtr:   &fixes,
+							SourceFile: file,
+							Severity:   r.Severity,
+						})
+					},
 					ReportNode: func(node *ast.Node, msg rule.RuleMessage) {
 						// Check if rule is disabled at this position
 						if disableManager.IsRuleDisabled(r.Name, node.Pos()) {

internal/plugins/typescript/rules/ban_tslint_comment/ban_tslint_comment.go

@@ -0,0 +1,205 @@
+package ban_tslint_comment
+
+import (
+	"regexp"
+	"strings"
+
+	"github.com/microsoft/typescript-go/shim/core"
+	"github.com/web-infra-dev/rslint/internal/rule"
+)
+
+// Regular expressions for matching TSLint directives
+var (
+	// Matches single-line comments: // tslint:disable or // tslint:enable
+	singleLineTslintRegex = regexp.MustCompile(`^//\s*tslint:(disable|enable)`)
+
+	// Matches multi-line comments: /* tslint:disable */ or /* tslint:enable */
+	multiLineTslintRegex = regexp.MustCompile(`^/\*\s*tslint:(disable|enable)`)
+)
+
+// BanTslintCommentRule implements the ban-tslint-comment rule
+// Bans // tslint:<rule-flag> comments
+var BanTslintCommentRule = rule.CreateRule(rule.Rule{
+	Name: "ban-tslint-comment",
+	Run:  run,
+})
+
+func run(ctx rule.RuleContext, options any) rule.RuleListeners {
+	// Get the full text of the source file
+	text := ctx.SourceFile.Text()
+
+	// Process the text to find tslint comments
+	processComments(ctx, text)
+
+	return rule.RuleListeners{}
+}
+
+// processComments scans the source text for tslint comments
+func processComments(ctx rule.RuleContext, text string) {
+	pos := 0
+	length := len(text)
+	lineStarts := calculateLineStarts(text)
+
+	for pos < length {
+		// Skip to next potential comment
+		if pos+1 < length {
+			if text[pos] == '/' && text[pos+1] == '/' {
+				// Single-line comment
+				commentStart := pos
+				pos += 2
+				lineEnd := pos
+				for lineEnd < length && text[lineEnd] != '\n' && text[lineEnd] != '\r' {
+					lineEnd++
+				}
+				commentText := text[commentStart:lineEnd]
+
+				// Check if this is a tslint comment
+				if singleLineTslintRegex.MatchString(commentText) {
+					reportTslintComment(ctx, commentText, commentStart, lineEnd, lineStarts, text)
+				}
+
+				pos = lineEnd
+			} else if text[pos] == '/' && text[pos+1] == '*' {
+				// Multi-line comment
+				commentStart := pos
+				pos += 2
+				commentEnd := pos
+				for commentEnd+1 < length {
+					if text[commentEnd] == '*' && text[commentEnd+1] == '/' {
+						commentEnd += 2
+						break
+					}
+					commentEnd++
+				}
+				commentText := text[commentStart:commentEnd]
+
+				// Check if this is a tslint comment
+				if multiLineTslintRegex.MatchString(commentText) {
+					reportTslintComment(ctx, commentText, commentStart, commentEnd, lineStarts, text)
+				}
+
+				pos = commentEnd
+			} else {
+				pos++
+			}
+		} else {
+			pos++
+		}
+	}
+}
+
+// calculateLineStarts returns the starting positions of each line
+func calculateLineStarts(text string) []int {
+	lineStarts := []int{0}
+	for i := 0; i < len(text); i++ {
+		if text[i] == '\n' {
+			lineStarts = append(lineStarts, i+1)
+		}
+	}
+	return lineStarts
+}
+
+// getLineAndColumn returns the line and column numbers for a given position
+func getLineAndColumn(pos int, lineStarts []int) (line, column int) {
+	for i := len(lineStarts) - 1; i >= 0; i-- {
+		if pos >= lineStarts[i] {
+			line = i + 1
+			column = pos - lineStarts[i] + 1
+			return
+		}
+	}
+	return 1, 1
+}
+
+// reportTslintComment reports a tslint comment with autofix
+func reportTslintComment(ctx rule.RuleContext, commentText string, start, end int, lineStarts []int, fullText string) {
+	line, column := getLineAndColumn(start, lineStarts)
+
+	// Create the fix
+	fix := createFix(start, end, fullText)
+
+	ctx.ReportRangeWithFixes(
+		core.NewTextRange(start, end),
+		rule.RuleMessage{
+			Id:          "commentDetected",
+			Description: "tslint is deprecated and you should stop using it",
+		},
+		*fix,
+	)
+
+	_ = line
+	_ = column
+}
+
+// createFix creates a fix that removes the tslint comment
+func createFix(start, end int, fullText string) *rule.RuleFix {
+	// Check if we need to remove the entire line or just the comment
+
+	// Look backwards to see if there's any non-whitespace before the comment
+	hasContentBefore := false
+	lineStart := start
+	for lineStart > 0 && fullText[lineStart-1] != '\n' && fullText[lineStart-1] != '\r' {
+		lineStart--
+		if !isWhitespace(fullText[lineStart]) {
+			hasContentBefore = true
+		}
+	}
+
+	// Look forwards to see if there's any non-whitespace after the comment (on the same line)
+	hasContentAfter := false
+	lineEnd := end
+	for lineEnd < len(fullText) && fullText[lineEnd] != '\n' && fullText[lineEnd] != '\r' {
+		if !isWhitespace(fullText[lineEnd]) {
+			hasContentAfter = true
+			break
+		}
+		lineEnd++
+	}
+
+	// Skip the newline characters if removing the entire line
+	if !hasContentBefore && !hasContentAfter {
+		// Include the newline in the removal
+		if lineEnd < len(fullText) && fullText[lineEnd] == '\r' {
+			lineEnd++
+		}
+		if lineEnd < len(fullText) && fullText[lineEnd] == '\n' {
+			lineEnd++
+		}
+
+		return &rule.RuleFix{
+			Range: core.NewTextRange(lineStart, lineEnd),
+			Text:  "",
+		}
+	}
+
+	// If there's content before the comment (e.g., "someCode(); // tslint:disable-line")
+	if hasContentBefore {
+		// Remove just the comment, preserving whitespace before it but removing the comment
+		// Find where the actual code ends
+		codeEnd := start
+		for codeEnd > lineStart && isWhitespace(fullText[codeEnd-1]) {
+			codeEnd--
+		}
+
+		return &rule.RuleFix{
+			Range: core.NewTextRange(codeEnd, end),
+			Text:  "",
+		}
+	}
+
+	// Otherwise, just remove the comment
+	return &rule.RuleFix{
+		Range: core.NewTextRange(start, end),
+		Text:  "",
+	}
+}
+
+// isWhitespace checks if a character is whitespace
+func isWhitespace(ch byte) bool {
+	return ch == ' ' || ch == '\t' || ch == '\r' || ch == '\n'
+}
+
+// trimTrailingWhitespace removes trailing whitespace and newlines
+func trimTrailingWhitespace(s string) string {
+	return strings.TrimRight(s, " \t\r\n")
+}

internal/rule/rule.go

@@ -168,6 +168,7 @@ type RuleContext struct {
 	DisableManager             *DisableManager
 	ReportRange                func(textRange core.TextRange, msg RuleMessage)
 	ReportRangeWithSuggestions func(textRange core.TextRange, msg RuleMessage, suggestions ...RuleSuggestion)
+	ReportRangeWithFixes       func(textRange core.TextRange, msg RuleMessage, fixes ...RuleFix)
 	ReportNode                 func(node *ast.Node, msg RuleMessage)
 	ReportNodeWithFixes        func(node *ast.Node, msg RuleMessage, fixes ...RuleFix)
 	ReportNodeWithSuggestions  func(node *ast.Node, msg RuleMessage, suggestions ...RuleSuggestion)

packages/rslint-test-tools/rstest.config.mts

@@ -33,7 +33,7 @@ export default defineConfig({
     // Additional tests (commented out)
     // typescript-eslint - additional rules
     './tests/typescript-eslint/rules/ban-ts-comment.test.ts',
-    // './tests/typescript-eslint/rules/ban-tslint-comment.test.ts',
+    './tests/typescript-eslint/rules/ban-tslint-comment.test.ts',
     // './tests/typescript-eslint/rules/class-methods-use-this/class-methods-use-this-core.test.ts',
     // './tests/typescript-eslint/rules/class-methods-use-this/class-methods-use-this.test.ts',
     // './tests/typescript-eslint/rules/consistent-generic-constructors.test.ts',