@ttsc/lint 0.8.0-dev.20260505 → 0.8.0

package/plugin/directives.go

@@ -0,0 +1,296 @@
+package main
+
+import (
+  "strings"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimscanner "github.com/microsoft/typescript-go/shim/scanner"
+)
+
+type lintDirectiveKind int
+
+const (
+  lintDirectiveDisable lintDirectiveKind = iota
+  lintDirectiveEnable
+  lintDirectiveDisableLine
+  lintDirectiveDisableNextLine
+)
+
+type lintDirective struct {
+  kind  lintDirectiveKind
+  rules lintDirectiveRules
+}
+
+type lintDirectiveRules struct {
+  all   bool
+  rules map[string]struct{}
+}
+
+type lintDirectiveEvent struct {
+  pos   int
+  rules lintDirectiveRules
+  on    bool
+}
+
+type lintInlineDirectives struct {
+  lines  map[int][]lintDirectiveRules
+  events []lintDirectiveEvent
+}
+
+type lintDisableState struct {
+  all          bool
+  rules        map[string]struct{}
+  enabledInAll map[string]struct{}
+}
+
+func filterInlineDisabledFindings(file *shimast.SourceFile, findings []*Finding) []*Finding {
+  if len(findings) == 0 || file == nil {
+    return findings
+  }
+  directives := parseLintInlineDirectives(file)
+  if directives.empty() {
+    return findings
+  }
+  filtered := findings[:0]
+  for _, finding := range findings {
+    if finding == nil || !directives.suppresses(file, finding) {
+      filtered = append(filtered, finding)
+    }
+  }
+  return filtered
+}
+
+func parseLintInlineDirectives(file *shimast.SourceFile) *lintInlineDirectives {
+  directives := &lintInlineDirectives{
+    lines: make(map[int][]lintDirectiveRules),
+  }
+  scanner := shimscanner.NewScanner()
+  scanner.SetText(file.Text())
+  scanner.SetSkipTrivia(false)
+
+scan:
+  for {
+    kind := scanner.Scan()
+    switch kind {
+    case shimast.KindEndOfFile:
+      break scan
+    case shimast.KindSingleLineCommentTrivia, shimast.KindMultiLineCommentTrivia:
+    default:
+      continue
+    }
+    directive, ok := parseLintDirectiveComment(scanner.TokenText())
+    if !ok {
+      continue
+    }
+    start := scanner.TokenStart()
+    end := scanner.TokenEnd()
+    startLine := shimscanner.GetECMALineOfPosition(file, start)
+    endLine := startLine
+    if end > start {
+      endLine = shimscanner.GetECMALineOfPosition(file, end-1)
+    }
+    switch directive.kind {
+    case lintDirectiveDisableLine:
+      directives.lines[startLine] = append(directives.lines[startLine], directive.rules)
+    case lintDirectiveDisableNextLine:
+      directives.lines[endLine+1] = append(directives.lines[endLine+1], directive.rules)
+    case lintDirectiveDisable:
+      directives.events = append(directives.events, lintDirectiveEvent{
+        pos:   start,
+        rules: directive.rules,
+        on:    true,
+      })
+    case lintDirectiveEnable:
+      directives.events = append(directives.events, lintDirectiveEvent{
+        pos:   start,
+        rules: directive.rules,
+        on:    false,
+      })
+    }
+  }
+  return directives
+}
+
+func (d *lintInlineDirectives) empty() bool {
+  return d == nil || (len(d.lines) == 0 && len(d.events) == 0)
+}
+
+func (d *lintInlineDirectives) suppresses(file *shimast.SourceFile, finding *Finding) bool {
+  if d == nil || finding == nil || file == nil {
+    return false
+  }
+  line := shimscanner.GetECMALineOfPosition(file, finding.Pos)
+  for _, rules := range d.lines[line] {
+    if rules.matches(finding.Rule) {
+      return true
+    }
+  }
+  var state lintDisableState
+  for _, event := range d.events {
+    if event.pos > finding.Pos {
+      break
+    }
+    state.apply(event)
+  }
+  return state.matches(finding.Rule)
+}
+
+func (s *lintDisableState) apply(event lintDirectiveEvent) {
+  if event.on {
+    if event.rules.all {
+      s.all = true
+      s.enabledInAll = nil
+      return
+    }
+    if s.rules == nil {
+      s.rules = make(map[string]struct{}, len(event.rules.rules))
+    }
+    for rule := range event.rules.rules {
+      s.rules[rule] = struct{}{}
+      delete(s.enabledInAll, rule)
+    }
+    return
+  }
+
+  if event.rules.all {
+    s.all = false
+    s.rules = nil
+    s.enabledInAll = nil
+    return
+  }
+  for rule := range event.rules.rules {
+    delete(s.rules, rule)
+    if s.all {
+      if s.enabledInAll == nil {
+        s.enabledInAll = make(map[string]struct{}, len(event.rules.rules))
+      }
+      s.enabledInAll[rule] = struct{}{}
+    }
+  }
+}
+
+func (s lintDisableState) matches(rule string) bool {
+  normalized := normalizeDirectiveRuleName(rule)
+  if _, ok := s.rules[normalized]; ok {
+    return true
+  }
+  if !s.all {
+    return false
+  }
+  _, enabled := s.enabledInAll[normalized]
+  return !enabled
+}
+
+func (r lintDirectiveRules) matches(rule string) bool {
+  if r.all {
+    return true
+  }
+  _, ok := r.rules[normalizeDirectiveRuleName(rule)]
+  return ok
+}
+
+func parseLintDirectiveComment(raw string) (lintDirective, bool) {
+  text := stripCommentDelimiters(raw)
+  if directive, ok := parseLintDirectiveLine(text); ok {
+    return directive, true
+  }
+  return lintDirective{}, false
+}
+
+func stripCommentDelimiters(raw string) string {
+  switch {
+  case strings.HasPrefix(raw, "//"):
+    return strings.TrimSpace(raw[2:])
+  case strings.HasPrefix(raw, "/*"):
+    text := raw[2:]
+    if strings.HasSuffix(text, "*/") {
+      text = text[:len(text)-2]
+    }
+    text = strings.TrimSpace(text)
+    if strings.HasPrefix(text, "*") {
+      text = strings.TrimSpace(text[1:])
+    }
+    return text
+  default:
+    return strings.TrimSpace(raw)
+  }
+}
+
+func parseLintDirectiveLine(text string) (lintDirective, bool) {
+  for _, prefix := range []string{"eslint", "lint"} {
+    for _, form := range []struct {
+      suffix string
+      kind   lintDirectiveKind
+    }{
+      {"disable-next-line", lintDirectiveDisableNextLine},
+      {"disable-line", lintDirectiveDisableLine},
+      {"disable", lintDirectiveDisable},
+      {"enable", lintDirectiveEnable},
+    } {
+      marker := prefix + "-" + form.suffix
+      payload, ok := directivePayload(text, marker)
+      if !ok {
+        continue
+      }
+      return lintDirective{
+        kind:  form.kind,
+        rules: parseDirectiveRules(payload),
+      }, true
+    }
+  }
+  return lintDirective{}, false
+}
+
+func directivePayload(text, marker string) (string, bool) {
+  if !strings.HasPrefix(text, marker) {
+    return "", false
+  }
+  rest := text[len(marker):]
+  if rest != "" && rest[0] != ' ' && rest[0] != '\t' && rest[0] != '\r' && rest[0] != '\n' {
+    return "", false
+  }
+  return strings.TrimSpace(rest), true
+}
+
+func parseDirectiveRules(payload string) lintDirectiveRules {
+  payload = stripDirectiveDescription(payload)
+  payload = strings.ReplaceAll(payload, ",", " ")
+  fields := strings.Fields(payload)
+  rules := make(map[string]struct{}, len(fields))
+  for _, field := range fields {
+    if strings.HasPrefix(field, "--") {
+      break
+    }
+    name := normalizeDirectiveRuleName(field)
+    if name != "" {
+      rules[name] = struct{}{}
+    }
+  }
+  if len(rules) == 0 {
+    return lintDirectiveRules{all: true}
+  }
+  return lintDirectiveRules{rules: rules}
+}
+
+func stripDirectiveDescription(payload string) string {
+  for i := 0; i < len(payload)-1; i++ {
+    if payload[i] != '-' || payload[i+1] != '-' {
+      continue
+    }
+    prevOK := i == 0 || payload[i-1] == ' ' || payload[i-1] == '\t'
+    next := i + 2
+    nextOK := next >= len(payload) || payload[next] == ' ' || payload[next] == '\t'
+    if prevOK && nextOK {
+      return strings.TrimSpace(payload[:i])
+    }
+  }
+  return payload
+}
+
+func normalizeDirectiveRuleName(name string) string {
+  name = strings.TrimSpace(name)
+  name = strings.TrimPrefix(name, "@typescript-eslint/")
+  name = strings.TrimPrefix(name, "typescript-eslint/")
+  name = strings.TrimPrefix(name, "eslint/")
+  return name
+}

