@ttsc/lint 0.26.1 → 0.26.2

package/README.md

@@ -4,7 +4,7 @@
 
 [![GitHub license](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/samchon/ttsc/blob/master/LICENSE) [![NPM Version](https://img.shields.io/npm/v/@ttsc/lint.svg)](https://www.npmjs.com/package/@ttsc/lint) [![NPM Downloads](https://img.shields.io/npm/dm/@ttsc/lint.svg)](https://www.npmjs.com/package/@ttsc/lint) [![Build Status](https://github.com/samchon/ttsc/workflows/test/badge.svg)](https://github.com/samchon/ttsc/actions?query=workflow%3Atest) [![Guide Documents](https://img.shields.io/badge/Guide-Documents-forestgreen)](https://ttsc.dev/docs) [![Discord Badge](https://img.shields.io/badge/discord-samchon-d91965?style=flat&labelColor=5866f2&logo=discord&logoColor=white&link=https://discord.gg/E94XhzrUCZ)](https://discord.gg/E94XhzrUCZ)
 
-A linter and formatter. Co-protagonist of the [`ttsc`](https://ttsc.dev) toolchain, paired with `ttsc`, it replaces `eslint` and `prettier`.
+A linter and formatter. Co-protagonist of the [`ttsc`](https://ttsc.dev) toolchain, paired with `ttsc`, it replaces `eslint` and covers most of `prettier`.
 
 720+ rules across 21 families. Lint violations surface as `error TSxxxxx` from a single compile pass; the formatter applies via `ttsc format`.
 
@@ -102,6 +102,8 @@ npx ttsc format
 
 Configure the formatter through the `format` block in `lint.config.ts`. Keys mirror `.prettierrc`; the presence of the block, even empty `format: {}`, enables the always-on format rules at Prettier defaults so `ttsc format` rewrites your source to match.
 
+One boundary to know before you drop `prettier`: no pass normalizes the whitespace between two tokens, so `a=1`, `if(x){`, and `const i : number` are left as written. See [Format → Scope](https://ttsc.dev/docs/lint/format#scope).
+
 ```ts
 // lint.config.ts
 import type { ITtscLintConfig } from "@ttsc/lint";
@@ -128,7 +130,7 @@ Each `format` key controls one behavior:
 | Config key | Effect |
 | --- | --- |
 | `severity` (default `"off"`) | Check-time diagnostic level for formatting. Does not gate `ttsc format`. |
-| `semi` | Insert trailing semicolons on ASI-terminated statements. |
+| `semi` | Insert trailing semicolons on ASI-terminated statements, and own the member separator in interface, type-literal, mapped-type, and class bodies. |
 | `singleQuote` | Convert quoted strings to the preferred quote style. |
 | `arrowParens` | Add or remove parens around a single arrow parameter. |
 | `bracketSpacing` | Spaces inside object and named-import/export braces. |

package/lib/structures/format/ITtscLintFormat.d.ts

@@ -28,9 +28,10 @@ export interface ITtscLintFormat {
      */
     severity?: TtscLintSeverity;
     /**
-     * Insert trailing semicolons on ASI-terminated statements. Mirrors Prettier's
-     * `semi`. `false` flips the rule to require _no_ trailing semicolon (rare;
-     * matches prettier's `semi: false`).
+     * Insert trailing semicolons on ASI-terminated statements, and on the
+     * interface, type-literal, and class members that carry no body. Mirrors
+     * Prettier's `semi`. `false` flips the rule to require _no_ trailing
+     * semicolon (rare; matches prettier's `semi: false`).
      *
      * @default true
      */

package/linthost/config.go

@@ -3028,14 +3028,15 @@ func loadTypeScriptConfigEvaluationWithin(
     // ttsx build hermetic.
     "--no-plugins",
   }
-  if tsgo := os.Getenv("TTSC_TSGO_BINARY"); tsgo != "" {
+  anchors := configToolAnchors(location, resolutionRoot)
+  if tsgo := resolveConfigTsgo(anchors); tsgo != "" {
     args = append(args, "--binary", tsgo)
   }
   args = append(args, loader)
 
   ctx, cancel := context.WithCancel(context.Background())
   defer cancel()
-  cmd := ttsxCommandContext(ctx, args...)
+  cmd := ttsxCommandContext(ctx, anchors, args...)
   cmd.Env = nodeConfigLoaderEnv(location)
   return runConfigLoaderCommand(cmd, location, "TypeScript config file", outputPath)
 }
@@ -4276,6 +4277,23 @@ func typeScriptConfigLoaderTsconfig(loader, location, outDir string) string {
   return string(body)
 }
 
+// ttsc:config-loader-shared begin
+//
+// One policy in three Go copies: everything between these markers is
+// duplicated verbatim in packages/lint/linthost/config.go,
+// packages/banner/driver/banner.go and packages/strip/driver/config.go. #1169
+// decided against extracting it — the only home the three modules could share
+// is the public `packages/ttsc/driver` seam, and packages/lint's go.mod
+// deliberately requires no in-tree ttsc module — and replaced the checklist
+// with a gate: `scripts/ci/config-loader-copies.cjs` compares every function
+// between these markers across all three copies on every pull request, so
+// editing one and not the others fails by name. That file's header carries the
+// full decision and the rules for changing this block.
+//
+// The code between the markers must stay identical. Comments may differ, the
+// `@ttsc/<pkg>:` error prefix may differ, and @ttsc/strip spells each name with
+// a `strip` prefix. Anything package-specific belongs outside the markers.
+
 // configModuleOption returns the loader tsconfig's "module" for a config file:
 // the module kind Node itself would give that file.
 //
@@ -4406,21 +4424,235 @@ func resolveDirLink(dir string) string {
   return dir
 }
 
+// Both tools the TypeScript config evaluator needs — the `ttsx` launcher it
+// spawns and the native compiler it hands that launcher — are resolved from the
+// project being linted, with an explicit environment variable winning and a
+// last resort that invents no path.
+//
+// The three Go copies are held identical by the gate named at the top of this
+// block. The JS original — `resolveConfigTsgo` / `resolveTtsxLauncher` in
+// packages/lint/src/index.ts — is a fourth copy in another language that no Go
+// gate can reach; the two evaluators must keep one policy, because it was a
+// divergence between them that made a TypeScript lint config unevaluable
+// outside a `ttsx`-launched host.
+//
+// The environment alone is the wrong place to ask. `ttsx` exports
+// TTSC_TSGO_BINARY and TTSC_TTSX_BINARY to its own descendants, so a host
+// launched under `ttsx` inherited both and a host launched any other way
+// inherited neither. The shipped `ttscserver` binary invoked with its
+// documented `--tsgo <path>` flag keeps that path in a local and exports
+// nothing, and an embedder of the driver package exports nothing either. For
+// those the evaluator spawned a bare `ttsx` that only a global install puts on
+// PATH, and, past that, a compiler-less child that aborted with
+// `ttsc: typescript is required` before a line of the config was read.
+//
+// configToolAnchors lists the file paths those resolutions walk upward from,
+// in order: the config file being evaluated, then the resolution root's
+// manifest. The config comes first because it is the file whose own
+// installation decides which toolchain the config's imports were written
+// against; the resolution root answers for a config that lives outside the
+// project tree (an `extends` target, or a `configFile` pointed at a shared
+// package).
+//
+// The JS evaluator carries a third anchor, the loaded descriptor's own
+// directory. It has no counterpart here: this host is a compiled binary rather
+// than a module some `node_modules` copy of `@ttsc/lint` was loaded from, so
+// there is no third installation to ask.
+func configToolAnchors(configPath, resolutionRoot string) []string {
+  anchors := make([]string, 0, 2)
+  if strings.TrimSpace(configPath) != "" {
+    anchors = append(anchors, configPath)
+  }
+  if strings.TrimSpace(resolutionRoot) != "" {
+    anchors = append(anchors, filepath.Join(resolutionRoot, "package.json"))
+  }
+  return anchors
+}
+
+// resolveConfigTsgo returns the native TypeScript compiler the evaluator hands
+// its ttsx child through `--binary`, or "" to leave the child resolving for
+// itself.
+//
+// The child runs with `--cwd <ephemeral loader dir>`, so it cannot discover
+// `typescript` the way an ordinary invocation does: linkNearestNodeModules is
+// the only thing that puts the project's modules within its reach, and it links
+// nothing when the config's ancestry carries no node_modules. An explicit
+// TTSC_TSGO_BINARY still wins, so an embedder that pins a compiler keeps
+// pinning it. "" is the unchanged last resort: a project that cannot answer
+// here could not answer inside the child either, and the child's own diagnostic
+// is the one that names the missing package.
+func resolveConfigTsgo(anchors []string) string {
+  if explicit := strings.TrimSpace(os.Getenv("TTSC_TSGO_BINARY")); explicit != "" {
+    return explicit
+  }
+  for _, anchor := range anchors {
+    if binary := tsgoBinaryFrom(anchor); binary != "" {
+      return binary
+    }
+  }
+  return ""
+}
+
+// tsgoBinaryFrom returns the platform compiler executable of the `typescript`
+// install `anchor` can see, or "" when this anchor reaches neither the package
+// nor its platform dependency.
+//
+// Mirrors resolveTsgo.ts so the Go host and the JS launcher name one file: the
+// `typescript` manifest, then `@typescript/typescript-<platform>-<arch>`
+// resolved from that manifest, then `lib/tsc` inside it.
+//
+// The install is chased to its real directory before the second hop, because
+// Node resolves a module's own dependencies from its real location. pnpm keeps
+// the real `typescript` directory in its content-addressed store with the
+// platform package beside it and leaves a link in the project's node_modules,
+// so a walk that started at the link would climb straight past the platform
+// package. NTFS junctions defeat filepath.EvalSymlinks, so the link component
+// is chased by hand first, the same order loaderTempBase uses.
+func tsgoBinaryFrom(anchor string) string {
+  manifest := nodePackageManifestFrom(anchor, "typescript")
+  if manifest == "" {
+    return ""
+  }
+  packageDir := realpathIfPossible(resolveDirLink(filepath.Dir(manifest)))
+  platform, arch := nodePlatformPair()
+  platformManifest := nodePackageManifestFrom(
+    filepath.Join(packageDir, "package.json"),
+    "@typescript/typescript-"+platform+"-"+arch,
+  )
+  if platformManifest == "" {
+    return ""
+  }
+  name := "tsc"
+  if runtime.GOOS == "windows" {
+    name = "tsc.exe"
+  }
+  binary := filepath.Join(filepath.Dir(platformManifest), "lib", name)
+  if stat, err := os.Stat(binary); err != nil || stat.IsDir() {
+    return ""
+  }
+  return binary
+}
+
+// resolveTtsxLauncher returns the launcher ttsxCommandContext spawns.
+//
+// An explicit TTSC_TTSX_BINARY wins. Otherwise the launcher is derived from the
+// `ttsc` installation one of the anchors can see, because a bare command name
+// only works when a bin link happens to be on PATH — which it is for a global
+// install and is not for the ordinary project-local one. The bare `"ttsx"` name
+// remains the unchanged last resort for an installation no anchor reaches.
+func resolveTtsxLauncher(anchors []string) string {
+  if explicit := strings.TrimSpace(os.Getenv("TTSC_TTSX_BINARY")); explicit != "" {
+    return explicit
+  }
+  for _, anchor := range anchors {
+    if launcher := ttsxLauncherFrom(anchor); launcher != "" {
+      return launcher
+    }
+  }
+  return "ttsx"
+}
+
+// ttsxLauncherFrom returns `lib/launcher/ttsx.js` of the `ttsc` install
+// `anchor` can see, or "" when this anchor reaches no such install. Only the
+// manifest is an exported subpath, so the launcher is derived from where the
+// manifest resolved rather than requested as a subpath of its own.
+func ttsxLauncherFrom(anchor string) string {
+  manifest := nodePackageManifestFrom(anchor, "ttsc")
+  if manifest == "" {
+    return ""
+  }
+  launcher := filepath.Join(filepath.Dir(manifest), "lib", "launcher", "ttsx.js")
+  if stat, err := os.Stat(launcher); err != nil || stat.IsDir() {
+    return ""
+  }
+  return launcher
+}
+
+// nodePackageManifestFrom resolves `<pkg>/package.json` the way Node's
+// require.resolve does from the FILE `anchor`: walk upward from the anchor's
+// directory and return the first `<dir>/node_modules/<pkg>/package.json` that
+// exists. The anchor is treated as a file path, so its own directory is the
+// first candidate's parent, and it need not exist — Node derives the search
+// paths from the string alone.
+//
+// A directory already named `node_modules` contributes no candidate of its own,
+// matching Module._nodeModulePaths, so nothing ever resolves through
+// `node_modules/node_modules`.
+//
+// A relative anchor is resolved against the process directory before the walk,
+// again matching Node. Walking a relative path instead would terminate at "."
+// after one step and silently answer nothing for a config named relatively.
+func nodePackageManifestFrom(anchor, pkg string) string {
+  if strings.TrimSpace(anchor) == "" || pkg == "" {
+    return ""
+  }
+  if absolute, err := filepath.Abs(anchor); err == nil {
+    anchor = absolute
+  }
+  dir := filepath.Dir(filepath.Clean(anchor))
+  for {
+    if filepath.Base(dir) != "node_modules" {
+      candidate := filepath.Join(dir, "node_modules", filepath.FromSlash(pkg), "package.json")
+      if stat, err := os.Stat(candidate); err == nil && !stat.IsDir() {
+        return candidate
+      }
+    }
+    parent := filepath.Dir(dir)
+    if parent == dir {
+      return ""
+    }
+    dir = parent
+  }
+}
+
+// nodePlatformPair is nodePlatformPairFor applied to this build's own target.
+func nodePlatformPair() (string, string) {
+  return nodePlatformPairFor(runtime.GOOS, runtime.GOARCH)
+}
+
+// nodePlatformPairFor maps a Go build target onto the `process.platform` and
+// `process.arch` pair npm spells a platform package with, so the package name
+// this host resolves is the same one the JS launcher resolves.
+//
+// Only the members whose two vocabularies disagree are mapped. Every other
+// value is identical on both sides and passes through, which keeps a target
+// neither side publishes yet resolvable rather than silently wrong, and keeps
+// this from becoming a list that has to grow with every new port.
+func nodePlatformPairFor(goos, goarch string) (string, string) {
+  platform := goos
+  switch platform {
+  case "windows":
+    platform = "win32"
+  case "solaris":
+    platform = "sunos"
+  }
+  arch := goarch
+  switch arch {
+  case "amd64":
+    arch = "x64"
+  case "386":
+    arch = "ia32"
+  case "ppc64le":
+    arch = "ppc64"
+  }
+  return platform, arch
+}
+
 // ttsxCommand returns a ttsx exec.Cmd bound to a background context. Use
 // ttsxCommandContext when the caller owns a cancellable context.
-func ttsxCommand(args ...string) *exec.Cmd {
-  return ttsxCommandContext(context.Background(), args...)
+func ttsxCommand(anchors []string, args ...string) *exec.Cmd {
+  return ttsxCommandContext(context.Background(), anchors, args...)
 }
 
 // ttsxCommandContext is the cancellable variant, used by the config loaders so
 // their subprocess is torn down with the call that started it. It carries no
 // deadline: evaluating a user config is the user's own code running, and how
 // long that is allowed to take is not this binary's decision.
-func ttsxCommandContext(ctx context.Context, args ...string) *exec.Cmd {
-  ttsx := os.Getenv("TTSC_TTSX_BINARY")
-  if ttsx == "" {
-    ttsx = "ttsx"
-  }
+//
+// `anchors` are the file paths the launcher is resolved from; see
+// resolveTtsxLauncher.
+func ttsxCommandContext(ctx context.Context, anchors []string, args ...string) *exec.Cmd {
+  ttsx := resolveTtsxLauncher(anchors)
   if shouldRunTtsxThroughNode(ttsx) {
     node := os.Getenv("TTSC_NODE_BINARY")
     if node == "" {
@@ -4531,6 +4763,8 @@ func setEnv(env []string, key, value string) []string {
   return append(env, prefix+value)
 }
 
+// ttsc:config-loader-shared end
+
 // parseExternalRuleEntry delegates to parseRuleEntry. It is kept under this
 // name because test files in the same package call it directly.
 func parseExternalRuleEntry(v any) (Severity, json.RawMessage, error) {

package/linthost/rules_format_semi.go

@@ -2,6 +2,7 @@ package linthost
 
 import (
   shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimscanner "github.com/microsoft/typescript-go/shim/scanner"
 )
 
 // formatSemi controls trailing-semicolon style on ASI statements.
@@ -15,6 +16,46 @@ import (
 // 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.
+//
+// Interface, type-literal, and class members do not take the statement
+// path. Both directions route through member-specific code
+// (stripMemberSemicolon, insertMemberSemicolon) that reads the written
+// line structure and the list's own wrap rather than the member kind,
+// because Prettier prints a member's `;` between two members in either
+// layout and after the last one only where the list breaks.
+//
+// That makes this rule the owner of a type member's SEPARATOR, not just
+// of a terminator, and the whole member surface follows from one rule
+// measured against pinned Prettier 3.8.3. Prettier prints an interface or
+// type-literal separator as `ifBreak(semi, ";")` and its trailing one
+// inside a further `ifBreak`, which resolves to two answers:
+//
+//   - BETWEEN two members: `;` whenever `semi` is on OR the list is laid
+//     out flat, because the flat branch of that `ifBreak` is a literal
+//     `";"` whatever `semi` says.
+//   - AFTER the last member: `;` only when `semi` is on AND the list
+//     breaks; nothing in all three other combinations.
+//
+// Two consequences follow that would otherwise have to be inferred.
+//
+// A `,` is the same separator spelled the other way. TypeScript accepts
+// either in a type member list and the parser folds either into the
+// member, so both answers above apply to it unchanged. Every separator
+// Prettier keeps it spells `;`, in both layouts and both modes, so a `,`
+// this rule does not drop it normalizes rather than leaves as written.
+// That is a separator normalization, not a terminator insert, and neither
+// direction needs a line-structure test to make it.
+//
+// A type member of a body still written on one line is never terminated,
+// so `interface D { (a: number): void }` keeps its bare call signature.
+// Prettier reaches its own terminator by breaking the body first, and
+// breaking it is format/indent's decision, which today covers property,
+// method, and index signatures but not a call or construct signature.
+// Terminating a one-line member here instead would be a layout decision
+// this rule does not own, and would emit a shape Prettier never does.
+//
+// A mapped type is neither a statement nor a member list; it takes its own
+// path in mappedTypeSemicolon.
 type formatSemi struct{ optionsRule }
 
 // formatSemiOptions is the Go mirror of `TtscLintRuleOptions.Semi`. The
@@ -43,9 +84,11 @@ 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.
+    // Interface / type-literal members, plus the class-member spellings
+    // the accessor and index-signature kinds share. Prettier's `;` here
+    // is a separator between two members and a trailing terminator only
+    // where the list breaks; see stripMemberSemicolon and
+    // insertMemberSemicolon for the per-direction rules.
     shimast.KindPropertySignature,
     shimast.KindMethodSignature,
     shimast.KindIndexSignature,
@@ -53,6 +96,10 @@ func (formatSemi) Visits() []shimast.Kind {
     shimast.KindConstructSignature,
     shimast.KindGetAccessor,
     shimast.KindSetAccessor,
+    // A mapped type spells its whole body as one clause instead of a
+    // member list, so no member node exists to carry its terminator and
+    // the kind itself has to be visited; see mappedTypeSemicolon.
+    shimast.KindMappedType,
   }
 }
 
@@ -69,12 +116,16 @@ func (formatSemi) Check(ctx *Context, node *shimast.Node) {
   if end <= 0 || end > len(src) {
     return
   }
+  if node.Kind == shimast.KindMappedType {
+    mappedTypeSemicolon(ctx, src, node, preferNever)
+    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.
+  // ASI rules, distinct from top-level statements, so each direction
+  // routes through a dedicated member path. A class field keeps its
+  // existing always-direction insertion by falling through to the
+  // statement branch below: its body always breaks in Prettier, so it
+  // needs no line-structure test.
   isClassField := node.Kind == shimast.KindPropertyDeclaration
   isTypeMember := isTypeMemberKind(node.Kind)
   if preferNever && (isClassField || isTypeMember) {
@@ -82,6 +133,7 @@ func (formatSemi) Check(ctx *Context, node *shimast.Node) {
     return
   }
   if isTypeMember {
+    insertMemberSemicolon(ctx, src, node, end)
     return
   }
   hasSemi := src[end-1] == ';'
@@ -282,11 +334,22 @@ func preferNeverSafeKind(kind shimast.Kind) bool {
 }
 
 // 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 (`<`)
+// object-type-literal member: the kinds whose trailing `;` Prettier
+// strips under semi:false and inserts under semi:true.
+//
+// All seven take the same answer in both directions, which is measured
+// rather than assumed from symmetry. The `format/semi` conformance cases
+// run a property, method, index, call, and construct signature plus both
+// accessors through pinned Prettier 3.8.3, and every one of them comes
+// back terminated once its body is broken across lines.
+// GetAccessor and SetAccessor also spell a class or object-literal
+// accessor, which is not a type member at all; the context test in
+// memberTakesSemicolonTerminator, not this predicate, separates those.
+//
+// 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 {
@@ -303,65 +366,108 @@ func isTypeMemberKind(kind shimast.Kind) bool {
   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().
+// stripMemberSemicolon settles the separator of an interface /
+// type-literal member or a class field under semi:false.
+//
+// Two outcomes are possible, because semi:false silences only the
+// separators Prettier itself would omit. A separator the oracle drops is
+// removed; a separator it keeps is spelled `;`, so a `,` that survives is
+// normalized instead of left as written. A `;` that survives is already
+// in that spelling and produces no finding, which is also the
+// idempotency guard: once removed there is nothing left to act on, and
+// once normalized the `;` is what the next pass reads.
 //
-// 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.
+// See findMemberSeparator for how the byte is located and
+// memberSemicolonRedundant for the drop decision.
 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
-    }
+  sepPos := findMemberSeparator(src, node, isClassField)
+  if sepPos < 0 {
+    return
   }
-  if semiPos < 0 {
+  if memberSemicolonRedundant(src, node, sepPos+1, isClassField) {
+    message := "Unexpected trailing semicolon."
+    if src[sepPos] == ',' {
+      message = "Unexpected member separator."
+    }
+    ctx.ReportRangeFix(
+      sepPos,
+      sepPos+1,
+      message,
+      TextEdit{Pos: sepPos, End: sepPos + 1, Text: ""},
+    )
     return
   }
-  if !memberSemicolonRedundant(src, semiPos+1, isClassField) {
+  if src[sepPos] != ',' {
     return
   }
-  ctx.ReportRangeFix(
-    semiPos,
-    semiPos+1,
-    "Unexpected trailing semicolon.",
-    TextEdit{Pos: semiPos, End: semiPos + 1, Text: ""},
-  )
+  reportMemberSeparatorNormalization(ctx, sepPos)
 }
 
-// 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, via
-// scanPastTrivia) 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 {
+// findMemberSeparator returns the offset of the separator byte that closes
+// `node`, or -1 when the member carries none.
+//
+// The byte is located robustly. typescript-go consumes it as a separate
+// token before closing the node (parseTypeMemberSemicolon and
+// parseSemicolonAfterPropertyName both run ahead of finishNode), so End()
+// normally sits just past it; an error-recovery path that returns without
+// consuming leaves it outside instead. Accept either a separator already
+// at End()-1 or the first one reached scanning horizontal whitespace
+// forward from End().
+//
+// A `,` counts only where Prettier would print a `;`, which is what
+// memberTakesSemicolonTerminator answers. The exclusion is not cosmetic:
+// an object literal's accessor arrives here as the same GetAccessor /
+// SetAccessor kind, its body's `}` leaves the following `,` sitting right
+// where this scan looks, and removing or rewriting that comma would
+// corrupt the literal. A class field is excluded for the same reason from
+// the other side: `,` is not a class-member separator at all, so one found
+// next to a field belongs to some recovered parse.
+func findMemberSeparator(src string, node *shimast.Node, isClassField bool) int {
+  commaCounts := !isClassField && memberTakesSemicolonTerminator(node)
+  matches := func(i int) bool {
+    if i < 0 || i >= len(src) {
+      return false
+    }
+    return src[i] == ';' || (commaCounts && src[i] == ',')
+  }
+  end := node.End()
+  if matches(end - 1) {
+    return end - 1
+  }
+  i := end
+  for i < len(src) && (src[i] == ' ' || src[i] == '\t') {
+    i++
+  }
+  if matches(i) {
+    return i
+  }
+  return -1
+}
+
+// memberSemicolonRedundant reports whether the member separator whose
+// following byte is at `after` can be dropped without changing the parse.
+// It scans past trivia (whitespace + comments, via scanPastTrivia) to the
+// next significant byte and applies Prettier's semi:false member rules:
+//
+//   - The closing `}` (or end of file) always makes the separator
+//     redundant: the trailing one is printed inside an `ifBreak` that
+//     resolves to nothing under semi:false, in either layout.
+//   - A next member on the SAME line (no newline crossed) keeps the
+//     separator, the rule never inserts the newline that would let ASI
+//     take over, so dropping it here would corrupt the source.
+//   - A next member in a list Prettier lays out FLAT keeps it too. Between
+//     two members the separator is `ifBreak(semi, ";")`, whose flat branch
+//     is `";"` whatever `semi` says, so only the trailing one is silenced
+//     by semi:false in a flat list. memberListBreaks is the same question
+//     insertMemberSemicolon asks from the other end.
+//   - A newline-separated next member in a broken list drops the separator
+//     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). Prettier defends the same shapes, printing
+//     `a: number;` ahead of a call signature even under semi:false.
+func memberSemicolonRedundant(src string, node *shimast.Node, after int, isClassField bool) bool {
   i, sawNewline := scanPastTrivia(src, after)
   if i >= len(src) {
     return true
@@ -373,6 +479,9 @@ func memberSemicolonRedundant(src string, after int, isClassField bool) bool {
   if !sawNewline {
     return false
   }
+  if !memberListBreaks(src, node.Parent) {
+    return false
+  }
   if isClassField {
     switch c {
     case '[', '(', '`', '+', '-', '*', '/', ',':
@@ -387,6 +496,334 @@ func memberSemicolonRedundant(src string, after int, isClassField bool) bool {
   return true
 }
 
+// reportMemberSeparatorNormalization rewrites the `,` at `pos` to the `;`
+// Prettier spells every type-member separator it keeps. Both directions
+// share it so the two cannot drift into different spellings.
+func reportMemberSeparatorNormalization(ctx *Context, pos int) {
+  ctx.ReportRangeFix(
+    pos,
+    pos+1,
+    "Normalize the member separator to a semicolon.",
+    TextEdit{Pos: pos, End: pos + 1, Text: ";"},
+  )
+}
+
+// insertMemberSemicolon appends the `;` Prettier prints after an
+// interface, type-literal, or class member that ends its physical line.
+//
+// A member's `;` plays two roles in Prettier's object printer, and the
+// insert answers them separately:
+//
+//   - BETWEEN two members it is a separator, printed in both layouts. So
+//     a member with another member below it takes the `;` whether or not
+//     the list ends up broken.
+//   - AFTER the last member it is a trailing terminator, printed inside
+//     an `ifBreak` and therefore only when the list breaks. That is why
+//     `type T = { a: number }` is Prettier's own output for that input,
+//     and why memberListBreaks decides this case rather than the line
+//     structure at the member itself.
+//
+// Both roles need the member to end its line: a `;` the author did not
+// write between two same-line members is one Prettier would print only
+// after inserting the line break this rule never inserts.
+//
+// memberSemicolonRedundant reads the same oracle rule from the other end,
+// which is why the two are complementary rather than opposite: a `;`
+// before a same-line `}` closes a flat list, where Prettier prints no
+// trailing separator at all, so the strip drops it and this never adds
+// one back.
+//
+// The edit is a zero-width insertion at the member's End(), so it stays
+// disjoint from the format/statement-split, format/indent, and
+// format/print-width edits that may land on the same lines; the applier
+// keeps one finding per contested range, so an overlap would cost a whole
+// cascade pass. It cannot change the parse either: the parser already
+// ended the member at that offset (parseTypeMemberSemicolon runs before
+// finishNode), so the inserted `;` only spells out a boundary the parse
+// had already made.
+//
+// Idempotent: a re-parse folds the inserted `;` into the member's range,
+// so the next pass reads it at End()-1 and abstains.
+func insertMemberSemicolon(ctx *Context, src string, node *shimast.Node, end int) {
+  if !memberTakesSemicolonTerminator(node) {
+    return
+  }
+  switch src[end-1] {
+  case ';':
+    // Already terminated. Also the idempotency guard.
+    return
+  case ',':
+    // The same separator spelled the other way, so this is a separator
+    // normalization rather than a terminator insert, and appending would
+    // emit `a: number,;`. It needs neither the line-structure test below
+    // nor memberListBreaks: under semi:"always" Prettier prints `;` for a
+    // separator in both layouts, so no layout knowledge is required to
+    // pick the spelling. The one case the oracle answers differently is a
+    // trailing `,` in a flat list, which it drops outright; this direction
+    // drops nothing, and it already leaves a written `;` standing in that
+    // same position, so normalizing lands on the shape it tolerates.
+    reportMemberSeparatorNormalization(ctx, end-1)
+    return
+  }
+  // Trivia is crossed with scanPastTrivia, so a trailing line comment and
+  // a block comment carrying a line terminator both count as the break
+  // ECMA-262 says they are, and both member scanners keep one notion of
+  // "a line was crossed". Reaching end of input means the body has no
+  // closing `}`; that source is too broken to reason about, so abstain.
+  next, sawNewline := scanPastTrivia(src, end)
+  if next >= len(src) || !sawNewline {
+    return
+  }
+  // The list's `}` is the only thing that can follow the last member, so
+  // this is the trailing-terminator case and the list has to be one
+  // Prettier breaks.
+  if src[next] == '}' && !memberListBreaks(src, node.Parent) {
+    return
+  }
+  // Anchored on the member's last character for the same reason the
+  // statement branch is: the banner underlines "the place a semicolon
+  // should follow", while the fix stays zero-width at End().
+  ctx.ReportRangeFix(
+    end-1,
+    end,
+    "Missing semicolon.",
+    TextEdit{Pos: end, End: end, Text: ";"},
+  )
+}
+
+// memberTakesSemicolonTerminator reports whether Prettier terminates
+// `node` with a `;` at all. It decides on the member's own shape and on
+// the member list holding it, not on its kind, because one kind spells
+// members of both a `;`-separated and a `,`-separated list:
+//
+//   - A member carrying a body ends in `}`, and Prettier never follows a
+//     braced member with a terminator. The reachable case is an accessor:
+//     GetAccessor and SetAccessor spell both a bodiless interface
+//     accessor and a class accessor with a body.
+//   - Interface and type-literal bodies are `;`-separated. So is a class
+//     body, whose index signatures and bodiless (`declare` / `abstract`)
+//     accessors take the same terminator as their type-member spellings,
+//     and are broken onto their own lines by the same format/indent pass.
+//   - An object literal is `,`-separated. Its accessors arrive here as
+//     the same two kinds, and a `;` after one is a syntax error.
+func memberTakesSemicolonTerminator(node *shimast.Node) bool {
+  if node.Body() != nil {
+    return false
+  }
+  parent := node.Parent
+  if parent == nil {
+    return false
+  }
+  switch parent.Kind {
+  case shimast.KindInterfaceDeclaration,
+    shimast.KindTypeLiteral,
+    shimast.KindClassDeclaration,
+    shimast.KindClassExpression:
+    return true
+  }
+  return false
+}
+
+// memberListBreaks reports whether Prettier lays `owner`'s braced body out
+// across lines. Both directions ask it, and both ask about a separator
+// whose presence is conditional on the wrap: the trailing terminator
+// Prettier prints inside an `ifBreak`, and (under semi:false) the
+// separator between two members, whose flat branch is a literal `";"`.
+//
+// `owner` is a member's parent, or a mapped type itself. An interface body
+// and a class body always break once they hold a member, so the source's
+// own line structure does not enter into it.
+//
+// An object type is the exception, and a mapped type is decided the same
+// way: both preserve the author's wrap (Prettier's
+// `objectWrap: "preserve"`), breaking when a line terminator separates the
+// `{` from what follows it and otherwise staying on one line however the
+// source placed the closing `}`. Prettier 3.8.3 returns
+// `type T = { a: number\n};` as the one-line `type T = { a: number };` and
+// `type M = { [K in string]: string\n};` as `type M = { [K in string]: string };`,
+// both with nothing before the brace, so reading where the `}` landed would
+// insert a `;` the oracle never prints.
+//
+// The width half of Prettier's break decision (a flat body that overflows
+// its budget breaks) is deliberately absent: no ttsc pass reflows an
+// object or mapped type, so a flat one stays flat and a trailing
+// terminator would be one this formatter's own output never justifies. A
+// pass that ever breaks them writes the line terminator this reads.
+func memberListBreaks(src string, owner *shimast.Node) bool {
+  if owner == nil {
+    return false
+  }
+  switch owner.Kind {
+  case shimast.KindTypeLiteral, shimast.KindMappedType:
+  default:
+    return true
+  }
+  open := shimscanner.SkipTrivia(src, owner.Pos())
+  if open < 0 || open >= len(src) || src[open] != '{' {
+    // Not the shape this reads. Keep the author's bytes.
+    return false
+  }
+  _, sawNewline := scanPastTrivia(src, open+1)
+  return sawNewline
+}
+
+// mappedTypeSemicolon settles the `;` Prettier prints after a mapped
+// type's clause.
+//
+// A mapped type is not a member list. `{ readonly [K in T as N]?: V }`
+// holds one clause, typescript-go hangs its parts off the MappedTypeNode
+// itself, and parseMappedType consumes the optional `;` with
+// parseSemicolon before finishNode, so no child's range covers it and no
+// member node exists to carry one. Every position is therefore the
+// trailing-terminator position, which Prettier prints as
+// `options.semi ? ifBreak(";") : ""`: present exactly when `semi` is on
+// and the mapped type is one it breaks, absent in every other
+// combination. The `readonly` / `?` modifiers and their `+` and `-`
+// variants do not change that answer, measured rather than assumed.
+//
+// memberListBreaks reads the mapped type's own braces because Prettier
+// decides its wrap the way it decides an object type's. That is also why,
+// unlike insertMemberSemicolon, this needs no "ends its line" test: a
+// member list needs a break before Prettier will print a separator
+// between two same-line members, while a lone terminator needs only the
+// wrap the `{` already decided. Prettier 3.8.3 terminates
+// `type M = {\n  [K in string]: string };` and leaves
+// `type M = { [K in string]: string\n};` bare.
+//
+// Idempotent in both directions: the inserted `;` is what the next pass
+// finds ahead of the `}` and abstains on, and the stripped one leaves the
+// `}` the strip abstains on.
+func mappedTypeSemicolon(ctx *Context, src string, node *shimast.Node, preferNever bool) {
+  clauseEnd := mappedTypeClauseEnd(src, node)
+  if clauseEnd <= 0 {
+    return
+  }
+  next, _ := scanPastTrivia(src, clauseEnd)
+  if next >= len(src) || next >= node.End() {
+    // No closing `}` in range. That source is too broken to reason about.
+    return
+  }
+  if src[next] == ';' {
+    if !preferNever {
+      return // already terminated, and the always direction never strips
+    }
+    ctx.ReportRangeFix(
+      next,
+      next+1,
+      "Unexpected trailing semicolon.",
+      TextEdit{Pos: next, End: next + 1, Text: ""},
+    )
+    return
+  }
+  if preferNever || src[next] != '}' || !memberListBreaks(src, node) {
+    return
+  }
+  pos := mappedTypeTerminatorPos(src, clauseEnd)
+  ctx.ReportRangeFix(
+    pos-1,
+    pos,
+    "Missing semicolon.",
+    TextEdit{Pos: pos, End: pos, Text: ";"},
+  )
+}
+
+// mappedTypeClauseEnd returns the offset just past the last significant
+// byte of a mapped type's clause, or -1 when the node is not the shape
+// this reads.
+//
+// With a type annotation the clause simply ends where that type does. The
+// annotation is optional, though, and the parser's own token nodes stop
+// short of the trailing punctuation in that case: `NameType` and
+// `TypeParameter` both end before the `]`, and a `+`/`-` modifier is
+// parsed as the question token with the `?` it decorates consumed by a
+// bare parseExpected. So the remaining shapes are reached by stepping over
+// exactly the bytes that can follow a clause child, which is why the walk
+// runs only when there is no annotation to end at.
+//
+// A non-empty Members list means the parser recovered from a second member
+// inside the braces (`{ [K in T]: V; a: number }`), which is not a shape
+// with a single terminator position; abstain rather than guess.
+func mappedTypeClauseEnd(src string, node *shimast.Node) int {
+  mapped := node.AsMappedTypeNode()
+  if mapped == nil {
+    return -1
+  }
+  if mapped.Members != nil && len(mapped.Members.Nodes) > 0 {
+    return -1
+  }
+  if mapped.Type != nil {
+    end := mapped.Type.End()
+    if end <= 0 || end > len(src) {
+      return -1
+    }
+    return end
+  }
+  lo := -1
+  switch {
+  case mapped.QuestionToken != nil:
+    lo = mapped.QuestionToken.End()
+  case mapped.NameType != nil:
+    lo = mapped.NameType.End()
+  case mapped.TypeParameter != nil:
+    lo = mapped.TypeParameter.End()
+  }
+  if lo <= 0 || lo > len(src) {
+    return -1
+  }
+  for {
+    next, _ := scanPastTrivia(src, lo)
+    if next >= len(src) {
+      return -1
+    }
+    switch src[next] {
+    case ']', '?', '+', '-':
+      lo = next + 1
+    default:
+      return lo
+    }
+  }
+}
+
+// mappedTypeTerminatorPos returns the offset Prettier's mapped-type `;`
+// occupies, given the clause end.
+//
+// It is the clause end in every ordinary shape, and the two comment cases
+// are the reason it is a function rather than that offset. Prettier
+// attaches a trailing block comment written on the clause's own line to
+// the value type and prints the terminator after it
+// (`[K in string]: string /* note */;`), while a line comment becomes the
+// mapped type's dangling comment and is printed after the terminator
+// (`[K in string]: string; // note`). A block comment that spans lines is
+// a line terminator per ECMA-262 and ends the clause's line, so the walk
+// stops there too. This is the one place a mapped type and a member
+// disagree: a member takes its `;` at End(), ahead of the same block
+// comment.
+func mappedTypeTerminatorPos(src string, clauseEnd int) int {
+  pos := clauseEnd
+  i := clauseEnd
+  for i < len(src) {
+    for i < len(src) && (src[i] == ' ' || src[i] == '\t') {
+      i++
+    }
+    if i+1 >= len(src) || src[i] != '/' || src[i+1] != '*' {
+      return pos
+    }
+    j := i + 2
+    for j+1 < len(src) && !(src[j] == '*' && src[j+1] == '/') {
+      if src[j] == '\n' || src[j] == '\r' {
+        return pos
+      }
+      j++
+    }
+    if j+1 >= len(src) {
+      return pos // unterminated block comment swallows the rest
+    }
+    i = j + 2
+    pos = i
+  }
+  return pos
+}
+
 func init() {
   Register(formatSemi{})
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ttsc/lint",
-  "version": "0.26.1",
+  "version": "0.26.2",
   "description": "Reference ttsc plugin: ESLint-style lint rules over the TypeScript-Go Program used by the type-check pass.",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -37,7 +37,7 @@
     "@types/node": "^25.3.0",
     "rimraf": "^6.1.2",
     "typescript": "^7.0.2",
-    "ttsc": "0.26.1"
+    "ttsc": "0.26.2"
   },
   "repository": {
     "type": "git",

package/src/structures/format/ITtscLintFormat.ts

@@ -30,9 +30,10 @@ export interface ITtscLintFormat {
   severity?: TtscLintSeverity;
 
   /**
-   * Insert trailing semicolons on ASI-terminated statements. Mirrors Prettier's
-   * `semi`. `false` flips the rule to require _no_ trailing semicolon (rare;
-   * matches prettier's `semi: false`).
+   * Insert trailing semicolons on ASI-terminated statements, and on the
+   * interface, type-literal, and class members that carry no body. Mirrors
+   * Prettier's `semi`. `false` flips the rule to require _no_ trailing
+   * semicolon (rare; matches prettier's `semi: false`).
    *
    * @default true
    */