@ttsc/lint 0.30.4 → 0.31.0

package/linthost/format_semi_prefer_never_normalizes_a_comma_it_must_keep_test.go

@@ -0,0 +1,37 @@
+package linthost
+
+import "testing"
+
+// TestFormatSemiPreferNeverNormalizesACommaItMustKeep verifies a `,` that
+// semi:false cannot drop is still spelled `;`, the two shapes at once.
+//
+// This is the negative twin of the strip: semi:false silences only the
+// separators Prettier itself omits, and every separator it keeps it prints
+// as `;`. Prettier 3.8.3 returns `{ alpha: number, bravo: string }` as
+// `{ alpha: number; bravo: string }` under semi:false, because the flat
+// branch of `ifBreak(semi, ";")` is a literal `";"` whatever `semi` says;
+// and it prints `charlie: number;` ahead of a call signature for the same
+// ASI reason this rule refuses to drop a separator there. Leaving the
+// written `,` in either place would keep a spelling the oracle never emits.
+//
+//  1. Parse a flat type literal separated with `,` and an interface whose
+//     `,` precedes a call signature.
+//  2. Apply format/semi with prefer:"never".
+//  3. Assert both commas become `;` while the statement terminator is
+//     stripped.
+//
+// @evidence contracts/testing.md#behavioral-verification format/semi must normalize required commas to semicolons for a flat type list and before a call signature while removing the safe outer alias terminator under never.
+// @evidence contracts/testing.md#independent-expectations The independently authored full output preserves the flat-list and call-signature separation required for type syntax while retaining every annotation and callable member.
+// @evidence contracts/testing.md#distinguishing-cases One flat-list separator and one call-signature hazard separator must remain but change spelling; the safe statement terminator disappears and the broken-interface comma-removal case owns the opposing decision.
+// @evidence contracts/testing.md#execution-ownership TestFormatSemiPreferNeverNormalizesACommaItMustKeep 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 TestFormatSemiPreferNeverNormalizesACommaItMustKeep(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/semi",
+    "type Flat = { alpha: number, bravo: string };\n"+
+      "interface Call {\n  charlie: number,\n  (): void\n}\n",
+    `{"prefer":"never"}`,
+    "type Flat = { alpha: number; bravo: string }\n"+
+      "interface Call {\n  charlie: number;\n  (): void\n}\n",
+  )
+}

package/linthost/format_semi_prefer_never_strips_a_comma_member_separator_test.go

@@ -0,0 +1,32 @@
+package linthost
+
+import "testing"
+
+// TestFormatSemiPreferNeverStripsACommaMemberSeparator verifies semi:false
+// drops a `,` separator wherever it drops a `;`.
+//
+// The separator's spelling never changes what the oracle wants: a broken
+// interface body prints `ifBreak(semi, ";")` between its members, which is
+// nothing under semi:false, and its trailing separator is silenced the same
+// way. Prettier 3.8.3 returns this body with neither `,` nor `;`, so a rule
+// that handled only the `;` spelling would leave this fixture's two commas
+// in place instead of producing the independently authored output.
+//
+//  1. Parse an interface whose members are `,`-separated, including a
+//     trailing one before the closing brace.
+//  2. Apply format/semi with prefer:"never".
+//  3. Assert both commas are removed.
+//
+// @evidence contracts/testing.md#behavioral-verification format/semi must remove both broken-interface comma separators under never while preserving its number/string member declarations.
+// @evidence contracts/testing.md#independent-expectations The literal expected broken-interface output follows the semi:false omission convention for interior and final separators, independent of the written comma spelling.
+// @evidence contracts/testing.md#distinguishing-cases An interior comma and a trailing comma must both change; flat or hazard-required comma normalization cases own the complementary retained-separator decisions.
+// @evidence contracts/testing.md#execution-ownership TestFormatSemiPreferNeverStripsACommaMemberSeparator 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 TestFormatSemiPreferNeverStripsACommaMemberSeparator(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/semi",
+    "interface Shape {\n  alpha: number,\n  bravo: string,\n}\n",
+    `{"prefer":"never"}`,
+    "interface Shape {\n  alpha: number\n  bravo: string\n}\n",
+  )
+}

