@ttsc/lint 0.30.4 → 0.31.0

package/linthost/format_trailing_comma_inserts_after_non_rest_object_assignment_target_test.go

@@ -0,0 +1,27 @@
+package linthost
+
+import "testing"
+
+// TestFormatTrailingCommaInsertsAfterNonRestObjectAssignmentTarget is the
+// over-suppression twin on the target axis: a destructuring assignment
+// target WITHOUT a trailing rest (`({ a, b } = obj)`) legally takes a
+// trailing comma under the ordinary-property assignment grammar.
+//
+// An ordinary property at the end of an object assignment target permits a trailing comma. Target ownership alone must not disable the rule.
+//
+// 1. Parse a multi-line object assignment target whose last member is not a rest.
+// 2. Apply the rule's finding through the disk-backed fixer.
+// 3. Assert the trailing comma lands after the last member.
+//
+// @evidence contracts/testing.md#behavioral-verification The destructuring object target without rest must gain a comma after b while retaining its parentheses, both assigned names and right-hand obj.
+// @evidence contracts/testing.md#independent-expectations ECMAScript object-assignment grammar permits a final comma after an ordinary property. The authored literal output preserves binding meaning and defines legal punctuation independently of the target classifier.
+// @evidence contracts/testing.md#distinguishing-cases The target ends in an ordinary property, contrasting the final-rest object negative and value-spread positive. Keeping target ownership while changing final-member kind distinguishes over-suppression.
+// @evidence contracts/testing.md#execution-ownership TestFormatTrailingCommaInsertsAfterNonRestObjectAssignmentTarget 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 TestFormatTrailingCommaInsertsAfterNonRestObjectAssignmentTarget(t *testing.T) {
+  assertFixSnapshot(
+    t,
+    "format/trailing-comma",
+    "({\n  a,\n  b\n} = obj);\n",
+    "({\n  a,\n  b,\n} = obj);\n",
+  )
+}

package/linthost/format_trailing_comma_inserts_after_object_spread_in_value_literal_test.go

@@ -0,0 +1,26 @@
+package linthost
+
+import "testing"
+
+// TestFormatTrailingCommaInsertsAfterObjectSpreadInValueLiteral is the
+// over-suppression twin of the object rest-target skip: a real object VALUE
+// literal ending in a spread (`{ a, ...o }`) legally takes a trailing comma.
+//
+// Object value spread and object assignment rest share an AST shape but different comma grammar. This positive prevents a rest-target guard from suppressing all object spreads.
+//
+// 1. Parse a multi-line object value literal whose last member 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 object must gain a comma after spread o while retaining shorthand a and its order. Full output detects treating every spread assignment as prohibited rest syntax.
+// @evidence contracts/testing.md#independent-expectations ECMAScript object-initializer grammar permits a final comma after a spread property. The authored literal expected object independently preserves the copied properties; this direct unit does not execute a reference formatter.
+// @evidence contracts/testing.md#distinguishing-cases The value spread is positive, contrasting SkipsObjectRestAssignmentTarget. NonRestObjectAssignmentTarget distinguishes legal destructuring targets from targets ending in rest.
+// @evidence contracts/testing.md#execution-ownership TestFormatTrailingCommaInsertsAfterObjectSpreadInValueLiteral 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 TestFormatTrailingCommaInsertsAfterObjectSpreadInValueLiteral(t *testing.T) {
+  assertFixSnapshot(
+    t,
+    "format/trailing-comma",
+    "const merged = {\n  a,\n  ...o\n};\n",
+    "const merged = {\n  a,\n  ...o,\n};\n",
+  )
+}

package/linthost/format_trailing_comma_inserts_after_parameter_property_in_constructor_test.go

@@ -0,0 +1,28 @@
+package linthost
+
+import "testing"
+
+// TestFormatTrailingCommaInsertsAfterParameterPropertyInConstructor verifies
+// the rule fires correctly when the last constructor parameter is a
+// private TypeScript parameter property, following a public readonly property.
+//
+// Stacked parameter-property modifiers do not alter the final parameter comma policy. The edit must follow the complete final declaration and preserve every modifier.
+//
+//  1. Parse a source file with one class whose constructor declares two
+//     multi-line parameter properties with mixed modifiers.
+//  2. Apply the rule's finding through the disk-backed fixer.
+//  3. Assert the rewritten file contains the trailing comma after the
+//     last parameter property.
+//
+// @evidence contracts/testing.md#behavioral-verification The constructor must gain a comma after private y:number while retaining public readonly x:number and every class/body token.
+// @evidence contracts/testing.md#independent-expectations Prettier all-mode permits terminal constructor-parameter commas. The literal output independently preserves both modifiers, field names and parameter types.
+// @evidence contracts/testing.md#distinguishing-cases The first property has stacked public/readonly modifiers and the final property is private, unlike the simple public/public constructor peer. The constructor ES5 host supplies mode exclusion.
+// @evidence contracts/testing.md#execution-ownership TestFormatTrailingCommaInsertsAfterParameterPropertyInConstructor 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 TestFormatTrailingCommaInsertsAfterParameterPropertyInConstructor(t *testing.T) {
+  assertFixSnapshot(
+    t,
+    "format/trailing-comma",
+    "class Point {\n  constructor(\n    public readonly x: number,\n    private y: number\n  ) {}\n}\nPoint;\n",
+    "class Point {\n  constructor(\n    public readonly x: number,\n    private y: number,\n  ) {}\n}\nPoint;\n",
+  )
+}

