@ttsc/lint 0.30.3 → 0.31.0

package/linthost/format_quotes_switches_double_to_single_to_minimize_escapes_test.go

@@ -0,0 +1,31 @@
+package linthost
+
+import "testing"
+
+// TestFormatQuotesSwitchesDoubleToSingleToMinimizeEscapes verifies the
+// rule flips an already-double-quoted literal to single quotes when that
+// strictly reduces escapes, even under the default prefer:"double".
+//
+// The supported policy chooses fewer required escapes before applying
+// delimiter preference on a tie. This already-double positive requires
+// the strictly cheaper single form; it does not execute an earlier
+// single-to-double-only implementation.
+//
+//  1. Parse a source file with a double-quoted literal holding one
+//     escaped double quote.
+//  2. Apply the rule through the disk-backed fixer (default options).
+//  3. Assert the literal is rewritten to the zero-escape single-quoted
+//     form.
+//
+// @evidence contracts/testing.md#behavioral-verification format/quotes must switch a double-quoted double-quote payload to single quotes even under the default double preference.
+// @evidence contracts/testing.md#independent-expectations The complete output literal retains the cooked one-double-quote value and declaration while reducing one required escape to zero; minimum escapes outranks delimiter preference.
+// @evidence contracts/testing.md#distinguishing-cases This strict-cost positive complements the already-double escape-tie negative and the symmetric prefer:single override, distinguishing cost minimization from always honoring preference.
+// @evidence contracts/testing.md#execution-ownership TestFormatQuotesSwitchesDoubleToSingleToMinimizeEscapes is a public Go unit selected by the lint semantic-unit Evidence claim. This host owns its literal inputs and complete output assertions; the shared syntax-only harness invokes the owning rule and applies source edits in process without a consumer install, native product build or product host.
+func TestFormatQuotesSwitchesDoubleToSingleToMinimizeEscapes(t *testing.T) {
+  assertFixSnapshot(
+    t,
+    "format/quotes",
+    `const s = "\"";`+"\n",
+    `const s = '"';`+"\n",
+  )
+}

package/linthost/format_quotes_switches_single_to_double_to_minimize_escapes_test.go

@@ -0,0 +1,22 @@
+package linthost
+
+import "testing"
+
+// TestFormatQuotesSwitchesSingleToDoubleToMinimizeEscapes verifies the required quote conversion.
+//
+// The apostrophe payload requires one escape with single quotes and none
+// with double quotes. The lower escape cost must override prefer:single.
+//
+// @evidence contracts/testing.md#behavioral-verification format/quotes must switch an escaped apostrophe literal to double quotes even under prefer:single.
+// @evidence contracts/testing.md#independent-expectations The complete output literal preserves the one-apostrophe cooked value and declaration while removing its required escape; the supported minimum-escape policy outranks the preferred delimiter.
+// @evidence contracts/testing.md#distinguishing-cases This strict-cost positive is the symmetric option override; the plain prefer:single positive owns the tie branch and redundant-escape negatives own already-cheaper spellings.
+// @evidence contracts/testing.md#execution-ownership TestFormatQuotesSwitchesSingleToDoubleToMinimizeEscapes is a public Go unit selected by the lint semantic-unit Evidence claim. This host owns its literal inputs and complete output assertions; the shared syntax-only harness invokes the owning rule and applies source edits in process without a consumer install, native product build or product host.
+func TestFormatQuotesSwitchesSingleToDoubleToMinimizeEscapes(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/quotes",
+    `const s = '\'';`+"\n",
+    `{"prefer":"single"}`,
+    `const s = "'";`+"\n",
+  )
+}

package/linthost/format_quotes_unescapes_apostrophe_when_converting_test.go

@@ -0,0 +1,30 @@
+package linthost
+
+import "testing"
+
+// TestFormatQuotesUnescapesApostropheWhenConverting verifies the conversion
+// rewrites `\'` to bare `'` when wrapping with double quotes.
+//
+// The reverse of the unescaped-`"` case: `'don\'t'` has one escaped quote
+// in the source. Converting to double quotes makes that escape unnecessary,
+// so the rule should emit `"don't"`. Without this branch the formatter
+// would retain an unnecessary apostrophe escape in the double form.
+// This one-pass assertion owns escape removal, not repeated-pass convergence.
+//
+//  1. Parse a source file with one escaped apostrophe in a single-quoted
+//     literal.
+//  2. Apply the rule's finding through the disk-backed fixer.
+//  3. Assert the converted text drops the redundant backslash.
+//
+// @evidence contracts/testing.md#behavioral-verification format/quotes must remove the now-unnecessary apostrophe escape when converting the single-quoted phrase to double quotes.
+// @evidence contracts/testing.md#independent-expectations The complete literal output retains the cooked don't value, declaration and JSON.stringify call; double delimiters require no apostrophe escape.
+// @evidence contracts/testing.md#distinguishing-cases This escaped-apostrophe positive owns escape removal without an embedded double quote; the mixed conversion owns simultaneous removal and insertion, while canonical-double negatives own no edits.
+// @evidence contracts/testing.md#execution-ownership TestFormatQuotesUnescapesApostropheWhenConverting is a public Go unit selected by the lint semantic-unit Evidence claim. This host owns its literal inputs and complete output assertions; the shared syntax-only harness invokes the owning rule and applies source edits in process without a consumer install, native product build or product host.
+func TestFormatQuotesUnescapesApostropheWhenConverting(t *testing.T) {
+  assertFixSnapshot(
+    t,
+    "format/quotes",
+    "const phrase = 'don\\'t';\nJSON.stringify(phrase);\n",
+    "const phrase = \"don't\";\nJSON.stringify(phrase);\n",
+  )
+}

