@ttsc/lint 0.14.0-dev.20260529.1 → 0.14.0

package/linthost/rules_format_quotes.go

@@ -59,35 +59,63 @@ func (formatQuotes) Check(ctx *Context, node *shimast.Node) {
   }
   src := ctx.File.Text()
   raw := src[pos:end]
+  isDouble := raw[0] == '"' && raw[len(raw)-1] == '"'
+  isSingle := raw[0] == '\'' && raw[len(raw)-1] == '\''
+  if !isDouble && !isSingle {
+    return
+  }
+  inner := raw[1 : len(raw)-1]
+
+  // Prettier's quote rule chooses the quote that yields fewer escapes and
+  // only falls back to the configured preference on a tie. So the rule
+  // must inspect both directions regardless of the literal's current
+  // quote: a double-quoted `"\""` (one escape) is rewritten to single
+  // `'"'` (zero escapes) even under prefer:"double", and symmetrically a
+  // single-quoted literal flips to double when double is strictly cheaper
+  // even under prefer:"single". On a tie the preferred quote wins, which
+  // for a literal already in the preferred quote means no edit (keeping
+  // the rule idempotent).
   if preferSingle {
-    if raw[0] != '"' || raw[len(raw)-1] != '"' {
+    if isDouble {
+      // Tie resolves to single (the preference), so convert whenever
+      // single is no worse, exactly convertDoubleQuotedToSingle's `ok`.
+      converted, ok := convertDoubleQuotedToSingle(inner)
+      if ok && converted != raw {
+        ctx.ReportRangeFix(pos, end, "Strings must use single quotes.",
+          TextEdit{Pos: pos, End: end, Text: converted})
+      }
       return
     }
-    converted, ok := convertDoubleQuotedToSingle(raw[1 : len(raw)-1])
-    if !ok || converted == raw {
-      return
+    // Already single: only flip to double when double is STRICTLY cheaper,
+    // so a tie keeps the preferred single quote.
+    escapedSingle, unescapedDouble := countSingleEscapes(inner)
+    if unescapedDouble < escapedSingle {
+      if converted, ok := convertSingleQuotedToDouble(inner); ok && converted != raw {
+        ctx.ReportRangeFix(pos, end, "Strings must use double quotes.",
+          TextEdit{Pos: pos, End: end, Text: converted})
+      }
     }
-    ctx.ReportRangeFix(
-      pos,
-      end,
-      "Strings must use single quotes.",
-      TextEdit{Pos: pos, End: end, Text: converted},
-    )
     return
   }
-  if raw[0] != '\'' || raw[len(raw)-1] != '\'' {
+  if isSingle {
+    // Tie resolves to double (the preference), so convert whenever double
+    // is no worse, exactly convertSingleQuotedToDouble's `ok`.
+    converted, ok := convertSingleQuotedToDouble(inner)
+    if ok && converted != raw {
+      ctx.ReportRangeFix(pos, end, "Strings must use double quotes.",
+        TextEdit{Pos: pos, End: end, Text: converted})
+    }
     return
   }
-  converted, ok := convertSingleQuotedToDouble(raw[1 : len(raw)-1])
-  if !ok || converted == raw {
-    return
+  // Already double: only flip to single when single is STRICTLY cheaper,
+  // so a tie keeps the preferred double quote.
+  escapedDouble, unescapedSingle := countDoubleEscapes(inner)
+  if unescapedSingle < escapedDouble {
+    if converted, ok := convertDoubleQuotedToSingle(inner); ok && converted != raw {
+      ctx.ReportRangeFix(pos, end, "Strings must use single quotes.",
+        TextEdit{Pos: pos, End: end, Text: converted})
+    }
   }
-  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
@@ -133,14 +161,25 @@ func convertDoubleQuotedToSingle(inner string) (string, bool) {
   return b.String(), true
 }
 
-// countDoubleEscapes returns the number of `\"` sequences and bare `'`
-// bytes inside a double-quoted literal's text. Pairs with
-// countSingleEscapes.
+// countDoubleEscapes returns, for a double-quoted literal's text, the
+// escape cost of each quote style: `escapedDouble` is how many `"` are
+// escaped today, `unescapedSingle` is how many `'` characters the value
+// holds (each would need escaping if the literal were single-quoted).
+// Pairs with countSingleEscapes.
+//
+// A `'` reaches the value two ways inside double quotes: bare (`'`) or as
+// a redundant escape (`\'`). Both are a single-quote character in the
+// cooked string, so both count toward unescapedSingle, otherwise a
+// literal like `"a\'b"` looks like a 0-vs-0 tie and flips to single,
+// where Prettier keeps double because single would cost the one escape.
 func countDoubleEscapes(inner string) (escapedDouble, unescapedSingle int) {
   for i := 0; i < len(inner); {
     if inner[i] == '\\' && i+1 < len(inner) {
-      if inner[i+1] == '"' {
+      switch inner[i+1] {
+      case '"':
         escapedDouble++
+      case '\'':
+        unescapedSingle++
       }
       i += 2
       continue
@@ -196,15 +235,22 @@ func convertSingleQuotedToDouble(inner string) (string, bool) {
   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).
+// countSingleEscapes is the mirror of countDoubleEscapes for a
+// single-quoted literal's text: `escapedSingle` is how many `'` are
+// escaped today, `unescapedDouble` is how many `"` characters the value
+// holds (each would need escaping if the literal were double-quoted). A
+// `"` reaches the value either bare (`"`) or as a redundant escape
+// (`\"`), and both count toward unescapedDouble so a literal like
+// `'a\"b'` does not look like a tie and flip to double, Prettier keeps
+// single because double would cost the one escape.
 func countSingleEscapes(inner string) (escapedSingle, unescapedDouble int) {
   for i := 0; i < len(inner); {
     if inner[i] == '\\' && i+1 < len(inner) {
-      if inner[i+1] == '\'' {
+      switch inner[i+1] {
+      case '\'':
         escapedSingle++
+      case '"':
+        unescapedDouble++
       }
       i += 2
       continue

package/linthost/rules_format_semi.go

@@ -43,6 +43,16 @@ func (formatSemi) Visits() []shimast.Kind {
     shimast.KindExportAssignment,
     shimast.KindPropertyDeclaration,
     shimast.KindTypeAliasDeclaration,
+    // Interface / type-literal members. Prettier drops their trailing
+    // `;` under semi:false when they are newline-separated; see
+    // stripMemberSemicolon for the per-context hazard rules.
+    shimast.KindPropertySignature,
+    shimast.KindMethodSignature,
+    shimast.KindIndexSignature,
+    shimast.KindCallSignature,
+    shimast.KindConstructSignature,
+    shimast.KindGetAccessor,
+    shimast.KindSetAccessor,
   }
 }
 
@@ -59,6 +69,21 @@ func (formatSemi) Check(ctx *Context, node *shimast.Node) {
   if end <= 0 || end > len(src) {
     return
   }
+  // Interface / type-literal members and class fields carry their own
+  // ASI rules, distinct from top-level statements, so the never
+  // direction routes through a dedicated stripper. Class fields keep
+  // their existing always-direction insertion (falling through below);
+  // inserting a missing interface/type member terminator is out of scope
+  // for this strip fix, so type members short-circuit in always mode.
+  isClassField := node.Kind == shimast.KindPropertyDeclaration
+  isTypeMember := isTypeMemberKind(node.Kind)
+  if preferNever && (isClassField || isTypeMember) {
+    stripMemberSemicolon(ctx, src, node, isClassField)
+    return
+  }
+  if isTypeMember {
+    return
+  }
   hasSemi := src[end-1] == ';'
   if preferNever {
     if !hasSemi {
@@ -66,7 +91,7 @@ func (formatSemi) Check(ctx *Context, node *shimast.Node) {
     }
     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 {} }`
+      // 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.
@@ -96,7 +121,7 @@ func (formatSemi) Check(ctx *Context, node *shimast.Node) {
   }
   // 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
+  // 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 {
@@ -119,11 +144,14 @@ func (formatSemi) Check(ctx *Context, node *shimast.Node) {
 //
 // Hazard tokens per the ASI spec:
 //
-//   - `[`  — bracket access continues an expression
-//   - `(`  — call expression continues
-//   - “ ` “ — tagged template literal continues
-//   - `+`, `-`, `*`, `/` — binary operator continues
-//   - `,`  — comma operator continues
+//   - `[`: bracket access continues an expression
+//   - `(`: call expression continues
+//   - “ ` “: tagged template literal continues
+//   - `+`, `-`, `*`: binary operator continues
+//   - `,`: comma operator continues
+//   - `/`: division operator or regex literal continues; handled by
+//     the comment-or-regex branch below (a leading `//` or `/*` is not a
+//     hazard, a bare `/` is), so it is absent from the token switch.
 func nextStatementHasASIHazard(src string, end int) bool {
   for i := end; i < len(src); i++ {
     c := src[i]
@@ -147,11 +175,18 @@ func nextStatementHasASIHazard(src string, end int) bool {
         }
         continue
       }
-      // bare `/` starts a regex literal or division — hazard.
+      // bare `/` starts a regex literal or division, hazard.
       return true
     }
     switch c {
-    case '[', '(', '`', '+', '-', '*', ',':
+    // If the next significant byte is one of these, dropping the terminator
+    // could let the following line re-associate with the prior expression.
+    // `( [`, a unary `+ -`, and a tagged-template backtick are the cases
+    // actually reachable from a valid statement start; `<` matters in .tsx
+    // (a leading `<` opens a JSX element). The remaining infix bytes cannot
+    // begin a valid statement on their own, but are listed defensively so
+    // the strip always cedes rather than risk a parse-changing edit.
+    case '[', '(', '`', '+', '-', '*', ',', '.', '<', '>', '=', '?', '%', '&', '|', '^':
       return true
     }
     return false
@@ -179,12 +214,152 @@ func preferNeverSafeKind(kind shimast.Kind) bool {
     shimast.KindImportDeclaration,
     shimast.KindImportEqualsDeclaration,
     shimast.KindExportDeclaration,
-    shimast.KindExportAssignment:
+    shimast.KindExportAssignment,
+    // `type T = …;` is a statement-position declaration; Prettier drops
+    // its terminator under semi:false. The nextStatementHasASIHazard
+    // guard keeps it whenever removal would let ASI mis-associate the
+    // following statement (e.g. a leading `(`/`[`).
+    shimast.KindTypeAliasDeclaration:
     return true
   }
   return false
 }
 
+// isTypeMemberKind reports whether `kind` is an interface or
+// object-type-literal member whose trailing `;` Prettier strips under
+// semi:false. Class fields (KindPropertyDeclaration) are handled
+// separately because their initializer is an expression and so they
+// carry the full expression-ASI hazard set, while type members only
+// risk a call/construct-signature (`(`) or generic-call-signature (`<`)
+// continuation.
+func isTypeMemberKind(kind shimast.Kind) bool {
+  switch kind {
+  case
+    shimast.KindPropertySignature,
+    shimast.KindMethodSignature,
+    shimast.KindIndexSignature,
+    shimast.KindCallSignature,
+    shimast.KindConstructSignature,
+    shimast.KindGetAccessor,
+    shimast.KindSetAccessor:
+    return true
+  }
+  return false
+}
+
+// stripMemberSemicolon removes a redundant trailing `;` from an
+// interface / type-literal member or a class field under semi:false.
+//
+// The member-terminating `;` is located robustly: typescript-go parses
+// the terminator as a separate token (parseTypeMemberSemicolon /
+// parseSemicolonAfterPropertyName run after finishNode), so a member
+// node's End() may sit before the `;`. Accept either a `;` already at
+// End()-1 or the first `;` reached scanning horizontal whitespace
+// forward from End().
+//
+// The `;` is dropped only when it is redundant, see
+// memberSemicolonRedundant, so single-line separators stay intact and
+// ASI-hazardous continuations keep their terminator. Idempotent: once
+// removed, no `;` remains for the rule to act on.
+func stripMemberSemicolon(ctx *Context, src string, node *shimast.Node, isClassField bool) {
+  end := node.End()
+  semiPos := -1
+  if end-1 >= 0 && src[end-1] == ';' {
+    semiPos = end - 1
+  } else {
+    i := end
+    for i < len(src) && (src[i] == ' ' || src[i] == '\t') {
+      i++
+    }
+    if i < len(src) && src[i] == ';' {
+      semiPos = i
+    }
+  }
+  if semiPos < 0 {
+    return
+  }
+  if !memberSemicolonRedundant(src, semiPos+1, isClassField) {
+    return
+  }
+  ctx.ReportRangeFix(
+    semiPos,
+    semiPos+1,
+    "Unexpected trailing semicolon.",
+    TextEdit{Pos: semiPos, End: semiPos + 1, Text: ""},
+  )
+}
+
+// memberSemicolonRedundant reports whether the member terminator `;`
+// whose following byte is at `after` can be dropped without changing the
+// parse. It scans past trivia (whitespace + comments) to the next
+// significant byte and applies Prettier's semi:false member rules:
+//
+//   - The closing `}` (or end of file) always makes the `;` redundant.
+//   - A next member on the SAME line (no newline crossed) keeps the `;`
+//     as a required separator, the rule never inserts the newline that
+//     would let ASI take over, so dropping it here would corrupt the
+//     source.
+//   - A newline-separated next member drops the `;` unless its lead token
+//     would re-associate with the prior member: the full expression-ASI
+//     hazard set for class fields (`[ ( ` + - * / ,`), or just a
+//     call/construct/generic signature (`(` / `<`) for type members
+//     (a leading `[` is an index signature there, not a continuation).
+func memberSemicolonRedundant(src string, after int, isClassField bool) bool {
+  sawNewline := false
+  for i := after; i < len(src); {
+    c := src[i]
+    if c == '\n' {
+      sawNewline = true
+      i++
+      continue
+    }
+    if c == ' ' || c == '\t' || c == '\r' {
+      i++
+      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] == '/') {
+          if src[i] == '\n' {
+            sawNewline = true
+          }
+          i++
+        }
+        if i+1 < len(src) {
+          i += 2
+        }
+        continue
+      }
+    }
+    if c == '}' {
+      return true
+    }
+    if !sawNewline {
+      return false
+    }
+    if isClassField {
+      switch c {
+      case '[', '(', '`', '+', '-', '*', '/', ',':
+        return false
+      }
+    } else {
+      switch c {
+      case '(', '<':
+        return false
+      }
+    }
+    return true
+  }
+  return true
+}
+
 func init() {
   Register(formatSemi{})
 }