package/linthost/format_trailing_comma_mode_none_removes_trailing_comma_test.go

@@ -0,0 +1,28 @@
+package linthost
+
+import "testing"
+
+// TestFormatTrailingCommaModeNoneRemovesTrailingComma verifies that `none`
+// actively removes an existing trailing comma.
+//
+// None is an active normalization policy. It must remove a pre-existing comma even on a single-line list and leave an already comma-free list alone.
+//
+// 1. Parse multiline and single-line arrays with a final comma.
+// 2. Apply format/trailing-comma with mode `none`.
+// 3. Require exact final-comma removal and no findings on the comma-free twin.
+//
+// @evidence contracts/testing.md#behavioral-verification None mode must remove only the final array comma and preserve both elements and their separator. Complete source prevents a no-op or deletion of the separator between first and second.
+// @evidence contracts/testing.md#independent-expectations Official Prettier none policy disallows trailing commas. The literal expected array keeps item order and deletes exactly the authored final comma independently of the comma scanner.
+// @evidence contracts/testing.md#distinguishing-cases The original multiline removal remains, with single-line removal and an already comma-free no-finding case added. All-mode array insertion provides the reverse policy.
+// @evidence contracts/testing.md#execution-ownership TestFormatTrailingCommaModeNoneRemovesTrailingComma 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 TestFormatTrailingCommaModeNoneRemovesTrailingComma(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/trailing-comma",
+    "const values = [\n  first,\n  second,\n];\n",
+    `{"mode":"none"}`,
+    "const values = [\n  first,\n  second\n];\n",
+  )
+  assertFixSnapshotWithOptions(t, "format/trailing-comma", "const values = [first, second,];\n", `{"mode":"none"}`, "const values = [first, second];\n")
+  assertRuleSkipsSourceWithOptions(t, "format/trailing-comma", "const values = [first, second];\n", `{"mode":"none"}`)
+}

package/linthost/format_trailing_comma_places_comma_before_trailing_line_comment_test.go

@@ -0,0 +1,31 @@
+package linthost
+
+import "testing"
+
+// TestFormatTrailingCommaPlacesCommaBeforeTrailingLineComment verifies
+// the rule inserts the trailing comma BEFORE a trailing `//` line comment
+// on the last element of a multi-line list, not after it.
+//
+// Final-item trivia is not part of the comma location. Insertion and removal must preserve the trailing line comment rather than moving punctuation into or past it.
+//
+//  1. Parse a source file with one multi-line array whose last element carries
+//     a trailing `// trailing` comment.
+//  2. Apply the rule's finding through the disk-backed fixer.
+//  3. Require the comma before the comment, canonical abstention, and none-mode removal.
+//
+// @evidence contracts/testing.md#behavioral-verification The final array comma must be inserted before the trailing line comment, preserving its text and newline. Already comma-terminated input must be canonical, and none mode must remove only that comma.
+// @evidence contracts/testing.md#independent-expectations Prettier places the terminal comma immediately after the final item before trailing comment trivia. Literal complete outputs prescribe both all-mode insertion and none-mode removal while retaining the comment.
+// @evidence contracts/testing.md#distinguishing-cases The original missing-comma line-comment positive remains. Its terminated fixed point and none-mode removal counterpart distinguish comment-aware insertion, abstention and reverse normalization.
+// @evidence contracts/testing.md#execution-ownership TestFormatTrailingCommaPlacesCommaBeforeTrailingLineComment owns the insertion/removal full-output fixtures and canonical no-finding input in the public Go unit population. The syntax-only owning rule and edit harness execute in one Go process without consumer installation, native builds or product-host children.
+func TestFormatTrailingCommaPlacesCommaBeforeTrailingLineComment(t *testing.T) {
+  assertFixSnapshot(
+    t,
+    "format/trailing-comma",
+    "const xs = [\n  1,\n  2 // trailing\n];\n",
+    "const xs = [\n  1,\n  2, // trailing\n];\n",
+  )
+  assertRuleSkipsSource(t, "format/trailing-comma", "const xs = [\n  1,\n  2, // trailing\n];\n")
+  assertFixSnapshotWithOptions(t, "format/trailing-comma",
+    "const xs = [\n  1,\n  2, // trailing\n];\n", `{"mode":"none"}`,
+    "const xs = [\n  1,\n  2 // trailing\n];\n")
+}