package/plugin/engine.go

@@ -145,7 +145,7 @@ func AllRuleNames() []string {
 // Engine binds a rule configuration to a Program and walks the AST once
 // per source file, dispatching each visited node to its interested rules.
 type Engine struct {
-  config  RuleConfig
+  config  RuleResolver
   rules   map[shimast.Kind][]Rule
   enabled map[string]Severity
   unknown []string
@@ -156,21 +156,28 @@ type Engine struct {
 // an unknown rule are recorded so the caller can surface them as a
 // configuration warning rather than a silent typo.
 func NewEngine(config RuleConfig) *Engine {
+  return NewEngineWithResolver(config)
+}
+
+// NewEngineWithResolver returns an engine configured by a resolver that can
+// vary rule severities per file.
+func NewEngineWithResolver(config RuleResolver) *Engine {
+  if config == nil {
+    config = RuleConfig{}
+  }
   eng := &Engine{
     config:  config,
     rules:   make(map[shimast.Kind][]Rule),
     enabled: make(map[string]Severity),
   }
-  for name, sev := range config {
+  displaySeverities := config.EnabledRuleConfig()
+  for _, name := range config.ActiveRuleNames() {
     rule, ok := registered.rules[name]
     if !ok {
       eng.unknown = append(eng.unknown, name)
       continue
     }
-    if sev == SeverityOff {
-      continue
-    }
-    eng.enabled[name] = sev
+    eng.enabled[name] = displaySeverities.Severity(name)
     for _, kind := range rule.Visits() {
       eng.rules[kind] = append(eng.rules[kind], rule)
     }
@@ -206,6 +213,11 @@ func (e *Engine) Run(files []*shimast.SourceFile, checker *shimchecker.Checker)
 func (e *Engine) runFile(file *shimast.SourceFile, checker *shimchecker.Checker) []*Finding {
   var collected []*Finding
   collect := func(f *Finding) { collected = append(collected, f) }
+  resolved := e.config.ResolveRules(file.FileName())
+  if resolved.Ignored {
+    return collected
+  }
+  fileRules := resolved.Rules
 
   var walk func(node *shimast.Node)
   walk = func(node *shimast.Node) {
@@ -214,10 +226,14 @@ func (e *Engine) runFile(file *shimast.SourceFile, checker *shimchecker.Checker)
     }
     if rules, ok := e.rules[node.Kind]; ok {
       for _, rule := range rules {
+        severity := fileRules.Severity(rule.Name())
+        if severity == SeverityOff {
+          continue
+        }
         ctx := &Context{
           File:     file,
           Checker:  checker,
-          Severity: e.enabled[rule.Name()],
+          Severity: severity,
           rule:     rule,
           collect:  collect,
         }
@@ -236,10 +252,14 @@ func (e *Engine) runFile(file *shimast.SourceFile, checker *shimchecker.Checker)
   // SourceFile).
   if rules, ok := e.rules[shimast.KindSourceFile]; ok {
     for _, rule := range rules {
+      severity := fileRules.Severity(rule.Name())
+      if severity == SeverityOff {
+        continue
+      }
       ctx := &Context{
         File:     file,
         Checker:  checker,
-        Severity: e.enabled[rule.Name()],
+        Severity: severity,
         rule:     rule,
         collect:  collect,
       }
@@ -254,5 +274,5 @@ func (e *Engine) runFile(file *shimast.SourceFile, checker *shimchecker.Checker)
   for _, stmt := range statements.Nodes {
     walk(stmt)
   }
-  return collected
+  return filterInlineDisabledFindings(file, collected)
 }

package/plugin/eslint_runtime.go

@@ -0,0 +1,246 @@
+package main
+
+import (
+  "encoding/json"
+  "fmt"
+  "os"
+  "os/exec"
+  "path/filepath"
+  "strings"
+  "unicode/utf8"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimdw "github.com/microsoft/typescript-go/shim/diagnosticwriter"
+)
+
+type eslintRuntimeProvider interface {
+  ExternalConfigPath() string
+  WantsESLintRuntime() bool
+  RequiresESLintRuntime() bool
+}
+
+type eslintRuntimeOutput struct {
+  Missing bool                `json:"missing"`
+  Results []eslintRuntimeFile `json:"results"`
+}
+
+type eslintRuntimeFile struct {
+  FilePath string                 `json:"filePath"`
+  Messages []eslintRuntimeMessage `json:"messages"`
+}
+
+type eslintRuntimeMessage struct {
+  RuleID    string `json:"ruleId"`
+  Severity  int    `json:"severity"`
+  Message   string `json:"message"`
+  Line      int    `json:"line"`
+  Column    int    `json:"column"`
+  EndLine   int    `json:"endLine"`
+  EndColumn int    `json:"endColumn"`
+}
+
+func runExternalESLintDiagnostics(
+  resolver RuleResolver,
+  cwd string,
+  files []*shimast.SourceFile,
+) ([]*shimdw.LintDiagnostic, bool, error) {
+  provider, ok := resolver.(eslintRuntimeProvider)
+  if !ok || !provider.WantsESLintRuntime() {
+    return nil, false, nil
+  }
+  configPath := provider.ExternalConfigPath()
+  if configPath == "" {
+    return nil, false, nil
+  }
+
+  fileNames := make([]string, 0, len(files))
+  byPath := make(map[string]*shimast.SourceFile, len(files))
+  for _, file := range files {
+    if file == nil || file.IsDeclarationFile {
+      continue
+    }
+    name := file.FileName()
+    if !filepath.IsAbs(name) {
+      name = filepath.Join(cwd, name)
+    }
+    if abs, err := filepath.Abs(name); err == nil {
+      name = abs
+    }
+    fileNames = append(fileNames, name)
+    byPath[filepath.ToSlash(name)] = file
+  }
+  if len(fileNames) == 0 {
+    return nil, true, nil
+  }
+
+  payload, err := json.Marshal(fileNames)
+  if err != nil {
+    return nil, false, fmt.Errorf("@ttsc/lint: encode ESLint file list: %w", err)
+  }
+
+  output, err := runExternalESLint(cwd, configPath, string(payload))
+  if err != nil {
+    return nil, false, err
+  }
+  if output.Missing {
+    if provider.RequiresESLintRuntime() {
+      return nil, false, fmt.Errorf("@ttsc/lint: ESLint runtime is required by %s; install eslint in the project or replace runtime-only config features", configPath)
+    }
+    return nil, false, nil
+  }
+
+  diagnostics := make([]*shimdw.LintDiagnostic, 0)
+  for _, result := range output.Results {
+    file := byPath[filepath.ToSlash(result.FilePath)]
+    if file == nil {
+      continue
+    }
+    for _, msg := range result.Messages {
+      if msg.Severity == 0 {
+        continue
+      }
+      ruleID := strings.TrimSpace(msg.RuleID)
+      if ruleID == "" {
+        ruleID = "eslint"
+      }
+      category := shimdw.LintCategoryWarning
+      if msg.Severity >= 2 {
+        category = shimdw.LintCategoryError
+      }
+      pos := positionOfESLintLocation(file.Text(), msg.Line, msg.Column)
+      end := positionOfESLintLocation(file.Text(), msg.EndLine, msg.EndColumn)
+      if end <= pos {
+        end = pos + 1
+      }
+      diagnostics = append(diagnostics, shimdw.NewLintDiagnostic(
+        file,
+        pos,
+        end,
+        ruleCode(ruleID),
+        category,
+        fmt.Sprintf("[%s] %s", ruleID, msg.Message),
+      ))
+    }
+  }
+  return diagnostics, true, nil
+}
+
+func runExternalESLint(cwd, configPath, fileListJSON string) (*eslintRuntimeOutput, error) {
+  node := os.Getenv("TTSC_NODE_BINARY")
+  if node == "" {
+    node = "node"
+  }
+  cmd := exec.Command(node, "-e", externalESLintRunnerScript, cwd, configPath, fileListJSON)
+  cmd.Env = nodeConfigLoaderEnv(configPath)
+  cmd.Dir = cwd
+  raw, err := cmd.Output()
+  if err != nil {
+    stderr := ""
+    if exit, ok := err.(*exec.ExitError); ok {
+      stderr = strings.TrimSpace(string(exit.Stderr))
+    }
+    if stderr != "" {
+      return nil, fmt.Errorf("@ttsc/lint: run ESLint config %s: %s", configPath, stderr)
+    }
+    return nil, fmt.Errorf("@ttsc/lint: run ESLint config %s: %w", configPath, err)
+  }
+  var output eslintRuntimeOutput
+  if err := json.Unmarshal(raw, &output); err != nil {
+    return nil, fmt.Errorf("@ttsc/lint: parse ESLint output for %s: %w", configPath, err)
+  }
+  return &output, nil
+}
+
+func positionOfESLintLocation(text string, line, column int) int {
+  if line <= 0 {
+    line = 1
+  }
+  if column <= 0 {
+    column = 1
+  }
+  lineStart := 0
+  currentLine := 1
+  for i := 0; i < len(text) && currentLine < line; {
+    r, size := utf8.DecodeRuneInString(text[i:])
+    if r == '\n' {
+      currentLine++
+      lineStart = i + size
+    }
+    i += size
+  }
+  targetUTF16 := column - 1
+  seenUTF16 := 0
+  for i := lineStart; i < len(text); {
+    if seenUTF16 >= targetUTF16 {
+      return i
+    }
+    r, size := utf8.DecodeRuneInString(text[i:])
+    if r == '\n' || r == '\r' {
+      return i
+    }
+    if r > 0xFFFF {
+      seenUTF16 += 2
+    } else {
+      seenUTF16++
+    }
+    i += size
+  }
+  return len(text)
+}
+
+const externalESLintRunnerScript = `
+const { createRequire } = require("node:module");
+const path = require("node:path");
+
+(async () => {
+  const cwd = process.argv[1];
+  const configPath = process.argv[2];
+  const files = JSON.parse(process.argv[3]);
+  const requireFromProject = createRequire(path.join(cwd, "package.json"));
+  let eslintPath;
+  try {
+    eslintPath = requireFromProject.resolve("eslint");
+  } catch (error) {
+    if (error && error.code === "MODULE_NOT_FOUND") {
+      process.stdout.write(JSON.stringify({ missing: true, results: [] }));
+      return;
+    }
+    throw error;
+  }
+  const eslintModule = requireFromProject(eslintPath);
+
+  const ESLintCtor = typeof eslintModule.loadESLint === "function"
+    ? await eslintModule.loadESLint({ useFlatConfig: true })
+    : eslintModule.ESLint ?? eslintModule.default?.ESLint ?? eslintModule.default;
+
+  if (typeof ESLintCtor !== "function") {
+    throw new Error("installed eslint package does not export ESLint or loadESLint");
+  }
+
+  const eslint = new ESLintCtor({
+    cwd,
+    overrideConfigFile: configPath,
+    ignore: true,
+    warnIgnored: false,
+  });
+  const results = await eslint.lintFiles(files);
+  process.stdout.write(JSON.stringify({
+    missing: false,
+    results: results.map((result) => ({
+      filePath: result.filePath,
+      messages: result.messages.map((message) => ({
+        ruleId: message.ruleId || "eslint",
+        severity: message.severity,
+        message: message.message,
+        line: message.line || 1,
+        column: message.column || 1,
+        endLine: message.endLine || message.line || 1,
+        endColumn: message.endColumn || message.column || 1,
+      })),
+    })),
+  }));
+})().catch((error) => {
+  process.stderr.write(error && error.stack ? error.stack : String(error));
+  process.exit(1);
+});
+`

package/src/config.ts

@@ -0,0 +1,3 @@
+export type { TtscLintConfig } from "./structures/TtscLintConfig";
+export type { TtscLintRule } from "./structures/TtscLintRule";
+export type { TtscLintSeverity } from "./structures/TtscLintSeverity";

package/src/structures/ITtscLintPluginConfig.ts

@@ -5,10 +5,11 @@ import type { TtscLintConfig } from "./TtscLintConfig";
 /** `compilerOptions.plugins[]` entry shape consumed by `@ttsc/lint`. */
 export interface ITtscLintPluginConfig extends ITtscProjectPluginConfig {
   /**
-   * Inline rule map or path to a JSON config file.
+   * Inline rule map or path to a standalone lint config file.
    *
    * Inline maps are passed to the native sidecar through `--plugins-json`.
-   * String values are resolved by the sidecar from the project root.
+   * String values are resolved by the sidecar from the owning tsconfig
+   * directory and may point at JSON, JavaScript, or TypeScript config files.
    */
   config?: string | TtscLintConfig;
 }

package/src/structures/TtscLintConfig.ts

@@ -4,9 +4,8 @@ import type { TtscLintSeverity } from "./TtscLintSeverity";
 /**
  * Inline rule map accepted by the `@ttsc/lint` tsconfig plugin entry.
  *
- * Each property key is a native lint rule name. Omitted rules use the sidecar's
- * default severity, while present rules override that severity for the current
- * project.
+ * Each property key is a native lint rule name. Omitted rules are disabled,
+ * while present rules enable or disable that rule for the current project.
  */
 export type TtscLintConfig = {
   [P in TtscLintRule]?: TtscLintSeverity;