package/linthost/format_semi_prefer_never_strips_a_flat_object_types_trailing_separator_test.go

@@ -0,0 +1,33 @@
+package linthost
+
+import "testing"
+
+// TestFormatSemiPreferNeverStripsAFlatObjectTypesTrailingSeparator verifies
+// the flat-list rule does not over-reach to the last member's terminator.
+//
+// The boundary between the two halves of Prettier's answer is the closing
+// `}`. Between two members the flat branch of `ifBreak(semi, ";")` prints
+// `";"`, which is why the separator in the sibling case survives semi:false;
+// after the last member the whole separator sits inside a further `ifBreak`
+// that resolves to nothing in a flat list, in either `semi` mode. So
+// Prettier 3.8.3 returns `type Flat = { alpha: number; };` as
+// `type Flat = { alpha: number }`, and a strip that keyed on "the list is
+// flat" alone would leave a `;` the oracle never prints.
+//
+//  1. Parse a flat object type whose only member is terminated.
+//  2. Apply format/semi with prefer:"never".
+//  3. Assert the member terminator and the statement terminator both go.
+//
+// @evidence contracts/testing.md#behavioral-verification format/semi must remove the flat singleton type-member final separator and its outer alias terminator under never, preserving the alpha:number annotation.
+// @evidence contracts/testing.md#independent-expectations The independently authored literal output distinguishes trailing punctuation from required interior flat-list separators and retains the type alias meaning.
+// @evidence contracts/testing.md#distinguishing-cases This changed final-member separator complements retained flat inter-member separators and default flat-member no-insertion cases.
+// @evidence contracts/testing.md#execution-ownership TestFormatSemiPreferNeverStripsAFlatObjectTypesTrailingSeparator 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 TestFormatSemiPreferNeverStripsAFlatObjectTypesTrailingSeparator(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/semi",
+    "type Flat = { alpha: number; };\n",
+    `{"prefer":"never"}`,
+    "type Flat = { alpha: number }\n",
+  )
+}

package/linthost/format_semi_prefer_never_strips_a_mapped_type_terminator_test.go

@@ -0,0 +1,35 @@
+package linthost
+
+import "testing"
+
+// TestFormatSemiPreferNeverStripsAMappedTypeTerminator verifies semi:false
+// removes a mapped type's `;` in both layouts.
+//
+// Prettier prints the terminator as `options.semi ? ifBreak(";") : ""`, so
+// semi:false silences it outright — the wrap does not enter into it, unlike
+// the insert direction where `ifBreak` still has to ask. Prettier 3.8.3
+// returns both a broken and a flat mapped type with nothing before the
+// closing brace, so the strip needs no break test and the two directions
+// deliberately differ. Removing the `;` cannot change the parse either:
+// only the `}` can follow it, and ASI's closing-brace rule applies whatever
+// the line structure.
+//
+//  1. Parse a broken mapped type and a flat one, both terminated.
+//  2. Apply format/semi with prefer:"never".
+//  3. Assert both terminators and both statement terminators go.
+//
+// @evidence contracts/testing.md#behavioral-verification format/semi must remove both mapped-clause and outer alias terminators under never for broken and flat mapped types while retaining the mapped type meaning.
+// @evidence contracts/testing.md#independent-expectations The independently authored full output follows semi:false mapped termination in both wraps and preserves both string-valued mapping declarations.
+// @evidence contracts/testing.md#distinguishing-cases Flat and broken existing terminators both change under never, contrasting with default flat no-insertion and default broken insertion cases.
+// @evidence contracts/testing.md#execution-ownership TestFormatSemiPreferNeverStripsAMappedTypeTerminator 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 TestFormatSemiPreferNeverStripsAMappedTypeTerminator(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/semi",
+    "type A = {\n  [K in string]: string;\n};\n"+
+      "type B = { [K in string]: string; };\n",
+    `{"prefer":"never"}`,
+    "type A = {\n  [K in string]: string\n}\n"+
+      "type B = { [K in string]: string }\n",
+  )
+}

package/linthost/format_semi_prefer_never_strips_across_crlf_test.go

