@ttsc/lint 0.19.3 → 0.20.1

package/linthost/contrib_adapter.go

@@ -94,6 +94,7 @@ type contributorMetadata struct {
   visits                 []shimast.Kind
   visitsDeclarationFiles bool
   needsTypeChecker       bool
+  diagnosticTags         []rule.DiagnosticTag
 }
 
 // inspectContributor evaluates the public rule metadata behind a recover
@@ -124,6 +125,9 @@ func inspectContributor(contributor rule.Rule) (metadata contributorMetadata, er
   if typeAware, ok := contributor.(rule.TypeAwareRule); ok {
     metadata.needsTypeChecker = typeAware.NeedsTypeChecker()
   }
+  if tagged, ok := contributor.(rule.TaggedRule); ok {
+    metadata.diagnosticTags = tagged.DiagnosticTags()
+  }
   if optionsRule, ok := contributor.(rule.OptionsRule); ok {
     metadata.acceptsOptions = optionsRule.AcceptsTtscLintOptions()
   }
@@ -142,6 +146,7 @@ func newContributorAdapter(metadata contributorMetadata) contributorAdapter {
     visits:                 metadata.visits,
     visitsDeclarationFiles: metadata.visitsDeclarationFiles,
     needsTypeChecker:       metadata.needsTypeChecker,
+    diagnosticTags:         metadata.diagnosticTags,
   }
 }
 
@@ -159,6 +164,7 @@ type contributorAdapter struct {
   visits                 []shimast.Kind
   visitsDeclarationFiles bool
   needsTypeChecker       bool
+  diagnosticTags         []rule.DiagnosticTag
 }
 
 // AcceptsTtscLintOptions preserves the public contributor contract:
@@ -190,6 +196,14 @@ func (a contributorAdapter) VisitsDeclarationFiles() bool {
   return a.visitsDeclarationFiles
 }
 
+// DiagnosticTags forwards the contributor's rule.TaggedRule classification so
+// the host reads it through the same assertion path as a built-in tagged rule.
+// Without this the wrapping adapter would hide the marker and every
+// contributor's tags would silently vanish.
+func (a contributorAdapter) DiagnosticTags() []rule.DiagnosticTag {
+  return a.diagnosticTags
+}
+
 // formatContributorAdapter is the FormatRule-tagged variant of
 // contributorAdapter. Wrapping the lint-only adapter (rather than
 // duplicating its method set) keeps the marker addition trivial and
@@ -241,6 +255,49 @@ func (r contextReporter) ReportRangeFix(pos, end int, message string, edits ...r
   r.ctx.ReportRangeFix(pos, end, message, toInternalTextEdits(edits)...)
 }
 
