@ttsc/lint 0.30.3 → 0.31.0

package/linthost/format_semi_keeps_class_field_semi_before_computed_member_test.go

@@ -0,0 +1,32 @@
+package linthost
+
+import "testing"
+
+// TestFormatSemiKeepsClassFieldSemiBeforeComputedMember verifies a class
+// field's `;` is kept when the next member begins with `[` (a computed
+// member name), which would otherwise reparse as an index access on the
+// field's value.
+//
+// `a = 1` followed by `["x"]() {}` must keep the `;`: dropping it yields
+// `a = 1\n["x"]()`, parsed as `a = (1["x"])()`. A later field with no
+// hazard ahead is still stripped, proving the guard is per-member.
+//
+//  1. Parse a class: a field before a computed method, then a trailing
+//     field before `}`.
+//  2. Apply format/semi with prefer:"never".
+//  3. Assert the hazardous field keeps its `;` while the trailing field
+//     is stripped.
+//
+// @evidence contracts/testing.md#behavioral-verification format/semi must keep the field terminator before a computed method while removing the later safe field terminator, preserving both initializers and the method.
+// @evidence contracts/testing.md#independent-expectations The independently authored exact output preserves the semicolon separating a=1 from the computed name; removing it would change the initializer parse while b=2 at the end is safe.
+// @evidence contracts/testing.md#distinguishing-cases The hazardous first field and safe last field form a changed/unchanged pair within one class, complementing the ordinary two-field removal positive.
+// @evidence contracts/testing.md#execution-ownership TestFormatSemiKeepsClassFieldSemiBeforeComputedMember 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 TestFormatSemiKeepsClassFieldSemiBeforeComputedMember(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/semi",
+    "class F {\n  a = 1;\n  [\"x\"]() {}\n  b = 2;\n}\n",
+    `{"prefer":"never"}`,
+    "class F {\n  a = 1;\n  [\"x\"]() {}\n  b = 2\n}\n",
+  )
+}

package/linthost/format_semi_keeps_object_literal_accessor_separators_untouched_test.go

@@ -0,0 +1,49 @@
+package linthost
+
+import "testing"
+
+// TestFormatSemiKeepsObjectLiteralAccessorSeparatorsUntouched verifies the
+// `,` after an object literal's accessor is never read as a member
+// separator, in either direction.
+//
+// This is the exclusion that makes the comma half of the rule safe rather
+// than the one that breaks it. GetAccessor and SetAccessor spell an object
+// literal's member with the same kinds a bodiless interface accessor uses,
+// and a braced accessor's body pushes its `}` right up against the list's
+// `,`, which is exactly where both directions scan for a separator. Reading
+// that comma would rewrite it to a `;` the grammar rejects, or delete it and
+// splice two properties together. memberTakesSemicolonTerminator is the
+// guard: it first rejects members with bodies, then checks eligible type
+// or class holders. This braced object getter exercises the body exclusion,
+// preserving its comma in both directions; it does not isolate the later
+// parent-only decision with an unsupported bodiless object accessor.
+//
+//  1. Parse an object literal holding a braced accessor followed by `,`.
+//  2. Run format/semi with default options, then through the fixer with
+//     prefer:"never".
+//  3. Assert the default direction reports nothing, and that the strip
+//     direction removes only the two statement terminators.
+//
+// @evidence contracts/testing.md#behavioral-verification format/semi must preserve the comma after an object-literal getter in both modes; never removes only its return-statement and outer declaration terminators.
+// @evidence contracts/testing.md#independent-expectations The independently authored full never-mode output retains the property-list comma and getter body while dropping the two optional statement semicolons; default no-findings is separately asserted.
+// @evidence contracts/testing.md#distinguishing-cases The same object fixture supplies a default unchanged result and a never-mode changed/retained pair, distinguishing object getter punctuation from semicolon-bearing type signatures at the shared accessor AST kind. The braced getter reaches the body exclusion before the eligible-parent check.
+// @evidence contracts/testing.md#execution-ownership TestFormatSemiKeepsObjectLiteralAccessorSeparatorsUntouched 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 TestFormatSemiKeepsObjectLiteralAccessorSeparatorsUntouched(t *testing.T) {
+  const source = "const holder = {\n" +
+    "  get first(): string {\n" +
+    "    return \"first\";\n" +
+    "  },\n" +
+    "};\n"
+  assertRuleSkipsSource(t, "format/semi", source)
+  assertFixSnapshotWithOptions(
+    t,
+    "format/semi",
+    source,
+    `{"prefer":"never"}`,
+    "const holder = {\n"+
+      "  get first(): string {\n"+
+      "    return \"first\"\n"+
+      "  },\n"+
+      "}\n",
+  )
+}

