@ttsc/lint 0.30.4 → 0.31.1

package/linthost/format_trailing_comma_inserts_after_last_array_element_test.go

@@ -0,0 +1,25 @@
+package linthost
+
+import "testing"
+
+// TestFormatTrailingCommaInsertsAfterLastArrayElement verifies the happy path:
+// a multi-line array literal gains a trailing comma after its last element.
+//
+// Arrays are the basic runtime list shape. A final comma must follow the final value rather than adding an empty element or changing an interior separator.
+//
+// 1. Parse a source file with one multi-line array literal.
+// 2. Apply the rule's finding through the disk-backed fixer.
+// 3. Assert the rewritten file contains the trailing comma.
+//
+// @evidence contracts/testing.md#behavioral-verification The array must gain only its final comma after 3 while retaining 1,2 and the existing separators.
+// @evidence contracts/testing.md#independent-expectations Official Prettier all-mode policy adds a terminal comma to a broken array. Literal expected source fixes its position and preserves every element independently of the list traversal.
+// @evidence contracts/testing.md#distinguishing-cases This three-element broken array is positive. Inline, empty, already-terminated and none-removal hosts supply nearby boundaries and reverse normalization.
+// @evidence contracts/testing.md#execution-ownership TestFormatTrailingCommaInsertsAfterLastArrayElement 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 TestFormatTrailingCommaInsertsAfterLastArrayElement(t *testing.T) {
+  assertFixSnapshot(
+    t,
+    "format/trailing-comma",
+    "const xs = [\n  1,\n  2,\n  3\n];\n",
+    "const xs = [\n  1,\n  2,\n  3,\n];\n",
+  )
+}

package/linthost/format_trailing_comma_inserts_after_last_arrow_parameter_test.go

@@ -0,0 +1,25 @@
+package linthost
+
+import "testing"
+
+// TestFormatTrailingCommaInsertsAfterLastArrowParameter verifies the rule
+// reaches multi-line parameter lists on arrow functions.
+//
+// A parenthesized arrow has a real parameter-list closer before its return annotation and arrow token. The comma belongs after the last parameter, not at a later body parenthesis.
+//
+// 1. Parse a source file with one multi-line arrow function.
+// 2. Apply the rule's finding through the disk-backed fixer.
+// 3. Assert the rewritten file contains the trailing comma after the last parameter.
+//
+// @evidence contracts/testing.md#behavioral-verification The parenthesized arrow must gain a comma after right:number while retaining its return annotation and left+right body.
+// @evidence contracts/testing.md#independent-expectations Prettier all-mode permits terminal commas in broken arrow parameter lists. The authored literal output preserves both parameters and the arrow grammar independently of the close-token scanner.
+// @evidence contracts/testing.md#distinguishing-cases The fully parenthesized two-parameter arrow is positive; ES5 removal and unparenthesized-arrow hosts distinguish option policy and absence of list parentheses.
+// @evidence contracts/testing.md#execution-ownership TestFormatTrailingCommaInsertsAfterLastArrowParameter 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 TestFormatTrailingCommaInsertsAfterLastArrowParameter(t *testing.T) {
+  assertFixSnapshot(
+    t,
+    "format/trailing-comma",
+    "const add = (\n  left: number,\n  right: number\n): number => left + right;\nadd;\n",
+    "const add = (\n  left: number,\n  right: number,\n): number => left + right;\nadd;\n",
+  )
+}

package/linthost/format_trailing_comma_inserts_after_last_call_argument_test.go

@@ -0,0 +1,25 @@
+package linthost
+
+import "testing"
+
+// TestFormatTrailingCommaInsertsAfterLastCallArgument verifies the trailing
+// comma reaches multi-line call expressions.
+//
+// An ordinary call with a broken final-argument boundary is eligible under all mode. Existing commas inside an object argument must not be confused with the outer call comma.
+//
+// 1. Parse a source file with one multi-line call site.
+// 2. Apply the rule's finding through the disk-backed fixer.
+// 3. Assert the rewritten file contains the trailing comma.
+//
+// @evidence contracts/testing.md#behavioral-verification JSON.stringify must gain only the comma after its final argument 2, retaining the already comma-terminated object, null argument and argument order.
+// @evidence contracts/testing.md#independent-expectations Prettier all-mode permits terminal commas in broken calls. The literal expected call changes only its final punctuation and independently preserves all three values.
+// @evidence contracts/testing.md#distinguishing-cases The final argument and call closer occupy different lines; the same-line-close host is negative, and ES5 call hosts exercise exclusion/removal.
+// @evidence contracts/testing.md#execution-ownership TestFormatTrailingCommaInsertsAfterLastCallArgument 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 TestFormatTrailingCommaInsertsAfterLastCallArgument(t *testing.T) {
+  assertFixSnapshot(
+    t,
+    "format/trailing-comma",
+    "JSON.stringify(\n  {\n    a: 1,\n    b: 2,\n  },\n  null,\n  2\n);\n",
+    "JSON.stringify(\n  {\n    a: 1,\n    b: 2,\n  },\n  null,\n  2,\n);\n",
+  )
+}