package/linthost/format_reflow_preserves_import_default_gap_comment_test.go

@@ -0,0 +1,29 @@
+package linthost
+
+import "testing"
+
+// TestFormatReflowPreservesImportDefaultGapComment verifies preservation of
+// trivia between a default import binding and its named import list.
+//
+// Rebuilding the combined import prefix must not delete its comment. The same
+// declaration without that comment must still break under a narrow width.
+//
+// 1. Format the original default-gap comment at width ten without changing it.
+// 2. Format its comment-free twin and require the literal broken named list.
+//
+// @evidence contracts/testing.md#behavioral-verification The in-process format command must retain the comment between the default binding and named import list. A comment-free combined import must reflow at width ten, detecting lost gap trivia or blanket import abstention. The owned result is: Format its comment-free twin and require the literal broken named list.
+// @evidence contracts/testing.md#independent-expectations The original comment and binding order are authored bytes that must survive. The independently authored literal narrow-width combined-import output fixes the supported layout, retaining default binding, named bindings and module specifier.
+// @evidence contracts/testing.md#distinguishing-cases The original default-binding gap comment stays negative for reflow; the same combined import without that comment is positive at width ten. ImportTypeGapComment independently covers the type-keyword boundary.
+// @evidence contracts/testing.md#execution-ownership TestFormatReflowPreservesImportDefaultGapComment owns both source/output fixtures and printWidth ten. Its helper directly calls Go run in process and observes temporary project files and streams, without native builds, consumer installations or a product-host child.
+func TestFormatReflowPreservesImportDefaultGapComment(t *testing.T) {
+  assertFormatUnchangedWithFormat(
+    t,
+    `import D /* c */, { alpha, bravo, charlie } from "x";
+`,
+    map[string]any{"printWidth": 10},
+  )
+  assertFormatResultWithFormat(t,
+    "import D, { alpha, bravo, charlie } from \"x\";\n",
+    "import D, {\n  alpha,\n  bravo,\n  charlie,\n} from \"x\";\n",
+    map[string]any{"printWidth": 10})
+}

package/linthost/format_reflow_preserves_import_type_gap_comment_test.go

@@ -0,0 +1,29 @@
+package linthost
+
+import "testing"
+
+// TestFormatReflowPreservesImportTypeGapComment verifies preservation of
+// trivia between the type keyword and a named import brace.
+//
+// Rebuilding the type-only prefix must not delete its comment. A comment-free
+// twin requires reflow while retaining type-only binding ownership.
+//
+// 1. Format the original type-gap comment at width ten without changing it.
+// 2. Remove that comment and require the literal broken type import.
+//
+// @evidence contracts/testing.md#behavioral-verification The in-process format command must preserve the comment between type and the named import brace. The comment-free type import must break at width ten while retaining type-only ownership and every binding. The owned result is: Remove that comment and require the literal broken type import.
+// @evidence contracts/testing.md#independent-expectations The authored type-gap comment must survive byte for byte. The independently authored literal fixes the supported type-only import break and trailing comma, preserving the module specifier and imported names.
+// @evidence contracts/testing.md#distinguishing-cases The original type-keyword gap remains negative for reflow, with a comment-free twin positive under the same narrow width. The default-gap host distinguishes a different prefix region that also must retain trivia.
+// @evidence contracts/testing.md#execution-ownership TestFormatReflowPreservesImportTypeGapComment owns the original and paired import fixtures plus width-ten options. Its helper directly invokes Go run in process and reads temporary project output and streams without consumer installation, native artifacts or a CLI child.
+func TestFormatReflowPreservesImportTypeGapComment(t *testing.T) {
+  assertFormatUnchangedWithFormat(
+    t,
+    `import type /* c */ { alpha, bravo, charlie } from "x";
+`,
+    map[string]any{"printWidth": 10},
+  )
+  assertFormatResultWithFormat(t,
+    "import type { alpha, bravo, charlie } from \"x\";\n",
+    "import type {\n  alpha,\n  bravo,\n  charlie,\n} from \"x\";\n",
+    map[string]any{"printWidth": 10})
+}

package/linthost/format_reflow_preserves_nested_call_arg_comment_test.go

