@ttsc/lint 0.10.1 → 0.11.0-dev.20260517

package/linthost/rules_format_quotes.go

@@ -0,0 +1,219 @@
+package linthost
+
+import (
+  "strings"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+// format/quotes normalizes string-literal quote style. Mirrors
+// prettier's `singleQuote` option:
+//
+//   - `prefer: "double"` (default) converts single-quoted literals to
+//     double-quoted when the escape cost is equal or better.
+//   - `prefer: "single"` does the reverse.
+//
+// In both directions the escape-cost tie-breaker holds: if conversion
+// would strictly increase the escape count, the literal is left alone.
+//
+// JSX attribute initializers (`<div className="foo" />`) are skipped on
+// purpose. Prettier exposes a separate `jsxSingleQuote` option for that
+// surface and never rewrites JSX attributes via `singleQuote`; the
+// JSX-grammar-canonical form is double quotes and rewriting to single
+// quotes corrupts working code. Template literals, no-substitution
+// template literals, and JSX text nodes use distinct AST kinds and are
+// also intentionally out of scope.
+type formatQuotes struct{}
+
+type formatQuotesOptions struct {
+  Prefer string `json:"prefer"`
+}
+
+func (formatQuotes) Name() string   { return "format/quotes" }
+func (formatQuotes) IsFormat() bool { return true }
+
+func (formatQuotes) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindStringLiteral}
+}
+
+func (formatQuotes) Check(ctx *Context, node *shimast.Node) {
+  if ctx == nil || ctx.File == nil || node == nil {
+    return
+  }
+  // JSX attribute initializers parse as plain StringLiteral but are
+  // grammatically required to use double quotes in the standard JSX
+  // form. Prettier mirrors that and never touches them via singleQuote.
+  if parent := node.Parent; parent != nil && parent.Kind == shimast.KindJsxAttribute {
+    return
+  }
+  var opts formatQuotesOptions
+  _ = ctx.DecodeOptions(&opts)
+  preferSingle := opts.Prefer == "single"
+
+  pos, end := tokenRange(ctx.File, node)
+  if pos < 0 || end-pos < 2 {
+    return
+  }
+  src := ctx.File.Text()
+  raw := src[pos:end]
+  if preferSingle {
+    if raw[0] != '"' || raw[len(raw)-1] != '"' {
+      return
+    }
+    converted, ok := convertDoubleQuotedToSingle(raw[1 : len(raw)-1])
+    if !ok || converted == raw {
+      return
+    }
+    ctx.ReportRangeFix(
+      pos,
+      end,
+      "Strings must use single quotes.",
+      TextEdit{Pos: pos, End: end, Text: converted},
+    )
+    return
+  }
+  if raw[0] != '\'' || raw[len(raw)-1] != '\'' {
+    return
+  }
+  converted, ok := convertSingleQuotedToDouble(raw[1 : len(raw)-1])
+  if !ok || converted == raw {
+    return
+  }
+  ctx.ReportRangeFix(
+    pos,
+    end,
+    "Strings must use double quotes.",
+    TextEdit{Pos: pos, End: end, Text: converted},
+  )
+}
+
+// convertDoubleQuotedToSingle walks the inner text of a double-quoted
+// literal and returns the single-quoted equivalent, plus an `ok`
+// boolean. `ok=false` means converting would require strictly more
+// escapes than the source (prettier's tie-breaker rule), so the
+// caller should leave the literal alone.
+//
+// Conversion is escape-aware:
+//   - `\"` becomes a bare `"` (no longer needs escaping).
+//   - Bare `'` becomes `\'` (now must be escaped).
+//   - Every other escape sequence (`\n`, `\\`, `\u{…}`) survives intact.
+func convertDoubleQuotedToSingle(inner string) (string, bool) {
+  escapedDouble, unescapedSingle := countDoubleEscapes(inner)
+  if unescapedSingle > escapedDouble {
+    return "", false
+  }
+  var b strings.Builder
+  b.Grow(len(inner) + 2)
+  b.WriteByte('\'')
+  for i := 0; i < len(inner); {
+    if inner[i] == '\\' && i+1 < len(inner) {
+      if inner[i+1] == '"' {
+        b.WriteByte('"')
+        i += 2
+        continue
+      }
+      b.WriteByte(inner[i])
+      b.WriteByte(inner[i+1])
+      i += 2
+      continue
+    }
+    if inner[i] == '\'' {
+      b.WriteByte('\\')
+      b.WriteByte('\'')
+      i++
+      continue
+    }
+    b.WriteByte(inner[i])
+    i++
+  }
+  b.WriteByte('\'')
+  return b.String(), true
+}
+
+// countDoubleEscapes returns the number of `\"` sequences and bare `'`
+// bytes inside a double-quoted literal's text. Pairs with
+// countSingleEscapes.
+func countDoubleEscapes(inner string) (escapedDouble, unescapedSingle int) {
+  for i := 0; i < len(inner); {
+    if inner[i] == '\\' && i+1 < len(inner) {
+      if inner[i+1] == '"' {
+        escapedDouble++
+      }
+      i += 2
+      continue
+    }
+    if inner[i] == '\'' {
+      unescapedSingle++
+    }
+    i++
+  }
+  return escapedDouble, unescapedSingle
+}
+
+// convertSingleQuotedToDouble walks the inner text of a single-quoted
+// literal and returns the double-quoted equivalent, plus an `ok`
+// boolean. `ok=false` means converting would require strictly more
+// escapes than the source (prettier's tie-breaker rule), so the
+// caller should leave the literal alone.
+//
+// Conversion is escape-aware:
+//   - `\'` becomes a bare `'` (no longer needs escaping).
+//   - Bare `"` becomes `\"` (now must be escaped).
+//   - Every other escape sequence (`\n`, `\\`, `\u{…}`) survives intact.
+func convertSingleQuotedToDouble(inner string) (string, bool) {
+  escapedSingle, unescapedDouble := countSingleEscapes(inner)
+  if unescapedDouble > escapedSingle {
+    return "", false
+  }
+  var b strings.Builder
+  b.Grow(len(inner) + 2)
+  b.WriteByte('"')
+  for i := 0; i < len(inner); {
+    if inner[i] == '\\' && i+1 < len(inner) {
+      if inner[i+1] == '\'' {
+        b.WriteByte('\'')
+        i += 2
+        continue
+      }
+      b.WriteByte(inner[i])
+      b.WriteByte(inner[i+1])
+      i += 2
+      continue
+    }
+    if inner[i] == '"' {
+      b.WriteByte('\\')
+      b.WriteByte('"')
+      i++
+      continue
+    }
+    b.WriteByte(inner[i])
+    i++
+  }
+  b.WriteByte('"')
+  return b.String(), true
+}
+
+// countSingleEscapes returns the number of `\'` sequences and bare `"`
+// bytes inside a single-quoted literal's text. Pairs with
+// countDoubleEscapes; the names describe what they count (the quote kind
+// that's been escape-prefixed).
+func countSingleEscapes(inner string) (escapedSingle, unescapedDouble int) {
+  for i := 0; i < len(inner); {
+    if inner[i] == '\\' && i+1 < len(inner) {
+      if inner[i+1] == '\'' {
+        escapedSingle++
+      }
+      i += 2
+      continue
+    }
+    if inner[i] == '"' {
+      unescapedDouble++
+    }
+    i++
+  }
+  return escapedSingle, unescapedDouble
+}
+
+func init() {
+  Register(formatQuotes{})
+}