@@ -0,0 +1,33 @@
+package linthost
+
+import "testing"
+
+// TestFormatSemiPreferNeverStripsAcrossCrlf verifies newline detection in
+// the hazard scan counts CRLF line endings, so newline-separated
+// statements in a CRLF source still lose their terminators under
+// semi:false.
+//
+// The sawNewline discipline keeps same-line separators; if it only
+// recognized bare `\n` after skipping `\r` as plain whitespace, a CRLF
+// file would still strip correctly — but a scan that treated `\r\n` as
+// no line break would wrongly keep every terminator. This pins CRLF
+// pair handling and exact byte preservation; the pair contains LF, so
+// it does not independently isolate bare-carriage-return recognition.
+//
+//  1. Parse two CRLF-separated statements, the first ending in `;`.
+//  2. Apply format/semi with prefer:"never".
+//  3. Assert the `;` is stripped and the `\r\n` endings are preserved.
+//
+// @evidence contracts/testing.md#behavioral-verification format/semi must remove the safe first statement terminator across CRLF while leaving the second assignment and both CRLF endings intact.
+// @evidence contracts/testing.md#independent-expectations The independently authored full output follows newline-separated safe ASI and specifies exact CRLF preservation rather than matching visual lines alone.
+// @evidence contracts/testing.md#distinguishing-cases One removable terminator followed by an unterminated assignment is the changed CRLF counterpart to LF stripping, contrasting with same-line separators that must survive.
+// @evidence contracts/testing.md#execution-ownership TestFormatSemiPreferNeverStripsAcrossCrlf 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 TestFormatSemiPreferNeverStripsAcrossCrlf(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/semi",
+    "a = 1;\r\nb = 2\r\n",
+    `{"prefer":"never"}`,
+    "a = 1\r\nb = 2\r\n",
+  )
+}

package/linthost/format_semi_prefer_never_strips_across_multiline_comment_gap_test.go

@@ -0,0 +1,32 @@
+package linthost
+
+import "testing"
+
+// TestFormatSemiPreferNeverStripsAcrossMultilineCommentGap verifies a `;`
+// followed by a block comment that SPANS lines is strippable under
+// semi:false.
+//
+// Per ECMA-262 (Comments), a multi-line comment containing a line
+// terminator is treated as a line terminator for ASI, so
+// `a = 1 /* note\nnote */ b = 2` parses as two statements. This is the
+// negative twin of the same-line comment-gap case: the decision keys on
+// the comment's content (does it contain a newline?), not on its token
+// kind, so a spanning comment must count as a crossed line.
+//
+//  1. Parse two statements separated by `;` and a two-line block comment.
+//  2. Apply format/semi with prefer:"never".
+//  3. Assert the `;` is stripped and the comment survives intact.
+//
+// @evidence contracts/testing.md#behavioral-verification format/semi must remove a terminator when the following block comment contains a line break, retaining both assignments and the full multiline note.
+// @evidence contracts/testing.md#independent-expectations A line terminator inside a block comment enables ASI under the lexical contract; the independently authored output preserves those comment bytes and declaration separation.
+// @evidence contracts/testing.md#distinguishing-cases This changed multiline-comment gap complements the same-line block-comment separator negative, distinguishing comment content rather than merely its token kind.
+// @evidence contracts/testing.md#execution-ownership TestFormatSemiPreferNeverStripsAcrossMultilineCommentGap 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 TestFormatSemiPreferNeverStripsAcrossMultilineCommentGap(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/semi",
+    "a = 1; /* note\nnote */ b = 2\n",
+    `{"prefer":"never"}`,
+    "a = 1 /* note\nnote */ b = 2\n",
+  )
+}

package/linthost/format_semi_prefer_never_strips_before_same_line_close_brace_test.go