package/linthost/format_semi_keeps_one_line_interface_body_bare_test.go

@@ -0,0 +1,29 @@
+package linthost
+
+import "testing"
+
+// TestFormatSemiKeepsOneLineInterfaceBodyBare verifies the insert direction
+// abstains while the body is still written on one line.
+//
+// This rule does not add a terminator while a member still has a
+// same-line successor or closing brace. An existing interior semicolon
+// remains a separator. These direct authored inputs own no findings;
+// body breaking and subsequent formatter passes are separate operations.
+//
+//  1. Parse two one-line interfaces, one member and two members. The
+//     interior `;` of the second is a separator, not a terminator, so it
+//     must not draw an edit either.
+//  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 the last member of either singleton or two-member flat interface bodies, preserving their existing interior separator.
+// @evidence contracts/testing.md#independent-expectations The literal one-line type lists follow the ifBreak terminator convention: the interior semicolon separates members while the final member stays bare until the body breaks.
+// @evidence contracts/testing.md#distinguishing-cases This flat singleton/pair negative contrasts with the seven-kind broken-interface insertion positive; it observes zero findings rather than claiming to perform body breaking.
+// @evidence contracts/testing.md#execution-ownership TestFormatSemiKeepsOneLineInterfaceBodyBare 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 observes zero findings in the same Go process without a consumer install, native product build or product host.
+func TestFormatSemiKeepsOneLineInterfaceBodyBare(t *testing.T) {
+  assertRuleSkipsSource(
+    t,
+    "format/semi",
+    "interface Alpha { alpha: number }\ninterface Bravo { alpha: number; bravo: string }\n",
+  )
+}

package/linthost/format_semi_keeps_same_line_type_member_separator_test.go

@@ -0,0 +1,31 @@
+package linthost
+
+import "testing"
+
+// TestFormatSemiKeepsSameLineTypeMemberSeparator verifies a `;` that
+// separates two type-literal members on the SAME line is kept, while the
+// type alias's own statement terminator is stripped.
+//
+// The semi rule never inserts the line break that would let ASI replace
+// a same-line separator, so dropping the inner `;` in
+// `{ a: number; b: string }` would corrupt the type. Only the outer
+// statement `;` (after `}`) is ASI-safe to remove.
+//
+//  1. Parse a single-line type alias with two members.
+//  2. Apply format/semi with prefer:"never".
+//  3. Assert the inner separator stays and the trailing statement `;` is
+//     removed.
+//
+// @evidence contracts/testing.md#behavioral-verification format/semi must keep the same-line type-member semicolon while removing the safe outer alias terminator under never.
+// @evidence contracts/testing.md#independent-expectations The independent full literal output retains the separator needed between a:number and b:string but drops only the alias-ending punctuation.
+// @evidence contracts/testing.md#distinguishing-cases A required interior separator and optional exterior terminator share one changed/unchanged fixture, contrasting with broken newline-separated member stripping.
+// @evidence contracts/testing.md#execution-ownership TestFormatSemiKeepsSameLineTypeMemberSeparator 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 TestFormatSemiKeepsSameLineTypeMemberSeparator(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/semi",
+    "type T = { a: number; b: string };\n",
+    `{"prefer":"never"}`,
+    "type T = { a: number; b: string }\n",
+  )
+}

package/linthost/format_semi_keeps_type_member_semi_before_call_signature_test.go