package/linthost/format_trailing_comma_removes_call_comma_under_es5_test.go

@@ -0,0 +1,27 @@
+package linthost
+
+import "testing"
+
+// TestFormatTrailingCommaRemovesCallCommaUnderEs5 verifies that the `es5`
+// policy removes a comma from a call argument list.
+//
+// Calls use the all comma level. Under es5, a final comma is forbidden on both multiline and single-line calls, while interior argument separators remain required.
+//
+// 1. Parse multiline and single-line calls whose final argument has a comma.
+// 2. Apply format/trailing-comma with mode `es5`.
+// 3. Assert the comma is removed.
+//
+// @evidence contracts/testing.md#behavioral-verification Es5 must remove the final call argument comma while retaining the first/second argument separator. Complete literal output detects preserving a forbidden comma or deleting an interior separator.
+// @evidence contracts/testing.md#independent-expectations Official Prettier es5 excludes call argument trailing commas. The independently authored call output changes only the final punctuation and retains argument order.
+// @evidence contracts/testing.md#distinguishing-cases The original multiline call removal stays, paired with a single-line removal case. HonorsModeEs5SkipsCallArgument covers the missing-comma fixed point and all-mode insertion covers the reverse decision.
+// @evidence contracts/testing.md#execution-ownership TestFormatTrailingCommaRemovesCallCommaUnderEs5 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 TestFormatTrailingCommaRemovesCallCommaUnderEs5(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/trailing-comma",
+    "call(\n  first,\n  second,\n);\n",
+    `{"mode":"es5"}`,
+    "call(\n  first,\n  second\n);\n",
+  )
+  assertFixSnapshotWithOptions(t, "format/trailing-comma", "call(first, second,);\n", `{"mode":"es5"}`, "call(first, second);\n")
+}

package/linthost/format_trailing_comma_skips_already_terminated_lists_test.go

@@ -0,0 +1,31 @@
+package linthost
+
+import (
+  "testing"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+// TestFormatTrailingCommaSkipsAlreadyTerminatedLists verifies idempotence.
+//
+// An allowed comma is already canonical and must not be reported again. Switching to none changes that same punctuation policy and must remove each final comma.
+//
+// 1. Parse multi-line lists that already end in trailing commas.
+// 2. Run the engine with formatTrailingComma enabled.
+// 3. Require all-mode silence and exact none-mode removal on the same source.
+//
+// @evidence contracts/testing.md#behavioral-verification Canonical multiline arrays and objects must produce no findings under all mode. Under none, the same source must lose both final commas while retaining its interior separators and item values.
+// @evidence contracts/testing.md#independent-expectations The all/none option policies independently prescribe keeping or removing terminal commas. Literal expected full output fixes both lists without consulting an implementation shortcut or assuming a cascade pass count.
+// @evidence contracts/testing.md#distinguishing-cases The original all-mode fixed point remains, paired with none-mode full removal on the exact same two lists. Missing-comma array/object hosts cover insertion rather than canonical input.
+// @evidence contracts/testing.md#execution-ownership TestFormatTrailingCommaSkipsAlreadyTerminatedLists owns the direct Engine all-mode absence assertion and complete none-mode removal output in the public Go unit population. The syntax-only owning rule and edit harness execute in one Go process without consumer installation, native builds or product-host children.
+func TestFormatTrailingCommaSkipsAlreadyTerminatedLists(t *testing.T) {
+  source := "const xs = [\n  1,\n  2,\n];\nconst obj = {\n  a: 1,\n  b: 2,\n};\n"
+  file := parseTS(t, source)
+  findings := NewEngine(RuleConfig{"format/trailing-comma": SeverityError}).
+    Run([]*shimast.SourceFile{file}, nil)
+  if len(findings) != 0 {
+    t.Fatalf("expected zero findings, got %d: %+v", len(findings), findings)
+  }
+  assertFixSnapshotWithOptions(t, "format/trailing-comma", source, `{"mode":"none"}`,
+    "const xs = [\n  1,\n  2\n];\nconst obj = {\n  a: 1,\n  b: 2\n};\n")
+}

package/linthost/format_trailing_comma_skips_array_rest_assignment_target_test.go

@@ -0,0 +1,28 @@
+package linthost
+
+import "testing"
+
+// TestFormatTrailingCommaSkipsArrayRestAssignmentTarget verifies the rule
+// adds no trailing comma to a multi-line array destructuring assignment
+// target ending in a rest (`[a, ...rest] = arr`).
+//
+// The array literal AST representation is shared by values and assignment targets. Only a target ending in rest forbids the comma, including nested and loop-initializer targets.
+//
+// 1. Parse standalone, nested and for-of/for-in array targets ending in rest.
+// 2. Run the rule.
+// 3. Assert zero findings, so no fix corrupts the source.
+//
+// @evidence contracts/testing.md#behavioral-verification The rule must leave array assignment targets ending in rest comma-free, including nested and loop-initializer targets. No-finding assertions prevent formatting valid targets into syntax errors.
+// @evidence contracts/testing.md#independent-expectations ECMAScript assignment-rest grammar forbids a comma after the final rest element. Authored source has no such comma and must remain intact independently of the literal-expression AST representation.
+// @evidence contracts/testing.md#distinguishing-cases The original standalone rest target remains; nested, for-of and for-in targets exercise ancestor ownership. ArraySpreadInValueLiteral and NonRestArrayAssignmentTarget provide legal comma positives.
+// @evidence contracts/testing.md#execution-ownership TestFormatTrailingCommaSkipsArrayRestAssignmentTarget 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 TestFormatTrailingCommaSkipsArrayRestAssignmentTarget(t *testing.T) {
+  assertRuleSkipsSource(
+    t,
+    "format/trailing-comma",
+    "[\n  aa,\n  ...arest\n] = arr;\n",
+  )
+  assertRuleSkipsSource(t, "format/trailing-comma", "({ x: [\n  aa,\n  ...arest\n] } = obj);\n")
+  assertRuleSkipsSource(t, "format/trailing-comma", "for ([\n  aa,\n  ...arest\n] of values) {}\n")
+  assertRuleSkipsSource(t, "format/trailing-comma", "for ([\n  aa,\n  ...arest\n] in values) {}\n")
+}

