@ttsc/lint 0.30.4 → 0.31.0

package/linthost/format_statement_split_breaks_three_statements_on_one_line_test.go

@@ -0,0 +1,27 @@
+package linthost
+
+import "testing"
+
+// TestFormatStatementSplitBreaksThreeStatementsOnOneLine verifies the
+// rule splits a line carrying three statements into three lines.
+//
+// One finding may carry many edits; three crammed statements must each
+// land on their own line, not just the second. This pins that the walk
+// reports every statement after the first, not a single break.
+//
+//  1. Parse three top-level statements sharing one line.
+//  2. Apply the rule's finding through the disk-backed fixer.
+//  3. Assert each statement lands on its own line.
+//
+// @evidence contracts/testing.md#behavioral-verification format/statement-split must move both later declarations onto separate lines in one fix, preserving the a/b/c declaration order and values one/two/three.
+// @evidence contracts/testing.md#independent-expectations The independently authored three-line literal specifies all required breaks and unchanged declarations, detecting a rewrite that handles only the second statement.
+// @evidence contracts/testing.md#distinguishing-cases Three same-line statements require two edits; the two-statement positive and already-separated three-statement negative cover the neighboring populations.
+// @evidence contracts/testing.md#execution-ownership TestFormatStatementSplitBreaksThreeStatementsOnOneLine is a public Go unit selected by the lint semantic-unit Evidence claim. Its shared syntax-only harness invokes the owning formatter on temporary fixture source and applies its reported edits for exact output assertions in the same process, without a consumer install, native product build or host execution.
+func TestFormatStatementSplitBreaksThreeStatementsOnOneLine(t *testing.T) {
+  assertFixSnapshot(
+    t,
+    "format/statement-split",
+    "const a = 1; const b = 2; const c = 3;\n",
+    "const a = 1;\nconst b = 2;\nconst c = 3;\n",
+  )
+}

package/linthost/format_statement_split_honors_crlf_end_of_line_test.go

@@ -0,0 +1,29 @@
+package linthost
+
+import "testing"
+
+// TestFormatStatementSplitHonorsCRLFEndOfLine verifies the inserted line
+// break uses `\r\n` when `endOfLine` is `crlf`.
+//
+// The rule synthesizes its break from the shared layout's EOL. Under CRLF
+// the break must be `\r\n`, not a bare `\n`, so a split file stays
+// consistently CRLF. This pins that the layout's endOfLine drives the
+// inserted separator.
+//
+//  1. Parse two statements sharing one CRLF-terminated line.
+//  2. Apply the rule with `{"endOfLine":"crlf"}` through the fixer.
+//  3. Assert the inserted break is `\r\n`.
+//
+// @evidence contracts/testing.md#behavioral-verification format/statement-split must insert CRLF between shared-line declarations when configured crlf, preserving both declarations and the existing terminal CRLF.
+// @evidence contracts/testing.md#independent-expectations The explicit endOfLine contract and literal escaped CRLF output determine separator bytes independently of the layout loader.
+// @evidence contracts/testing.md#distinguishing-cases This CRLF changed positive contrasts with default LF splitting and unchanged line-separated declarations; exact bytes reject a mixed bare-LF insertion.
+// @evidence contracts/testing.md#execution-ownership TestFormatStatementSplitHonorsCRLFEndOfLine is a public Go unit selected by the lint semantic-unit Evidence claim. Its shared syntax-only harness invokes the owning formatter on temporary fixture source and applies its reported edits for exact output assertions in the same process, without a consumer install, native product build or host execution.
+func TestFormatStatementSplitHonorsCRLFEndOfLine(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/statement-split",
+    "const a = 1; const b = 2;\r\n",
+    `{"endOfLine":"crlf"}`,
+    "const a = 1;\r\nconst b = 2;\r\n",
+  )
+}

package/linthost/format_statement_split_indents_split_statement_inside_block_test.go

@@ -0,0 +1,30 @@
+package linthost
+
+import "testing"
+
+// TestFormatStatementSplitIndentsSplitStatementInsideBlock verifies the
+// rule indents the statement it breaks out to the enclosing block's
+// depth, not column 0.
+//
+// A block body lives one nesting level deep, so the inserted line break
+// must carry the depth-1 indent (two spaces by default). This pins that
+// the rule reads the statement's nesting depth rather than always
+// emitting a bare newline.
+//
+//  1. Parse a function whose block holds two statements on one line.
+//  2. Apply the rule's finding through the disk-backed fixer.
+//  3. Assert the second statement lands on its own line at the block
+//     indent.
+//
+// @evidence contracts/testing.md#behavioral-verification format/statement-split must break the second function-body declaration at depth-one indentation while preserving the function, first declaration and braces.
+// @evidence contracts/testing.md#independent-expectations The literal output gives the default two-space block indent and retains a=1 and b=2; zero-column insertion would fail independently of its computed depth.
+// @evidence contracts/testing.md#distinguishing-cases The changed nested pair complements top-level no-indent splitting and already-separated statements; exact body output verifies both indentation and unchanged tokens.
+// @evidence contracts/testing.md#execution-ownership TestFormatStatementSplitIndentsSplitStatementInsideBlock is a public Go unit selected by the lint semantic-unit Evidence claim. Its shared syntax-only harness invokes the owning formatter on temporary fixture source and applies its reported edits for exact output assertions in the same process, without a consumer install, native product build or host execution.
+func TestFormatStatementSplitIndentsSplitStatementInsideBlock(t *testing.T) {
+  assertFixSnapshot(
+    t,
+    "format/statement-split",
+    "function f() {\n  const a = 1; const b = 2;\n}\n",
+    "function f() {\n  const a = 1;\n  const b = 2;\n}\n",
+  )
+}