@@ -0,0 +1,24 @@
+package linthost
+
+import "testing"
+
+// TestFormatReflowPreservesNestedCallArgComment verifies comment preservation
+// inside the argument gap of an inner call during outer-call reflow.
+//
+// Guarding only the outer call cannot protect trivia owned by a nested call.
+// The comment-free twin requires ordinary outer-call reflow to remain active.
+//
+// 1. Format the original nested argument comment and require unchanged bytes.
+// 2. Remove that comment and require the expected broken outer call.
+//
+// @evidence contracts/testing.md#behavioral-verification The in-process format command must preserve the nested call argument comment and all original source bytes. A comment-free twin must break the outer call, detecting either deleting the inner comment or disabling all call reflow. The owned result is: Remove that comment and require the expected broken outer call.
+// @evidence contracts/testing.md#independent-expectations The literal original comment must survive; an independently authored literal fixes the supported comment-free outer-call layout. Literal argument order and call names are retained in both oracles.
+// @evidence contracts/testing.md#distinguishing-cases The comment is inside the inner call argument gap, where guarding only the outer call is insufficient. The twin removes that comment while retaining the long outer callee and both inner arguments, giving an adjacent positive.
+// @evidence contracts/testing.md#execution-ownership TestFormatReflowPreservesNestedCallArgComment owns its two authored call fixtures and complete outputs. The helper invokes Go run directly in the same process with temporary project files and captured streams; no consumer install, native build or CLI child executes.
+func TestFormatReflowPreservesNestedCallArgComment(t *testing.T) {
+  assertFormatUnchanged(t, `const result = outerFunctionWithAQuiteLongName(innerCallHelper(alphaArgument, /* keep */ betaArgument));
+`)
+  assertFormatResult(t,
+    "const result = outerFunctionWithAQuiteLongName(innerCallHelper(alphaArgument, betaArgument));\n",
+    "const result = outerFunctionWithAQuiteLongName(\n  innerCallHelper(alphaArgument, betaArgument),\n);\n")
+}

package/linthost/format_reflow_preserves_new_constructee_gap_comment_test.go

@@ -0,0 +1,21 @@
+package linthost
+
+import "testing"
+
+// TestFormatReflowPreservesNewConstructeeGapComment verifies preservation of
+// a comment between new and its constructee when the argument list is absent.
+//
+// Reprinting this nested allocation must retain keyword-gap trivia even when
+// there is no argument list to trigger an argument-gap guard.
+//
+// 1. Seed an outer call with an array containing the comment-bearing allocation.
+// 2. Format it directly and require every original byte to survive.
+//
+// @evidence contracts/testing.md#behavioral-verification The in-process format command must preserve the comment between new and its no-argument constructee, including the original outer call and array. Full unchanged output catches dropping that gap while printing a nested allocation. The owned result is: Format it directly and require every original byte to survive. .
+// @evidence contracts/testing.md#independent-expectations The authored allocation comment and program bytes must survive. The source itself is the independent byte-preservation oracle, not an expected result obtained from printer coverage or AST traversal.
+// @evidence contracts/testing.md#distinguishing-cases This no-argument new expression distinguishes the keyword gap from argument-list comments. NestedCallArgComment and ReturnComment cover other recursive gaps; existing printer new-expression cases exercise ordinary comment-free allocation rendering.
+// @evidence contracts/testing.md#execution-ownership TestFormatReflowPreservesNewConstructeeGapComment owns its allocation/array/call fixture and unchanged output. Its helper directly calls Go run in the same process with temporary project files and captured streams, without building native artifacts, installing a consumer or starting a CLI child.
+func TestFormatReflowPreservesNewConstructeeGapComment(t *testing.T) {
+  assertFormatUnchanged(t, `const result = wrapWithAnEvenLongerFunctionNameToForceReflow([new /* keep */ AllocatorInstance]);
+`)
+}

package/linthost/format_reflow_preserves_return_comment_test.go

@@ -0,0 +1,24 @@
+package linthost
+
+import "testing"
+
+// TestFormatReflowPreservesReturnComment verifies the full formatter preserves
+// a comment between return and its argument inside a callback block.
+//
+// Reprinting a nested statement must not discard its leading expression trivia.
+// Exact source preservation catches losing the comment or moving surrounding
+// callback bytes, without depending on an internal coverage-flag value.
+//
+// 1. Seed a callback whose long return expression follows a block comment.
+// 2. Invoke the format command directly and require byte-identical output.
+//
+// @evidence contracts/testing.md#behavioral-verification The in-process format command must preserve the complete callback source, including the comment between return and its expression. Exact disk output detects deleting return-gap trivia during nested reprinting. The owned result is: Invoke the format command directly and require byte-identical output. .
+// @evidence contracts/testing.md#independent-expectations The authored comment and program tokens must survive formatting. The complete unchanged source is a byte-preservation oracle independent of the printer coverage flags, and does not claim the source is universally Prettier-canonical.
+// @evidence contracts/testing.md#distinguishing-cases This comment sits in a nested return expression rather than between top-level callback arguments. NestedCallArgComment and TernaryParenComment distinguish other recursive trivia boundaries; the existing printer return cases exercise ordinary comment-free rendering.
+// @evidence contracts/testing.md#execution-ownership TestFormatReflowPreservesReturnComment owns the callback fixture and its complete unchanged output. Its helper directly invokes Go run in the same process and observes temporary fixture files and captured streams; no CLI child, consumer install or native build is started.
+func TestFormatReflowPreservesReturnComment(t *testing.T) {
+  assertFormatUnchanged(t, `const wrapped = makeWrapperWithAName(() => {
+  return /* keep */ someObjectValueWithAQuiteLongNameThatOverflowsThePrintWidth;
+});
+`)
+}