package/linthost/format_trailing_comma_inserts_after_last_call_signature_parameter_test.go

@@ -0,0 +1,28 @@
+package linthost
+
+import "testing"
+
+// TestFormatTrailingCommaInsertsAfterLastCallSignatureParameter verifies
+// the rule reaches multi-line parameter lists on bare interface call
+// signatures.
+//
+// An interface call signature has its own syntax owner while sharing formal-parameter comma policy. Type-space signatures must not lose coverage when runtime functions are normalized.
+//
+//  1. Parse a source file with one interface containing a multi-line
+//     bare call signature.
+//  2. Apply the rule's finding through the disk-backed fixer.
+//  3. Assert the rewritten file contains the trailing comma after the
+//     last parameter.
+//
+// @evidence contracts/testing.md#behavioral-verification The interface call signature must gain a comma after right:number while retaining its return type, interface and surrounding use.
+// @evidence contracts/testing.md#independent-expectations TypeScript permits a terminal comma in formal parameters, and Prettier all-mode applies that policy to interface call signatures. The literal expected signature preserves type meaning independently of its AST kind.
+// @evidence contracts/testing.md#distinguishing-cases This bare interface call signature differs from named method signatures and construct signatures. Their separate positive hosts and ES5 parameter exclusion cover ownership and policy boundaries.
+// @evidence contracts/testing.md#execution-ownership TestFormatTrailingCommaInsertsAfterLastCallSignatureParameter 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 TestFormatTrailingCommaInsertsAfterLastCallSignatureParameter(t *testing.T) {
+  assertFixSnapshot(
+    t,
+    "format/trailing-comma",
+    "interface Combiner {\n  (\n    left: number,\n    right: number\n  ): number;\n}\nlet c: Combiner;\nc;\n",
+    "interface Combiner {\n  (\n    left: number,\n    right: number,\n  ): number;\n}\nlet c: Combiner;\nc;\n",
+  )
+}

package/linthost/format_trailing_comma_inserts_after_last_construct_signature_parameter_test.go

@@ -0,0 +1,28 @@
+package linthost
+
+import "testing"
+
+// TestFormatTrailingCommaInsertsAfterLastConstructSignatureParameter verifies
+// the rule reaches multi-line parameter lists on interface construct
+// signatures (`new (...): T`).
+//
+// Interface construct signatures are a separate syntax owner. Normalizing their final parameter must preserve the new marker and return type.
+//
+//  1. Parse a source file with one interface containing a multi-line
+//     construct signature.
+//  2. Apply the rule's finding through the disk-backed fixer.
+//  3. Assert the rewritten file contains the trailing comma after the
+//     last parameter.
+//
+// @evidence contracts/testing.md#behavioral-verification The interface construct signature must gain only the comma after y:number, retaining its new marker and returned x/y object type.
+// @evidence contracts/testing.md#independent-expectations TypeScript construct signatures permit terminal formal-parameter commas under Prettier all mode. The literal full output independently preserves type relationships and surrounding interface/use bytes.
+// @evidence contracts/testing.md#distinguishing-cases This interface new signature differs from bare call and named method signatures, whose dedicated hosts provide sibling positives.
+// @evidence contracts/testing.md#execution-ownership TestFormatTrailingCommaInsertsAfterLastConstructSignatureParameter 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 TestFormatTrailingCommaInsertsAfterLastConstructSignatureParameter(t *testing.T) {
+  assertFixSnapshot(
+    t,
+    "format/trailing-comma",
+    "interface PointFactory {\n  new (\n    x: number,\n    y: number\n  ): { x: number; y: number };\n}\nlet f: PointFactory;\nf;\n",
+    "interface PointFactory {\n  new (\n    x: number,\n    y: number,\n  ): { x: number; y: number };\n}\nlet f: PointFactory;\nf;\n",
+  )
+}

package/linthost/format_trailing_comma_inserts_after_last_constructor_parameter_test.go