@@ -0,0 +1,31 @@
+package linthost
+
+import "testing"
+
+// TestFormatSemiPreferNeverStripsBeforeSameLineCloseBrace verifies a `;`
+// whose next significant token is a same-line `}` is still stripped
+// under semi:false.
+//
+// The same-line hazard guard must not over-reach: ASI's closing-brace
+// rule applies regardless of line structure, so `{ a() }` is valid and
+// Prettier prints it without the terminator. This is the negative twin
+// of the same-line `else` / `do…while` cases — `}` is the one same-line
+// successor that keeps the strip safe.
+//
+//  1. Parse `if (x) { a(); }` (single line).
+//  2. Apply format/semi with prefer:"never".
+//  3. Assert the `;` before the same-line `}` is stripped.
+//
+// @evidence contracts/testing.md#behavioral-verification format/semi must remove the call terminator before a same-line closing brace under never while preserving the if condition, call and block.
+// @evidence contracts/testing.md#independent-expectations The independently authored full output follows ASI closing-brace safety without requiring a line break; the call remains inside the same if body.
+// @evidence contracts/testing.md#distinguishing-cases This changed same-line closing-brace successor contrasts with same-line else/do-while or next-statement separators that must remain.
+// @evidence contracts/testing.md#execution-ownership TestFormatSemiPreferNeverStripsBeforeSameLineCloseBrace 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 TestFormatSemiPreferNeverStripsBeforeSameLineCloseBrace(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/semi",
+    "if (x) { a(); }\n",
+    `{"prefer":"never"}`,
+    "if (x) { a() }\n",
+  )
+}

package/linthost/format_semi_prefer_never_strips_member_with_space_test.go

@@ -0,0 +1,52 @@
+package linthost
+
+import (
+  "encoding/json"
+  "testing"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+// TestFormatSemiPreferNeverStripsMemberWithSpace verifies that a type
+// member whose terminator is preceded by whitespace is still stripped.
+// Only the punctuation is removed; the preceding space is outside the edit.
+// This valid parsed fixture does not establish the separate parser-recovery
+// fallback that scans beyond the member range.
+//
+//  1. Parse an interface whose member is written "a: number ;", with a
+//     space before the terminator.
+//  2. Run format/semi configured `prefer: "never"`.
+//  3. Assert one finding: the member terminator is redundant and gets
+//     removed.
+//  4. Assert the fixed output drops only the `;` itself; the rule's edit
+//     is a single-byte removal, so the pre-terminator space remains.
+//
+// @evidence contracts/testing.md#behavioral-verification format/semi must remove a redundant interface member semicolon separated from its number annotation by a space, retaining that space and the annotation.
+// @evidence contracts/testing.md#independent-expectations The independently authored full output removes only the literal punctuation byte and leaves all preceding whitespace unchanged; the finding count is supplemented by exact fixed source.
+// @evidence contracts/testing.md#distinguishing-cases One whitespace-separated member is the changed positive beside ordinary adjacent-terminator stripping and required-separator negatives; this fixture does not establish parser-recovery fallback coverage.
+// @evidence contracts/testing.md#execution-ownership TestFormatSemiPreferNeverStripsMemberWithSpace 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 TestFormatSemiPreferNeverStripsMemberWithSpace(t *testing.T) {
+  const optionsJSON = `{"prefer":"never"}`
+  source := "interface I {\n" +
+    "  a: number ;\n" +
+    "}\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 1 finding (the space-separated member terminator is redundant), got %d:\n%v",
+      len(findings), findings)
+  }
+  assertFixSnapshotWithOptions(
+    t,
+    "format/semi",
+    source,
+    optionsJSON,
+    "interface I {\n  a: number \n}\n",
+  )
+}

package/linthost/format_semi_reads_a_mapped_types_wrap_at_its_opening_brace_test.go