@@ -0,0 +1,32 @@
+package linthost
+
+import "testing"
+
+// TestFormatSemiKeepsTypeMemberSemiBeforeCallSignature verifies a type
+// member's `;` is kept when the next member is a call signature (`(`),
+// while a member before the closing `}` is still stripped.
+//
+// In interface/type context a leading `[` is an index signature (safe to
+// strip before), but a leading `(` is a call signature that would
+// re-associate with the prior member's type, so Prettier keeps the `;`.
+// This pins the `(` arm of the type-member hazard set; it does not
+// exercise the generic call-signature `<` arm or class-field hazards.
+//
+//  1. Parse an interface whose first member precedes a call signature.
+//  2. Apply format/semi with prefer:"never".
+//  3. Assert the `;` before `(): void` is kept and the last member's is
+//     stripped.
+//
+// @evidence contracts/testing.md#behavioral-verification format/semi must keep the separator before a callable interface member while removing its safe final terminator under never.
+// @evidence contracts/testing.md#independent-expectations The independently authored literal output preserves a:number followed by the call signature as distinct members; the separator prevents type continuation while the closing-brace boundary is safe.
+// @evidence contracts/testing.md#distinguishing-cases One hazardous inter-member separator stays and one safe trailing terminator changes within the same interface, contrasting with ordinary property-only removal.
+// @evidence contracts/testing.md#execution-ownership TestFormatSemiKeepsTypeMemberSemiBeforeCallSignature 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 TestFormatSemiKeepsTypeMemberSemiBeforeCallSignature(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/semi",
+    "interface D {\n  a: number;\n  (): void;\n}\n",
+    `{"prefer":"never"}`,
+    "interface D {\n  a: number;\n  (): void\n}\n",
+  )
+}

package/linthost/format_semi_normalizes_a_comma_member_separator_test.go

@@ -0,0 +1,39 @@
+package linthost
+
+import "testing"
+
+// TestFormatSemiNormalizesACommaMemberSeparator verifies an authored `,`
+// member separator is rewritten to the `;` Prettier prints, in both the
+// broken and the flat layout.
+//
+// TypeScript accepts `,` as a type-member separator and the parser folds
+// it into the member's range exactly as it folds a `;`, so an insert that
+// looked only at "no `;` here" would emit `alpha: number,;`. Prettier 3.8.3
+// prints `;` for every separator it keeps under semi:"always", whatever the
+// layout, so no line-structure or break test guards this rewrite — it is a
+// separator normalization rather than a terminator insert. The flat literal
+// is the half that proves it: its bare last member stays bare (Prettier
+// prints no trailing separator in a flat list) while its inter-member `,`
+// still becomes `;`. The complete expected output independently specifies
+// comma normalization and the two final-member termination decisions.
+//
+//  1. Parse a broken interface and a flat type literal, each separated
+//     with `,`.
+//  2. Apply format/semi through the disk-backed fixer.
+//  3. Assert every `,` separator becomes `;`, the broken list's last
+//     member gains one, and the flat list's last member does not.
+//
+// @evidence contracts/testing.md#behavioral-verification format/semi must replace type-member commas with semicolons in both broken and flat lists, inserting the broken final terminator while keeping the flat final member bare.
+// @evidence contracts/testing.md#independent-expectations The independently authored complete output specifies separator spelling and layout-dependent final termination while retaining all four number/string member annotations.
+// @evidence contracts/testing.md#distinguishing-cases Broken interface and flat type-literal inputs share one host; exact output distinguishes comma replacement from comma-plus-semicolon insertion and final-member overtermination.
+// @evidence contracts/testing.md#execution-ownership TestFormatSemiNormalizesACommaMemberSeparator 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 applies edits for its complete output comparison in the same process without a consumer install, native product build or host execution.
+func TestFormatSemiNormalizesACommaMemberSeparator(t *testing.T) {
+  assertFixSnapshot(
+    t,
+    "format/semi",
+    "interface Shape {\n  alpha: number,\n  bravo: string\n}\n"+
+      "type Flat = { charlie: number, delta: string };\n",
+    "interface Shape {\n  alpha: number;\n  bravo: string;\n}\n"+
+      "type Flat = { charlie: number; delta: string };\n",
+  )
+}

package/linthost/format_semi_prefer_never_block_comment_is_not_hazard_test.go