@@ -0,0 +1,26 @@
+package linthost
+
+import "testing"
+
+// TestFormatTrailingCommaInsertsAfterLastConstructorParameter verifies the rule
+// reaches multi-line parameter lists on class constructors.
+//
+// A constructor parameter list owns property modifiers as well as ordinary parameter syntax. Adding its final comma must retain those property declarations.
+//
+//  1. Parse a source file with one class whose constructor parameter list spans
+//     multiple lines.
+//  2. Apply the rule's finding through the disk-backed fixer.
+//  3. Assert the rewritten file contains the trailing comma after the last parameter.
+//
+// @evidence contracts/testing.md#behavioral-verification The class constructor must gain only its final parameter comma while retaining both public x/y properties, their types and the empty body.
+// @evidence contracts/testing.md#independent-expectations Prettier all-mode permits the final constructor parameter comma. The literal output independently preserves property modifiers and class structure while changing terminal punctuation.
+// @evidence contracts/testing.md#distinguishing-cases The constructor has two public parameter properties and a separate closer line. ES5 constructor removal and stacked-property hosts distinguish mode and modifier spelling.
+// @evidence contracts/testing.md#execution-ownership TestFormatTrailingCommaInsertsAfterLastConstructorParameter 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 TestFormatTrailingCommaInsertsAfterLastConstructorParameter(t *testing.T) {
+  assertFixSnapshot(
+    t,
+    "format/trailing-comma",
+    "class Point {\n  constructor(\n    public x: number,\n    public y: number\n  ) {}\n}\nPoint;\n",
+    "class Point {\n  constructor(\n    public x: number,\n    public y: number,\n  ) {}\n}\nPoint;\n",
+  )
+}

package/linthost/format_trailing_comma_inserts_after_last_constructor_type_parameter_test.go

@@ -0,0 +1,28 @@
+package linthost
+
+import "testing"
+
+// TestFormatTrailingCommaInsertsAfterLastConstructorTypeParameter verifies
+// the rule reaches multi-line parameter lists on TypeScript constructor
+// type literals (`new (a, b) => T`).
+//
+// A constructor type literal has a parameter list in type space. Its comma policy matches formal parameters while its returned type remains untouched.
+//
+//  1. Parse a source file with one type alias whose body is a
+//     multi-line constructor type literal.
+//  2. Apply the rule's finding through the disk-backed fixer.
+//  3. Assert the rewritten file contains the trailing comma after the
+//     last parameter.
+//
+// @evidence contracts/testing.md#behavioral-verification The constructor type must gain a comma after y:number while retaining its new keyword, x parameter and returned object type.
+// @evidence contracts/testing.md#independent-expectations TypeScript constructor-type formal parameters permit terminal commas under the Prettier all policy. The literal expected type preserves its complete signature independently of runtime constructor dispatch.
+// @evidence contracts/testing.md#distinguishing-cases This new-flavored type literal differs from class constructors and interface construct signatures. Their separate hosts verify each syntax owner rather than assuming a shared shape is sufficient.
+// @evidence contracts/testing.md#execution-ownership TestFormatTrailingCommaInsertsAfterLastConstructorTypeParameter 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 TestFormatTrailingCommaInsertsAfterLastConstructorTypeParameter(t *testing.T) {
+  assertFixSnapshot(
+    t,
+    "format/trailing-comma",
+    "type PointCtor = new (\n  x: number,\n  y: number\n) => { x: number; y: number };\nlet c: PointCtor;\nc;\n",
+    "type PointCtor = new (\n  x: number,\n  y: number,\n) => { x: number; y: number };\nlet c: PointCtor;\nc;\n",
+  )
+}

package/linthost/format_trailing_comma_inserts_after_last_element_in_multiple_lists_test.go

@@ -0,0 +1,27 @@
+package linthost
+
+import "testing"
+
+// TestFormatTrailingCommaInsertsAfterLastElementInMultipleLists verifies
+// `applyTextEditsToFile`'s original-offset preservation when two independent
+// multi-line lists in the same source each need a trailing comma.
+//
+// Multiple edits must preserve the original position of each final item. Applying an insertion against already shifted offsets can damage a later list, so the complete two-array output verifies their combined application.
+//
+//  1. Parse a source file with two multi-line array literals, neither
+//     carrying a trailing comma.
+//  2. Apply the rule's findings through the disk-backed fixer.
+//  3. Assert both lists gain trailing commas at the correct positions.
+//
+// @evidence contracts/testing.md#behavioral-verification Both arrays in one source must gain exactly their final commas while retaining every element. Complete output detects applying later insertions against source offsets shifted by an earlier edit.
+// @evidence contracts/testing.md#independent-expectations Each authored multiline array independently requires its all-mode terminal comma. The literal complete file specifies both insertion positions without deriving order or output from the edit application implementation.
+// @evidence contracts/testing.md#distinguishing-cases Two independent arrays require two edits in one file, unlike a sole-list snapshot. The mixed ES5 array/function and terminated-array/object hosts independently cover eligible/ineligible and canonical populations.
+// @evidence contracts/testing.md#execution-ownership TestFormatTrailingCommaInsertsAfterLastElementInMultipleLists owns the two-array literal source and complete expected edited file 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 TestFormatTrailingCommaInsertsAfterLastElementInMultipleLists(t *testing.T) {
+  assertFixSnapshot(
+    t,
+    "format/trailing-comma",
+    "const xs = [\n  1,\n  2\n];\nconst ys = [\n  3,\n  4\n];\n",
+    "const xs = [\n  1,\n  2,\n];\nconst ys = [\n  3,\n  4,\n];\n",
+  )
+}