package/linthost/format_statement_split_keeps_block_on_case_label_line_test.go

@@ -0,0 +1,28 @@
+package linthost
+
+import "testing"
+
+// TestFormatStatementSplitKeepsBlockOnCaseLabelLine verifies the rule
+// leaves a `case X: {` block attached to its clause label.
+//
+// A block that opens right after its own `case`/`default` label is not
+// sharing a line with a preceding statement; the only thing before it is
+// the label. Prettier keeps the brace on the label line, so the rule must
+// abstain instead of breaking it off into `case 2:\n{`. This pins the
+// `firstStatementAfterCaseLabel` guard.
+//
+//  1. Parse a switch whose case clause opens a block on the label line.
+//  2. Run the rule.
+//  3. Assert it emits no finding (block stays on the label line).
+//
+// @evidence contracts/testing.md#behavioral-verification format/statement-split must offer no finding for a block attached to case two rather than detaching its brace from its own clause label.
+// @evidence contracts/testing.md#independent-expectations The literal switch case owns the following block, not a preceding statement; the case-label formatting convention permits that attachment independently from the split walk.
+// @evidence contracts/testing.md#distinguishing-cases This case-label negative complements actual same-line statement splitting and nested-body splitting, distinguishing a label-owned block from a second statement.
+// @evidence contracts/testing.md#execution-ownership TestFormatStatementSplitKeepsBlockOnCaseLabelLine is a public Go unit selected by the lint semantic-unit Evidence claim. Its shared syntax-only harness invokes the owning formatter on temporary fixture source and observes its no-finding result in the same process, without a consumer install, native product build or host execution.
+func TestFormatStatementSplitKeepsBlockOnCaseLabelLine(t *testing.T) {
+  assertRuleSkipsSource(
+    t,
+    "format/statement-split",
+    "switch (x) {\n  case 2: {\n    break;\n  }\n}\n",
+  )
+}

package/linthost/format_statement_split_keeps_leading_semi_guard_test.go

@@ -0,0 +1,31 @@
+package linthost
+
+import "testing"
+
+// TestFormatStatementSplitKeepsLeadingSemiGuard verifies statement-split
+// does not break a statement off a leading-semicolon ASI guard
+// (`;(expr)`).
+//
+// format/orphan-semi merges a lone `;` guard onto the statement it
+// protects. This direct entry starts with that authored merged shape and
+// checks statement-split alone; it does not run orphan-semi or a cascade.
+// Preserving the shape avoids proposing a competing split. The `;` is a
+// guard (not a `foo();bar()` terminator) when only whitespace precedes it
+// to the start of its line.
+//
+//  1. Parse a merged `;(expr)` guard on its own line.
+//  2. Run format/statement-split.
+//  3. Assert the rule reports nothing (the line is not re-split).
+//
+// @evidence contracts/testing.md#behavioral-verification format/statement-split must leave the leading semicolon attached to the cast expression it protects, preventing conflict with orphan-semicolon canonicalization.
+// @evidence contracts/testing.md#independent-expectations The literal line begins with an ASI guard rather than a previous statement terminator; preserving its association follows the guard contract independently of whitespace scanning.
+// @evidence contracts/testing.md#distinguishing-cases The protected ;(bar as Baz).qux call is the no-op counterpart to ordinary terminated-statement splitting; the leading comment line is retained fixture context.
+// @evidence contracts/testing.md#execution-ownership TestFormatStatementSplitKeepsLeadingSemiGuard is a public Go unit selected by the lint semantic-unit Evidence claim. Its shared syntax-only harness invokes the owning formatter on temporary fixture source and observes its no-finding result in the same process, without a consumer install, native product build or host execution.
+func TestFormatStatementSplitKeepsLeadingSemiGuard(t *testing.T) {
+  assertRuleSkipsSourceWithOptions(
+    t,
+    "format/statement-split",
+    "// guard\n;(bar as Baz).qux()\n",
+    `{"tabWidth":2}`,
+  )
+}

package/linthost/format_statement_split_skips_already_one_per_line_test.go

@@ -0,0 +1,26 @@
+package linthost
+
+import "testing"
+
+// TestFormatStatementSplitSkipsAlreadyOnePerLine verifies the rule emits
+// no finding when every statement already starts its own line.
+//
+// Idempotency: once each statement is alone on its line, step 2 abstains
+// for all of them and the rule must produce nothing. This pins that a
+// well-formed file is a fixed point of the split rule.
+//
+//  1. Parse a file with one statement per line.
+//  2. Run the rule.
+//  3. Assert it emits no finding.
+//
+// @evidence contracts/testing.md#behavioral-verification format/statement-split must emit no finding when all three declarations already begin separate lines.
+// @evidence contracts/testing.md#independent-expectations The complete literal input already fulfills one-statement-per-line formatting; this canonical-form decision is not derived from a previous rule output.
+// @evidence contracts/testing.md#distinguishing-cases This unchanged three-declaration negative complements the actual three-on-one-line transformation, so a no-op implementation fails the paired positive case.
+// @evidence contracts/testing.md#execution-ownership TestFormatStatementSplitSkipsAlreadyOnePerLine is a public Go unit selected by the lint semantic-unit Evidence claim. Its shared syntax-only harness invokes the owning formatter on temporary fixture source and observes its no-finding result in the same process, without a consumer install, native product build or host execution.
+func TestFormatStatementSplitSkipsAlreadyOnePerLine(t *testing.T) {
+  assertRuleSkipsSource(
+    t,
+    "format/statement-split",
+    "const a = 1;\nconst b = 2;\nconst c = 3;\n",
+  )
+}