+// ReportSuggestion and ReportRangeSuggestion satisfy rule.SuggestionReporter,
+// so a contributor can offer a choice of fixes — the surface built-in rules
+// already had internally and contributors could not reach.
+func (r contextReporter) ReportSuggestion(node *shimast.Node, message string, suggestions ...rule.Suggestion) {
+  r.ctx.ReportFixSuggestions(node, message, nil, toInternalSuggestions(suggestions)...)
+}
+
+func (r contextReporter) ReportRangeSuggestion(pos, end int, message string, suggestions ...rule.Suggestion) {
+  r.ctx.ReportRangeSuggestions(pos, end, message, toInternalSuggestions(suggestions)...)
+}
+
+func toInternalSuggestions(suggestions []rule.Suggestion) []Suggestion {
+  if len(suggestions) == 0 {
+    return nil
+  }
+  out := make([]Suggestion, len(suggestions))
+  for i, suggestion := range suggestions {
+    out[i] = Suggestion{
+      Title: suggestion.Title,
+      Edits: toInternalTextEdits(suggestion.Edits),
+    }
+  }
+  return out
+}
+
+func (r contextReporter) ReportRelated(node *shimast.Node, message string, related ...rule.RelatedInformation) {
+  r.ctx.ReportRelated(node, message, related...)
+}
+
+func (r contextReporter) ReportRangeRelated(pos, end int, message string, related ...rule.RelatedInformation) {
+  r.ctx.ReportRangeRelated(pos, end, message, related...)
+}
+
+// contextReporter must satisfy the optional reporter extensions whole, since the
+// public Context type-asserts against each: a signature drift here would
+// silently drop the rule back to the plain-diagnostic fallback instead of
+// failing the build.
+var (
+  _ rule.FixReporter        = contextReporter{}
+  _ rule.SuggestionReporter = contextReporter{}
+  _ rule.RelatedReporter    = contextReporter{}
+)
+
 func toInternalTextEdits(edits []rule.TextEdit) []TextEdit {
   if len(edits) == 0 {
     return nil

package/linthost/dispatch.go

@@ -76,7 +76,7 @@ func run(args []string) int {
     // Don't pay contributor-registration cost for the version banner.
     fmt.Fprintf(os.Stdout, "@ttsc/lint %s\n", Version)
     return 0
-  case "check", "fix", "format", "build", "transform", "lsp-command-ids", "lsp-code-action-kinds", "lsp-diagnostics", "lsp-code-actions", "lsp-execute-command":
+  case "check", "fix", "format", "build", "transform", "lsp-command-ids", "lsp-code-action-kinds", "lsp-diagnostics", "lsp-code-actions", "lsp-execute-command", "lsp-hints", "lsp-serve":
   default:
     fmt.Fprintf(os.Stderr, "@ttsc/lint: unknown command %q\n", args[0])
     return 2
@@ -105,6 +105,10 @@ func run(args []string) int {
     return RunLSPCodeActions(args[1:])
   case "lsp-execute-command":
     return RunLSPExecuteCommand(args[1:])
+  case "lsp-hints":
+    return RunLSPHints(args[1:])
+  case "lsp-serve":
+    return RunLSPServe(os.Stdin, os.Stdout, args[1:])
   }
   return 2
 }

package/linthost/display_width.go

@@ -1,25 +1,72 @@
 package linthost
 
-import "unicode"
+import (
+  "regexp"
+  "strings"
+  "sync"
+  "unicode/utf16"
+)
+
+//go:generate node ../tools/widthgen/main.cjs
 
 // displayWidth returns the number of terminal columns a string occupies,
-// matching Prettier's getStringWidth: an ASCII string's width equals its byte
-// length, a zero-width combining mark counts as zero, and a wide East Asian
-// (or emoji) code point counts as two. Width decisions across the formatter,
-// the layout engine's fit checks and the print-width rule's source measurement,
-// must use display columns rather than byte length, or a multi-byte token (a
+// matching Prettier's getStringWidth. Width decisions across the formatter —
+// the layout engine's fit checks and the print-width rule's source measurement
+// — must use display columns rather than byte length, or a multi-byte token (a
 // subscript digit, a Hangul or CJK identifier) is over-counted and the line is
 // wrongly broken.
 //
-// A tab counts as one column here; callers that need tab-stop expansion handle
-// it separately (the layout engine emits indentation outside of Text nodes, so
-// an embedded tab is rare and was already charged as one byte before this).
+// This is a transcription of `prettier/src/utilities/get-string-width.js`, not
+// an implementation of the same idea. That distinction is the whole history of
+// this function: it began as a hand-written 13-range table that diverged on
+// 11,482 code points, and a first repair ported `string-width` — the package
+// the report named — which Prettier does not use, and which regressed
+// Devanagari, the Hangul fillers, the bidi controls, and 98 astral
+// text-presentation emoji before it was reverted. The tables and the emoji
+// pattern are generated from the module the lockfile pins, so there is no
+// second source that can be right about a different Prettier.
+//
+// The procedure, in Prettier's order:
+//
+//  1. An empty string is zero, and a pure-ASCII string is its length. The fast
+//     path is observable, not merely an optimization: U+007F returns 1 through
+//     it although the loop below would skip it.
+//  2. Every RGI emoji match is replaced by one space (for the ~65 Prettier
+//     charges narrow) or two, so a sequence costs its own width and its code
+//     points are never counted individually.
+//  3. What remains is counted per code point, skipping C0/C1 controls, the
+//     combining diacriticals U+0300-U+036F, and the variation selectors
+//     U+FE00-U+FE0F, charging 2 for East Asian Wide or Fullwidth and 1
+//     otherwise. Per CODE POINT, not per grapheme cluster: a combining mark
+//     outside that one block is charged, which is why `हिंदी` is five columns.
+//
+// One deviation is deliberate and predates all of this: a tab counts as one
+// column here, where Prettier's loop skips it as a control. Callers that need
+// tab-stop expansion handle it separately, and the layout engine emits
+// indentation outside the text it measures.
 func displayWidth(s string) int {
-  w := 0
-  for _, r := range s {
-    w += runeWidth(r)
+  if s == "" {
+    return 0
+  }
+  if !hasNonASCII(s) {
+    return len(s)
   }
-  return w
+  width := 0
+  for _, r := range replacePrettierEmoji(s) {
+    switch {
+    case r == '\t':
+      // The documented deviation, kept so tab-stop expansion stays the caller's.
+      width++
+    case r <= 0x1F, r >= 0x7F && r <= 0x9F:
+    case r >= 0x0300 && r <= 0x036F:
+    case r >= 0xFE00 && r <= 0xFE0F:
+    case isPrettierWide(r):
+      width += 2
+    default:
+      width++
+    }
+  }
+  return width
 }
 
 // displayWidthAfterLastNewline returns the display width of the substring that
@@ -35,38 +82,129 @@ func displayWidthAfterLastNewline(s string) int {
   return displayWidth(s)
 }
 
-// runeWidth returns the column width of a single rune: zero for a combining
-// mark or zero-width space, two for a wide East Asian or emoji code point, one
-// otherwise (tabs included, see displayWidth).
-func runeWidth(r rune) int {
-  if r == 0x200B || unicode.Is(unicode.Mn, r) || unicode.Is(unicode.Me, r) {
-    return 0
+// displayWidthFromColumn returns the display width of s laid out starting at
+// column `start`, expanding a tab to the next multiple of tabWidth. It is the
+// tab-aware form the source-measuring rules need, where a literal tab in the
+// file does advance to a tab stop; displayWidth itself charges a tab one column
+// because the layout engine emits indentation outside the text it measures.
+func displayWidthFromColumn(s string, tabWidth int, start int) int {
+  if tabWidth <= 0 {
+    tabWidth = 2
   }
-  if isWideRune(r) {
-    return 2
+  // Walked one tab at a time rather than by splitting, so each tab advances
+  // from the column the text before it actually reached.
+  column := start
+  rest := s
+  for {
+    index := strings.IndexByte(rest, '\t')
+    if index < 0 {
+      column += displayWidth(rest)
+      break
+    }
+    column += displayWidth(rest[:index])
+    column += tabWidth - (column % tabWidth)
+    rest = rest[index+1:]
   }
-  return 1
+  return column - start
 }
 
-// isWideRune reports whether a rune renders in two terminal columns, covering
-// the East Asian Wide / Fullwidth ranges and the common emoji blocks the way
-// Prettier's width table does.
-func isWideRune(r rune) bool {
-  switch {
-  case r >= 0x1100 && r <= 0x115F, // Hangul Jamo
-    r >= 0x2E80 && r <= 0x303E,   // CJK Radicals .. CJK Symbols (part)
-    r >= 0x3041 && r <= 0x33FF,   // Hiragana .. CJK Compatibility
-    r >= 0x3400 && r <= 0x4DBF,   // CJK Extension A
-    r >= 0x4E00 && r <= 0x9FFF,   // CJK Unified Ideographs
-    r >= 0xA000 && r <= 0xA4CF,   // Yi
-    r >= 0xAC00 && r <= 0xD7A3,   // Hangul Syllables
-    r >= 0xF900 && r <= 0xFAFF,   // CJK Compatibility Ideographs
-    r >= 0xFE30 && r <= 0xFE4F,   // CJK Compatibility Forms
-    r >= 0xFF00 && r <= 0xFF60,   // Fullwidth Forms
-    r >= 0xFFE0 && r <= 0xFFE6,   // Fullwidth signs
-    r >= 0x1F300 && r <= 0x1FAFF, // emoji & pictographs
-    r >= 0x20000 && r <= 0x3FFFD: // CJK Extension B and beyond
-    return true
+// hasNonASCII reports whether s holds a byte outside Prettier's printable-ASCII
+// fast-path range, matching its `/[^\x20-\x7F]/u` test. A multi-byte rune's
+// lead byte is >= 0x80, so a byte scan answers the same question.
+func hasNonASCII(s string) bool {
+  for i := 0; i < len(s); i++ {
+    if s[i] < 0x20 || s[i] > 0x7F {
+      return true
+    }
+  }
+  return false
+}
+
+var prettierEmojiRegexp = sync.OnceValue(func() *regexp.Regexp {
+  return regexp.MustCompile(prettierEmojiPattern)
+})
+
+// replacePrettierEmoji performs Prettier's emoji substitution: every RGI emoji
+// becomes one space when Prettier charges it one column, two spaces otherwise.
+//
+// The work happens in the shifted UTF-16 domain the generated pattern is
+// written against, because emoji-regex matches code units and a Go string
+// cannot hold a lone surrogate. Text goes in as runes, becomes units, each
+// surrogate unit moves into a private-use range, the match runs, and the result
+// comes back. The mapping is a bijection over a range nothing else occupies.
+func replacePrettierEmoji(s string) string {
+  shifted := shiftToUTF16Domain(s)
+  replaced := prettierEmojiRegexp().ReplaceAllStringFunc(shifted, func(match string) string {
+    if isNarrowPrettierEmoji(match) {
+      return " "
+    }
+    return "  "
+  })
+  if replaced == shifted {
+    return s
+  }
+  return unshiftFromUTF16Domain(replaced)
+}
+
+// isNarrowPrettierEmoji reports whether a match is one of the emoji Prettier
+// charges a single column. The set is single code points, so a match of any
+// other length is never narrow.
+func isNarrowPrettierEmoji(match string) bool {
+  runes := []rune(unshiftFromUTF16Domain(match))
+  return len(runes) == 1 && inUnicodeRanges(prettierNarrowEmojiRanges[:], runes[0])
+}
+
+// shiftToUTF16Domain encodes s as UTF-16 and represents each code unit as one
+// rune, relocating surrogates so the result is a valid Go string.
+func shiftToUTF16Domain(s string) string {
+  units := utf16.Encode([]rune(s))
+  out := make([]rune, 0, len(units))
+  for _, unit := range units {
+    r := rune(unit)
+    if r >= 0xD800 && r <= 0xDFFF {
+      r = r - 0xD800 + surrogateShift
+    }
+    out = append(out, r)
+  }
+  return string(out)
+}
+
+// unshiftFromUTF16Domain is shiftToUTF16Domain's inverse.
+func unshiftFromUTF16Domain(s string) string {
+  units := make([]uint16, 0, len(s))
+  for _, r := range s {
+    if r >= surrogateShift && r <= surrogateShift+0x7FF {
+      r = r - surrogateShift + 0xD800
+    }
+    if r > 0xFFFF {
+      units = append(units, utf16.Encode([]rune{r})...)
+      continue
+    }
+    units = append(units, uint16(r))
+  }
+  return string(utf16.Decode(units))
+}
+
+func isPrettierWide(r rune) bool {
+  return inUnicodeRanges(prettierWideRanges[:], r) ||
+    inUnicodeRanges(prettierFullWidthRanges[:], r)
+}
+
+// inUnicodeRanges reports whether r falls in one of the sorted, disjoint
+// ranges of a generated property table.
+func inUnicodeRanges(ranges []unicodeRange, r rune) bool {
+  lo, hi := 0, len(ranges)
+  for lo < hi {
+    middle := int(uint(lo+hi) >> 1)
+    candidate := ranges[middle]
+    switch {
+    case r < candidate.lo:
+      hi = middle
+    case r > candidate.hi:
+      lo = middle + 1
+    default:
+      return true
+    }
   }
   return false
 }

package/linthost/engine.go

@@ -107,6 +107,17 @@ func ruleNeedsTypeChecker(r Rule) bool {
   return ok && tr.NeedsTypeChecker()
 }
 
+// ruleDiagnosticTags returns the diagnostic tags a rule classifies its findings
+// with, or nil when the rule implements no marker or returns none. Read once per
+// (file, rule) at dispatch and copied onto every finding the rule produces.
+func ruleDiagnosticTags(r Rule) []publicrule.DiagnosticTag {
+  tagged, ok := r.(publicrule.TaggedRule)
+  if !ok {
+    return nil
+  }
+  return tagged.DiagnosticTags()
+}
+
 func ruleAcceptsOptions(r Rule) bool {
   acceptor, ok := r.(ruleOptionsAcceptor)
   return ok && acceptor.AcceptsTtscLintOptions()
@@ -139,6 +150,7 @@ type Context struct {
 
   rule           Rule
   isFormat       bool
+  tags           []publicrule.DiagnosticTag
   quarantined    bool
   collect        func(*Finding)
   projectResults publicrule.ProjectResultReader
@@ -216,6 +228,15 @@ type Finding struct {
   Fix         []TextEdit
   Suggestions []Suggestion
   IsFormat    bool
+  // Tags classify what the finding is (unnecessary, deprecated), for an editor
+  // to render it distinctively. Populated from the rule's TaggedRule marker at
+  // dispatch, so every finding a tagged rule produces carries its tags.
+  Tags []publicrule.DiagnosticTag
+  // RelatedInformation are secondary locations this finding points at, each with
+  // a message. Positions are byte offsets into File — already normalized against
+  // it at report time — so the LSP renderer resolves them against File's text
+  // and attaches File's own URI.
+  RelatedInformation []publicrule.RelatedInformation
 
   engineFailure bool
 }
@@ -262,6 +283,7 @@ func (c *Context) ReportFix(node *shimast.Node, message string, edits ...TextEdi
     Message:  message,
     Fix:      cloneTextEdits(edits),
     IsFormat: c.isFormat,
+    Tags:     c.tags,
   })
 }
 
@@ -282,6 +304,7 @@ func (c *Context) ReportSuggestion(node *shimast.Node, message string, title str
     Message:     message,
     Suggestions: newSuggestions(title, edits),
     IsFormat:    c.isFormat,
+    Tags:        c.tags,
   })
 }
 
@@ -309,6 +332,7 @@ func (c *Context) ReportFixSuggestions(
     Fix:         cloneTextEdits(fix),
     Suggestions: cloneSuggestions(suggestions),
     IsFormat:    c.isFormat,
+    Tags:        c.tags,
   })
 }
 
@@ -348,6 +372,7 @@ func (c *Context) ReportRangeFix(pos, end int, message string, edits ...TextEdit
     Message:  message,
     Fix:      cloneTextEdits(edits),
     IsFormat: c.isFormat,
+    Tags:     c.tags,
   })
 }
 
@@ -368,9 +393,95 @@ func (c *Context) ReportRangeSuggestion(pos, end int, message string, title stri
     Message:     message,
     Suggestions: newSuggestions(title, edits),
     IsFormat:    c.isFormat,
+    Tags:        c.tags,
+  })
+}
+
+// ReportRangeSuggestions records a finding at an explicit range with several
+// candidate suggestions. It is the range counterpart of ReportFixSuggestions,
+// added so the public contributor surface can offer a choice at a sub-token
+// range and not only at a whole node.
+func (c *Context) ReportRangeSuggestions(pos, end int, message string, suggestions ...Suggestion) {
+  if c.Severity == SeverityOff || c.File == nil {
+    return
+  }
+  pos, end = shimdw.NormalizeLintRange(c.File, pos, end)
+  c.collect(&Finding{
+    Rule:        c.rule.Name(),
+    Severity:    c.Severity,
+    File:        c.File,
+    Pos:         pos,
+    End:         end,
+    Message:     message,
+    Suggestions: cloneSuggestions(suggestions),
+    IsFormat:    c.isFormat,
+    Tags:        c.tags,
+  })
+}
+
+// ReportRelated records a node-scoped finding with related source locations.
+// Each related location's Pos/End is normalized against the current file — the
+// same bounding a range finding gets — so a rule that miscomputed an offset
+// cannot point the editor outside the file.
+func (c *Context) ReportRelated(node *shimast.Node, message string, related ...publicrule.RelatedInformation) {
+  if c.Severity == SeverityOff || node == nil {
+    return
+  }
+  pos, end := c.nodeFindingRange(node)
+  c.collect(&Finding{
+    Rule:               c.rule.Name(),
+    Severity:           c.Severity,
+    File:               c.File,
+    Pos:                pos,
+    End:                end,
+    Message:            message,
+    RelatedInformation: c.normalizeRelated(related),
+    IsFormat:           c.isFormat,
+    Tags:               c.tags,
+  })
+}
+
+// ReportRangeRelated records an explicit-range finding with related source
+// locations. Both the primary range and each related range are normalized
+// against the current file.
+func (c *Context) ReportRangeRelated(pos, end int, message string, related ...publicrule.RelatedInformation) {
+  if c.Severity == SeverityOff || c.File == nil {
+    return
+  }
+  pos, end = shimdw.NormalizeLintRange(c.File, pos, end)
+  c.collect(&Finding{
+    Rule:               c.rule.Name(),
+    Severity:           c.Severity,
+    File:               c.File,
+    Pos:                pos,
+    End:                end,
+    Message:            message,
+    RelatedInformation: c.normalizeRelated(related),
+    IsFormat:           c.isFormat,
+    Tags:               c.tags,
   })
 }
 