package/linthost/format_trailing_comma_inserts_after_last_function_expression_parameter_test.go

@@ -0,0 +1,25 @@
+package linthost
+
+import "testing"
+
+// TestFormatTrailingCommaInsertsAfterLastFunctionExpressionParameter verifies
+// the rule reaches multi-line parameter lists on function expressions.
+//
+// Function expressions share formal-parameter punctuation with declarations but have a different syntax owner. The final comma must not disturb their binding or body.
+//
+// 1. Parse a source file with one multi-line function expression.
+// 2. Apply the rule's finding through the disk-backed fixer.
+// 3. Assert the rewritten file contains the trailing comma after the last parameter.
+//
+// @evidence contracts/testing.md#behavioral-verification The function expression must gain a comma after right:number while retaining its binding, numeric return annotation and addition body.
+// @evidence contracts/testing.md#independent-expectations Prettier all-mode applies formal-parameter commas to function expressions. Literal expected source retains left/right and every surrounding token independently of expression/declaration dispatch.
+// @evidence contracts/testing.md#distinguishing-cases The expression lives in a const initializer, distinct from a function declaration. Its ES5 peer supplies no-comma and removal cases.
+// @evidence contracts/testing.md#execution-ownership TestFormatTrailingCommaInsertsAfterLastFunctionExpressionParameter 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 TestFormatTrailingCommaInsertsAfterLastFunctionExpressionParameter(t *testing.T) {
+  assertFixSnapshot(
+    t,
+    "format/trailing-comma",
+    "const add = function (\n  left: number,\n  right: number\n): number {\n  return left + right;\n};\nadd;\n",
+    "const add = function (\n  left: number,\n  right: number,\n): number {\n  return left + right;\n};\nadd;\n",
+  )
+}

package/linthost/format_trailing_comma_inserts_after_last_function_parameter_test.go

@@ -0,0 +1,25 @@
+package linthost
+
+import "testing"
+
+// TestFormatTrailingCommaInsertsAfterLastFunctionParameter verifies the rule
+// reaches multi-line function parameter lists.
+//
+// The parameter list ends before its closing parenthesis; the return annotation follows that parenthesis. The comma must follow the last parameter, and only trivia may intervene before the closer.
+//
+// 1. Parse a source file with one multi-line function declaration.
+// 2. Apply the rule's finding through the disk-backed fixer.
+// 3. Assert the rewritten file contains the trailing comma.
+//
+// @evidence contracts/testing.md#behavioral-verification The function declaration must gain only the comma after right:number while retaining its numeric return type and left+right body.
+// @evidence contracts/testing.md#independent-expectations Prettier all-mode permits a final comma in this broken formal-parameter list. The literal expected declaration independently preserves its signature and body.
+// @evidence contracts/testing.md#distinguishing-cases The return annotation follows the closing parenthesis, while the comma belongs before it. Arrow, expression and method peers exercise other parameter owners; ES5 mixed-list tests supply exclusion.
+// @evidence contracts/testing.md#execution-ownership TestFormatTrailingCommaInsertsAfterLastFunctionParameter 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 TestFormatTrailingCommaInsertsAfterLastFunctionParameter(t *testing.T) {
+  assertFixSnapshot(
+    t,
+    "format/trailing-comma",
+    "function add(\n  left: number,\n  right: number\n): number {\n  return left + right;\n}\n",
+    "function add(\n  left: number,\n  right: number,\n): number {\n  return left + right;\n}\n",
+  )
+}

package/linthost/format_trailing_comma_inserts_after_last_function_type_parameter_test.go