@@ -0,0 +1,49 @@
+package linthost
+
+import (
+  "encoding/json"
+  "testing"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+// TestFormatSemiPreferNeverBlockCommentIsNotHazard verifies that a block
+// comment on a separate line is skipped during hazard detection. The next
+// significant token is a safe declaration start, so the semicolon is removable.
+//
+//  1. Parse two statements separated by a block comment.
+//  2. Run format/semi configured `prefer: "never"`.
+//  3. Assert two findings: the scanner crosses a newline and skips the
+//     comment before the safe declaration; the final statement reaches EOF.
+//  4. Assert the fixed output removes both `;` and keeps the comment
+//     intact.
+//
+// @evidence contracts/testing.md#behavioral-verification format/semi must strip both safe declaration terminators across a separate block-comment line while retaining the c comment.
+// @evidence contracts/testing.md#independent-expectations The independently authored output preserves a=b and d=e plus the exact block-comment bytes; newline-separated comment trivia does not continue either declaration expression.
+// @evidence contracts/testing.md#distinguishing-cases The direct engine asserts two findings and the fixture fixer asserts exact changed output; same-line comments and actual next-expression hazard cases own the complementary retained-terminator decisions.
+// @evidence contracts/testing.md#execution-ownership TestFormatSemiPreferNeverBlockCommentIsNotHazard is a public Go unit selected by the lint semantic-unit Evidence claim. This entry parses literal source and directly invokes Engine.Run with the owning semicolon rule; it also uses the syntax-only fixer harness for the exact output in the same Go process, without consumer installation, a native product build or host execution.
+func TestFormatSemiPreferNeverBlockCommentIsNotHazard(t *testing.T) {
+  const optionsJSON = `{"prefer":"never"}`
+  source := "const a = b;\n" +
+    "/* c */\n" +
+    "const d = e;\n"
+  file := parseTS(t, source)
+  resolver := InlineRuleResolver{
+    Rules: RuleConfig{"format/semi": SeverityError},
+    Options: RuleOptionsMap{
+      "format/semi": json.RawMessage(optionsJSON),
+    },
+  }
+  findings := NewEngineWithResolver(resolver).Run([]*shimast.SourceFile{file}, nil)
+  if len(findings) != 2 {
+    t.Fatalf("expected 2 findings (the block comment is not a hazard, so both semicolons are removable), got %d:\n%v",
+      len(findings), findings)
+  }
+  assertFixSnapshotWithOptions(
+    t,
+    "format/semi",
+    source,
+    optionsJSON,
+    "const a = b\n/* c */\nconst d = e\n",
+  )
+}

package/linthost/format_semi_prefer_never_keeps_a_flat_object_types_separator_test.go

@@ -0,0 +1,38 @@
+package linthost
+
+import "testing"
+
+// TestFormatSemiPreferNeverKeepsAFlatObjectTypesSeparator verifies semi:false
+// keeps the `;` between two members of an object type Prettier lays out
+// flat, while still stripping both separators of one it breaks.
+//
+// Prettier prints a member separator as `ifBreak(semi, ";")`, and the flat
+// branch of that `ifBreak` is a literal `";"` whatever `semi` says. So
+// The direct rule uses the opening-brace wrap decision to keep a flat-opened
+// interior separator, even when a later member starts on a new line. The
+// independently authored output retains that layout; it does not assert
+// a complete Prettier reflow or a historical implementation result.
+// memberListBreaks is the same question insertMemberSemicolon asks from the
+// other end, so the two directions now share one model of the wrap.
+//
+//  1. Parse a flat-opened object type whose members are split across lines
+//     and a broken one whose members are terminated.
+//  2. Apply format/semi with prefer:"never".
+//  3. Assert the flat type's separator survives, the broken type loses
+//     both of its own, and both statement terminators go.
+//
+// @evidence contracts/testing.md#behavioral-verification format/semi must keep a flat-opened type-list interior separator while removing both broken-list member separators and both alias terminators under never.
+// @evidence contracts/testing.md#independent-expectations The independent full output distinguishes list wrap at its opening brace and preserves both alpha:number/bravo:string member pairs; a member newline alone cannot determine retention.
+// @evidence contracts/testing.md#distinguishing-cases Flat-opened later-split and genuinely broken type lists share one fixture as retained/removed interior twins, with safe trailing statement punctuation removed in both.
+// @evidence contracts/testing.md#execution-ownership TestFormatSemiPreferNeverKeepsAFlatObjectTypesSeparator 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 TestFormatSemiPreferNeverKeepsAFlatObjectTypesSeparator(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/semi",
+    "type Flat = { alpha: number;\n  bravo: string };\n"+
+      "type Broken = {\n  alpha: number;\n  bravo: string;\n};\n",
+    `{"prefer":"never"}`,
+    "type Flat = { alpha: number;\n  bravo: string }\n"+
+      "type Broken = {\n  alpha: number\n  bravo: string\n}\n",
+  )
+}

