@ttsc/lint 0.10.2 → 0.11.0-dev.20260517

package/linthost/print_nodes_imports.go

@@ -0,0 +1,171 @@
+package linthost
+
+import (
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+// printNamedImports renders `{ a, b, c }` inside an import declaration.
+// Each specifier flows through PrintNode, so `a as b` shapes that the
+// dispatcher does not understand yet still print verbatim.
+//
+// Flat:    `{ a, b, c }`
+//
+//  Broken:  `{
+//              a,
+//              b,
+//              c,
+//           }`
+//
+// The open/close braces always carry a single space inside in flat
+// mode, matching Prettier's `bracketSpacing: true` default for import
+// declarations (which is hard-coded; Prettier ignores `bracketSpacing`
+// for imports). Empty named imports `{}` collapse cleanly.
+func printNamedImports(ctx *PrintContext, node *shimast.Node) Doc {
+  if node == nil {
+    return Doc{}
+  }
+  ni := node.AsNamedImports()
+  if ni == nil || ni.Elements == nil {
+    return verbatim(ctx, node)
+  }
+  items := make([]Doc, 0, len(ni.Elements.Nodes))
+  for _, spec := range ni.Elements.Nodes {
+    if spec == nil {
+      return verbatim(ctx, node)
+    }
+    doc, _ := PrintNode(ctx, spec)
+    items = append(items, doc)
+  }
+  return printList(ctx, listShape{
+    OpenTok:  "{",
+    CloseTok: "}",
+    Items:    items,
+    Space:    true,
+    AddComma: true,
+  })
+}
+
+// printNamedExports renders `export { a, b }`. The shape is identical
+// to NamedImports; only the surrounding declaration differs.
+func printNamedExports(ctx *PrintContext, node *shimast.Node) Doc {
+  if node == nil {
+    return Doc{}
+  }
+  ne := node.AsNamedExports()
+  if ne == nil || ne.Elements == nil {
+    return verbatim(ctx, node)
+  }
+  items := make([]Doc, 0, len(ne.Elements.Nodes))
+  for _, spec := range ne.Elements.Nodes {
+    if spec == nil {
+      return verbatim(ctx, node)
+    }
+    doc, _ := PrintNode(ctx, spec)
+    items = append(items, doc)
+  }
+  return printList(ctx, listShape{
+    OpenTok:  "{",
+    CloseTok: "}",
+    Items:    items,
+    Space:    true,
+    AddComma: true,
+  })
+}
+
+// printImportDeclaration renders the surrounding `import … from "x";`.
+// The default specifier, namespace import, named-imports clause, and
+// module specifier are all individually dispatched so the named-imports
+// portion can reflow while the rest stays verbatim.
+//
+// The dispatcher hands off to the per-clause printers; the top-level
+// frame stitches them together with the keywords and `from` token.
+func printImportDeclaration(ctx *PrintContext, node *shimast.Node) Doc {
+  if node == nil {
+    return Doc{}
+  }
+  imp := node.AsImportDeclaration()
+  if imp == nil {
+    return verbatim(ctx, node)
+  }
+  // If the declaration uses anything other than a vanilla
+  // `import { ... } from "x"` shape (default specifier, namespace
+  // alias, attributes clause, etc.), fall back to verbatim. The
+  // canonical reflow target is the named-import body.
+  clause := imp.ImportClause
+  if clause == nil {
+    return verbatim(ctx, node)
+  }
+  clauseData := clause.AsImportClause()
+  if clauseData == nil || clauseData.NamedBindings == nil {
+    return verbatim(ctx, node)
+  }
+  if clauseData.NamedBindings.Kind != shimast.KindNamedImports {
+    // Namespace imports (`import * as ns from "x"`) have no
+    // reflow surface; leave them alone.
+    return verbatim(ctx, node)
+  }
+  if clause.Name() != nil {
+    // `import Default, { … } from "x"` — keep verbatim for v1.
+    return verbatim(ctx, node)
+  }
+
+  // Bracketed clause prefix: `import ` (and optional `type `).
+  prefix := "import "
+  if clause.IsTypeOnly() {
+    prefix = "import type "
+  }
+  named, _ := PrintNode(ctx, clauseData.NamedBindings)
+  moduleSpec := verbatim(ctx, imp.ModuleSpecifier)
+  parts := []Doc{Text(prefix), named, Text(" from "), moduleSpec}
+  if sourceHasStatementTerminator(ctx.Source, node.End()) {
+    // Preserve the user's terminator decision. Emitting `;`
+    // unconditionally would collide with `format/semi`'s
+    // zero-width insert on the same cascade pass and produce
+    // `;;` — `format/semi` owns terminator placement.
+    parts = append(parts, Text(";"))
+  }
+  // AttributeClause (`with { ... }` / `assert { ... }`) lives after
+  // the module specifier. Fall back to verbatim when present so we
+  // don't drop attributes silently.
+  if imp.Attributes != nil {
+    return verbatim(ctx, node)
+  }
+  return Concat(parts...)
+}
+
+// sourceHasStatementTerminator reports whether the last non-trivia
+// byte at or before `end` is `;`. TypeScript-Go's parser folds an
+// optional trailing semicolon into the statement's End(), so this
+// check tells the printer whether the user wrote one.
+//
+// Trailing block comments (`import { … } from "x" /* tail */;`) sit
+// between the module specifier and the `;`. The backward walk must
+// step past them; otherwise the helper sees `/` from `*/` and
+// concludes "no terminator".
+func sourceHasStatementTerminator(src string, end int) bool {
+  i := end - 1
+  for i >= 0 {
+    c := src[i]
+    if c == ' ' || c == '\t' || c == '\r' || c == '\n' {
+      i--
+      continue
+    }
+    if c == ';' {
+      return true
+    }
+    // Skip a trailing block comment: walk back past `*/`...`/*`.
+    if c == '/' && i-1 >= 0 && src[i-1] == '*' {
+      j := i - 2
+      for j-1 >= 0 && !(src[j-1] == '/' && src[j] == '*') {
+        j--
+      }
+      if j-1 < 0 {
+        return false
+      }
+      i = j - 2
+      continue
+    }
+    return false
+  }
+  return false
+}

package/linthost/print_nodes_list.go

@@ -0,0 +1,64 @@
+package linthost
+
+// Shared helpers for comma-separated list printers.
+//
+// Object literals, array literals, call arguments, parameter lists,
+// named imports, named exports, tuple types, type-parameter lists —
+// they all share the same broken/flat shape:
+//
+//  flat:    OPEN child, child, child CLOSE
+//  broken:  OPEN
+//               child,
+//               child,
+//               child,        // optional trailing comma
+//           CLOSE
+//
+// printList captures that shape in one place so every per-node printer
+// can stay tiny.
+//
+// `openTok` and `closeTok` are the literal punctuation strings; the
+// helper does not look them up from the source because that lookup
+// would couple every list to its own scanner. `space` toggles the
+// "single space between OPEN and the first child" used by object
+// literals (`{ a }`) but not arrays (`[a]`).
+type listShape struct {
+  OpenTok  string
+  CloseTok string
+  Items    []Doc
+  Space    bool // emit a space after OPEN / before CLOSE in flat mode
+  AddComma bool // emit a trailing comma in broken mode
+}
+
+// printList renders the list shape as a Doc tree. Empty lists collapse
+// to `OPENCLOSE`. Single-element lists still wrap so trailing-comma
+// logic stays uniform.
+func printList(ctx *PrintContext, shape listShape) Doc {
+  if len(shape.Items) == 0 {
+    return Text(shape.OpenTok + shape.CloseTok)
+  }
+  sep := Concat(Text(","), Line())
+  body := Join(sep, shape.Items)
+
+  flatPad := Doc{Kind: docNil}
+  if shape.Space {
+    flatPad = Text(" ")
+  }
+
+  trailing := Doc{Kind: docNil}
+  if shape.AddComma {
+    trailing = IfBreak(Text(","), Doc{Kind: docNil})
+  }
+
+  openTok := Text(shape.OpenTok)
+  closeTok := Text(shape.CloseTok)
+
+  // In flat mode: OPEN [pad] body [pad] CLOSE
+  // In broken mode: OPEN \n body, \n CLOSE — using Softline so the
+  // flat form collapses cleanly.
+  leadingSep := IfBreak(Hardline(), flatPad)
+  trailingSep := IfBreak(Hardline(), flatPad)
+
+  bodyBlock := Indent(ctx.indentUnit(), leadingSep, body, trailing)
+  doc := Concat(openTok, bodyBlock, trailingSep, closeTok)
+  return Group(doc)
+}

package/linthost/print_nodes_object.go

@@ -0,0 +1,51 @@
+package linthost
+
+import (
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+// printObjectLiteral renders an ObjectLiteralExpression with width-aware
+// fit-or-break. Members are emitted verbatim from the source — only
+// the outer braces and the comma layout participate in reflow. That
+// keeps the per-member behavior compatible with shapes the dispatcher
+// has not yet learned (computed property keys, accessor declarations,
+// spread elements, etc.), while still solving the headline use case:
+// long member lists that need to break across lines.
+//
+// Flat:    `{ a: 1, b: 2 }`
+//
+//  Broken:  `{
+//              a: 1,
+//              b: 2,
+//           }`
+//
+// The flat form uses a single space inside the braces, matching
+// Prettier's `bracketSpacing: true` default. Empty object literals
+// collapse to `{}` with no inner space, matching every formatter.
+func printObjectLiteral(ctx *PrintContext, node *shimast.Node) Doc {
+  if node == nil {
+    return Doc{}
+  }
+  obj := node.AsObjectLiteralExpression()
+  if obj == nil || obj.Properties == nil {
+    return verbatim(ctx, node)
+  }
+  items := make([]Doc, 0, len(obj.Properties.Nodes))
+  for _, prop := range obj.Properties.Nodes {
+    if prop == nil {
+      // A nil child entry would render as an empty Doc and surface
+      // as `a, , b` in the output. Bail to verbatim so the source
+      // bytes round-trip unchanged.
+      return verbatim(ctx, node)
+    }
+    doc, _ := PrintNode(ctx, prop)
+    items = append(items, doc)
+  }
+  return printList(ctx, listShape{
+    OpenTok:  "{",
+    CloseTok: "}",
+    Items:    items,
+    Space:    true,
+    AddComma: true,
+  })
+}

package/{plugin → linthost}/rules_arrays.go

@@ -1,4 +1,4 @@
-package main
+package linthost
 
 import shimast "github.com/microsoft/typescript-go/shim/ast"
 

package/{plugin → linthost}/rules_console.go

@@ -1,4 +1,4 @@
-package main
+package linthost
 
 import shimast "github.com/microsoft/typescript-go/shim/ast"
 

package/{plugin → linthost}/rules_debugger.go

@@ -1,4 +1,4 @@
-package main
+package linthost
 
 import shimast "github.com/microsoft/typescript-go/shim/ast"
 

package/{plugin → linthost}/rules_dupes.go

@@ -1,4 +1,4 @@
-package main
+package linthost
 
 import shimast "github.com/microsoft/typescript-go/shim/ast"
 

package/{plugin → linthost}/rules_empty.go

@@ -1,4 +1,4 @@
-package main
+package linthost
 
 import shimast "github.com/microsoft/typescript-go/shim/ast"
 

package/linthost/rules_escape.go

@@ -0,0 +1,238 @@
+package linthost
+
+import (
+  "strings"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+// no-useless-escape: flag backslashes that escape characters which do not
+// require escaping. Inside string/template literals the meaningful
+// escapes are limited to a fixed set; everywhere else the backslash is
+// noise from a copy/paste accident or a confused author. ESLint
+// canonical: https://eslint.org/docs/latest/rules/no-useless-escape
+//
+// The rule is `eslint:recommended` and ships a one-byte autofix that
+// deletes the redundant backslash. We mirror that fixer when the byte
+// after the backslash is ASCII; multi-byte UTF-8 sequences are left
+// detection-only because byte-deletion in the middle of a code point
+// would corrupt the file.
+type noUselessEscape struct{}
+
+func (noUselessEscape) Name() string { return "no-useless-escape" }
+func (noUselessEscape) Visits() []shimast.Kind {
+  return []shimast.Kind{
+    shimast.KindStringLiteral,
+    shimast.KindNoSubstitutionTemplateLiteral,
+    shimast.KindTemplateHead,
+    shimast.KindTemplateMiddle,
+    shimast.KindTemplateTail,
+    shimast.KindRegularExpressionLiteral,
+  }
+}
+func (noUselessEscape) Check(ctx *Context, node *shimast.Node) {
+  if ctx.File == nil {
+    return
+  }
+  // Tagged templates expose the raw bytes of the template to the tag
+  // function (`String.raw`, `dedent`, `gql`, `css`, …), so a backslash
+  // that looks redundant to the JS lexer is meaningful at the tag
+  // boundary. ESLint canonical skips tagged templates entirely.
+  if isInsideTaggedTemplate(node) {
+    return
+  }
+  src := ctx.File.Text()
+  pos := node.Pos()
+  end := node.End()
+  if pos < 0 || end > len(src) || pos >= end {
+    return
+  }
+  raw := src[pos:end]
+  // Determine quote/scan delimiters based on node kind so the
+  // single-char escape whitelist matches ESLint per-context.
+  switch node.Kind {
+  case shimast.KindStringLiteral:
+    reportStringEscapes(ctx, raw, pos, stringValidEscapes)
+  case shimast.KindNoSubstitutionTemplateLiteral,
+    shimast.KindTemplateHead,
+    shimast.KindTemplateMiddle,
+    shimast.KindTemplateTail:
+    reportStringEscapes(ctx, raw, pos, templateValidEscapes)
+  case shimast.KindRegularExpressionLiteral:
+    reportRegexEscapes(ctx, raw, pos)
+  }
+}
+
+const stringValidEscapes = "'\"\\bfnrtv0xuU\n\r"
+const templateValidEscapes = "`'\"\\bfnrtv0xuU$\n\r"
+
+// regexValidEscapes covers characters that are *always* meaningful when
+// preceded by `\` in a regex pattern. Character classes and group syntax
+// inside a regex add more legitimate escapes (`\d`, `\w`, …); we handle
+// those by allowing every ASCII letter (which makes the fix conservative
+// — it never deletes a backslash whose meaning could be context-sensitive).
+const regexValidEscapes = "^$\\.*+?()[]{}|/-\n\r"
+
+func reportStringEscapes(ctx *Context, raw string, base int, whitelist string) {
+  if len(raw) < 2 {
+    return
+  }
+  // Strip the enclosing quotes; first and last bytes are quote / backtick / `${` / `}`.
+  // For TemplateHead/Middle/Tail the head/tail use backtick + `${`, but
+  // every quoted form starts with one ASCII byte and ends with one or
+  // two ASCII bytes — neither contains a meaningful backslash, so just
+  // skip the first byte and stop one byte before the end.
+  startSkip := 1
+  endSkip := 1
+  if raw[len(raw)-2] == '$' && raw[len(raw)-1] == '{' {
+    endSkip = 2
+  }
+  for i := startSkip; i < len(raw)-endSkip; i++ {
+    if raw[i] != '\\' {
+      continue
+    }
+    if i+1 >= len(raw)-endSkip {
+      return
+    }
+    next := raw[i+1]
+    if isUselessStringEscape(next, whitelist) {
+      // Only emit a fix when both surrounding bytes are plain ASCII so
+      // deleting one byte cannot corrupt a multi-byte sequence.
+      if next < 0x80 {
+        ctx.ReportRangeFix(
+          base+i,
+          base+i+1,
+          "Unnecessary escape character: \\"+string(next)+".",
+          TextEdit{Pos: base + i, End: base + i + 1, Text: ""},
+        )
+      } else {
+        ctx.ReportRange(
+          base+i,
+          base+i+1,
+          "Unnecessary escape character: \\"+string(next)+".",
+        )
+      }
+    }
+    i++ // skip the escaped char so `\\\\` doesn't double-report.
+  }
+}
+
+func reportRegexEscapes(ctx *Context, raw string, base int) {
+  if len(raw) < 3 || raw[0] != '/' {
+    return
+  }
+  // The regex pattern is between the leading `/` and the trailing
+  // `/<flags>`; locate the closing slash by scanning right-to-left.
+  closing := strings.LastIndexByte(raw, '/')
+  if closing <= 0 {
+    return
+  }
+  body := raw[1:closing]
+  inClass := false
+  for i := 0; i < len(body); i++ {
+    ch := body[i]
+    if ch == '[' && !inClass {
+      inClass = true
+      continue
+    }
+    if ch == ']' && inClass {
+      inClass = false
+      continue
+    }
+    if ch != '\\' || i+1 >= len(body) {
+      continue
+    }
+    next := body[i+1]
+    if isUselessRegexEscape(next, inClass) {
+      // base + 1 (for the leading `/`) + i is the byte offset of the
+      // backslash in the source.
+      pos := base + 1 + i
+      if next < 0x80 {
+        ctx.ReportRangeFix(
+          pos,
+          pos+1,
+          "Unnecessary escape character: \\"+string(next)+".",
+          TextEdit{Pos: pos, End: pos + 1, Text: ""},
+        )
+      } else {
+        ctx.ReportRange(
+          pos,
+          pos+1,
+          "Unnecessary escape character: \\"+string(next)+".",
+        )
+      }
+    }
+    i++ // consume the escaped character.
+  }
+}
+
+func isUselessStringEscape(ch byte, whitelist string) bool {
+  // Whitespace + control chars are escape sequences too.
+  if ch < 0x20 {
+    return false
+  }
+  if strings.IndexByte(whitelist, ch) >= 0 {
+    return false
+  }
+  // ASCII letters that aren't in the whitelist are user-error escapes
+  // like `\a`, `\m`. Digits 1-9 are octal-shaped (`no-octal-escape`
+  // owns those). `0` is in the whitelist. Punctuation that isn't in the
+  // whitelist (e.g., `\.`) is also redundant.
+  return true
+}
+
+func isUselessRegexEscape(ch byte, inClass bool) bool {
+  if ch < 0x20 {
+    return false
+  }
+  // Regex meta-chars and their friends.
+  if strings.IndexByte(regexValidEscapes, ch) >= 0 {
+    return false
+  }
+  // Inside a character class `]`, `\`, and `-` are still meaningful
+  // beyond the always-list; everything else stays useless.
+  if inClass {
+    switch ch {
+    case ']', '\\', '-', 'b':
+      return false
+    }
+  }
+  // Common regex shorthand: \d \D \w \W \s \S \b \B \f \n \r \t \v \0
+  switch ch {
+  case 'd', 'D', 'w', 'W', 's', 'S', 'b', 'B', 'f', 'n', 'r', 't', 'v', '0',
+    'x', 'u', 'c', 'p', 'P', 'k', 'q':
+    return false
+  }
+  return true
+}
+
+// isInsideTaggedTemplate reports whether `node` is the template payload of
+// a TaggedTemplateExpression. Two AST shapes reach here:
+//
+//   - `KindNoSubstitutionTemplateLiteral` — the direct child of a
+//     TaggedTemplateExpression's Template slot.
+//   - `KindTemplateHead/Middle/Tail` — wrapped in TemplateSpan and
+//     TemplateExpression nodes; the TemplateExpression's parent is the
+//     TaggedTemplateExpression.
+func isInsideTaggedTemplate(node *shimast.Node) bool {
+  if node == nil || node.Parent == nil {
+    return false
+  }
+  parent := node.Parent
+  if parent.Kind == shimast.KindTaggedTemplateExpression {
+    return true
+  }
+  // Walk up at most two more hops to reach the TaggedTemplateExpression
+  // for the spans family.
+  for i := 0; i < 2 && parent.Parent != nil; i++ {
+    parent = parent.Parent
+    if parent.Kind == shimast.KindTaggedTemplateExpression {
+      return true
+    }
+  }
+  return false
+}
+
+func init() {
+  Register(noUselessEscape{})
+}

package/{plugin → linthost}/rules_eval.go

@@ -1,4 +1,4 @@
-package main
+package linthost
 
 import shimast "github.com/microsoft/typescript-go/shim/ast"
 

package/{plugin → linthost}/rules_finally.go

@@ -1,4 +1,4 @@
-package main
+package linthost
 
 import shimast "github.com/microsoft/typescript-go/shim/ast"