+// normalizeRelated copies the caller's related locations and bounds each range
+// to the current file, so the stored Finding owns its slice and every position
+// is already safe for the renderer. Returns nil for an empty input, keeping the
+// Finding field nil rather than a zero-length slice.
+func (c *Context) normalizeRelated(related []publicrule.RelatedInformation) []publicrule.RelatedInformation {
+  if len(related) == 0 {
+    return nil
+  }
+  out := make([]publicrule.RelatedInformation, 0, len(related))
+  for _, item := range related {
+    pos, end := shimdw.NormalizeLintRange(c.File, item.Pos, item.End)
+    out = append(out, publicrule.RelatedInformation{
+      Pos:     pos,
+      End:     end,
+      Message: item.Message,
+    })
+  }
+  return out
+}
+
 // cloneTextEdits returns a shallow copy of `edits` so that the caller's
 // variadic slice cannot be mutated through the stored Finding. Returns nil
 // when the input is empty, keeping the Finding.Fix field nil rather than
@@ -529,7 +640,11 @@ func NewEngineWithResolver(config RuleResolver) *Engine {
         fmt.Errorf("@ttsc/lint: invalid options for rule %q: rule does not accept options", name),
       )
     }
-    if setting.Declared && setting.Severity != SeverityOff {
+    // A project rule shares the engine-wide checker decision with every file
+    // rule, so one that declines the checker must not drag the whole run onto
+    // the serial walk. An unmarked rule keeps the conservative default.
+    if setting.Declared && setting.Severity != SeverityOff &&
+      projectRuleNeedsTypeChecker(name) {
       eng.needsTypeChecker = true
     }
   }