package/linthost/rules_format_semi.go

@@ -0,0 +1,190 @@
+package linthost
+
+import (
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+// format/semi controls trailing-semicolon style on ASI statements.
+// Mirrors prettier's `semi` option:
+//
+//   - `prefer: "always"` (default) inserts a missing terminator.
+//   - `prefer: "never"`  strips a trailing terminator from the same
+//     statement kinds.
+//
+// The rule scans only statement kinds where TypeScript inserts an
+// optional semicolon. Body-shaped declarations (functions, classes,
+// namespaces, enums) and control-flow statements (if/for/while/try)
+// are out of scope because they parse correctly without a terminator.
+type formatSemi struct{}
+
+// formatSemiOptions is the Go mirror of `TtscLintRuleOptions.Semi`. The
+// JSON tag matches the TypeScript field name so users get the same key
+// in both layers.
+type formatSemiOptions struct {
+  Prefer string `json:"prefer"`
+}
+
+func (formatSemi) Name() string   { return "format/semi" }
+func (formatSemi) IsFormat() bool { return true }
+
+func (formatSemi) Visits() []shimast.Kind {
+  return []shimast.Kind{
+    shimast.KindVariableStatement,
+    shimast.KindExpressionStatement,
+    shimast.KindReturnStatement,
+    shimast.KindThrowStatement,
+    shimast.KindBreakStatement,
+    shimast.KindContinueStatement,
+    shimast.KindDoStatement,
+    shimast.KindDebuggerStatement,
+    shimast.KindImportDeclaration,
+    shimast.KindImportEqualsDeclaration,
+    shimast.KindExportDeclaration,
+    shimast.KindExportAssignment,
+    shimast.KindPropertyDeclaration,
+    shimast.KindTypeAliasDeclaration,
+  }
+}
+
+func (formatSemi) Check(ctx *Context, node *shimast.Node) {
+  if ctx == nil || ctx.File == nil || node == nil {
+    return
+  }
+  var opts formatSemiOptions
+  _ = ctx.DecodeOptions(&opts)
+  preferNever := opts.Prefer == "never"
+
+  src := ctx.File.Text()
+  end := node.End()
+  if end <= 0 || end > len(src) {
+    return
+  }
+  hasSemi := src[end-1] == ';'
+  if preferNever {
+    if !hasSemi {
+      return
+    }
+    if !preferNeverSafeKind(node.Kind) {
+      // Dropping the `;` after a class field or a type alias can
+      // change parse — e.g. `class A { x: number; [k](): void {} }`
+      // would reparse `[k]` as a computed index access on `number`.
+      // Keep the terminator on those kinds even in prefer:"never"
+      // mode.
+      return
+    }
+    if nextStatementHasASIHazard(src, end) {
+      // Stripping `;` here would let ASI fail. Prettier defends with a
+      // leading-`;` on the next statement; this rule conservatively
+      // refuses to strip rather than synthesizing an edit on a node
+      // it didn't visit.
+      return
+    }
+    pos := end - 1
+    if pos < 0 {
+      pos = 0
+    }
+    ctx.ReportRangeFix(
+      pos,
+      end,
+      "Unexpected trailing semicolon.",
+      TextEdit{Pos: end - 1, End: end, Text: ""},
+    )
+    return
+  }
+  if hasSemi {
+    return
+  }
+  // Diagnostic anchors on the last character of the statement so the
+  // banner underlines "the place a semicolon should follow". The fix
+  // itself is a zero-width insertion at node.End() — keeping the edit
+  // disjoint from any other rule's edits on the same statement.
+  pos := end - 1
+  if pos < 0 {
+    pos = 0
+  }
+  ctx.ReportRangeFix(
+    pos,
+    end,
+    "Missing semicolon.",
+    TextEdit{Pos: end, End: end, Text: ";"},
+  )
+}
+
+// nextStatementHasASIHazard reports whether the next non-trivia byte
+// after `end` starts a token that would re-associate with the prior
+// expression if the trailing `;` is removed. Prettier handles this by
+// inserting a defensive leading `;` on the next line; this rule's
+// fixer is single-node, so the safer move is to keep the explicit
+// terminator.
+//
+// Hazard tokens per the ASI spec:
+//
+//   - `[`  — bracket access continues an expression
+//   - `(`  — call expression continues
+//   - “ ` “ — tagged template literal continues
+//   - `+`, `-`, `*`, `/` — binary operator continues
+//   - `,`  — comma operator continues
+func nextStatementHasASIHazard(src string, end int) bool {
+  for i := end; i < len(src); i++ {
+    c := src[i]
+    if c == ' ' || c == '\t' || c == '\r' || c == '\n' {
+      continue
+    }
+    if c == '/' && i+1 < len(src) {
+      if src[i+1] == '/' {
+        for i < len(src) && src[i] != '\n' {
+          i++
+        }
+        continue
+      }
+      if src[i+1] == '*' {
+        i += 2
+        for i+1 < len(src) && !(src[i] == '*' && src[i+1] == '/') {
+          i++
+        }
+        if i+1 < len(src) {
+          i++ // step past '*/'
+        }
+        continue
+      }
+      // bare `/` starts a regex literal or division — hazard.
+      return true
+    }
+    switch c {
+    case '[', '(', '`', '+', '-', '*', ',':
+      return true
+    }
+    return false
+  }
+  return false
+}
+
+// preferNeverSafeKind reports whether stripping the trailing semicolon
+// is safe for `kind`. Statement kinds end at a line break or `}` in
+// practice; declaration-style kinds (PropertyDeclaration,
+// TypeAliasDeclaration) live next to other class/module members where
+// the explicit terminator disambiguates the next token. The
+// prefer:"never" branch refuses to touch those.
+func preferNeverSafeKind(kind shimast.Kind) bool {
+  switch kind {
+  case
+    shimast.KindVariableStatement,
+    shimast.KindExpressionStatement,
+    shimast.KindReturnStatement,
+    shimast.KindThrowStatement,
+    shimast.KindBreakStatement,
+    shimast.KindContinueStatement,
+    shimast.KindDoStatement,
+    shimast.KindDebuggerStatement,
+    shimast.KindImportDeclaration,
+    shimast.KindImportEqualsDeclaration,
+    shimast.KindExportDeclaration,
+    shimast.KindExportAssignment:
+    return true
+  }
+  return false
+}
+
+func init() {
+  Register(formatSemi{})
+}