@@ -0,0 +1,34 @@
+package linthost
+
+import "testing"
+
+// TestFormatSemiReadsAMappedTypesWrapAtItsOpeningBrace verifies the two
+// half-wrapped mapped types come out opposite ways round.
+//
+// Prettier preserves a mapped type's wrap by the line terminator between
+// its `{` and the clause, exactly as it preserves an object type's, so the
+// closing brace's own position never enters the decision. The pair below is
+// what separates that rule from "the body spans lines": the direct
+// semicolon output terminates only the broken-opened clause and preserves
+// both authored brace positions. It does not assert complete reflow.
+// Reading the `}` instead would answer both punctuation decisions backwards.
+//
+//  1. Parse a mapped type broken at its `{` but closed on the clause's
+//     line, and one opened flat but closed on the next line.
+//  2. Apply format/semi through the disk-backed fixer.
+//  3. Assert only the one broken at its `{` gains a `;`.
+//
+// @evidence contracts/testing.md#behavioral-verification format/semi must terminate a mapped clause opened on a new line while leaving a flat-opened clause bare even if its closing brace occupies the next line.
+// @evidence contracts/testing.md#independent-expectations The independent full output preserves both mappings and applies the opening-brace wrap convention, so closing-brace position cannot supply the expected answer.
+// @evidence contracts/testing.md#distinguishing-cases The half-wrapped pair shares one fixture: opened-broken gains a semicolon while opened-flat remains unchanged, distinguishing wrap ownership from any-multiline heuristics.
+// @evidence contracts/testing.md#execution-ownership TestFormatSemiReadsAMappedTypesWrapAtItsOpeningBrace 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 TestFormatSemiReadsAMappedTypesWrapAtItsOpeningBrace(t *testing.T) {
+  assertFixSnapshot(
+    t,
+    "format/semi",
+    "type Opened = {\n  [K in string]: string };\n"+
+      "type Closed = { [K in string]: string\n};\n",
+    "type Opened = {\n  [K in string]: string; };\n"+
+      "type Closed = { [K in string]: string\n};\n",
+  )
+}

package/linthost/format_semi_skips_already_terminated_statements_test.go

@@ -0,0 +1,31 @@
+package linthost
+
+import (
+  "testing"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+// TestFormatSemiSkipsAlreadyTerminatedStatements verifies formatSemi is
+// idempotent on well-terminated statements.
+//
+// The default statement path abstains when src[End-1] is `;`. This
+// independently authored terminated declaration/call pair pins that guard;
+// it does not first apply an edit or execute a second cascade pass.
+
+// 1. Parse a source file whose every statement already ends with `;`.
+// 2. Run the engine with formatSemi enabled.
+// 3. Assert zero findings.
+//
+// @evidence contracts/testing.md#behavioral-verification format/semi must emit no findings for an already-terminated declaration and expression call rather than inserting duplicate semicolons.
+// @evidence contracts/testing.md#independent-expectations The literal source already has one terminator per statement under the default contract; zero findings is independently specified canonical behavior.
+// @evidence contracts/testing.md#distinguishing-cases The unchanged declaration/call pair complements missing-terminator insertion and the fourteen-kind changed edit matrix, so idempotency does not stand alone.
+// @evidence contracts/testing.md#execution-ownership TestFormatSemiSkipsAlreadyTerminatedStatements 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 TestFormatSemiSkipsAlreadyTerminatedStatements(t *testing.T) {
+  file := parseTS(t, "const value = 1;\nJSON.stringify(value);\n")
+  findings := NewEngine(RuleConfig{"format/semi": SeverityError}).
+    Run([]*shimast.SourceFile{file}, nil)
+  if len(findings) != 0 {
+    t.Fatalf("expected zero findings, got %d", len(findings))
+  }
+}

package/linthost/format_semi_strips_class_field_semicolons_test.go

@@ -0,0 +1,29 @@
+package linthost
+
+import "testing"
+
+// TestFormatSemiStripsClassFieldSemicolons verifies semi:false removes
+// the trailing `;` from newline-separated class fields.
+//
+// Class fields carry the full expression-ASI hazard set because their
+// initializer is an expression, but plain identifier-named fields
+// followed by another field (or `}`) are safe. Prettier drops their
+// terminators under semi:false.
+//
+//  1. Parse a class with two semicolon-terminated fields.
+//  2. Apply format/semi with prefer:"never".
+//  3. Assert both field terminators are removed.
+//
+// @evidence contracts/testing.md#behavioral-verification format/semi must remove safe semicolons from both ordinary newline-separated class fields under never while preserving their names and one/two initializers.
+// @evidence contracts/testing.md#independent-expectations The independently authored class output follows safe field ASI and preserves both field expressions; only their optional trailing semicolons disappear.
+// @evidence contracts/testing.md#distinguishing-cases The changed ordinary field pair contrasts with the computed-member hazard case, where the first field terminator must remain and the last can still change.
+// @evidence contracts/testing.md#execution-ownership TestFormatSemiStripsClassFieldSemicolons 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 TestFormatSemiStripsClassFieldSemicolons(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/semi",
+    "class A {\n  a = 1;\n  b = 2;\n}\n",
+    `{"prefer":"never"}`,
+    "class A {\n  a = 1\n  b = 2\n}\n",
+  )
+}