@@ -0,0 +1,28 @@
+package linthost
+
+import "testing"
+
+// TestFormatTrailingCommaInsertsAfterLastFunctionTypeParameter verifies
+// the rule reaches multi-line parameter lists on TypeScript function
+// type literals (`(a, b) => T`).
+//
+// Function-type parameter lists live in type space but still need all-mode terminal punctuation. Their return type must remain outside the edit.
+//
+//  1. Parse a source file with one type alias whose body is a
+//     multi-line function type literal.
+//  2. Apply the rule's finding through the disk-backed fixer.
+//  3. Assert the rewritten file contains the trailing comma after the
+//     last parameter.
+//
+// @evidence contracts/testing.md#behavioral-verification The function type must gain a comma after right:number while retaining both parameter types and the numeric result type.
+// @evidence contracts/testing.md#independent-expectations TypeScript function types use formal-parameter comma grammar, which Prettier all mode permits. The literal expected type is independent of runtime function AST ownership.
+// @evidence contracts/testing.md#distinguishing-cases The type alias has no runtime body, contrasting the expression/declaration positives and the constructor-type peer with its new marker.
+// @evidence contracts/testing.md#execution-ownership TestFormatTrailingCommaInsertsAfterLastFunctionTypeParameter 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 TestFormatTrailingCommaInsertsAfterLastFunctionTypeParameter(t *testing.T) {
+  assertFixSnapshot(
+    t,
+    "format/trailing-comma",
+    "type BinaryOp = (\n  left: number,\n  right: number\n) => number;\nlet f: BinaryOp;\nf;\n",
+    "type BinaryOp = (\n  left: number,\n  right: number,\n) => number;\nlet f: BinaryOp;\nf;\n",
+  )
+}

package/linthost/format_trailing_comma_inserts_after_last_method_parameter_test.go

@@ -0,0 +1,26 @@
+package linthost
+
+import "testing"
+
+// TestFormatTrailingCommaInsertsAfterLastMethodParameter verifies the rule
+// reaches multi-line parameter lists on class method declarations.
+//
+// A class method has its own parameter-bearing syntax owner. Normalizing its final comma must preserve the method body and containing class.
+//
+//  1. Parse a source file with one class containing a method whose parameter
+//     list spans multiple lines.
+//  2. Apply the rule's finding through the disk-backed fixer.
+//  3. Assert the rewritten file contains the trailing comma after the last parameter.
+//
+// @evidence contracts/testing.md#behavioral-verification The Calculator method must gain only the comma after right:number while retaining class ownership, return annotation and addition body.
+// @evidence contracts/testing.md#independent-expectations Prettier all-mode permits final commas in broken class-method formal parameters. The literal output independently preserves left/right and their runtime computation.
+// @evidence contracts/testing.md#distinguishing-cases The method has a body and class owner, distinct from top-level functions and body-free method signatures. Its ES5 peer covers the forbidden-comma policy.
+// @evidence contracts/testing.md#execution-ownership TestFormatTrailingCommaInsertsAfterLastMethodParameter 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 TestFormatTrailingCommaInsertsAfterLastMethodParameter(t *testing.T) {
+  assertFixSnapshot(
+    t,
+    "format/trailing-comma",
+    "class Calculator {\n  add(\n    left: number,\n    right: number\n  ): number {\n    return left + right;\n  }\n}\nCalculator;\n",
+    "class Calculator {\n  add(\n    left: number,\n    right: number,\n  ): number {\n    return left + right;\n  }\n}\nCalculator;\n",
+  )
+}

package/linthost/format_trailing_comma_inserts_after_last_method_signature_parameter_test.go

@@ -0,0 +1,28 @@
+package linthost
+
+import "testing"
+
+// TestFormatTrailingCommaInsertsAfterLastMethodSignatureParameter verifies
+// the rule reaches multi-line parameter lists on interface method
+// signatures.
+//
+// A method signature declares callable shape without a body. Its final parameter must follow the same all-mode comma policy without changing its type declaration.
+//
+//  1. Parse a source file with one interface containing a multi-line
+//     method signature.
+//  2. Apply the rule's finding through the disk-backed fixer.
+//  3. Assert the rewritten file contains the trailing comma after the
+//     last parameter.
+//
+// @evidence contracts/testing.md#behavioral-verification The interface method signature must gain a comma after right:number while preserving its numeric result type, interface name and subsequent use.
+// @evidence contracts/testing.md#independent-expectations TypeScript permits formal-parameter terminal commas in method signatures under Prettier all mode. The literal complete source independently preserves type meaning.
+// @evidence contracts/testing.md#distinguishing-cases The method signature has no implementation body. Runtime method, bare call-signature and construct-signature hosts distinguish each declaration owner.
+// @evidence contracts/testing.md#execution-ownership TestFormatTrailingCommaInsertsAfterLastMethodSignatureParameter 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 TestFormatTrailingCommaInsertsAfterLastMethodSignatureParameter(t *testing.T) {
+  assertFixSnapshot(
+    t,
+    "format/trailing-comma",
+    "interface Calculator {\n  add(\n    left: number,\n    right: number\n  ): number;\n}\nlet c: Calculator;\nc;\n",
+    "interface Calculator {\n  add(\n    left: number,\n    right: number,\n  ): number;\n}\nlet c: Calculator;\nc;\n",
+  )
+}