package/linthost/format_ternary_nullish_parens_leaves_logical_and_parenthesized_test.go

@@ -0,0 +1,30 @@
+package linthost
+
+import "testing"
+
+// TestFormatTernaryNullishParensLeavesLogicalAndParenthesized verifies
+// the rule does not touch `||`/`&&` operands and is idempotent on an
+// already-parenthesized `??`.
+//
+// Only `??` needs the parens under Prettier 3; logical-or/and arms stay
+// bare, and a `(a ?? b)` that already has parentheses parses as a
+// parenthesized expression (not a bare `??`) so the rule must not
+// double-wrap.
+//
+//  1. Parse logical-and/or operands and already-wrapped nullish operands.
+//  2. Run format/ternary-nullish-parens.
+//  3. Assert the rule reports nothing.
+//
+// @evidence contracts/testing.md#behavioral-verification The owning ternary-nullish rule must abstain on logical-and/or operands and already parenthesized nullish operands. No-finding assertions detect treating every binary operator as nullish or double-wrapping canonical input.
+// @evidence contracts/testing.md#independent-expectations The independently authored canonical spellings leave logical operands bare and retain existing parentheses around each complete nullish operand. These inputs specify no change without deriving the expectation from the rule operator switch; this entry does not execute a reference formatter.
+// @evidence contracts/testing.md#distinguishing-cases The original logical-or and wrapped-nullish fixture remains. Added logical-and/or positions and the fully wrapped three-nullish conditional distinguish operator eligibility and the canonical fixed point from WrapsAllPositions positives.
+// @evidence contracts/testing.md#execution-ownership TestFormatTernaryNullishParensLeavesLogicalAndParenthesized owns every authored negative source in the public Go unit population. The syntax-only owning rule executes in process without consumer installation, native builds or real product hosts.
+func TestFormatTernaryNullishParensLeavesLogicalAndParenthesized(t *testing.T) {
+  assertRuleSkipsSource(
+    t,
+    "format/ternary-nullish-parens",
+    "const r = cond ? a || b : (c ?? d);\n",
+  )
+  assertRuleSkipsSource(t, "format/ternary-nullish-parens", "const r = a && b ? c || d : (e ?? f);\n")
+  assertRuleSkipsSource(t, "format/ternary-nullish-parens", "const r = (a ?? b) ? (c ?? d) : (e ?? f);\n")
+}

package/linthost/format_ternary_nullish_parens_wraps_all_positions_test.go

@@ -0,0 +1,29 @@
+package linthost
+
+import "testing"
+
+// TestFormatTernaryNullishParensWrapsAllPositions verifies a `??` operand
+// in any of a conditional's three positions is parenthesized, matching
+// Prettier 3.
+//
+// Prettier 3 wraps a nullish-coalescing condition, consequent, or
+// alternate of a `?:` for clarity (TypeScript allows the bare form, but
+// Prettier adds the parens). `||`/`&&` are left bare.
+//
+//  1. Parse a conditional whose condition, consequent, and alternate are
+//     each a bare `??` expression.
+//  2. Apply format/ternary-nullish-parens.
+//  3. Assert all three are parenthesized.
+//
+// @evidence contracts/testing.md#behavioral-verification The owning ternary-nullish rule must parenthesize each of condition, consequent and alternate without changing identifiers, operators or the conditional structure. The complete literal output detects missing a position or wrapping the wrong span.
+// @evidence contracts/testing.md#independent-expectations The independently authored complete output parenthesizes each full nullish operand in the condition, consequent and alternate, preserving its existing TypeScript grouping and all identifiers. This entry applies the owning rule to that literal expectation; it does not execute a reference formatter.
+// @evidence contracts/testing.md#distinguishing-cases One conditional has all three nullish positions as positives. LeavesLogicalAndParenthesized supplies logical-and, logical-or and already wrapped negatives, including a fully canonical three-position counterpart.
+// @evidence contracts/testing.md#execution-ownership TestFormatTernaryNullishParensWrapsAllPositions owns the literal input/output in the public Go unit population. The syntax-only owning rule and edit application run in process without consumer installation, native artifact building or a product host.
+func TestFormatTernaryNullishParensWrapsAllPositions(t *testing.T) {
+  assertFixSnapshot(
+    t,
+    "format/ternary-nullish-parens",
+    "const r = a ?? b ? c ?? d : e ?? f;\n",
+    "const r = (a ?? b) ? (c ?? d) : (e ?? f);\n",
+  )
+}

package/linthost/format_trailing_comma_honors_mode_es5_for_enum_members_test.go