package/linthost/format_semi_strips_interface_member_semicolons_test.go

@@ -0,0 +1,29 @@
+package linthost
+
+import "testing"
+
+// TestFormatSemiStripsInterfaceMemberSemicolons verifies semi:false
+// removes the trailing `;` from newline-separated interface members.
+//
+// The member path strips these PropertySignature terminators when they
+// are newline-separated, including the last member before `}`. This entry
+// specifies those current edits; it does not measure benchmark divergence
+// or certify an earlier visitor population.
+
+//  1. Parse an interface with two semicolon-terminated members.
+//  2. Apply format/semi with prefer:"never".
+//  3. Assert both member terminators are removed.
+//
+// @evidence contracts/testing.md#behavioral-verification format/semi must remove both newline-separated interface member terminators under never while retaining the number/string annotations and member order.
+// @evidence contracts/testing.md#independent-expectations The independently authored full output records semi:false broken-interface layout with identical member declarations and braces.
+// @evidence contracts/testing.md#distinguishing-cases The changed broken two-member interface complements flat-body separators that must remain and canonical already-stripped interface negatives.
+// @evidence contracts/testing.md#execution-ownership TestFormatSemiStripsInterfaceMemberSemicolons 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 TestFormatSemiStripsInterfaceMemberSemicolons(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/semi",
+    "interface A {\n  a: number;\n  b: string;\n}\n",
+    `{"prefer":"never"}`,
+    "interface A {\n  a: number\n  b: string\n}\n",
+  )
+}

package/linthost/format_semi_strips_type_alias_semicolon_test.go

@@ -0,0 +1,29 @@
+package linthost
+
+import "testing"
+
+// TestFormatSemiStripsTypeAliasSemicolon verifies semi:false removes the
+// terminator of a top-level `type` alias declaration.
+//
+// A type alias is a statement-position declaration; Prettier drops its
+// `;` under semi:false. The current preferNeverSafeKind includes it,
+// and nextStatementHasASIHazard decides the following boundary. This
+// fixture reaches EOF rather than a hazardous successor.
+//
+//  1. Parse a single type-alias statement ending in `;`.
+//  2. Apply format/semi with prefer:"never".
+//  3. Assert the terminator is removed.
+//
+// @evidence contracts/testing.md#behavioral-verification format/semi must remove the optional top-level type-alias terminator under never while preserving T as number.
+// @evidence contracts/testing.md#independent-expectations The independently authored full output follows the semi:false declaration convention and retains all type-alias tokens unchanged.
+// @evidence contracts/testing.md#distinguishing-cases This changed single alias at EOF complements statement stripping and hazardous same-line/next-expression terminator preservation cases.
+// @evidence contracts/testing.md#execution-ownership TestFormatSemiStripsTypeAliasSemicolon 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 TestFormatSemiStripsTypeAliasSemicolon(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/semi",
+    "type T = number;\n",
+    `{"prefer":"never"}`,
+    "type T = number\n",
+  )
+}

package/linthost/format_semi_terminates_a_broken_mapped_type_test.go