package/linthost/format_trailing_comma_inserts_after_last_named_export_test.go

@@ -0,0 +1,25 @@
+package linthost
+
+import "testing"
+
+// TestFormatTrailingCommaInsertsAfterLastNamedExport verifies named export
+// lists get trailing commas when split across multiple lines.
+//
+// Named exports have their own list owner. The edit must affect only the final specifier punctuation while preserving the exported bindings.
+//
+// 1. Parse a source file with one multi-line named export.
+// 2. Apply the rule's finding through the disk-backed fixer.
+// 3. Assert the rewritten file contains the trailing comma after the last specifier.
+//
+// @evidence contracts/testing.md#behavioral-verification The named export list must gain a comma after beta while retaining alpha, both const declarations and their export order.
+// @evidence contracts/testing.md#independent-expectations Prettier applies terminal commas to broken named export specifiers. The literal expected file independently fixes punctuation and preserves which bindings are exported.
+// @evidence contracts/testing.md#distinguishing-cases The named export is positive with two ordinary specifiers. Named-import insertion and inline/canonical list negatives provide sibling and layout distinctions.
+// @evidence contracts/testing.md#execution-ownership TestFormatTrailingCommaInsertsAfterLastNamedExport 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 TestFormatTrailingCommaInsertsAfterLastNamedExport(t *testing.T) {
+  assertFixSnapshot(
+    t,
+    "format/trailing-comma",
+    "const alpha = 1;\nconst beta = 2;\nexport {\n  alpha,\n  beta\n};\n",
+    "const alpha = 1;\nconst beta = 2;\nexport {\n  alpha,\n  beta,\n};\n",
+  )
+}

package/linthost/format_trailing_comma_inserts_after_last_named_import_test.go

@@ -0,0 +1,25 @@
+package linthost
+
+import "testing"
+
+// TestFormatTrailingCommaInsertsAfterLastNamedImport verifies named import
+// lists get trailing commas on multiple lines.
+//
+// A named import comma belongs inside its specifier list. The module string and the imported bindings must stay unchanged.
+//
+// 1. Parse a source file with one multi-line named import.
+// 2. Apply the rule's finding through the disk-backed fixer.
+// 3. Assert the rewritten file contains the trailing comma.
+//
+// @evidence contracts/testing.md#behavioral-verification The named import list must gain only a comma after writeFileSync while retaining readFileSync, node:fs and both subsequent uses.
+// @evidence contracts/testing.md#independent-expectations Prettier applies terminal commas to broken named import specifiers. The literal complete output independently preserves imported binding order and module identity.
+// @evidence contracts/testing.md#distinguishing-cases This named-import positive differs from named exports and combined/default import reflow. Inline and canonical negatives distinguish insertion eligibility.
+// @evidence contracts/testing.md#execution-ownership TestFormatTrailingCommaInsertsAfterLastNamedImport 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 TestFormatTrailingCommaInsertsAfterLastNamedImport(t *testing.T) {
+  assertFixSnapshot(
+    t,
+    "format/trailing-comma",
+    "import {\n  readFileSync,\n  writeFileSync\n} from \"node:fs\";\nreadFileSync; writeFileSync;\n",
+    "import {\n  readFileSync,\n  writeFileSync,\n} from \"node:fs\";\nreadFileSync; writeFileSync;\n",
+  )
+}

package/linthost/format_trailing_comma_inserts_after_last_new_argument_test.go

@@ -0,0 +1,27 @@
+package linthost
+
+import "testing"
+
+// TestFormatTrailingCommaInsertsAfterLastNewArgument verifies the rule reaches
+// multi-line `new Foo(...)` argument lists.
+//
+// A constructor call with arguments follows all-mode call punctuation. A new expression without an argument list has no comma position and must remain untouched.
+//
+// 1. Parse a source file with one multi-line `new` expression.
+// 2. Apply the rule's finding through the disk-backed fixer.
+// 3. Assert the full rewritten source gains the comma after the last argument.
+// 4. Assert a no-parentheses new expression produces no finding.
+//
+// @evidence contracts/testing.md#behavioral-verification New Foo must gain a comma after its final argument 2 while retaining the constructor declaration, first argument and result use; a no-parentheses new expression must produce no finding.
+// @evidence contracts/testing.md#independent-expectations Prettier all-mode permits terminal commas in broken new-expression arguments. The literal expected source independently preserves constructor and argument meaning.
+// @evidence contracts/testing.md#distinguishing-cases The new expression has a present argument list, contrasting an added no-parentheses constructor no-finding case and ES5 new-argument removal.
+// @evidence contracts/testing.md#execution-ownership TestFormatTrailingCommaInsertsAfterLastNewArgument owns its authored insertion source, complete expected edit output and no-argument-list negative 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 TestFormatTrailingCommaInsertsAfterLastNewArgument(t *testing.T) {
+  assertFixSnapshot(
+    t,
+    "format/trailing-comma",
+    "declare class Foo { constructor(a: number, b: number); }\nconst r = new Foo(\n  1,\n  2\n);\nr;\n",
+    "declare class Foo { constructor(a: number, b: number); }\nconst r = new Foo(\n  1,\n  2,\n);\nr;\n",
+  )
+  assertRuleSkipsSource(t, "format/trailing-comma", "const r = new Foo;\n")
+}