package/linthost/format_reflow_preserves_ternary_paren_comment_test.go

@@ -0,0 +1,26 @@
+package linthost
+
+import "testing"
+
+// TestFormatReflowPreservesTernaryParenComment verifies a nested consequent
+// retains a comment between its parentheses and conditional expression.
+//
+// Unwrapping that consequent for staircase layout must not drop the comment.
+// A comment-free twin requires normal chain reflow at the same width.
+//
+// 1. Format the original comment-bearing parenthesized consequent unchanged.
+// 2. Remove its comment and require the literal nested staircase output.
+//
+// @evidence contracts/testing.md#behavioral-verification The in-process format command must retain the comment inside the parenthesized nested consequent and keep the full original source. A paired comment-free consequent must reflow into the expected staircase, detecting a formatter that simply skips every conditional. The owned result is: Remove its comment and require the literal nested staircase output.
+// @evidence contracts/testing.md#independent-expectations Comment preservation requires retaining the authored comment bytes. The independently authored literal fixes the supported comment-free staircase, whose nested consequent grouping preserves the conditional meaning without consulting this printer.
+// @evidence contracts/testing.md#distinguishing-cases The original comment-bearing parenthesized consequent remains negative for reflow. Removing only that comment supplies a positive at the same width and nesting, distinguishing trivia protection from disabling the chain formatter.
+// @evidence contracts/testing.md#execution-ownership TestFormatReflowPreservesTernaryParenComment owns both full source/output fixtures. The helper directly calls Go run in process and reads its temporary project output and streams without consumer installation, native artifact production or a product-host child.
+func TestFormatReflowPreservesTernaryParenComment(t *testing.T) {
+  assertFormatUnchanged(t, `const value = someOuterConditionValueHere
+  ? (/* keep */ innerCondition ? innerTrueResultValue : innerFalseResultValue)
+  : outerFalsyFallbackResultValue;
+`)
+  assertFormatResult(t,
+    "const value = someOuterConditionValueHere\n  ? (innerCondition ? innerTrueResultValue : innerFalseResultValue)\n  : outerFalsyFallbackResultValue;\n",
+    "const value = someOuterConditionValueHere\n  ? innerCondition\n    ? innerTrueResultValue\n    : innerFalseResultValue\n  : outerFalsyFallbackResultValue;\n")
+}

package/linthost/format_semi_fires_for_every_asi_statement_kind_test.go