package/linthost/format_semi_prefer_never_keeps_do_while_separator_test.go

@@ -0,0 +1,32 @@
+package linthost
+
+import "testing"
+
+// TestFormatSemiPreferNeverKeepsDoWhileSeparator verifies the `;` between
+// a single-statement do-body and its same-line `while` is kept under
+// semi:false.
+//
+// In `do f(); while (x);` the first `;` terminates the body expression
+// statement; without a line terminator before `while`, ASI cannot
+// replace it, so stripping yields the SyntaxError `do f() while (x)`.
+// The statement's own trailing `;` at end of file stays strippable —
+// this is the positive/negative pair inside one fixture.
+//
+//  1. Parse `do f(); while (x);` (single line).
+//  2. Apply format/semi with prefer:"never".
+//  3. Assert the body separator survives and only the do-statement's
+//     final `;` is stripped.
+//
+// @evidence contracts/testing.md#behavioral-verification format/semi must preserve the single-statement do-body separator before same-line while while removing the safe trailing do-statement terminator.
+// @evidence contracts/testing.md#independent-expectations The independently authored full output retains valid do/while grammar: the body call remains terminated before while, and the final EOF boundary needs no optional semicolon.
+// @evidence contracts/testing.md#distinguishing-cases One required body separator and one removable final terminator share a changed/retained pair, contrasting with same-line closing-brace safe removal.
+// @evidence contracts/testing.md#execution-ownership TestFormatSemiPreferNeverKeepsDoWhileSeparator 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 TestFormatSemiPreferNeverKeepsDoWhileSeparator(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/semi",
+    "do f(); while (x);\n",
+    `{"prefer":"never"}`,
+    "do f(); while (x)\n",
+  )
+}

package/linthost/format_semi_prefer_never_keeps_same_line_else_separator_test.go

@@ -0,0 +1,31 @@
+package linthost
+
+import "testing"
+
+// TestFormatSemiPreferNeverKeepsSameLineElseSeparator verifies the `;`
+// between `if (a) b();` and a same-line `else` is kept under semi:false.
+//
+// ASI only fires at a line terminator, end of input, or before `}`.
+// With `else` on the same line nothing can re-terminate the then-branch
+// once the `;` is gone, so `if (a) b() else c()` is a SyntaxError. The
+// fixture pins the current sawNewline discipline in
+// nextStatementHasASIHazard: same-line `else` prevents removal.
+//
+//  1. Parse `if (a) b(); else c();` (single line).
+//  2. Apply format/semi with prefer:"never".
+//  3. Assert only the trailing EOF-adjacent `;` is stripped and the
+//     required separator before `else` survives.
+//
+// @evidence contracts/testing.md#behavioral-verification format/semi must retain the then-branch call terminator before same-line else while removing only the final branch EOF terminator.
+// @evidence contracts/testing.md#independent-expectations The independently authored literal output keeps valid if/else separation and identical condition/calls; no line break exists to replace the semicolon before else.
+// @evidence contracts/testing.md#distinguishing-cases The required internal and safe final semicolons form a changed/retained pair, contrasting with closing-brace removal and ordinary newline-separated stripping.
+// @evidence contracts/testing.md#execution-ownership TestFormatSemiPreferNeverKeepsSameLineElseSeparator 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 TestFormatSemiPreferNeverKeepsSameLineElseSeparator(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/semi",
+    "if (a) b(); else c();\n",
+    `{"prefer":"never"}`,
+    "if (a) b(); else c()\n",
+  )
+}