@@ -0,0 +1,26 @@
+package linthost
+
+import "testing"
+
+// TestFormatTrailingCommaHonorsModeEs5ForEnumMembers verifies enum members
+// use Prettier's ES5 comma level.
+//
+// Enum comma policy follows the formatter option level rather than the age of enum syntax. A missing enum dispatch must not silently skip the final-member comma.
+//
+// 1. Parse a multi-line enum without a final comma.
+// 2. Apply format/trailing-comma with mode `es5`.
+// 3. Assert the final member gains a trailing comma.
+//
+// @evidence contracts/testing.md#behavioral-verification Enum Direction must gain only the comma after Down under mode es5; complete source preserves Up, the enum name and brace layout.
+// @evidence contracts/testing.md#independent-expectations The independently authored Down-comma output specifies the enum comma policy at the es5 option level, preserving the enum name, both member names and brace layout. The expectation is a literal fixture oracle rather than a value generated from the visited-kind table; this entry does not run a reference formatter.
+// @evidence contracts/testing.md#distinguishing-cases The broken enum is positive under es5. None-removal and terminated-list hosts cover the opposite normalization and canonical fixed point.
+// @evidence contracts/testing.md#execution-ownership TestFormatTrailingCommaHonorsModeEs5ForEnumMembers owns each literal source, option and expected output in the public Go unit population. The syntax-only owning rule and edit/no-finding harness run in one process without consumer installation, native product builds or a product-host child.
+func TestFormatTrailingCommaHonorsModeEs5ForEnumMembers(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/trailing-comma",
+    "enum Direction {\n  Up,\n  Down\n}\n",
+    `{"mode":"es5"}`,
+    "enum Direction {\n  Up,\n  Down,\n}\n",
+  )
+}

package/linthost/format_trailing_comma_honors_mode_es5_includes_type_level_lists_test.go

@@ -0,0 +1,26 @@
+package linthost
+
+import "testing"
+
+// TestFormatTrailingCommaHonorsModeEs5IncludesTypeLevelLists verifies that
+// Prettier's `es5` level includes tuple types and type parameters.
+//
+// TypeScript lists are governed by the formatter option, not a strict claim that their entire surrounding syntax existed in ES5. Both tuple and generic lists share the es5 comma level.
+//
+// 1. Parse a multi-line tuple and type-parameter declaration.
+// 2. Apply format/trailing-comma with mode `es5`.
+// 3. Assert both type-level lists gain a trailing comma.
+//
+// @evidence contracts/testing.md#behavioral-verification The tuple and generic declaration must both gain final commas under es5 without changing type names or the function body. Complete output detects losing either type-space list.
+// @evidence contracts/testing.md#independent-expectations Official Prettier options include TypeScript type parameters under es5. The independently authored First/Second tuple and generic outputs preserve both complete type lists and specify their final commas; this entry uses those literal oracles without executing a reference formatter.
+// @evidence contracts/testing.md#distinguishing-cases The same source exercises tuple elements and declaration type parameters, distinct from runtime function parameters excluded by the ES5Option host.
+// @evidence contracts/testing.md#execution-ownership TestFormatTrailingCommaHonorsModeEs5IncludesTypeLevelLists owns each literal source, option and expected output in the public Go unit population. The syntax-only owning rule and edit/no-finding harness run in one process without consumer installation, native product builds or a product-host child.
+func TestFormatTrailingCommaHonorsModeEs5IncludesTypeLevelLists(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/trailing-comma",
+    "type Pair = [\n  First,\n  Second\n];\nfunction pair<\n  First,\n  Second\n>() {}\n",
+    `{"mode":"es5"}`,
+    "type Pair = [\n  First,\n  Second,\n];\nfunction pair<\n  First,\n  Second,\n>() {}\n",
+  )
+}

package/linthost/format_trailing_comma_honors_mode_es5_option_test.go

@@ -0,0 +1,28 @@
+package linthost
+
+import "testing"
+
+// TestFormatTrailingCommaHonorsModeES5Option verifies `mode: "es5"` adds
+// trailing commas to eligible lists while excluding function parameters.
+//
+// The es5 option includes arrays, objects, named specifiers, enums and type-level lists while excluding runtime parameter and argument commas. This mixed fixture pins an eligible array beside ineligible function parameters.
+//
+//  1. Parse a file mixing a multi-line array and a multi-line function
+//     declaration, with `mode: "es5"` configured.
+//  2. Apply the rule's findings.
+//  3. Assert the array gains a trailing comma but the parameter list
+//     does not.
+//
+// @evidence contracts/testing.md#behavioral-verification The array must gain its final comma while the multiline function parameters and existing call stay unchanged under es5. Full output catches ignoring the option or suppressing all list edits.
+// @evidence contracts/testing.md#independent-expectations Official Prettier es5 policy permits array commas and excludes function parameter/call commas. The literal expected file preserves parameter names, return type, body and call while changing only the array.
+// @evidence contracts/testing.md#distinguishing-cases A positive array and negative function declaration share one file and option. IncludesTypeLevelLists distinguishes tuple/type-parameter eligibility from runtime parameter eligibility.
+// @evidence contracts/testing.md#execution-ownership TestFormatTrailingCommaHonorsModeES5Option owns each literal source, option and expected output in the public Go unit population. The syntax-only owning rule and edit/no-finding harness run in one process without consumer installation, native product builds or a product-host child.
+func TestFormatTrailingCommaHonorsModeES5Option(t *testing.T) {
+  source := "const xs = [\n  1,\n  2\n];\n" +
+    "function f(\n  a: number,\n  b: number\n): number { return a + b; }\n" +
+    "f(1, 2);\n"
+  want := "const xs = [\n  1,\n  2,\n];\n" +
+    "function f(\n  a: number,\n  b: number\n): number { return a + b; }\n" +
+    "f(1, 2);\n"
+  assertFixSnapshotWithOptions(t, "format/trailing-comma", source, `{"mode":"es5"}`, want)
+}