@@ -0,0 +1,103 @@
+package linthost
+
+import (
+  "strings"
+  "testing"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+// TestFormatSemiFiresForEveryAsiStatementKind verifies formatSemi covers the
+// fourteen ASI statement and class-field spellings in this fixture.
+//
+// The rule's Visits() list is the load-bearing contract: dropping a kind
+// silently strips its diagnostics and fixes. This scenario owns fourteen
+// terminator-less statement/class-field spellings, not every visited kind.
+// Additional type-member and mapped-type kinds have separate hosts. Each
+// insertion here must match its independently authored statement ending.
+//
+// 1. Parse a source file with one of each ASI statement kind missing `;`.
+// 2. Run the engine with formatSemi enabled.
+// 3. Assert one classified semicolon insertion at each literal statement ending.
+//
+// @evidence contracts/testing.md#behavioral-verification format/semi must emit one correctly classified zero-width semicolon insertion at each of fourteen independently identified statement/member endings, detecting a missing kind disguised by a duplicate elsewhere.
+// @evidence contracts/testing.md#independent-expectations Literal unique fixture statement markers independently determine their insertion offsets; expected zero-width semicolon bytes and formatter classification follow the default rule contract, not Visits metadata.
+// @evidence contracts/testing.md#distinguishing-cases This host owns all fourteen local import/export/declaration/expression/control/debugger/class-field cases. Every exact insertion is consumed once; already-terminated statements own the adjacent no-finding negative, and dedicated type-member tests own additional member kinds.
+// @evidence contracts/testing.md#execution-ownership TestFormatSemiFiresForEveryAsiStatementKind is a selected public Go unit under the lint semantic-unit Evidence claim. The entry parses literal fixture source and directly calls Engine.Run with the owning semicolon rule, observing its findings and edits in the same Go process without a consumer install, native product build or product host.
+func TestFormatSemiFiresForEveryAsiStatementKind(t *testing.T) {
+  // Each line is exactly one statement that ASI would terminate. The
+  // class body holds the PropertyDeclaration case; the test imports use
+  // a synthetic module specifier so the parser accepts them without a
+  // resolved program.
+  source := `import x from "x"
+import y = require("y")
+export * from "z"
+export = x
+let a = 1
+type Alias = number
+class Wrap { field = 1 }
+JSON.stringify(a)
+function loop() {
+  do {} while (false)
+  for (;;) { break }
+  for (;;) { continue }
+  return 1
+  throw 1
+}
+debugger
+`
+  file := parseTS(t, source)
+  findings := NewEngine(RuleConfig{"format/semi": SeverityError}).
+    Run([]*shimast.SourceFile{file}, nil)
+
+  // 14 ASI-terminated kinds in the fixture: import, importEquals,
+  // exportDecl, exportAssignment, varStmt, typeAlias, propertyDecl,
+  // exprStmt, doStmt, break, continue, return, throw, debugger.
+  const wantKinds = 14
+  if len(findings) != wantKinds {
+    t.Fatalf("want %d findings (one per ASI kind), got %d", wantKinds, len(findings))
+  }
+  expectedInsertions := map[int]string{}
+  for _, marker := range []string{
+    "import x from \"x\"", "import y = require(\"y\")", "export * from \"z\"", "export = x",
+    "let a = 1", "type Alias = number", "field = 1", "JSON.stringify(a)",
+    "do {} while (false)", "break", "continue", "return 1", "throw 1", "debugger",
+  } {
+    offset := strings.Index(source, marker)
+    if offset < 0 || strings.Contains(source[offset+1:], marker) {
+      t.Fatalf("literal fixture marker must occur exactly once: %q", marker)
+    }
+    expectedInsertions[offset+len(marker)] = marker
+  }
+  // Every finding must be tagged as a format-rule finding so the fix
+  // filter routes it to the format subcommand.
+  for _, finding := range findings {
+    if !finding.IsFormat {
+      t.Fatalf("expected IsFormat=true on %s @ %d", finding.Rule, finding.Pos)
+    }
+    if finding.Rule != "format/semi" {
+      t.Fatalf("unexpected rule %q in finding", finding.Rule)
+    }
+    if len(finding.Fix) != 1 {
+      t.Fatalf("expected exactly one edit per finding, got %d", len(finding.Fix))
+    }
+    edit := finding.Fix[0]
+    if _, ok := expectedInsertions[edit.Pos]; !ok {
+      t.Fatalf("unexpected or duplicate insertion at %d: %+v", edit.Pos, edit)
+    }
+    delete(expectedInsertions, edit.Pos)
+    if edit.Pos != edit.End || edit.Text != ";" {
+      t.Fatalf("expected zero-width `;` edit, got %+v", edit)
+    }
+  }
+
+  if len(expectedInsertions) != 0 {
+    t.Fatalf("missing literal statement insertions: %v", expectedInsertions)
+  }
+
+  // Sanity: parser reproduces real AST. Confirms the fixture isn't
+  // silently degrading to JSDocText or similar.
+  if file.Statements == nil || len(file.Statements.Nodes) < 8 {
+    t.Fatalf("parser produced unexpected statement count: %d", len(file.Statements.Nodes))
+  }
+}

package/linthost/format_semi_honors_prefer_never_option_test.go

@@ -0,0 +1,28 @@
+package linthost
+
+import "testing"
+
+// TestFormatSemiHonorsPreferNeverOption verifies the `prefer: "never"`
+// branch strips trailing semicolons from both ASI-safe statements and
+// ASI-safe class fields, matching Prettier semi:false.
+//
+// A class field's `;` is dropped only when removing it cannot change the
+// parse — here the field is the last member before `}`, so it is safe.
+// The hazardous case, where the next member begins with `[`/`(` and the
+// `;` must be kept, is pinned by
+// format_semi_keeps_class_field_semi_before_computed_member.
+//
+//  1. Parse a file with an expression statement and a class field, both
+//     ending in `;`, with `prefer: "never"` configured.
+//  2. Apply the rule's findings through the disk-backed fixer.
+//  3. Assert both terminators are removed.
+//
+// @evidence contracts/testing.md#behavioral-verification format/semi must remove the safe expression and last class-field terminators under never while preserving the call argument and numeric initializer.
+// @evidence contracts/testing.md#independent-expectations The literal output follows the semi:false safety convention; deleting only the two semicolons retains JSON.stringify(1) and x:number=0 meaning.
+// @evidence contracts/testing.md#distinguishing-cases This changed statement-plus-field pair complements the default insertion direction and computed-member/ASI-hazard negatives that must retain separators.
+// @evidence contracts/testing.md#execution-ownership TestFormatSemiHonorsPreferNeverOption is a selected public Go unit under the lint semantic-unit Evidence claim. The shared syntax-only fixture harness calls the owning semicolon rule and applies edits for the complete literal output assertion in the same Go process without a consumer install, native product build or product host.
+func TestFormatSemiHonorsPreferNeverOption(t *testing.T) {
+  source := "JSON.stringify(1);\nclass A { x: number = 0; }\n"
+  want := "JSON.stringify(1)\nclass A { x: number = 0 }\n"
+  assertFixSnapshotWithOptions(t, "format/semi", source, `{"prefer":"never"}`, want)
+}

package/linthost/format_semi_idempotent_on_stripped_interface_test.go

@@ -0,0 +1,28 @@
+package linthost
+
+import "testing"
+
+// TestFormatSemiIdempotentOnStrippedInterface verifies the member-strip
+// path is idempotent: an interface already free of member semicolons
+// produces zero findings under prefer:"never".
+//
+// Once the member terminators are absent, the direct rule must report
+// no further removal. This authored no-findings assertion does not run
+// a second format command or establish whole-cascade convergence.
+//
+//  1. Parse an interface whose members already lack `;`.
+//  2. Run format/semi with prefer:"never".
+//  3. Assert the rule reports nothing.
+//
+// @evidence contracts/testing.md#behavioral-verification format/semi must offer no further edit for newline-separated interface members already lacking terminators under never.
+// @evidence contracts/testing.md#independent-expectations The independent a:number and b:string source already satisfies semi:false broken-member layout; absence of a terminator is the canonical no-op oracle.
+// @evidence contracts/testing.md#distinguishing-cases This unchanged two-member interface complements the actual semicolon-stripping positive, so the suite does not rely on idempotency alone.
+// @evidence contracts/testing.md#execution-ownership TestFormatSemiIdempotentOnStrippedInterface is a public Go unit selected by the lint semantic-unit Evidence claim. The shared syntax-only fixture harness invokes the owning semicolon rule and observes zero findings in the same Go process without consumer installation, a native product build or a product host.
+func TestFormatSemiIdempotentOnStrippedInterface(t *testing.T) {
+  assertRuleSkipsSourceWithOptions(
+    t,
+    "format/semi",
+    "interface A {\n  a: number\n  b: string\n}\n",
+    `{"prefer":"never"}`,
+  )
+}

package/linthost/format_semi_idempotent_on_terminated_members_test.go

@@ -0,0 +1,38 @@
+package linthost
+
+import "testing"
+
+// TestFormatSemiIdempotentOnTerminatedMembers verifies zero findings
+// on independently authored, already-terminated member spellings.
+//
+// The parsed member includes its written semicolon, so the insert path
+// reads End()-1 and abstains. This direct rule input does not come from
+// a previous formatter result and does not execute a convergence cascade.
+//
+//  1. Parse a Prettier-shaped interface, type literal, and class body.
+//  2. Run format/semi with default options.
+//  3. Assert the rule reports nothing.
+//
+// @evidence contracts/testing.md#behavioral-verification format/semi must emit no findings for already-terminated interface signatures, a broken type-literal property and a class index signature, preventing duplicate insertion.
+// @evidence contracts/testing.md#independent-expectations The independently authored canonical literal already gives each required member its semicolon; the no-finding result follows default semi policy rather than a previous run.
+// @evidence contracts/testing.md#distinguishing-cases Five interface signature shapes plus the alias property and class index signature share this host; broken-interface/type-literal insertion positives distinguish correctness from mere idempotency.
+// @evidence contracts/testing.md#execution-ownership TestFormatSemiIdempotentOnTerminatedMembers is a public Go unit selected by the lint semantic-unit Evidence claim. The shared syntax-only fixture harness invokes the owning semicolon rule and observes zero findings in the same Go process without consumer installation, a native product build or a product host.
+func TestFormatSemiIdempotentOnTerminatedMembers(t *testing.T) {
+  assertRuleSkipsSource(
+    t,
+    "format/semi",
+    "interface Shape {\n"+
+      "  value: string;\n"+
+      "  method(): void;\n"+
+      "  [key: string]: string;\n"+
+      "  (): void;\n"+
+      "  new (): Shape;\n"+
+      "}\n"+
+      "type Alias = {\n"+
+      "  name: string;\n"+
+      "};\n"+
+      "class Value {\n"+
+      "  [key: string]: string;\n"+
+      "}\n",
+  )
+}

package/linthost/format_semi_inserts_after_missing_terminator_test.go

@@ -0,0 +1,28 @@
+package linthost
+
+import "testing"
+
+// TestFormatSemiInsertsAfterMissingTerminator verifies formatSemi inserts a
+// missing trailing semicolon on a simple expression statement.
+//
+// The rule inserts at the statement's End position. This full-output
+// assertion owns placement, not interaction with every other rule's edit.
+// One ExpressionStatement with no trailing
+// semicolon becomes the same statement with the terminator appended.
+//
+// 1. Parse a source file with one terminator-less expression statement.
+// 2. Apply the rule's finding through the disk-backed fixer.
+// 3. Assert the rewritten file contains the expected `;` at the new end.
+//
+// @evidence contracts/testing.md#behavioral-verification format/semi must append a missing semicolon to JSON.stringify(1) without changing the call or its LF ending.
+// @evidence contracts/testing.md#independent-expectations The independent full source literal specifies the default statement terminator and identical call payload; an unchanged or displaced insertion fails the exact output comparison.
+// @evidence contracts/testing.md#distinguishing-cases This simple changed expression positive complements already-terminated statement negatives and the fourteen-kind exact insertion matrix.
+// @evidence contracts/testing.md#execution-ownership TestFormatSemiInsertsAfterMissingTerminator is a selected public Go unit under the lint semantic-unit Evidence claim. The shared syntax-only fixture harness calls the owning semicolon rule and applies edits for the complete literal output assertion in the same Go process without a consumer install, native product build or product host.
+func TestFormatSemiInsertsAfterMissingTerminator(t *testing.T) {
+  assertFixSnapshot(
+    t,
+    "format/semi",
+    "JSON.stringify(1)\n",
+    "JSON.stringify(1);\n",
+  )
+}

package/linthost/format_semi_inserts_member_terminator_before_trailing_comment_test.go

@@ -0,0 +1,29 @@
+package linthost
+
+import "testing"
+
+// TestFormatSemiInsertsMemberTerminatorBeforeTrailingComment verifies the
+// terminator lands at the member's end rather than at the end of its line.
+//
+// The edit is zero-width at End(), which sits before the member's trailing
+// trivia, so a `// note` after the member keeps its position and its text.
+// The comment is also what proves the line-structure test crosses trivia:
+// the next significant byte is the `}` a line below, and scanPastTrivia has
+// to walk the comment to see that break.
+//
+//  1. Parse an interface member followed by a line comment.
+//  2. Apply format/semi through the disk-backed fixer.
+//  3. Assert the `;` lands before the comment and the comment survives.
+//
+// @evidence contracts/testing.md#behavioral-verification format/semi must insert the broken interface member terminator before its trailing line comment while retaining note and all source lines.
+// @evidence contracts/testing.md#independent-expectations The independently authored full output places the semicolon after the string annotation and before the line-comment bytes, following ordinary member comment ownership.
+// @evidence contracts/testing.md#distinguishing-cases This changed line-comment member contrasts with bare-member insertion and mapped-type comment placement; the latter owns both line and block attachment differences.
+// @evidence contracts/testing.md#execution-ownership TestFormatSemiInsertsMemberTerminatorBeforeTrailingComment is a public Go unit selected by the lint semantic-unit Evidence claim. The shared syntax-only fixture harness invokes the owning semicolon rule and applies edits for complete literal output comparison in the same Go process without consumer installation, a native product build or a product host.
+func TestFormatSemiInsertsMemberTerminatorBeforeTrailingComment(t *testing.T) {
+  assertFixSnapshot(
+    t,
+    "format/semi",
+    "interface Shape {\n  value: string // note\n}\n",
+    "interface Shape {\n  value: string; // note\n}\n",
+  )
+}

package/linthost/format_semi_keeps_a_flat_mapped_type_bare_test.go

@@ -0,0 +1,31 @@
+package linthost
+
+import "testing"
+
+// TestFormatSemiKeepsAFlatMappedTypeBare is the negative twin of the broken
+// mapped-type insert: a flat mapped type takes no terminator, and one
+// already terminated takes no second finding.
+//
+// The supported mapped-clause policy reads wrap at the opening brace.
+// A later closing brace alone does not require a terminator, while an
+// already written terminator prevents a duplicate. These authored
+// no-findings inputs do not execute an external formatter or cascade.
+//
+//  1. Parse a one-line mapped type, a flat-opened one whose brace fell to
+//     the next line, and a broken one already carrying its `;`.
+//  2. Run format/semi with default options.
+//  3. Assert the rule reports nothing.
+//
+// @evidence contracts/testing.md#behavioral-verification format/semi must offer no insertion for flat-opened mapped clauses, including a later closing brace, and no duplicate insertion for an already-terminated broken clause.
+// @evidence contracts/testing.md#independent-expectations The independent literal fixtures specify wrap at the opening brace and canonical termination; a closing-brace newline alone does not make the clause broken.
+// @evidence contracts/testing.md#distinguishing-cases Flat singleton, flat-opened/later-closed and broken-already-terminated cases share this host; broken unterminated mapped-type positives ensure this is not an unconditional no-op oracle.
+// @evidence contracts/testing.md#execution-ownership TestFormatSemiKeepsAFlatMappedTypeBare is a public Go unit selected by the lint semantic-unit Evidence claim. This entry owns every literal declaration in its fixture; the shared syntax-only harness invokes the semicolon rule and observes zero findings in the same process without a consumer install, native product build or host execution.
+func TestFormatSemiKeepsAFlatMappedTypeBare(t *testing.T) {
+  assertRuleSkipsSource(
+    t,
+    "format/semi",
+    "type Flat = { [K in string]: string };\n"+
+      "type Wrapped = { [K in string]: string\n};\n"+
+      "type Done = {\n  [K in string]: string;\n};\n",
+  )
+}

package/linthost/format_semi_keeps_a_flat_object_types_last_member_bare_test.go

@@ -0,0 +1,36 @@
+package linthost
+
+import "testing"
+
+// TestFormatSemiKeepsAFlatObjectTypesLastMemberBare verifies an object type
+// the author opened on one line keeps its last member bare, wherever the
+// closing brace landed.
+//
+// The supported object-type punctuation policy reads wrap between the
+// opening brace and first member. A flat list keeps its last member
+// bare even with a later closing brace, but a newline-separated interior
+// member still needs its separator. The outer interface has its own
+// termination decision; its nested flat type does not inherit that wrap.
+//
+//  1. Parse a flat-opened object type, a flat-opened one whose members are
+//     split, and an interface member whose type is a flat-opened literal.
+//  2. Apply format/semi through the disk-backed fixer.
+//  3. Assert only the inter-member separator and the interface member gain
+//     a `;`.
+//
+// @evidence contracts/testing.md#behavioral-verification format/semi must leave a flat-opened type literal last member bare, add an interior member separator, and terminate an outer interface member without terminating its inner flat literal.
+// @evidence contracts/testing.md#independent-expectations The independently authored full output specifies list ownership at each opening brace; retained flat last members and inserted outer/interior semicolons preserve all nested type annotations.
+// @evidence contracts/testing.md#distinguishing-cases Three literal declarations distinguish flat trailing, flat interior and outer broken-interface punctuation within one batch, rejecting a member-newline-only heuristic.
+// @evidence contracts/testing.md#execution-ownership TestFormatSemiKeepsAFlatObjectTypesLastMemberBare is a public Go unit selected by the lint semantic-unit Evidence claim. The shared syntax-only harness invokes the owning semicolon rule and applies edits for exact output in the same Go process, without consumer installation, a native product build or host execution.
+func TestFormatSemiKeepsAFlatObjectTypesLastMemberBare(t *testing.T) {
+  assertFixSnapshot(
+    t,
+    "format/semi",
+    "type Flat = { flat: number\n};\n"+
+      "type Split = { alpha: number\n  bravo: string };\n"+
+      "interface Outer {\n  nested: { inner: number\n  }\n}\n",
+    "type Flat = { flat: number\n};\n"+
+      "type Split = { alpha: number;\n  bravo: string };\n"+
+      "interface Outer {\n  nested: { inner: number\n  };\n}\n",
+  )
+}

package/linthost/format_semi_keeps_braced_and_object_literal_accessors_bare_test.go

@@ -0,0 +1,40 @@
+package linthost
+
+import "testing"
+
+// TestFormatSemiKeepsBracedAndObjectLiteralAccessorsBare verifies the two
+// shapes the accessor kinds reach that must never take a terminator.
+//
+// GetAccessor and SetAccessor spell three different members: a bodiless
+// interface accessor (terminated), a class accessor with a body (Prettier
+// never follows a braced member with `;`), and an object-literal accessor
+// (whose list is comma-separated, so a `;` there is a syntax error). A
+// kind-only insert would corrupt the third and diverge on the second, so
+// both negatives are pinned against the positive twin in
+// format_semi_terminates_broken_interface_members_test.go.
+//
+//  1. Parse a class accessor with a body and an object-literal accessor,
+//     each ending in `}` on its own line.
+//  2. Run format/semi with default options.
+//  3. Assert the rule reports nothing.
+//
+// @evidence contracts/testing.md#behavioral-verification format/semi must offer no terminator for class and object-literal getters carrying bodies, keeping their braced members and the object comma valid.
+// @evidence contracts/testing.md#independent-expectations The independent source uses complete getter bodies whose return statements are already terminated; a braced accessor is not a bodiless type signature and the object list requires commas.
+// @evidence contracts/testing.md#distinguishing-cases Class-bodied and object-bodied getter negatives complement bodiless interface and ambient-class accessor insertion positives.
+// @evidence contracts/testing.md#execution-ownership TestFormatSemiKeepsBracedAndObjectLiteralAccessorsBare is a public Go unit selected by the lint semantic-unit Evidence claim. The shared syntax-only harness invokes the owning semicolon rule and observes zero findings in the same Go process, without consumer installation, a native product build or host execution.
+func TestFormatSemiKeepsBracedAndObjectLiteralAccessorsBare(t *testing.T) {
+  assertRuleSkipsSource(
+    t,
+    "format/semi",
+    "class Value {\n"+
+      "  get first(): string {\n"+
+      "    return \"first\";\n"+
+      "  }\n"+
+      "}\n"+
+      "const holder = {\n"+
+      "  get first(): string {\n"+
+      "    return \"first\";\n"+
+      "  },\n"+
+      "};\n",
+  )
+}