feat: extract comments from ast (#209)

Author: CPunisher

internal/linter/linter.go

@@ -54,11 +54,15 @@ func RunLinter(programs []*compiler.Program, singleThreaded bool, allowFiles []s
 						}
 					}
 					lintedFileCount.Add(1)
+
+					comments := make([]*ast.CommentRange, 0)
+					utils.ForEachComment(&file.Node, func(comment *ast.CommentRange) { comments = append(comments, comment) }, file)
+
 					registeredListeners := make(map[ast.Kind][](func(node *ast.Node)), 20)
 					{
 						rules := getRulesForFile(file)
 						// Create disable manager for this file
-						disableManager := rule.NewDisableManager(file)
+						disableManager := rule.NewDisableManager(file, comments)
 
 						for _, r := range rules {
 							ctx := rule.RuleContext{

internal/rule/disable_manager.go

@@ -1,7 +1,6 @@
 package rule
 
 import (
-	"regexp"
 	"strings"
 
 	"github.com/microsoft/typescript-go/shim/ast"
@@ -33,72 +32,77 @@ type DisableManager struct {
 }
 
 // NewDisableManager creates a new DisableManager for the given source file
-func NewDisableManager(sourceFile *ast.SourceFile) *DisableManager {
+func NewDisableManager(sourceFile *ast.SourceFile, comments []*ast.CommentRange) *DisableManager {
 	dm := &DisableManager{
 		sourceFile:            sourceFile,
 		disabledRules:         make(map[string]bool),
 		lineDisabledRules:     make(map[int][]string),
 		nextLineDisabledRules: make(map[int][]string),
 	}
 
-	dm.parseESLintDirectives()
+	dm.parseESLintDirectives(comments)
 	return dm
 }
 
 // parseESLintDirectives parses ESLint-style disable/enable comments from the source text
-func (dm *DisableManager) parseESLintDirectives() {
-	if dm.sourceFile.Text() == "" {
+func (dm *DisableManager) parseESLintDirectives(comments []*ast.CommentRange) {
+	if dm.sourceFile.Text() == "" || len(comments) == 0 {
 		return
 	}
 
 	text := dm.sourceFile.Text()
-	lines := strings.Split(text, "\n")
 
-	// Regular expressions to match ESLint directives
-	eslintDisableLineRe := regexp.MustCompile(`//\s*eslint-disable-line(?:\s+([^\r\n]+))?`)
-	eslintDisableNextLineRe := regexp.MustCompile(`//\s*eslint-disable-next-line(?:\s+([^\r\n]+))?`)
-	eslintDisableRe := regexp.MustCompile(`/\*\s*eslint-disable(?:\s+([^*]+))?\s*\*/`)
-	eslintEnableRe := regexp.MustCompile(`/\*\s*eslint-enable(?:\s+([^*]+))?\s*\*/`)
-
-	for i, line := range lines {
-		lineNum := i // 0-based line numbers
-
-		// Check for eslint-disable-line
-		if matches := eslintDisableLineRe.FindStringSubmatch(line); matches != nil {
-			rules := parseRuleNames(matches[1])
-			if len(rules) == 0 {
-				dm.lineDisabledRules[lineNum] = append(dm.lineDisabledRules[lineNum], "*")
-			} else {
-				dm.lineDisabledRules[lineNum] = append(dm.lineDisabledRules[lineNum], rules...)
-			}
+	for _, comment := range comments {
+		var commentContent string
+		switch comment.Kind {
+		case ast.KindSingleLineCommentTrivia:
+			commentContent = strings.TrimSpace(text[comment.Pos()+2 : comment.End()])
+		case ast.KindMultiLineCommentTrivia:
+			commentContent = strings.TrimSpace(text[comment.Pos()+2 : comment.End()-2])
 		}
 
-		// Check for eslint-disable-next-line
-		if matches := eslintDisableNextLineRe.FindStringSubmatch(line); matches != nil {
-			rules := parseRuleNames(matches[1])
-			nextLineNum := lineNum + 1
-			if len(rules) == 0 {
-				dm.nextLineDisabledRules[nextLineNum] = append(dm.nextLineDisabledRules[nextLineNum], "*")
-			} else {
-				dm.nextLineDisabledRules[nextLineNum] = append(dm.nextLineDisabledRules[nextLineNum], rules...)
-			}
-		}
-
-		// Check for eslint-disable (block comments)
-		if matches := eslintDisableRe.FindStringSubmatch(line); matches != nil {
-			rules := parseRuleNames(matches[1])
-			if len(rules) == 0 {
-				dm.disabledRules["*"] = true
+		lineNum, _ := scanner.GetLineAndCharacterOfPosition(dm.sourceFile, comment.Pos())
+		rulePos := 0
+
+		if strings.HasPrefix(commentContent, "eslint-disable") {
+			rulePos += 14
+			text := commentContent[rulePos:]
+
+			if strings.HasPrefix(text, "-line") {
+				// Check for eslint-disable-line
+				rulePos += 5
+				rules := parseRuleNames(commentContent[rulePos:])
+				if len(rules) == 0 {
+					dm.lineDisabledRules[lineNum] = append(dm.lineDisabledRules[lineNum], "*")
+				} else {
+					dm.lineDisabledRules[lineNum] = append(dm.lineDisabledRules[lineNum], rules...)
+				}
+			} else if strings.HasPrefix(text, "-next-line") {
+				// Check for eslint-disable-next-line
+				rulePos += 10
+				rules := parseRuleNames(commentContent[rulePos:])
+				nextLineNum := lineNum + 1
+				if len(rules) == 0 {
+					dm.nextLineDisabledRules[nextLineNum] = append(dm.nextLineDisabledRules[nextLineNum], "*")
+				} else {
+					dm.nextLineDisabledRules[nextLineNum] = append(dm.nextLineDisabledRules[nextLineNum], rules...)
+				}
 			} else {
-				for _, rule := range rules {
-					dm.disabledRules[rule] = true
+				// Check for eslint-disable (block comments)
+				rules := parseRuleNames(commentContent[rulePos:])
+				if len(rules) == 0 {
+					dm.disabledRules["*"] = true
+				} else {
+					for _, rule := range rules {
+						dm.disabledRules[rule] = true
+					}
 				}
 			}
-		}
+		} else if strings.HasPrefix(commentContent, "eslint-enable") {
+			rulePos += 13
 
-		// Check for eslint-enable (block comments)
-		if matches := eslintEnableRe.FindStringSubmatch(line); matches != nil {
-			rules := parseRuleNames(matches[1])
+			// Check for eslint-enable (block comments)
+			rules := parseRuleNames(commentContent[rulePos:])
 			if len(rules) == 0 {
 				// Enable all rules
 				for key := range dm.disabledRules {

internal/utils/ts_api_utils.go

@@ -4,6 +4,7 @@ import (
 	"github.com/microsoft/typescript-go/shim/ast"
 	"github.com/microsoft/typescript-go/shim/checker"
 	"github.com/microsoft/typescript-go/shim/core"
+	"github.com/microsoft/typescript-go/shim/scanner"
 )
 
 func UnionTypeParts(t *checker.Type) []*checker.Type {
@@ -157,30 +158,54 @@ func GetWellKnownSymbolPropertyOfType(t *checker.Type, name string, typeChecker
 	return checker.Checker_getPropertyOfType(typeChecker, t, checker.Checker_getPropertyNameForKnownSymbolName(typeChecker, name))
 }
 
-/**
- * Checks if a given compiler option is enabled, accounting for whether all flags
- * (except `strictPropertyInitialization`) have been enabled by `strict: true`.
- * @category Compiler Options
- * @example
- * ```ts
- * const optionsLenient = {
- * 	noImplicitAny: true,
- * };
- *
- * isStrictCompilerOptionEnabled(optionsLenient, "noImplicitAny"); // true
- * isStrictCompilerOptionEnabled(optionsLenient, "noImplicitThis"); // false
- * ```
- * @example
- * ```ts
- * const optionsStrict = {
- * 	noImplicitThis: false,
- * 	strict: true,
- * };
- *
- * isStrictCompilerOptionEnabled(optionsStrict, "noImplicitAny"); // true
- * isStrictCompilerOptionEnabled(optionsStrict, "noImplicitThis"); // false
- * ```
- */
+func GetChildren(node *ast.Node, sourceFile *ast.SourceFile) []*ast.Node {
+	children := make([]*ast.Node, 0)
+
+	pos := node.Pos()
+	node.ForEachChild(func(child *ast.Node) bool {
+		childPos := child.Pos()
+		if pos < childPos {
+			scanner := scanner.GetScannerForSourceFile(sourceFile, pos)
+			for pos < childPos {
+				token := scanner.Token()
+				tokenFullStart := scanner.TokenFullStart()
+				tokenEnd := scanner.TokenEnd()
+				children = append(children, sourceFile.GetOrCreateToken(token, tokenFullStart, tokenEnd, node))
+				pos = tokenEnd
+				scanner.Scan()
+			}
+		}
+
+		children = append(children, child)
+		pos = child.End()
+		return false
+	})
+	return children
+}
+
+// Checks if a given compiler option is enabled, accounting for whether all flags
+// (except `strictPropertyInitialization`) have been enabled by `strict: true`.
+//
+// @category Compiler Options
+//
+// @example
+//
+//	const optionsLenient = {
+//		noImplicitAny: true,
+//	};
+//
+// isStrictCompilerOptionEnabled(optionsLenient, "noImplicitAny"); // true
+// isStrictCompilerOptionEnabled(optionsLenient, "noImplicitThis"); // false
+//
+// @example
+//
+//	const optionsStrict = {
+//		noImplicitThis: false,
+//		strict: true,
+//	};
+//
+// isStrictCompilerOptionEnabled(optionsStrict, "noImplicitAny"); // true
+// isStrictCompilerOptionEnabled(optionsStrict, "noImplicitThis"); // false
 func IsStrictCompilerOptionEnabled(
 	options *core.CompilerOptions,
 	option core.Tristate,
@@ -195,3 +220,125 @@ func IsStrictCompilerOptionEnabled(
 	// 		isStrictCompilerOptionEnabled(options, "strictNullChecks"))
 	// );
 }
+
+// Port https://github.com/JoshuaKGoldberg/ts-api-utils/blob/491c0374725a5dd64632405efea101f20ed5451f/src/tokens.ts#L34
+//
+// Iterates over all tokens of `node`
+//
+// @category Nodes - Other Utilities
+//
+// @example
+//
+// declare const node: ts.Node;
+//
+//	forEachToken(node, (token) => {
+//		console.log("Found token:", token.getText());
+//	});
+//
+// @param node The node whose tokens should be visited
+// @param callback Is called for every token contained in `node`
+func ForEachToken(node *ast.Node, callback func(token *ast.Node), sourceFile *ast.SourceFile) {
+	queue := make([]*ast.Node, 0)
+
+	for {
+		if ast.IsTokenKind(node.Kind) {
+			callback(node)
+		} else {
+			children := GetChildren(node, sourceFile)
+			for i := len(children) - 1; i >= 0; i-- {
+				queue = append(queue, children[i])
+			}
+		}
+
+		if len(queue) == 0 {
+			break
+		}
+
+		node = queue[len(queue)-1]
+		queue = queue[:len(queue)-1]
+	}
+}
+
+// Port https://github.com/JoshuaKGoldberg/ts-api-utils/blob/491c0374725a5dd64632405efea101f20ed5451f/src/comments.ts#L37C17-L37C31
+//
+// Iterates over all comments owned by `node` or its children.
+//
+// @category Nodes - Other Utilities
+//
+// @example
+//
+// declare const node: ts.Node;
+//
+//	forEachComment(node, (fullText, comment) => {
+//	   console.log(`Found comment at position ${comment.pos}: '${fullText}'.`);
+//	});
+func ForEachComment(node *ast.Node, callback func(comment *ast.CommentRange), sourceFile *ast.SourceFile) {
+	fullText := sourceFile.Text()
+	notJsx := sourceFile.LanguageVariant != core.LanguageVariantJSX
+
+	ForEachToken(
+		node,
+		func(token *ast.Node) {
+			if token.Pos() == token.End() {
+				return
+			}
+
+			if token.Kind != ast.KindJsxText {
+				pos := token.Pos()
+				if pos == 0 {
+					pos = len(scanner.GetShebang(fullText))
+				}
+
+				for comment := range scanner.GetLeadingCommentRanges(&ast.NodeFactory{}, fullText, pos) {
+					callback(&comment)
+				}
+			}
+
+			if notJsx || canHaveTrailingTrivia(token) {
+				for comment := range scanner.GetTrailingCommentRanges(&ast.NodeFactory{}, fullText, token.End()) {
+					callback(&comment)
+				}
+				return
+			}
+		},
+		sourceFile,
+	)
+}
+
+// Port https://github.com/JoshuaKGoldberg/ts-api-utils/blob/491c0374725a5dd64632405efea101f20ed5451f/src/comments.ts#L84
+//
+// Exclude trailing positions that would lead to scanning for trivia inside `JsxText`.
+// @internal
+func canHaveTrailingTrivia(token *ast.Node) bool {
+	switch token.Kind {
+	case ast.KindCloseBraceToken:
+		// after a JsxExpression inside a JsxElement's body can only be other JsxChild, but no trivia
+		return token.Parent.Kind != ast.KindJsxExpression || !isJsxElementOrFragment(token.Parent.Parent)
+	case ast.KindGreaterThanToken:
+		switch token.Parent.Kind {
+		case ast.KindJsxClosingElement:
+		case ast.KindJsxClosingFragment:
+			// there's only trailing trivia if it's the end of the top element
+			return !isJsxElementOrFragment(token.Parent.Parent.Parent)
+		case ast.KindJsxOpeningElement:
+			// if end is not equal, this is part of the type arguments list. in all other cases it would be inside the element body
+			return token.End() != token.Parent.End()
+		case ast.KindJsxOpeningFragment:
+			return false // would be inside the fragment
+		case ast.KindJsxSelfClosingElement:
+			// if end is not equal, this is part of the type arguments list
+			// there's only trailing trivia if it's the end of the top element
+			return token.End() != token.Parent.End() || !isJsxElementOrFragment(token.Parent.Parent)
+		}
+	}
+
+	return true
+}
+
+// Port https://github.com/JoshuaKGoldberg/ts-api-utils/blob/491c0374725a5dd64632405efea101f20ed5451f/src/comments.ts#L118
+//
+// Test if a node is a `JsxElement` or `JsxFragment`.
+// @internal
+func isJsxElementOrFragment(node *ast.Node) bool {
+	return node.Kind == ast.KindJsxElement || node.Kind == ast.KindJsxFragment
+}