package/linthost/format_trailing_comma_honors_mode_es5_skips_arrow_parameter_test.go

@@ -0,0 +1,29 @@
+package linthost
+
+import "testing"
+
+// TestFormatTrailingCommaHonorsModeEs5SkipsArrowParameter verifies the
+// rule emits no findings on a multi-line arrow-function parameter list
+// under `mode: "es5"`.
+//
+// The es5 parameter policy forbids a final comma rather than skipping this node entirely. Both the no-comma fixed point and removal of a pre-existing comma must work for arrows.
+//
+// 1. Parse the original comma-free list and a twin with a final comma.
+// 2. Run format/trailing-comma with mode es5.
+// 3. Require no findings for the original and exact comma removal for the twin.
+//
+// @evidence contracts/testing.md#behavioral-verification Arrow parameters without a final comma must remain untouched under es5; an existing final comma must be removed while preserving the arrow return type and body.
+// @evidence contracts/testing.md#independent-expectations Prettier es5 excludes function parameter trailing commas. Both unchanged missing-comma input and literal removal output follow that option policy independently of the parameter scanner.
+// @evidence contracts/testing.md#distinguishing-cases The original multiline parenthesized arrow negative remains, paired with its already-comma-terminated removal case. The all-mode arrow insertion host supplies the other mode direction.
+// @evidence contracts/testing.md#execution-ownership TestFormatTrailingCommaHonorsModeEs5SkipsArrowParameter owns each literal source, option and expected output in the public Go unit population. The syntax-only owning rule and edit/no-finding harness run in one process without consumer installation, native product builds or a product-host child.
+func TestFormatTrailingCommaHonorsModeEs5SkipsArrowParameter(t *testing.T) {
+  assertRuleSkipsSourceWithOptions(
+    t,
+    "format/trailing-comma",
+    "const add = (\n  a: number,\n  b: number\n): number => a + b;\nadd;\n",
+    `{"mode":"es5"}`,
+  )
+  assertFixSnapshotWithOptions(t, "format/trailing-comma",
+    "const add = (\n  a: number,\n  b: number,\n): number => a + b;\nadd;\n", `{"mode":"es5"}`,
+    "const add = (\n  a: number,\n  b: number\n): number => a + b;\nadd;\n")
+}

package/linthost/format_trailing_comma_honors_mode_es5_skips_call_argument_test.go

@@ -0,0 +1,28 @@
+package linthost
+
+import "testing"
+
+// TestFormatTrailingCommaHonorsModeEs5SkipsCallArgument verifies the rule
+// emits no findings on a multi-line call expression under `mode: "es5"`.
+//
+// The es5 call policy forbids final argument commas. Normalization must preserve a missing comma and remove an existing one, rather than returning early for every call.
+//
+// 1. Parse the original comma-free list and a twin with a final comma.
+// 2. Run format/trailing-comma with mode es5.
+// 3. Require no findings for the original and exact comma removal for the twin.
+//
+// @evidence contracts/testing.md#behavioral-verification A multiline call without a final comma must receive no findings under es5. Its already comma-terminated counterpart must lose only the final argument comma.
+// @evidence contracts/testing.md#independent-expectations Official Prettier options exclude call argument commas under es5. The literal call arguments and declaration remain identical while the authored removal oracle deletes the final comma.
+// @evidence contracts/testing.md#distinguishing-cases The original two-argument call abstention stays and a pre-existing comma exercises removal in the same dispatch arm. The all-mode call host covers insertion.
+// @evidence contracts/testing.md#execution-ownership TestFormatTrailingCommaHonorsModeEs5SkipsCallArgument owns each literal source, option and expected output in the public Go unit population. The syntax-only owning rule and edit/no-finding harness run in one process without consumer installation, native product builds or a product-host child.
+func TestFormatTrailingCommaHonorsModeEs5SkipsCallArgument(t *testing.T) {
+  assertRuleSkipsSourceWithOptions(
+    t,
+    "format/trailing-comma",
+    "declare function foo(a: number, b: number): number;\nfoo(\n  1,\n  2\n);\n",
+    `{"mode":"es5"}`,
+  )
+  assertFixSnapshotWithOptions(t, "format/trailing-comma",
+    "declare function foo(a: number, b: number): number;\nfoo(\n  1,\n  2,\n);\n", `{"mode":"es5"}`,
+    "declare function foo(a: number, b: number): number;\nfoo(\n  1,\n  2\n);\n")
+}

package/linthost/format_trailing_comma_honors_mode_es5_skips_constructor_parameter_test.go