@@ -554,11 +669,11 @@ func NewEngineWithResolver(config RuleResolver) *Engine {
     }
   }
   for _, name := range config.ActiveRuleNames() {
-    if _, isProjectRule := registeredProjectRules[name]; isProjectRule {
-      continue
-    }
     rule, ok := registered.rules[name]
     if !ok {
+      if _, isProjectRule := registeredProjectRules[name]; isProjectRule {
+        continue
+      }
       eng.unknown = append(eng.unknown, name)
       continue
     }
@@ -869,6 +984,7 @@ func (e *Engine) runFile(
             Options:          options,
             rule:             rule,
             isFormat:         isFormatRule(rule),
+            tags:             ruleDiagnosticTags(rule),
             collect:          collect,
             projectResults:   results,
             fileMemo:         memo,

package/linthost/flags_gen.go

@@ -17,17 +17,17 @@ var LintFlagAllowList = map[string]bool{
   "cwd":                  true,
   "diagnostics":          false,
   "emit":                 false,
-  "extendedDiagnostics":  false,
+  "extendeddiagnostics":  false,
   "file":                 true,
-  "noEmit":               false,
+  "noemit":               false,
   "out":                  true,
-  "outDir":               true,
+  "outdir":               true,
   "p":                    true,
   "plugins-json":         true,
   "project":              true,
   "project-context-json": true,
   "quiet":                false,
-  "singleThreaded":       false,
+  "singlethreaded":       false,
   "tsconfig":             true,
   "tsgo-args":            true,
   "verbose":              false,