@@ -0,0 +1,40 @@
+package linthost
+
+import "testing"
+
+// TestFormatSemiTerminatesABrokenMappedType verifies a mapped type whose
+// body is written across lines takes its terminator, through every modifier
+// spelling.
+//
+// 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 the optional `;` is consumed by parseSemicolon outside every child's
+// range, so no member node exists to carry it. The current mapped-type
+// path locates the typed clause end independently of those modifier parts.
+// These four authored modifier/remapping inputs specify identical default
+// termination while retaining every modifier byte; this entry itself does
+// not perform a reference measurement or establish earlier visitor history.
+
+//  1. Parse four broken mapped types covering `readonly`, `+readonly`/`+?`,
+//     `-readonly`/`-?`, and an `as` clause with `?`.
+//  2. Apply format/semi through the disk-backed fixer.
+//  3. Assert each clause gains a `;` before its closing brace.
+//
+// @evidence contracts/testing.md#behavioral-verification format/semi must insert a mapped-clause terminator for readonly, plus/minus readonly/optional modifiers and a template-literal key remapping while preserving every modifier and type.
+// @evidence contracts/testing.md#independent-expectations The independently authored full output preserves the four mapped declarations and inserts only the clause-ending semicolons; modifier spelling cannot alter that default termination policy.
+// @evidence contracts/testing.md#distinguishing-cases Four modifier/remapping forms require a change in one batch; flat and already-terminated mapped clauses own the adjacent no-op cases.
+// @evidence contracts/testing.md#execution-ownership TestFormatSemiTerminatesABrokenMappedType 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 TestFormatSemiTerminatesABrokenMappedType(t *testing.T) {
+  assertFixSnapshot(
+    t,
+    "format/semi",
+    "type A = {\n  readonly [K in string]: string\n};\n"+
+      "type B = {\n  +readonly [K in string]+?: string\n};\n"+
+      "type C = {\n  -readonly [K in string]-?: string\n};\n"+
+      "type D = {\n  [K in string as `p${K}`]?: string\n};\n",
+    "type A = {\n  readonly [K in string]: string;\n};\n"+
+      "type B = {\n  +readonly [K in string]+?: string;\n};\n"+
+      "type C = {\n  -readonly [K in string]-?: string;\n};\n"+
+      "type D = {\n  [K in string as `p${K}`]?: string;\n};\n",
+  )
+}

package/linthost/format_semi_terminates_a_mapped_type_across_crlf_test.go

@@ -0,0 +1,32 @@
+package linthost
+
+import "testing"
+
+// TestFormatSemiTerminatesAMappedTypeAcrossCrlf verifies the mapped-type
+// path reads a CRLF break everywhere it reads a line break.
+//
+// These typed clauses reach the opening-wrap test and trailing-comment
+// placement path while their value type already supplies the clause end.
+// The complete expected output keeps every CRLF pair and places a plain
+// terminator before the pair or a noted terminator after the block comment.
+// This does not exercise unannotated-clause token walking or isolate CR
+// recognition independently of the LF byte in each pair.
+
+//  1. Parse a CRLF broken mapped type and one trailed by a block comment.
+//  2. Apply format/semi through the disk-backed fixer.
+//  3. Assert both gain a `;` and every ending stays CRLF.
+//
+// @evidence contracts/testing.md#behavioral-verification format/semi must append the plain and block-comment-trailed mapped-clause terminators without changing any CRLF separator or note comment.
+// @evidence contracts/testing.md#independent-expectations The complete escaped output literal independently specifies every original CRLF byte and the correct plain/after-block-comment insertion position.
+// @evidence contracts/testing.md#distinguishing-cases Two changed CRLF mapped types complement LF modifier/comment positives; exact full output distinguishes correct punctuation from a stray insertion on the following CR byte.
+// @evidence contracts/testing.md#execution-ownership TestFormatSemiTerminatesAMappedTypeAcrossCrlf 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 TestFormatSemiTerminatesAMappedTypeAcrossCrlf(t *testing.T) {
+  assertFixSnapshot(
+    t,
+    "format/semi",
+    "type Plain = {\r\n  [K in string]: string\r\n};\r\n"+
+      "type Noted = {\r\n  [K in string]: string /* note */\r\n};\r\n",
+    "type Plain = {\r\n  [K in string]: string;\r\n};\r\n"+
+      "type Noted = {\r\n  [K in string]: string /* note */;\r\n};\r\n",
+  )
+}

package/linthost/format_semi_terminates_a_mapped_type_around_its_trailing_comment_test.go