package/linthost/format_semi_prefer_never_keeps_same_line_statement_separator_test.go

@@ -0,0 +1,29 @@
+package linthost
+
+import "testing"
+
+// TestFormatSemiPreferNeverKeepsSameLineStatementSeparator verifies the
+// `;` between two statements on the SAME line is kept under semi:false.
+//
+// `a = 1; b = 2` needs its separator: with no line terminator in the
+// gap, ASI cannot fire and `a = 1 b = 2` is a SyntaxError. This direct
+// semicolon entry does not execute statement splitting or a later cascade
+// pass; it owns only the retained same-line separator. It is the negative
+// twin of newline-separated stripping in TestFormatSemiHonorsPreferNeverOption.
+//
+//  1. Parse `a = 1; b = 2` (single line).
+//  2. Run format/semi with prefer:"never".
+//  3. Assert zero findings: the same-line successor keeps the `;`.
+//
+// @evidence contracts/testing.md#behavioral-verification format/semi must offer no removal of the separator between a=1 and b=2 on the same line under never.
+// @evidence contracts/testing.md#independent-expectations The literal source has no intervening line terminator, so removing its sole semicolon would make two assignments invalid; the no-finding oracle follows grammar independently.
+// @evidence contracts/testing.md#distinguishing-cases This same-line negative complements safe newline-separated stripping and separate statement-split positives; this host does not claim to execute the full cascade.
+// @evidence contracts/testing.md#execution-ownership TestFormatSemiPreferNeverKeepsSameLineStatementSeparator 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 TestFormatSemiPreferNeverKeepsSameLineStatementSeparator(t *testing.T) {
+  assertRuleSkipsSourceWithOptions(
+    t,
+    "format/semi",
+    "a = 1; b = 2\n",
+    `{"prefer":"never"}`,
+  )
+}

package/linthost/format_semi_prefer_never_keeps_semi_before_asi_hazard_test.go

@@ -0,0 +1,58 @@
+package linthost
+
+import (
+  "encoding/json"
+  "testing"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+// TestFormatSemiPreferNeverKeepsSemiBeforeASIHazard verifies the rule
+// refuses to strip a trailing `;` when the next statement starts with
+// an ASI-hazard token.
+//
+// `const a = b` followed by `;[1, 2].forEach(…)` parses as two
+// statements because of the explicit terminator. Removing the `;`
+// would re-associate the `[1, 2]` as a member-access on `b`, changing
+// program semantics. The rule's fixer applies to one statement at a
+// time and cannot synthesize prettier's defensive leading-`;` on the
+// next line, so it conservatively keeps the terminator instead of
+// stripping it.
+//
+//  1. Parse a two-statement source where the second statement starts
+//     with `[`.
+//  2. Run formatSemi configured `prefer: "never"`.
+//  3. Assert exactly one finding, a single-byte removal of the final
+//     end-of-file `;` — the hazard guard kept the first `;` in place.
+//
+// @evidence contracts/testing.md#behavioral-verification format/semi must preserve the terminator before an array-start expression while offering exactly the safe EOF-semicolon removal under never.
+// @evidence contracts/testing.md#independent-expectations The independently authored two-statement source makes removal of the first semicolon re-associate the array with one; its final terminator alone has no following hazard, fixing the expected exact edit range.
+// @evidence contracts/testing.md#distinguishing-cases One hazardous retained terminator and one safe changed candidate share this fixture; count, format classification and exact sole removal range distinguish the guard from removing the wrong semicolon.
+// @evidence contracts/testing.md#execution-ownership TestFormatSemiPreferNeverKeepsSemiBeforeASIHazard 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 TestFormatSemiPreferNeverKeepsSemiBeforeASIHazard(t *testing.T) {
+  source := "const a = 1;\n" +
+    "[1, 2].forEach((n) => n);\n"
+  file := parseTS(t, source)
+  resolver := InlineRuleResolver{
+    Rules: RuleConfig{"format/semi": SeverityError},
+    Options: RuleOptionsMap{
+      "format/semi": json.RawMessage(`{"prefer":"never"}`),
+    },
+  }
+  findings := NewEngineWithResolver(resolver).Run([]*shimast.SourceFile{file}, nil)
+  // The first statement's `;` is followed by `[`, which would parse
+  // as `1[1, 2]` if stripped. The rule must keep that terminator.
+  // The second statement's `;` is at end-of-file with no following
+  // hazard, so it's the only candidate to strip.
+  if len(findings) != 1 {
+    t.Fatalf("expected exactly 1 finding (only the trailing-EOF semicolon is safe to strip), got %d:\n%v",
+      len(findings), findings)
+  }
+  if finding := findings[0]; finding.Rule != "format/semi" || !finding.IsFormat || len(finding.Fix) != 1 {
+    t.Fatalf("the safe EOF terminator must have one formatter edit: %+v", finding)
+  }
+  edit := findings[0].Fix[0]
+  if edit.Pos != len(source)-2 || edit.End != len(source)-1 || edit.Text != "" {
+    t.Fatalf("only the final semicolon may be removed; hazardous first terminator must survive: %+v", edit)
+  }
+}