package/linthost/format_trailing_comma_inserts_after_last_object_property_test.go

@@ -0,0 +1,25 @@
+package linthost
+
+import "testing"
+
+// TestFormatTrailingCommaInsertsAfterLastObjectProperty verifies trailing
+// commas land on multi-line object literals.
+//
+// An ordinary object value list must add only its final separator. Property keys, values and order remain outside the edit.
+//
+// 1. Parse a source file with one multi-line object literal.
+// 2. Apply the rule's finding through the disk-backed fixer.
+// 3. Assert the rewritten file contains the trailing comma.
+//
+// @evidence contracts/testing.md#behavioral-verification The object must gain a comma after b:2 while retaining a:1, property order and object binding.
+// @evidence contracts/testing.md#independent-expectations Prettier all-mode permits terminal commas in broken object value lists. The literal expected object independently preserves all property keys and values.
+// @evidence contracts/testing.md#distinguishing-cases This ordinary-property value positive differs from value spread, assignment rest and non-rest target hosts. Empty and terminated objects are negative boundaries.
+// @evidence contracts/testing.md#execution-ownership TestFormatTrailingCommaInsertsAfterLastObjectProperty 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 TestFormatTrailingCommaInsertsAfterLastObjectProperty(t *testing.T) {
+  assertFixSnapshot(
+    t,
+    "format/trailing-comma",
+    "const obj = {\n  a: 1,\n  b: 2\n};\n",
+    "const obj = {\n  a: 1,\n  b: 2,\n};\n",
+  )
+}

package/linthost/format_trailing_comma_inserts_after_last_set_accessor_parameter_test.go

@@ -0,0 +1,26 @@
+package linthost
+
+import "testing"
+
+// TestFormatTrailingCommaInsertsAfterLastSetAccessorParameter verifies the rule
+// reaches the (singular) parameter on a multi-line setter declaration.
+//
+// A setter has one formal parameter and can carry its final comma under all mode. This differs from a getter with no parameter item.
+//
+//  1. Parse a source file with one class whose setter parameter spans multiple
+//     lines.
+//  2. Apply the rule's finding through the disk-backed fixer.
+//  3. Assert the rewritten file contains the trailing comma after the parameter.
+//
+// @evidence contracts/testing.md#behavioral-verification The setter must gain a comma after its sole next:number parameter while retaining the backing field and assignment body.
+// @evidence contracts/testing.md#independent-expectations The authored expected class specifies the all-mode final comma for this broken one-parameter setter list while independently preserving its field and assignment behavior. This direct unit does not execute a reference formatter.
+// @evidence contracts/testing.md#distinguishing-cases The setter has exactly one parameter, unlike a zero-parameter getter. Its ES5 peer covers both comma-free abstention and forbidden-comma removal.
+// @evidence contracts/testing.md#execution-ownership TestFormatTrailingCommaInsertsAfterLastSetAccessorParameter 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 TestFormatTrailingCommaInsertsAfterLastSetAccessorParameter(t *testing.T) {
+  assertFixSnapshot(
+    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",
+    "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_last_tuple_element_test.go

@@ -0,0 +1,25 @@
+package linthost
+
+import "testing"
+
+// TestFormatTrailingCommaInsertsAfterLastTupleElement verifies the rule
+// covers tuple types in addition to runtime arrays.
+//
+// Tuple types share brackets with runtime arrays but declare ordered types. Their final comma must not change tuple positions or the surrounding runtime value.
+//
+// 1. Parse a source file with one multi-line tuple type.
+// 2. Apply the rule's finding through the disk-backed fixer.
+// 3. Assert the rewritten file contains the trailing comma.
+//
+// @evidence contracts/testing.md#behavioral-verification The tuple type must gain a comma after string while retaining its number/string order and the existing runtime pair value.
+// @evidence contracts/testing.md#independent-expectations The authored literal expected type specifies only the final comma for this broken tuple while independently preserving element positions and the value declaration. This direct unit does not execute a reference formatter.
+// @evidence contracts/testing.md#distinguishing-cases Type-level tuple elements differ from runtime array elements. The ES5 type-level host supplies option coverage and the runtime-array host supplies the sibling syntax owner.
+// @evidence contracts/testing.md#execution-ownership TestFormatTrailingCommaInsertsAfterLastTupleElement 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 TestFormatTrailingCommaInsertsAfterLastTupleElement(t *testing.T) {
+  assertFixSnapshot(
+    t,
+    "format/trailing-comma",
+    "type Pair = [\n  number,\n  string\n];\nconst p: Pair = [1, \"two\"];\n",
+    "type Pair = [\n  number,\n  string,\n];\nconst p: Pair = [1, \"two\"];\n",
+  )
+}