@@ -0,0 +1,37 @@
+package linthost
+
+import "testing"
+
+// TestFormatSemiTerminatesAMappedTypeAroundItsTrailingComment verifies the
+// mapped-type terminator lands on the side of a trailing comment Prettier
+// puts it on, which is not the same side for both comment kinds.
+//
+// Prettier attaches a same-line trailing block comment to the mapped type's
+// value type and prints the terminator after it, while a line comment
+// becomes the mapped type's dangling comment and is printed after the
+// terminator. Prettier 3.8.3 returns `string; // note` and
+// `string /* note */;` from the two inputs below. This is also the one place
+// a mapped type and an ordinary member disagree — a member takes its `;` at
+// End(), ahead of the same block comment — so the offset cannot simply be
+// borrowed from the member path.
+//
+//  1. Parse a broken mapped type trailed by a line comment and another
+//     trailed by a block comment.
+//  2. Apply format/semi through the disk-backed fixer.
+//  3. Assert the `;` lands before the line comment and after the block
+//     comment, with both comments intact.
+//
+// @evidence contracts/testing.md#behavioral-verification format/semi must insert before a mapped-clause trailing line comment but after a same-line block comment, preserving both note comments and mapped types.
+// @evidence contracts/testing.md#independent-expectations The independently authored literal output follows mapped-comment attachment semantics; the exact note bytes and differing semicolon sides are not generated by the scanner under test.
+// @evidence contracts/testing.md#distinguishing-cases Line and block comments form adjacent different-placement positives in one host; ordinary member trailing-comment insertion is a separately owned boundary with different attachment.
+// @evidence contracts/testing.md#execution-ownership TestFormatSemiTerminatesAMappedTypeAroundItsTrailingComment 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 TestFormatSemiTerminatesAMappedTypeAroundItsTrailingComment(t *testing.T) {
+  assertFixSnapshot(
+    t,
+    "format/semi",
+    "type A = {\n  [K in string]: string // note\n};\n"+
+      "type B = {\n  [K in string]: string /* note */\n};\n",
+    "type A = {\n  [K in string]: string; // note\n};\n"+
+      "type B = {\n  [K in string]: string /* note */;\n};\n",
+  )
+}

package/linthost/format_semi_terminates_a_mapped_type_without_a_type_annotation_test.go

@@ -0,0 +1,37 @@
+package linthost
+
+import "testing"
+
+// TestFormatSemiTerminatesAMappedTypeWithoutATypeAnnotation verifies the
+// terminator still lands when the mapped type has no `: V` to end at.
+//
+// The value annotation is optional, and the parser's own token nodes stop
+// short of the punctuation that closes the clause without it: the type
+// parameter and the `as` name type both end before the `]`, and a `+`/`-`
+// modifier is parsed as the question token with the `?` it decorates
+// consumed by a bare parseExpected. Anchoring the insert on the last child's
+// End() alone would put the `;` inside the brackets. Prettier 3.8.3 prints
+// `[K in string];` and `[K in string]?;`, so the offset has to step over the
+// trailing `]` and `?` the way the parser skipped them.
+//
+//  1. Parse three broken mapped types with no value annotation: a bare one,
+//     one ending in `?`, and one with an `as` clause.
+//  2. Apply format/semi through the disk-backed fixer.
+//  3. Assert each `;` lands after the clause's last written byte.
+//
+// @evidence contracts/testing.md#behavioral-verification format/semi must place the terminator after the final bracket or optional marker when a broken mapped clause omits its value annotation.
+// @evidence contracts/testing.md#independent-expectations The independent output literals keep the unannotated clause grammar intact: semicolons follow the closing bracket or question marker rather than an earlier type child.
+// @evidence contracts/testing.md#distinguishing-cases Bare, readonly-optional and remapped unannotated clauses require a change, contrasting with annotated mapped clauses and flat-layout no-insertion negatives.
+// @evidence contracts/testing.md#execution-ownership TestFormatSemiTerminatesAMappedTypeWithoutATypeAnnotation 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 TestFormatSemiTerminatesAMappedTypeWithoutATypeAnnotation(t *testing.T) {
+  assertFixSnapshot(
+    t,
+    "format/semi",
+    "type A = {\n  [K in string]\n};\n"+
+      "type B = {\n  readonly [K in string]?\n};\n"+
+      "type C = {\n  [K in string as `p${K}`]\n};\n",
+    "type A = {\n  [K in string];\n};\n"+
+      "type B = {\n  readonly [K in string]?;\n};\n"+
+      "type C = {\n  [K in string as `p${K}`];\n};\n",
+  )
+}