package/linthost/format_semi_prefer_never_keeps_semi_before_regex_hazard_test.go

@@ -0,0 +1,51 @@
+package linthost
+
+import (
+  "encoding/json"
+  "testing"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+// TestFormatSemiPreferNeverKeepsSemiBeforeRegexHazard verifies the rule
+// keeps a semicolon when the following line begins with a bare slash,
+// because automatic semicolon insertion would otherwise treat it as a
+// division/regex continuation of the previous expression.
+//
+//  1. Parse two statements where the second begins with a regex literal
+//     "/re/".
+//  2. Run format/semi configured `prefer: "never"`.
+//  3. Assert exactly one finding: the hazardous first `;` is kept, while
+//     the trailing-EOF `;` (no following hazard) is the only candidate to
+//     strip.
+//  4. Assert the fixed output retains the hazardous `;` and strips only
+//     the safe trailing one.
+//
+// @evidence contracts/testing.md#behavioral-verification format/semi must preserve the declaration terminator before a slash-leading regex expression and remove the final safe call terminator.
+// @evidence contracts/testing.md#independent-expectations The independently authored fixed source retains const a=b as a separate declaration and /re/.test(c) as a regex call; removing the first semicolon would risk expression continuation.
+// @evidence contracts/testing.md#distinguishing-cases Direct count-one and exact complete fixed output verify a retained hazardous candidate plus a changed EOF candidate, complementing the bracket-start hazard and trivia-only safe cases.
+// @evidence contracts/testing.md#execution-ownership TestFormatSemiPreferNeverKeepsSemiBeforeRegexHazard is a public Go unit selected by the lint semantic-unit Evidence claim. This entry parses literal source and directly invokes Engine.Run with the owning semicolon rule; it also uses the syntax-only fixer harness for the exact output in the same Go process, without consumer installation, a native product build or host execution.
+func TestFormatSemiPreferNeverKeepsSemiBeforeRegexHazard(t *testing.T) {
+  const optionsJSON = `{"prefer":"never"}`
+  source := "const a = b;\n" +
+    "/re/.test(c);\n"
+  file := parseTS(t, source)
+  resolver := InlineRuleResolver{
+    Rules: RuleConfig{"format/semi": SeverityError},
+    Options: RuleOptionsMap{
+      "format/semi": json.RawMessage(optionsJSON),
+    },
+  }
+  findings := NewEngineWithResolver(resolver).Run([]*shimast.SourceFile{file}, nil)
+  if len(findings) != 1 {
+    t.Fatalf("expected exactly 1 finding (the bare-slash hazard keeps the first semicolon; only the trailing-EOF one is safe to strip), got %d:\n%v",
+      len(findings), findings)
+  }
+  assertFixSnapshotWithOptions(
+    t,
+    "format/semi",
+    source,
+    optionsJSON,
+    "const a = b;\n/re/.test(c)\n",
+  )
+}

package/linthost/format_semi_prefer_never_keeps_semi_before_same_line_comment_gap_test.go

@@ -0,0 +1,30 @@
+package linthost
+
+import "testing"
+
+// TestFormatSemiPreferNeverKeepsSemiBeforeSameLineCommentGap verifies a
+// `;` followed by a single-line block comment and then a second
+// statement on the SAME line is kept under semi:false.
+//
+// This direct entry does not run statement splitting or a format cascade.
+// A comment without a line terminator is not a line
+// terminator for ASI (ECMA-262, Comments), so stripping would produce
+// the SyntaxError `a = 1 /* note */ b = 2`. The scan must classify the
+// comment by content — no newline inside means no newline crossed.
+//
+//  1. Parse two same-line statements separated by `; /* note */`.
+//  2. Run format/semi with prefer:"never".
+//  3. Assert zero findings: the `;` is a required separator.
+//
+// @evidence contracts/testing.md#behavioral-verification format/semi must retain the separator between two same-line assignments despite an intervening single-line block comment.
+// @evidence contracts/testing.md#independent-expectations The literal note comment has no line terminator, so ASI cannot replace the semicolon; deleting it would join a=1 and b=2 into invalid source.
+// @evidence contracts/testing.md#distinguishing-cases The unchanged same-line-comment negative complements multiline-comment-gap stripping and comment-free newline stripping, distinguishing comment contents from token kind.
+// @evidence contracts/testing.md#execution-ownership TestFormatSemiPreferNeverKeepsSemiBeforeSameLineCommentGap 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 TestFormatSemiPreferNeverKeepsSemiBeforeSameLineCommentGap(t *testing.T) {
+  assertRuleSkipsSourceWithOptions(
+    t,
+    "format/semi",
+    "a = 1; /* note */ b = 2\n",
+    `{"prefer":"never"}`,
+  )
+}