@@ -0,0 +1,29 @@
+package linthost
+
+import "testing"
+
+// TestFormatTrailingCommaHonorsModeEs5SkipsConstructorParameter verifies
+// the rule emits no findings on a multi-line constructor parameter list
+// under `mode: "es5"`.
+//
+// Constructor parameters follow the es5 function-parameter exclusion. That exclusion requires removing an existing final comma while preserving the parameter properties.
+//
+// 1. Parse the original comma-free list and a twin with a final comma.
+// 2. Run format/trailing-comma with mode es5.
+// 3. Require no findings for the original and exact comma removal for the twin.
+//
+// @evidence contracts/testing.md#behavioral-verification Constructor property parameters without a trailing comma must remain untouched under es5; the same list with a final comma must lose it without changing public property modifiers.
+// @evidence contracts/testing.md#independent-expectations Prettier es5 excludes constructor parameter commas. Literal removal preserves x/y property ownership, types and constructor body independently of the shared parameter handler.
+// @evidence contracts/testing.md#distinguishing-cases The original public-property constructor negative remains and its final-comma counterpart supplies removal. The all-mode constructor and modifier-stacked hosts supply insertion positives.
+// @evidence contracts/testing.md#execution-ownership TestFormatTrailingCommaHonorsModeEs5SkipsConstructorParameter owns each literal source, option and expected output in the public Go unit population. The syntax-only owning rule and edit/no-finding harness run in one process without consumer installation, native product builds or a product-host child.
+func TestFormatTrailingCommaHonorsModeEs5SkipsConstructorParameter(t *testing.T) {
+  assertRuleSkipsSourceWithOptions(
+    t,
+    "format/trailing-comma",
+    "class Point {\n  constructor(\n    public x: number,\n    public y: number\n  ) {}\n}\nPoint;\n",
+    `{"mode":"es5"}`,
+  )
+  assertFixSnapshotWithOptions(t, "format/trailing-comma",
+    "class Point {\n  constructor(\n    public x: number,\n    public y: number,\n  ) {}\n}\nPoint;\n", `{"mode":"es5"}`,
+    "class Point {\n  constructor(\n    public x: number,\n    public y: number\n  ) {}\n}\nPoint;\n")
+}

package/linthost/format_trailing_comma_honors_mode_es5_skips_function_expression_parameter_test.go

@@ -0,0 +1,29 @@
+package linthost
+
+import "testing"
+
+// TestFormatTrailingCommaHonorsModeEs5SkipsFunctionExpressionParameter
+// verifies the rule emits no findings on a multi-line function expression
+// parameter list under `mode: "es5"`.
+//
+// Function expressions have a separate syntax owner but share the es5 parameter-comma exclusion. The no-comma fixed point and existing-comma removal both belong to that policy.
+//
+// 1. Parse the original comma-free list and a twin with a final comma.
+// 2. Run format/trailing-comma with mode es5.
+// 3. Require no findings for the original and exact comma removal for the twin.
+//
+// @evidence contracts/testing.md#behavioral-verification Function-expression parameters must stay comma-free under es5, and an existing final comma must be removed while preserving the numeric return type and addition body.
+// @evidence contracts/testing.md#independent-expectations Prettier es5 excludes function parameter commas for expressions as well as declarations. The authored full output independently retains a/b and their body while deleting only the forbidden comma.
+// @evidence contracts/testing.md#distinguishing-cases The original function-expression no-finding input remains beside its final-comma removal counterpart. The all-mode expression insertion host distinguishes mode from AST ownership.
+// @evidence contracts/testing.md#execution-ownership TestFormatTrailingCommaHonorsModeEs5SkipsFunctionExpressionParameter owns each literal source, option and expected output in the public Go unit population. The syntax-only owning rule and edit/no-finding harness run in one process without consumer installation, native product builds or a product-host child.
+func TestFormatTrailingCommaHonorsModeEs5SkipsFunctionExpressionParameter(t *testing.T) {
+  assertRuleSkipsSourceWithOptions(
+    t,
+    "format/trailing-comma",
+    "const add = function (\n  a: number,\n  b: number\n): number {\n  return a + b;\n};\nadd;\n",
+    `{"mode":"es5"}`,
+  )
+  assertFixSnapshotWithOptions(t, "format/trailing-comma",
+    "const add = function (\n  a: number,\n  b: number,\n): number {\n  return a + b;\n};\nadd;\n", `{"mode":"es5"}`,
+    "const add = function (\n  a: number,\n  b: number\n): number {\n  return a + b;\n};\nadd;\n")
+}

package/linthost/format_trailing_comma_honors_mode_es5_skips_method_parameter_test.go