package/linthost/format_trailing_comma_skips_call_when_close_paren_shares_line_with_last_argument_test.go

@@ -0,0 +1,30 @@
+package linthost
+
+import "testing"
+
+// TestFormatTrailingCommaSkipsCallWhenCloseParenSharesLineWithLastArgument
+// verifies the rule leaves the trailing comma off when a multi-line argument
+// shares its closing line with the call's `)`.
+//
+// A multiline argument alone does not require a call trailing comma. The final argument and call closer must be on different lines; an adjacent newline-close twin tests that boundary.
+//
+//  1. Parse a source file with one multi-line call whose sole argument is a
+//     multi-line object literal whose closing `}` shares a line with `)`.
+//  2. Run the engine with formatTrailingComma enabled.
+//  3. Require silence, then move the call closer to a new line and require
+//     only the call argument comma to be inserted.
+//
+// @evidence contracts/testing.md#behavioral-verification A call whose object argument ends beside the call closer must receive no findings, despite the object interior being multiline. Moving only the call closer to a new line must add its final argument comma.
+// @evidence contracts/testing.md#independent-expectations The local supported policy charges the gap after the final argument, matching Prettier broken-call punctuation. Literal paired outputs preserve the already comma-terminated object and differ only in the eligible call boundary.
+// @evidence contracts/testing.md#distinguishing-cases The original same-line object-end/call-close case stays negative. Its newline-close twin is positive, distinguishing argument-internal newlines from the gap that actually governs the comma.
+// @evidence contracts/testing.md#execution-ownership TestFormatTrailingCommaSkipsCallWhenCloseParenSharesLineWithLastArgument owns the same-line no-finding fixture and newline-close complete insertion output in the public Go unit population. The syntax-only owning rule and edit harness execute in one Go process without consumer installation, native builds or product-host children.
+func TestFormatTrailingCommaSkipsCallWhenCloseParenSharesLineWithLastArgument(t *testing.T) {
+  assertRuleSkipsSource(
+    t,
+    "format/trailing-comma",
+    "JSON.stringify({\n  a: 1,\n  b: 2,\n});\n",
+  )
+  assertFixSnapshot(t, "format/trailing-comma",
+    "JSON.stringify({\n  a: 1,\n  b: 2,\n}\n);\n",
+    "JSON.stringify({\n  a: 1,\n  b: 2,\n},\n);\n")
+}

package/linthost/format_trailing_comma_skips_dynamic_import_argument_test.go

@@ -0,0 +1,28 @@
+package linthost
+
+import "testing"
+
+// TestFormatTrailingCommaSkipsDynamicImportArgument verifies the rule
+// never appends a trailing comma to a multi-line dynamic `import(...)`
+// argument list, even under the default trailingComma:"all".
+//
+// The local supported policy exempts dynamic import from comma insertion. Ordinary calls must still follow all-mode multiline insertion, so exempting every call would be wrong.
+//
+//  1. Parse a multiline dynamic import and an ordinary load-call twin.
+//  2. Run the rule with default (mode "all") options.
+//  3. Require no import finding and exact ordinary-call comma insertion.
+//
+// @evidence contracts/testing.md#behavioral-verification A dynamic import must remain comma-free under all mode while an ordinary call with the same multiline argument gains its final comma. The pair detects both missing the import exception and excluding every call.
+// @evidence contracts/testing.md#independent-expectations The authored pair specifies the local supported dynamic-import exception and the ordinary-call all-mode comma independently of the callee-kind switch. This direct unit does not execute a reference formatter.
+// @evidence contracts/testing.md#distinguishing-cases The original dynamic import negative stays. An ordinary load call with the same module string supplies an adjacent all-mode positive at the same line-break boundary.
+// @evidence contracts/testing.md#execution-ownership TestFormatTrailingCommaSkipsDynamicImportArgument 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 TestFormatTrailingCommaSkipsDynamicImportArgument(t *testing.T) {
+  assertRuleSkipsSource(
+    t,
+    "format/trailing-comma",
+    "const m = import(\n  \"./mod\"\n);\n",
+  )
+  assertFixSnapshot(t, "format/trailing-comma",
+    "const m = load(\n  \"./mod\"\n);\n",
+    "const m = load(\n  \"./mod\",\n);\n")
+}