package/linthost/format_trailing_comma_inserts_after_last_type_parameter_test.go

@@ -0,0 +1,28 @@
+package linthost
+
+import "testing"
+
+// TestFormatTrailingCommaInsertsAfterLastTypeParameter verifies the rule
+// reaches multi-line TypeScript type-parameter declaration lists.
+//
+// Declaration type parameters and call-site type arguments have different comma policies. Only the declaration list in this positive must gain terminal punctuation.
+//
+//  1. Parse a source file with one multi-line generic function declaration.
+//  2. Apply the rule's finding through the disk-backed fixer.
+//  3. Assert the rewritten file contains the trailing comma after the
+//     last type parameter.
+//  4. Assert a broken generic-call type-argument list produces no finding.
+//
+// @evidence contracts/testing.md#behavioral-verification The generic function must gain one comma after K extends keyof T while retaining both constraints, its value parameters and indexed return/body; a generic call must keep its type-argument list unchanged.
+// @evidence contracts/testing.md#independent-expectations Official Prettier options permit terminal commas in TypeScript declaration type parameters. The literal expected generic function independently preserves its constraints and type relationship.
+// @evidence contracts/testing.md#distinguishing-cases Two constrained declaration type parameters supply a positive, unlike type arguments at call sites. An added broken generic-call type-argument negative distinguishes declaration from application.
+// @evidence contracts/testing.md#execution-ownership TestFormatTrailingCommaInsertsAfterLastTypeParameter owns its authored declaration source, complete expected edit output and call-site type-argument negative 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 TestFormatTrailingCommaInsertsAfterLastTypeParameter(t *testing.T) {
+  assertFixSnapshot(
+    t,
+    "format/trailing-comma",
+    "function pick<\n  T extends object,\n  K extends keyof T\n>(obj: T, key: K): T[K] {\n  return obj[key];\n}\npick;\n",
+    "function pick<\n  T extends object,\n  K extends keyof T,\n>(obj: T, key: K): T[K] {\n  return obj[key];\n}\npick;\n",
+  )
+  assertRuleSkipsSource(t, "format/trailing-comma", "pick<\n  FirstType,\n  SecondType\n>(value);\n")
+}

package/linthost/format_trailing_comma_inserts_after_non_rest_array_assignment_target_test.go

@@ -0,0 +1,27 @@
+package linthost
+
+import "testing"
+
+// TestFormatTrailingCommaInsertsAfterNonRestArrayAssignmentTarget is the
+// array twin of the non-rest target over-suppression check: a destructuring
+// array assignment target without a trailing rest (`[a, b] = arr`) legally
+// takes a trailing comma (`[a, b,] = arr` parses).
+//
+// Assignment-target position alone does not forbid trailing commas. A target with ordinary final element must still normalize under the permissive comma policy.
+//
+// 1. Parse a multi-line array assignment target whose last element is not a rest.
+// 2. Apply the rule's finding through the disk-backed fixer.
+// 3. Assert the trailing comma lands after the last element.
+//
+// @evidence contracts/testing.md#behavioral-verification A destructuring array target without final rest must gain its legal comma after b. Exact output preserves both assigned bindings and the right-hand arr expression.
+// @evidence contracts/testing.md#independent-expectations ECMAScript array-assignment grammar accepts a terminal comma after an ordinary element. The literal expected target independently fixes that legal punctuation without relying on the ancestor walk.
+// @evidence contracts/testing.md#distinguishing-cases This target has two ordinary elements and no rest, contrasting SkipsArrayRestAssignmentTarget. ArraySpreadInValueLiteral distinguishes a legal spread outside target ownership.
+// @evidence contracts/testing.md#execution-ownership TestFormatTrailingCommaInsertsAfterNonRestArrayAssignmentTarget 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 TestFormatTrailingCommaInsertsAfterNonRestArrayAssignmentTarget(t *testing.T) {
+  assertFixSnapshot(
+    t,
+    "format/trailing-comma",
+    "[\n  a,\n  b\n] = arr;\n",
+    "[\n  a,\n  b,\n] = arr;\n",
+  )
+}