@@ -0,0 +1,29 @@
+package linthost
+
+import "testing"
+
+// TestFormatTrailingCommaHonorsModeEs5SkipsMethodParameter verifies the
+// rule emits no findings on a multi-line class-method parameter list
+// under `mode: "es5"`.
+//
+// Method parameters follow the es5 parameter-comma exclusion. The rule must normalize an existing comma away as well as abstaining on an already comma-free method.
+//
+// 1. Parse the original comma-free list and a twin with a final comma.
+// 2. Run format/trailing-comma with mode es5.
+// 3. Require no findings for the original and exact comma removal for the twin.
+//
+// @evidence contracts/testing.md#behavioral-verification Class-method parameters without a trailing comma must produce no findings under es5. An existing comma after b must be removed while leaving Calculator and its addition body intact.
+// @evidence contracts/testing.md#independent-expectations Prettier es5 excludes method parameter commas. The literal complete removal output preserves both parameter declarations and return expression independently of the method dispatch arm.
+// @evidence contracts/testing.md#distinguishing-cases The original class-method negative stays and its already comma-terminated counterpart supplies removal. The all-mode method host supplies insertion under the permissive mode.
+// @evidence contracts/testing.md#execution-ownership TestFormatTrailingCommaHonorsModeEs5SkipsMethodParameter owns each literal source, option and expected output in the public Go unit population. The syntax-only owning rule and edit/no-finding harness run in one process without consumer installation, native product builds or a product-host child.
+func TestFormatTrailingCommaHonorsModeEs5SkipsMethodParameter(t *testing.T) {
+  assertRuleSkipsSourceWithOptions(
+    t,
+    "format/trailing-comma",
+    "class Calculator {\n  add(\n    a: number,\n    b: number\n  ): number {\n    return a + b;\n  }\n}\nCalculator;\n",
+    `{"mode":"es5"}`,
+  )
+  assertFixSnapshotWithOptions(t, "format/trailing-comma",
+    "class Calculator {\n  add(\n    a: number,\n    b: number,\n  ): number {\n    return a + b;\n  }\n}\nCalculator;\n", `{"mode":"es5"}`,
+    "class Calculator {\n  add(\n    a: number,\n    b: number\n  ): number {\n    return a + b;\n  }\n}\nCalculator;\n")
+}

package/linthost/format_trailing_comma_honors_mode_es5_skips_new_argument_test.go

@@ -0,0 +1,28 @@
+package linthost
+
+import "testing"
+
+// TestFormatTrailingCommaHonorsModeEs5SkipsNewArgument verifies the rule
+// emits no findings on a multi-line `new` expression under `mode: "es5"`.
+//
+// New-expression argument lists follow the es5 call-comma exclusion. No-comma abstention and existing-comma removal must both work without confusing an absent argument list with an existing one.
+//
+// 1. Parse the original comma-free list and a twin with a final comma.
+// 2. Run format/trailing-comma with mode es5.
+// 3. Require no findings for the original and exact comma removal for the twin.
+//
+// @evidence contracts/testing.md#behavioral-verification New-expression arguments without a trailing comma must remain untouched under es5. The corresponding existing final comma must be removed while retaining constructor declaration and argument order.
+// @evidence contracts/testing.md#independent-expectations Prettier es5 excludes constructor-call argument commas. Literal full output retains new Foo, both values and the surrounding declaration while deleting only the forbidden comma.
+// @evidence contracts/testing.md#distinguishing-cases The original new Foo argument-list negative remains and its comma-terminated removal counterpart exercises this distinct syntax owner. The all-mode new-argument host covers insertion.
+// @evidence contracts/testing.md#execution-ownership TestFormatTrailingCommaHonorsModeEs5SkipsNewArgument owns each literal source, option and expected output in the public Go unit population. The syntax-only owning rule and edit/no-finding harness run in one process without consumer installation, native product builds or a product-host child.
+func TestFormatTrailingCommaHonorsModeEs5SkipsNewArgument(t *testing.T) {
+  assertRuleSkipsSourceWithOptions(
+    t,
+    "format/trailing-comma",
+    "declare class Foo { constructor(a: number, b: number); }\nconst r = new Foo(\n  1,\n  2\n);\nr;\n",
+    `{"mode":"es5"}`,
+  )
+  assertFixSnapshotWithOptions(t, "format/trailing-comma",
+    "declare class Foo { constructor(a: number, b: number); }\nconst r = new Foo(\n  1,\n  2,\n);\nr;\n", `{"mode":"es5"}`,
+    "declare class Foo { constructor(a: number, b: number); }\nconst r = new Foo(\n  1,\n  2\n);\nr;\n")
+}

package/linthost/format_trailing_comma_honors_mode_es5_skips_set_accessor_parameter_test.go

@@ -0,0 +1,29 @@
+package linthost
+
+import "testing"
+
+// TestFormatTrailingCommaHonorsModeEs5SkipsSetAccessorParameter verifies
+// the rule emits no findings on a multi-line setter parameter under
+// `mode: "es5"`.
+//
+// A setter accepts one parameter, so its es5 final-comma policy still needs both a comma-free fixed point and removal of an existing comma. The getter empty-list boundary is separate.
+//
+// 1. Parse the original comma-free list and a twin with a final comma.
+// 2. Run format/trailing-comma with mode es5.
+// 3. Require no findings for the original and exact comma removal for the twin.
+//
+// @evidence contracts/testing.md#behavioral-verification The single setter parameter must remain comma-free under es5. An existing final comma must be removed without changing its assigned value or private backing field.
+// @evidence contracts/testing.md#independent-expectations Prettier es5 excludes function-parameter commas. The independently authored complete removal output retains the setter assignment, sole parameter and backing field; all-mode insertion belongs to its separate host, and this entry does not execute a reference formatter.
+// @evidence contracts/testing.md#distinguishing-cases The original one-parameter setter negative remains with its final-comma removal counterpart. The all-mode setter insertion host covers the permitted opposite mode; a getter has no parameter item.
+// @evidence contracts/testing.md#execution-ownership TestFormatTrailingCommaHonorsModeEs5SkipsSetAccessorParameter owns each literal source, option and expected output in the public Go unit population. The syntax-only owning rule and edit/no-finding harness run in one process without consumer installation, native product builds or a product-host child.
+func TestFormatTrailingCommaHonorsModeEs5SkipsSetAccessorParameter(t *testing.T) {
+  assertRuleSkipsSourceWithOptions(
+    t,
+    "format/trailing-comma",
+    "class Box {\n  private _value = 0;\n  set value(\n    next: number\n  ) {\n    this._value = next;\n  }\n}\nBox;\n",
+    `{"mode":"es5"}`,
+  )
+  assertFixSnapshotWithOptions(t, "format/trailing-comma",
+    "class Box {\n  private _value = 0;\n  set value(\n    next: number,\n  ) {\n    this._value = next;\n  }\n}\nBox;\n", `{"mode":"es5"}`,
+    "class Box {\n  private _value = 0;\n  set value(\n    next: number\n  ) {\n    this._value = next;\n  }\n}\nBox;\n")
+}