package/linthost/format_trailing_comma_skips_empty_lists_test.go

@@ -0,0 +1,32 @@
+package linthost
+
+import (
+  "testing"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+// TestFormatTrailingCommaSkipsEmptyLists verifies the rule shrugs at empty
+// lists.
+//
+// Empty lists have no final item or comma position. Normalizing a neighboring nonempty list must not create punctuation in any of them.
+//
+//  1. Parse empty function declarations, calls, and array literals.
+//  2. Run the engine with formatTrailingComma enabled.
+//  3. Require zero findings, then normalize a neighboring nonempty array while
+//     preserving every original empty list.
+//
+// @evidence contracts/testing.md#behavioral-verification Empty function, array, object, call and new lists must produce no findings. A neighboring nonempty multiline array must still gain its comma while every original empty list stays byte-identical.
+// @evidence contracts/testing.md#independent-expectations An empty list has no last item after which a comma could be inserted. The literal neighboring array output follows the supported all-mode policy and retains the complete original empty-list source.
+// @evidence contracts/testing.md#distinguishing-cases The original empty population includes both single-line and multiline lists. A nonempty multiline array in the same source supplies an adjacent positive, distinguishing empty-list safety from a disabled rule.
+// @evidence contracts/testing.md#execution-ownership TestFormatTrailingCommaSkipsEmptyLists owns the direct Engine empty-list absence assertion and neighboring-array complete output in the public Go unit population. The syntax-only owning rule and edit harness execute in one Go process without consumer installation, native builds or product-host children.
+func TestFormatTrailingCommaSkipsEmptyLists(t *testing.T) {
+  source := "function noop() {}\nfunction nullary(\n) {\n}\nconst empty = [];\nconst arr = [\n];\nconst obj = {};\nJSON.stringify();\nnew Date();\n"
+  file := parseTS(t, source)
+  findings := NewEngine(RuleConfig{"format/trailing-comma": SeverityError}).
+    Run([]*shimast.SourceFile{file}, nil)
+  if len(findings) != 0 {
+    t.Fatalf("expected zero findings, got %d: %+v", len(findings), findings)
+  }
+  assertFixSnapshot(t, "format/trailing-comma", "const nearby = [\n  value\n];\n"+source, "const nearby = [\n  value,\n];\n"+source)
+}

package/linthost/format_trailing_comma_skips_inline_block_comment_before_close_bracket_test.go

@@ -0,0 +1,31 @@
+package linthost
+
+import "testing"
+
+// TestFormatTrailingCommaSkipsInlineBlockCommentBeforeCloseBracket verifies
+// the rule leaves the trailing comma off when a block comment sits between
+// the last element and the close bracket on the SAME physical line.
+//
+// A block comment between the last element and closer must survive. The closer line controls comma insertion, so changing just that boundary distinguishes a safe no-op from an eligible edit.
+//
+//  1. Parse a source file with one multi-line array literal whose last
+//     element is followed by an inline block comment and `]` on the same
+//     line.
+//  2. Run the engine with formatTrailingComma enabled.
+//  3. Require silence, then move the closer to a new line and require its
+//     comma while preserving the comment.
+//
+// @evidence contracts/testing.md#behavioral-verification An inline final-item comment and array closer on one line must produce no findings. Moving only the closer to the next line must add a comma before the comment and preserve its bytes.
+// @evidence contracts/testing.md#independent-expectations The supported insertion policy follows the last-item-to-closer line boundary and retains trivia. Literal expected output places punctuation after the item while leaving the block comment unchanged independently of AST End positions.
+// @evidence contracts/testing.md#distinguishing-cases The original same-line comment/closer stays negative, paired with a newline-close positive using the identical item and block comment. The line-comment host covers a different comment termination boundary.
+// @evidence contracts/testing.md#execution-ownership TestFormatTrailingCommaSkipsInlineBlockCommentBeforeCloseBracket owns the same-line no-finding fixture and complete newline-close comment-preserving output in the public Go unit population. The syntax-only owning rule and edit harness execute in one Go process without consumer installation, native builds or product-host children.
+func TestFormatTrailingCommaSkipsInlineBlockCommentBeforeCloseBracket(t *testing.T) {
+  assertRuleSkipsSource(
+    t,
+    "format/trailing-comma",
+    "const xs = [\n  1,\n  2/* note */];\n",
+  )
+  assertFixSnapshot(t, "format/trailing-comma",
+    "const xs = [\n  1,\n  2/* note */\n];\n",
+    "const xs = [\n  1,\n  2,/* note */\n];\n")
+}

package/linthost/format_trailing_comma_skips_object_rest_assignment_target_test.go

@@ -0,0 +1,28 @@
+package linthost
+
+import "testing"
+
+// TestFormatTrailingCommaSkipsObjectRestAssignmentTarget verifies the rule
+// adds no trailing comma to a multi-line object destructuring assignment
+// target ending in a rest (`({ a, ...rest } = obj)`).
+//
+// Object rest at the end of an assignment target differs from value-position spread. Nested targets and loop initializers must retain that grammar distinction.
+//
+// 1. Parse standalone, nested and for-of/for-in object targets ending in rest.
+// 2. Run the rule.
+// 3. Assert zero findings, so no fix rewrites the source into invalid syntax.
+//
+// @evidence contracts/testing.md#behavioral-verification The rule must keep object assignment targets ending in rest comma-free, including a nested target and loop initializer. Absence assertions detect producing an invalid comma after the rest property.
+// @evidence contracts/testing.md#independent-expectations ECMAScript object-assignment rest-property grammar forbids a following comma. The authored valid targets independently determine no change, irrespective of the AST spread-assignment node kind.
+// @evidence contracts/testing.md#distinguishing-cases The original standalone rest target remains with nested and for-of/for-in variants. ObjectSpreadInValueLiteral and NonRestObjectAssignmentTarget supply legal value and non-rest target positives.
+// @evidence contracts/testing.md#execution-ownership TestFormatTrailingCommaSkipsObjectRestAssignmentTarget 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 TestFormatTrailingCommaSkipsObjectRestAssignmentTarget(t *testing.T) {
+  assertRuleSkipsSource(
+    t,
+    "format/trailing-comma",
+    "({\n  ra,\n  ...rrest\n} = obj);\n",
+  )
+  assertRuleSkipsSource(t, "format/trailing-comma", "[{\n  ra,\n  ...rrest\n}] = arr;\n")
+  assertRuleSkipsSource(t, "format/trailing-comma", "for ({\n  ra,\n  ...rrest\n} of values) {}\n")
+  assertRuleSkipsSource(t, "format/trailing-comma", "for ({\n  ra,\n  ...rrest\n} in values) {}\n")
+}