package/linthost/format_semi_prefer_never_line_comment_is_not_hazard_test.go

@@ -0,0 +1,49 @@
+package linthost
+
+import (
+  "encoding/json"
+  "testing"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+// TestFormatSemiPreferNeverLineCommentIsNotHazard verifies that a line
+// comment between newline-separated declarations is skipped during hazard
+// detection; the next significant declaration token permits removal.
+//
+//  1. Parse two statements separated by a line comment.
+//  2. Run format/semi configured `prefer: "never"`.
+//  3. Assert two findings: the first declaration crosses comment trivia
+//     to a safe declaration start, and the last reaches end of input.
+//  4. Assert the fixed output removes both `;` and keeps the comment
+//     intact.
+//
+// @evidence contracts/testing.md#behavioral-verification format/semi must strip both safe declaration terminators across a standalone line comment while preserving its note bytes.
+// @evidence contracts/testing.md#independent-expectations The independently authored complete output retains a=b, c=d and the line comment; its existing line separators establish safe declaration boundaries independently of the hazard scan.
+// @evidence contracts/testing.md#distinguishing-cases The direct engine observes two findings and the fixture fixer requires exact output; regex/bracket-leading next-expression cases complement this trivia-only changed positive.
+// @evidence contracts/testing.md#execution-ownership TestFormatSemiPreferNeverLineCommentIsNotHazard is a public Go unit selected by the lint semantic-unit Evidence claim. This entry parses literal source and directly invokes Engine.Run with the owning semicolon rule; it also uses the syntax-only fixer harness for the exact output in the same Go process, without consumer installation, a native product build or host execution.
+func TestFormatSemiPreferNeverLineCommentIsNotHazard(t *testing.T) {
+  const optionsJSON = `{"prefer":"never"}`
+  source := "const a = b;\n" +
+    "// note\n" +
+    "const c = d;\n"
+  file := parseTS(t, source)
+  resolver := InlineRuleResolver{
+    Rules: RuleConfig{"format/semi": SeverityError},
+    Options: RuleOptionsMap{
+      "format/semi": json.RawMessage(optionsJSON),
+    },
+  }
+  findings := NewEngineWithResolver(resolver).Run([]*shimast.SourceFile{file}, nil)
+  if len(findings) != 2 {
+    t.Fatalf("expected 2 findings (the line comment is not a hazard, so both semicolons are removable), got %d:\n%v",
+      len(findings), findings)
+  }
+  assertFixSnapshotWithOptions(
+    t,
+    "format/semi",
+    source,
+    optionsJSON,
+    "const a = b\n// note\nconst c = d\n",
+  )
+}