package/linthost/format_trailing_comma_inserts_after_array_spread_in_value_literal_test.go

@@ -0,0 +1,26 @@
+package linthost
+
+import "testing"
+
+// TestFormatTrailingCommaInsertsAfterArraySpreadInValueLiteral is the
+// over-suppression twin of the array rest-target skip: a real array VALUE
+// literal ending in a spread (`[a, ...rest]`) legally takes a trailing comma.
+//
+// A spread in a value array can legally be followed by a trailing comma. The syntax restriction belongs to assignment rest, so a spread-only test must not suppress this insertion.
+//
+// 1. Parse a multi-line array value literal whose last element is a spread.
+// 2. Apply the rule's finding through the disk-backed fixer.
+// 3. Assert the trailing comma lands after the spread.
+//
+// @evidence contracts/testing.md#behavioral-verification The value array must gain a comma after its spread while preserving aa and rest. Full output detects incorrectly applying assignment-rest exclusion to all spread elements.
+// @evidence contracts/testing.md#independent-expectations ECMAScript array-value grammar permits a trailing comma after an element list ending in spread. The independently authored expected array preserves aa, rest, their order and spread meaning while specifying the final comma; this entry does not execute a reference formatter.
+// @evidence contracts/testing.md#distinguishing-cases The value-position spread is positive, contrasting SkipsArrayRestAssignmentTarget and its nested/loop negatives. NonRestArrayAssignmentTarget separately establishes legal target insertion.
+// @evidence contracts/testing.md#execution-ownership TestFormatTrailingCommaInsertsAfterArraySpreadInValueLiteral owns every authored source, no-finding or complete-output assertion in the public Go unit population. The syntax-only owning rule and edit harness execute in one Go process without consumer installation, native product builds or a product-host child.
+func TestFormatTrailingCommaInsertsAfterArraySpreadInValueLiteral(t *testing.T) {
+  assertFixSnapshot(
+    t,
+    "format/trailing-comma",
+    "const combined = [\n  aa,\n  ...rest\n];\n",
+    "const combined = [\n  aa,\n  ...rest,\n];\n",
+  )
+}

package/linthost/format_trailing_comma_inserts_after_decorated_parameter_test.go

@@ -0,0 +1,27 @@
+package linthost
+
+import "testing"
+
+// TestFormatTrailingCommaInsertsAfterDecoratedParameter verifies the rule
+// fires correctly when the last parameter carries a parameter decorator.
+//
+// Decorator punctuation belongs to the parameter, not to its list closer. The final comma must follow the complete decorated parameter without touching the decorator arguments.
+//
+//  1. Parse a source file with one class method whose last parameter
+//     carries a decorator and spans across the line break.
+//  2. Apply the rule's finding through the disk-backed fixer.
+//  3. Assert the rewritten file contains the trailing comma after the
+//     decorated parameter.
+//
+// @evidence contracts/testing.md#behavioral-verification The method must gain only a comma after tagged:number, retaining inject TOKEN decorator, plain parameter and addition body.
+// @evidence contracts/testing.md#independent-expectations TypeScript decorated parameters still follow all-mode formal-parameter comma policy. The literal expected method preserves the complete decorator call and both bindings independently of their AST spans.
+// @evidence contracts/testing.md#distinguishing-cases The final parameter carries a decorator with its own parentheses. Ordinary-method and stacked constructor-property hosts distinguish other parameter-prefix shapes.
+// @evidence contracts/testing.md#execution-ownership TestFormatTrailingCommaInsertsAfterDecoratedParameter owns its authored literal source and complete expected edit output in the public Go unit population. The syntax-only owning rule and edit application execute in one Go process without consumer installation, native artifact building or product-host children.
+func TestFormatTrailingCommaInsertsAfterDecoratedParameter(t *testing.T) {
+  assertFixSnapshot(
+    t,
+    "format/trailing-comma",
+    "declare function inject(token: string): ParameterDecorator;\nclass Service {\n  method(\n    plain: number,\n    @inject(\"TOKEN\") tagged: number\n  ): number {\n    return plain + tagged;\n  }\n}\nService;\n",
+    "declare function inject(token: string): ParameterDecorator;\nclass Service {\n  method(\n    plain: number,\n    @inject(\"TOKEN\") tagged: number,\n  ): number {\n    return plain + tagged;\n  }\n}\nService;\n",
+  )
+}