package/linthost/format_trailing_comma_skips_rest_parameter_test.go

@@ -0,0 +1,39 @@
+package linthost
+
+import (
+  "testing"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+// TestFormatTrailingCommaSkipsRestParameter verifies the rule refuses to
+// insert a trailing comma after a rest parameter.
+//
+// A rest parameter must stay the last formal parameter without a following comma. This grammar restriction must override the all-mode multiline insertion policy.
+//
+//  1. Parse a multi-line function declaration whose last parameter is
+//     a rest parameter without a trailing comma.
+//  2. Run formatTrailingComma with mode:"all".
+//  3. Assert zero findings. The rule must not propose an edit that
+//     would render the source unparseable.
+//
+// @evidence contracts/testing.md#behavioral-verification The function rest parameter must remain comma-free and every original array/call token must survive. The direct no-finding assertion detects inserting invalid rest-parameter punctuation.
+// @evidence contracts/testing.md#independent-expectations ECMAScript formal-parameter grammar forbids a comma after a rest parameter. The literal source is already valid, so unchanged punctuation is required independently of the AST rest-token check.
+// @evidence contracts/testing.md#distinguishing-cases The last parameter is rest while its preceding parameter is ordinary. The ordinary function-parameter insertion host supplies a positive; value array spread is separately legal.
+// @evidence contracts/testing.md#execution-ownership TestFormatTrailingCommaSkipsRestParameter 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 TestFormatTrailingCommaSkipsRestParameter(t *testing.T) {
+  source := "function f(\n" +
+    "  a: string,\n" +
+    "  ...rest: number[]\n" +
+    ") {\n" +
+    "  return [a, ...rest];\n" +
+    "}\n" +
+    "f(\"x\", 1, 2);\n"
+  file := parseTS(t, source)
+  findings := NewEngine(RuleConfig{"format/trailing-comma": SeverityError}).
+    Run([]*shimast.SourceFile{file}, nil)
+  if len(findings) != 0 {
+    t.Fatalf("expected zero findings (rest param disallows trailing comma), got %d:\n%v",
+      len(findings), findings)
+  }
+}

package/linthost/format_trailing_comma_skips_single_line_lists_test.go

@@ -0,0 +1,34 @@
+package linthost
+
+import (
+  "testing"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+// TestFormatTrailingCommaSkipsSingleLineLists verifies the rule never adds a
+// trailing comma to a single-line list.
+//
+// Comma insertion depends on the final item and closing delimiter being on different lines. Inline lists must stay unchanged even while a neighboring broken list is normalized.
+//
+//  1. Parse a source file with single-line array, object, and call lists.
+//  2. Run the engine with formatTrailingComma enabled.
+//  3. Require silence and then normalize a neighboring broken array while
+//     preserving the original inline lists.
+//
+// @evidence contracts/testing.md#behavioral-verification Single-line arrays, objects and call arguments must receive no findings under all mode. A neighboring multiline array must gain its final comma without changing those original lists.
+// @evidence contracts/testing.md#independent-expectations Official Prettier options exclude trailing commas on single-line lists. Authored literal complete output preserves the original inline containers and changes only the added broken array.
+// @evidence contracts/testing.md#distinguishing-cases The original three inline forms remain negative and a neighboring broken array is positive. SameLineCloseParen distinguishes a multiline interior with its final item and closer still on one line.
+// @evidence contracts/testing.md#execution-ownership TestFormatTrailingCommaSkipsSingleLineLists owns the direct Engine inline-list absence assertion and neighboring-array complete output in the public Go unit population. The syntax-only owning rule and edit harness execute in one Go process without consumer installation, native builds or product-host children.
+func TestFormatTrailingCommaSkipsSingleLineLists(t *testing.T) {
+  source := "const xs = [1, 2, 3];\n" +
+    "const obj = { a: 1, b: 2 };\n" +
+    "JSON.stringify({ a: 1, b: 2 }, null, 2);\n"
+  file := parseTS(t, source)
+  findings := NewEngine(RuleConfig{"format/trailing-comma": SeverityError}).
+    Run([]*shimast.SourceFile{file}, nil)
+  if len(findings) != 0 {
+    t.Fatalf("expected zero findings, got %d: %+v", len(findings), findings)
+  }
+  assertFixSnapshot(t, "format/trailing-comma", "const nearby = [\n  value\n];\n"+source, "const nearby = [\n  value,\n];\n"+source)
+}

package/linthost/format_trailing_comma_skips_unparenthesized_arrow_with_multiline_body_test.go

@@ -0,0 +1,28 @@
+package linthost
+
+import "testing"
+
+// TestFormatTrailingCommaSkipsUnparenthesizedArrowWithMultilineBody verifies
+// the rule does not insert a trailing comma after the parameter of an
+// unparenthesized single-parameter arrow whose body spans multiple lines.
+//
+// A closing parenthesis later in an arrow body cannot serve as its parameter-list delimiter. Both standalone and call-wrapped unparenthesized arrows must abstain.
+//
+//  1. Parse standalone and call-wrapped unparenthesized arrows whose bodies
+//     contain an unrelated closing parenthesis on a later line.
+//  2. Run the engine with formatTrailingComma enabled.
+//  3. Assert zero findings. The inner call already carries its own trailing
+//     comma, so silence on the arrow's parameter list is the entire signal.
+//
+// @evidence contracts/testing.md#behavioral-verification An unparenthesized arrow parameter must never gain a comma based on a closing parenthesis inside its multiline body. Both standalone and outer-call forms must produce no findings.
+// @evidence contracts/testing.md#independent-expectations ECMAScript unparenthesized arrow syntax has one binding and no parameter-list comma position. The authored valid sources retain their inner call commas and independently require no parameter edit.
+// @evidence contracts/testing.md#distinguishing-cases The original standalone arrow stays, and an added map-call wrapper places an unrelated later close parenthesis after the arrow. Parenthesized multi-parameter insertion supplies the eligible counterpart.
+// @evidence contracts/testing.md#execution-ownership TestFormatTrailingCommaSkipsUnparenthesizedArrowWithMultilineBody 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 TestFormatTrailingCommaSkipsUnparenthesizedArrowWithMultilineBody(t *testing.T) {
+  assertRuleSkipsSource(
+    t,
+    "format/trailing-comma",
+    "declare function foo(x: number): number;\nconst f = a => {\n  return foo(\n    a,\n  );\n};\nf;\n",
+  )
+  assertRuleSkipsSource(t, "format/trailing-comma", "const result = xs.map(a => {\n  return foo(\n    a,\n  );\n});\n")
+}

package/linthost/format_whitespace_collapses_all_blank_file_to_single_eol_test.go

@@ -0,0 +1,30 @@
+package linthost
+
+import "testing"
+
+// TestFormatWhitespaceCollapsesAllBlankFileToSingleEOL verifies a file
+// of only blank lines collapses to a single EOL.
+//
+// With no content line to anchor against, the rule replaces the whole
+// whitespace-only file with one EOL. This pins the all-blank branch,
+// distinct from the leading/trailing-blank trimming that needs a content
+// anchor.
+//
+//  1. Parse a file holding only blank lines.
+//  2. Apply the rule through the disk-backed fixer.
+//  3. Assert the file reduces to a single newline.
+//
+// @evidence contracts/testing.md#behavioral-verification format/whitespace must collapse nonempty whitespace-only sources to one configured EOL rather than treat them as zero-length source.
+// @evidence contracts/testing.md#independent-expectations Independent LF/CRLF literals specify the normalized empty-content representation; the input spaces/tabs carry no declaration or string payload.
+// @evidence contracts/testing.md#distinguishing-cases Blank LF runs and added mixed space/tab LF/CRLF runs change; the truly empty negative distinguishes absent input from nonempty blank source.
+// @evidence contracts/testing.md#execution-ownership TestFormatWhitespaceCollapsesAllBlankFileToSingleEOL is a public Go unit selected by the lint semantic-unit Evidence claim. This host owns every literal input and assertion; the shared syntax-only harness invokes the whitespace rule and applies edits for complete output comparisons in the same process without a consumer install, native product build or product host.
+func TestFormatWhitespaceCollapsesAllBlankFileToSingleEOL(t *testing.T) {
+  assertFixSnapshot(
+    t,
+    "format/whitespace",
+    "\n\n\n",
+    "\n",
+  )
+  assertFixSnapshot(t, "format/whitespace", " \t\n\t \n", "\n")
+  assertFixSnapshotWithOptions(t, "format/whitespace", " \t\r\n\t \r\n", `{"endOfLine":"crlf"}`, "\r\n")
+}

package/linthost/format_whitespace_collapses_consecutive_blank_lines_test.go

@@ -0,0 +1,27 @@
+package linthost
+
+import "testing"
+
+// TestFormatWhitespaceCollapsesConsecutiveBlankLines verifies
+// formatWhitespace collapses a run of multiple blank lines between two
+// statements to exactly one blank line.
+//
+// Prettier keeps at most one consecutive blank line. This pins operation
+// (b): three blank lines between two statements become one.
+//
+//  1. Parse two statements separated by three blank lines.
+//  2. Apply the rule's finding through the disk-backed fixer.
+//  3. Assert exactly one blank line remains between them.
+//
+// @evidence contracts/testing.md#behavioral-verification format/whitespace must reduce three interior blank lines to exactly one while retaining declaration order and payload.
+// @evidence contracts/testing.md#independent-expectations The independently authored full output permits one blank line and preserves a=1 followed by b=2.
+// @evidence contracts/testing.md#distinguishing-cases The over-threshold positive complements the exactly-one negative and protected template blank runs.
+// @evidence contracts/testing.md#execution-ownership TestFormatWhitespaceCollapsesConsecutiveBlankLines is a public Go unit selected by the lint semantic-unit Evidence claim. This host owns every literal input and assertion; the shared syntax-only harness invokes the whitespace rule and applies edits for complete output comparisons in the same process without a consumer install, native product build or product host.
+func TestFormatWhitespaceCollapsesConsecutiveBlankLines(t *testing.T) {
+  assertFixSnapshot(
+    t,
+    "format/whitespace",
+    "const a = 1;\n\n\n\nconst b = 2;\n",
+    "const a = 1;\n\nconst b = 2;\n",
+  )
+}

package/linthost/format_whitespace_fixes_missing_final_newline_with_trailing_space_test.go

@@ -0,0 +1,29 @@
+package linthost
+
+import "testing"
+
+// TestFormatWhitespaceFixesMissingFinalNewlineWithTrailingSpace verifies
+// the rule trims a trailing space on the last line and appends the
+// missing final newline in one pass.
+//
+// The last content line owns its tail through branch (d): the rule
+// replaces everything after the last visible byte with a single EOL, so a
+// `const a = 1; ` with no newline becomes `const a = 1;\n`. This pins the
+// combined trailing-trim plus final-newline insertion on the final line.
+//
+//  1. Parse a single statement ending in a space with no final newline.
+//  2. Apply the rule through the disk-backed fixer.
+//  3. Assert the trailing space is gone and one newline is appended.
+//
+// @evidence contracts/testing.md#behavioral-verification format/whitespace must remove a final stray space and append one LF in the same fix without changing the declaration.
+// @evidence contracts/testing.md#independent-expectations The complete independent output specifies both tail corrections and otherwise identical source tokens.
+// @evidence contracts/testing.md#distinguishing-cases This combined defect must change in both respects; bare missing-EOL insertion and trailing-blank collapse own neighboring cases.
+// @evidence contracts/testing.md#execution-ownership TestFormatWhitespaceFixesMissingFinalNewlineWithTrailingSpace is a public Go unit selected by the lint semantic-unit Evidence claim. This host owns every literal input and assertion; the shared syntax-only harness invokes the whitespace rule and applies edits for complete output comparisons in the same process without a consumer install, native product build or product host.
+func TestFormatWhitespaceFixesMissingFinalNewlineWithTrailingSpace(t *testing.T) {
+  assertFixSnapshot(
+    t,
+    "format/whitespace",
+    "const a = 1; ",
+    "const a = 1;\n",
+  )
+}