@ttsc/lint 0.30.4 → 0.31.1

package/linthost/prefer_template_fix_preserves_newline_test.go

@@ -0,0 +1,30 @@
+package linthost
+
+import "testing"
+
+// TestFixPreferTemplatePreservesNewline verifies the template-body escape
+// branch keeps a literal's newline as a `\n` escape rather than a raw LF.
+//
+// Emitting the cooked LF raw would still parse, but it would reshape the
+// template into a multi-line literal whose source layout no longer matches
+// the original single-line concat. Escaping it as `\n` keeps both the cooked
+// value and the on-one-line source shape stable.
+//
+//  1. Snapshot a concat whose literal contains a newline.
+//  2. Apply `prefer-template` fix.
+//  3. Assert the newline survives as a `\n` escape inside the template.
+//
+// @evidence contracts/testing.md#behavioral-verification Fixes concatenation while retaining the string's escaped newline.
+// Every dynamic slot explicitly retains default-hint concatenation coercion.
+//
+// @evidence contracts/testing.md#independent-expectations Literal expected \n spelling preserves U+000A in the value and all source outside the replaced expression.
+// @evidence contracts/testing.md#distinguishing-cases Newline contrasts with carriage return and ordinary literal text.
+// @evidence contracts/testing.md#execution-ownership assertFixSnapshot calls runFixSnapshot, applies the rule's actual edits to the fixture and compares complete independently authored output. This Test entry owns this exact source/output pair. All execute in the lint Go process without installing consumers or building/launching a native product host.
+func TestFixPreferTemplatePreservesNewline(t *testing.T) {
+  assertFixSnapshot(
+    t,
+    "prefer-template",
+    "const foo = 1;\nconst s = \"a\\nb\" + foo;\nJSON.stringify(s);\n",
+    "const foo = 1;\nconst s = `a\\nb${\"\" + (foo)}`;\nJSON.stringify(s);\n",
+  )
+}

package/linthost/prefer_template_fix_preserves_template_operand_group_test.go

@@ -0,0 +1,27 @@
+package linthost
+
+import "testing"
+
+// TestFixPreferTemplatePreservesTemplateOperandGroup verifies that
+// `a + `x${y}` + "s"` keeps `a + `x${y}“ as one interpolation.
+//
+// An effectful right template must finish before the left object is coerced.
+// The fix preserves the complete a + template addition in one interpolation,
+// and moves only the inert trailing string into the outer template's literal body.
+//
+// 1. Snapshot a chain whose second operand is a template literal with a substitution.
+// 2. Apply `prefer-template` fix.
+// 3. Assert the output groups `a` and the template in one slot followed by `s`.
+//
+// @evidence contracts/testing.md#behavioral-verification Real edits preserve the original a-plus-template grouping and its inner y substitution while moving the suffix into one outer template.
+// @evidence contracts/testing.md#independent-expectations Binary addition evaluates both operands before default-hint coercion. The literal full output retains that order instead of coercing a before the right template runs.
+// @evidence contracts/testing.md#distinguishing-cases A right template expression requires grouped preservation; inert right string literals and string-leading chains permit separate slots in companion tests.
+// @evidence contracts/testing.md#execution-ownership This Go unit applies actual Engine edits to the authored disk-backed fixture through assertFixSnapshot without installing a consumer or launching a native host.
+func TestFixPreferTemplatePreservesTemplateOperandGroup(t *testing.T) {
+  assertFixSnapshot(
+    t,
+    "prefer-template",
+    "const a: any = 1;\nconst y: any = 2;\nconst s = a + `x${y}` + \"s\";\nJSON.stringify(s);\n",
+    "const a: any = 1;\nconst y: any = 2;\nconst s = `${\"\" + (a + `x${y}`)}s`;\nJSON.stringify(s);\n",
+  )
+}

package/linthost/prefer_template_fix_renders_empty_string_operand_with_default_coercion_test.go

@@ -0,0 +1,31 @@
+package linthost
+
+import "testing"
+
+// TestFixPreferTemplateRendersEmptyStringOperandWithDefaultCoercion
+// verifies the empty-literal boundary: `"" + a` → “ `${"" + (a)}` “.
+//
+// The empty string contributes zero cooked characters, so the merged
+// literal run is empty and the renderer's flush must emit nothing —
+// the template collapses to a single placeholder. This exercises the empty
+// literal-run boundary without distinguishing the renderer's length guard:
+// an unconditional flush of an empty string would produce the same output.
+//
+// 1. Snapshot a concat whose only literal is the empty string.
+// 2. Apply `prefer-template` fix.
+// 3. Assert the output is a coercion-preserving `${"" + (a)}` template.
+//
+// @evidence contracts/testing.md#behavioral-verification Fixes empty-string plus a as a coercion-preserving interpolation without adding literal characters.
+// Every dynamic slot explicitly retains default-hint concatenation coercion.
+//
+// @evidence contracts/testing.md#independent-expectations Empty string contributes no characters but establishes string coercion; authored ${"" + (a)} preserves that meaning.
+// @evidence contracts/testing.md#distinguishing-cases Empty literal operand is the zero-length segment boundary beside ordinary prefix/suffix cases.
+// @evidence contracts/testing.md#execution-ownership assertFixSnapshot calls runFixSnapshot, applies the rule's actual edits to the fixture and compares complete independently authored output. This Test entry owns this exact source/output pair. All execute in the lint Go process without installing consumers or building/launching a native product host.
+func TestFixPreferTemplateRendersEmptyStringOperandWithDefaultCoercion(t *testing.T) {
+  assertFixSnapshot(
+    t,
+    "prefer-template",
+    "const a: any = 1;\nconst s = \"\" + a;\nJSON.stringify(s);\n",
+    "const a: any = 1;\nconst s = `${\"\" + (a)}`;\nJSON.stringify(s);\n",
+  )
+}

package/linthost/prefer_template_fix_sees_string_through_parens_when_flattening_test.go

@@ -0,0 +1,34 @@
+package linthost
+
+import "testing"
+
+// TestFixPreferTemplateSeesStringThroughParensWhenFlattening verifies
+// parentheses are transparent to the flattening DECISION:
+// `("a" + b) + c + " s"` → “ `${"" + (("a" + b))}${"" + (c)} s` “.
+//
+// The parenthesized operand itself stays one slot, but its string
+// literal still marks the enclosing chain as string concatenation —
+// `("a" + b)` evaluates to a string, so `+ c` appends and `c` can keep
+// its own `${"" + (c)}` slot. Were the containment gate opaque to parens it
+// would demote the whole left side to `${"" + (("a" + b) + c)}` — still
+// value-correct, but different from the authored separate-slot output. This
+// case pins that source grouping policy rather than a changed runtime value.
+//
+// 1. Snapshot a chain whose only string literal hides inside parens.
+// 2. Apply `prefer-template` fix.
+// 3. Assert `c` still flattens into its own slot.
+//
+// @evidence contracts/testing.md#behavioral-verification Recognizes a string-producing parenthesized operand while retaining that operand whole in a slot and flattening later c.
+// Every dynamic slot explicitly retains default-hint concatenation coercion.
+//
+// @evidence contracts/testing.md#independent-expectations The authored (a-string+b) operand already yields a string, but explicit grouping remains; literal nested slot then c preserves evaluation.
+// @evidence contracts/testing.md#distinguishing-cases Contrasts grouped arithmetic subchains, which do not establish string mode until the suffix.
+// @evidence contracts/testing.md#execution-ownership assertFixSnapshot calls runFixSnapshot, applies the rule's actual edits to the fixture and compares complete independently authored output. This Test entry owns this exact source/output pair. All execute in the lint Go process without installing consumers or building/launching a native product host.
+func TestFixPreferTemplateSeesStringThroughParensWhenFlattening(t *testing.T) {
+  assertFixSnapshot(
+    t,
+    "prefer-template",
+    "const b: any = 1;\nconst c: any = 2;\nconst s = (\"a\" + b) + c + \" s\";\nJSON.stringify(s);\n",
+    "const b: any = 1;\nconst c: any = 2;\nconst s = `${\"\" + ((\"a\" + b))}${\"\" + (c)} s`;\nJSON.stringify(s);\n",
+  )
+}

package/linthost/prefer_template_fix_three_part_concat_test.go

@@ -0,0 +1,31 @@
+package linthost
+
+import "testing"
+
+// TestFixPreferTemplateRewritesThreePartConcatChain verifies the
+// canonical `"hi " + name + "!"` → “ `hi ${"" + (name)}!` “ rewrite.
+//
+// Detection fires only on the topmost `+` chain, so the fixer must
+// flatten the whole chain in one pass; otherwise a partial rewrite
+// would leave nested template literals or stranded `+` operators. This
+// snapshot requires the complete three-operand rewrite in one application;
+// it does not execute fixture benchmarks or a convergence loop.
+//
+// 1. Snapshot a 3-part concat (`"hi " + name + "!"`).
+// 2. Apply `prefer-template` fix.
+// 3. Assert the result is the canonical template literal.
+//
+// @evidence contracts/testing.md#behavioral-verification Fixes greeting plus name plus punctuation to one template while retaining declarations and use.
+// Every dynamic slot explicitly retains default-hint concatenation coercion.
+//
+// @evidence contracts/testing.md#independent-expectations The literal expected hi/name/exclamation output follows concatenation value and evaluation order independently.
+// @evidence contracts/testing.md#distinguishing-cases Prefix, dynamic middle and suffix preserve all three operands, complementing minimal and delimiter boundary cases.
+// @evidence contracts/testing.md#execution-ownership assertFixSnapshot calls runFixSnapshot, applies the rule's actual edits to the fixture and compares complete independently authored output. This Test entry owns this exact source/output pair. All execute in the lint Go process without installing consumers or building/launching a native product host.
+func TestFixPreferTemplateRewritesThreePartConcatChain(t *testing.T) {
+  assertFixSnapshot(
+    t,
+    "prefer-template",
+    "const name = \"world\";\nconst s = \"hi \" + name + \"!\";\nJSON.stringify(s);\n",
+    "const name = \"world\";\nconst s = `hi ${\"\" + (name)}!`;\nJSON.stringify(s);\n",
+  )
+}

package/linthost/prefer_template_offers_withheld_template_as_suggestion_test.go

@@ -0,0 +1,37 @@
+package linthost
+
+import "testing"
+
+// TestPreferTemplateOffersWithheldTemplateAsSuggestion verifies the rendered
+// template literal withheld from a seam-commented concatenation is offered as
+// an opt-in suggestion that discards the seam comment.
+//
+// The native rebuild replaces the whole `+` chain with one literal and
+// drops an operator-seam comment. Automatic fixing is withheld; the suggestion
+// title discloses that loss, and this test applies the authored edits explicitly.
+//
+//  1. Report on `"hi " + /* keep */ who` and assert nothing auto-applies.
+//  2. Assert the single suggestion yields the template literal `hi ${"" + (who)}`.
+//  3. Assert the comment-free twin is still autofixed without asking.
+//
+// @evidence contracts/testing.md#behavioral-verification A seam-comment concatenation offers a titled opt-in lossy suggestion without an automatic edit; removing the comment permits automatic fixing.
+// Every dynamic slot explicitly retains default-hint concatenation coercion.
+//
+// @evidence contracts/testing.md#independent-expectations Literal title explicitly discloses discarded comments and authored complete output fixes the intended value; the clean control independently permits the same rewrite.
+// @evidence contracts/testing.md#distinguishing-cases Comment-bearing suggestion and comment-free automatic fix distinguish channels, not merely eventual output.
+// @evidence contracts/testing.md#execution-ownership assertSuggestionSnapshot owns withheld automatic edits, the exact title and opt-in rewrite; assertFixSnapshot owns the comment-free automatic rewrite. Both authored invocations belong to this Test. All execute in the lint Go process without installing consumers or building/launching a native product host.
+func TestPreferTemplateOffersWithheldTemplateAsSuggestion(t *testing.T) {
+  assertSuggestionSnapshot(
+    t,
+    "prefer-template",
+    "const who = \"world\";\nconst s = \"hi \" + /* keep */ who;\nJSON.stringify(s);\n",
+    "Use a template literal, discarding the comments between the operands.",
+    "const who = \"world\";\nconst s = `hi ${\"\" + (who)}`;\nJSON.stringify(s);\n",
+  )
+  assertFixSnapshot(
+    t,
+    "prefer-template",
+    "const who = \"world\";\nconst s = \"hi \" + who;\nJSON.stringify(s);\n",
+    "const who = \"world\";\nconst s = `hi ${\"\" + (who)}`;\nJSON.stringify(s);\n",
+  )
+}

package/linthost/prefer_template_preserves_default_coercion_hint_test.go

@@ -0,0 +1,30 @@
+package linthost
+
+import "testing"
+
+// TestPreferTemplatePreservesDefaultCoercionHint verifies that prefer-template
+// fixes keep concatenation's default coercion hint inside each interpolation.
+//
+// Template interpolation requests the string hint, so the fix writes
+// `${"" + (x)}` to keep the hint that `+` requested originally.
+//
+// 1. Fix concatenations of a custom toPrimitive object, Date, Symbol() and two calls.
+// 2. Assert the already-rewritten output reports nothing, for a plain and a grouped chain.
+// 3. Assert the grouped chain reports exactly its full span.
+//
+// @evidence contracts/testing.md#behavioral-verification Real fixes keep explicit default-hint coercion for custom primitives, Date, Symbol and ordered calls; a second rule pass leaves that coercion intact.
+// @evidence contracts/testing.md#independent-expectations ECMAScript plus requests the default ToPrimitive hint while direct interpolation requests string. Empty-prefix plus preserves the original hint and Symbol throw before interpolation.
+// @evidence contracts/testing.md#distinguishing-cases Custom primitive hints, built-in Date, Symbol errors and sequential effectful operands contrast with an already preserved interpolation.
+// @evidence contracts/testing.md#execution-ownership The Go unit applies real Engine edits to disk-backed authored sources through assertFixSnapshot and compares independent complete output; it does not evaluate the rewritten code at runtime.
+func TestPreferTemplatePreservesDefaultCoercionHint(t *testing.T) {
+  assertFixSnapshot(t, "prefer-template",
+    `const x={ [Symbol.toPrimitive](hint){return hint==='string'?'s':'d'} }; const out='x'+x;`,
+    "const x={ [Symbol.toPrimitive](hint){return hint==='string'?'s':'d'} }; const out=`x${\"\" + (x)}`;")
+  assertFixSnapshot(t, "prefer-template", `const out='x'+new Date(0);`, "const out=`x${\"\" + (new Date(0))}`;")
+  assertFixSnapshot(t, "prefer-template", `const out='x'+Symbol();`, "const out=`x${\"\" + (Symbol())}`;")
+  assertFixSnapshot(t, "prefer-template", `const out='x'+first()+second();`, "const out=`x${\"\" + (first())}${\"\" + (second())}`;")
+  assertRuleSkipsSource(t, "prefer-template", "const out=`x${\"\" + (x)}`;")
+  assertFixSnapshot(t, "prefer-template", `const out=left+('x'+right())+'end';`, "const out=`${\"\" + (left+('x'+right()))}end`;")
+  assertRuleSkipsSource(t, "prefer-template", "const out=`${\"\" + (left+('x'+right()))}end`;")
+  assertRuleFindingRanges(t, "prefer-template", `const out=left+('x'+right())+'end';`, "left+('x'+right())+'end'")
+}

package/linthost/prefer_template_skips_all_literal_chain_test.go

@@ -0,0 +1,27 @@
+package linthost
+
+import "testing"
+
+// TestPreferTemplateSkipsAllLiteralChain verifies the rule stays silent
+// on a chain of nothing but string literals: `"a" + "b"`.
+//
+// All-literal concatenation is `no-useless-concat` territory — upstream
+// prefer-template only fires when a non-literal operand is mixed in, so
+// this chain must produce zero findings rather than an “ `ab` “
+// rewrite. Pins the `hasOther` half of the detection gate against the
+// flattening changes in the fixer.
+//
+// 1. Feed an all-string-literal `+` chain to the rule.
+// 2. Assert prefer-template reports no findings at all.
+//
+// @evidence contracts/testing.md#behavioral-verification Prefer-template leaves literal-only concatenation alone.
+// @evidence contracts/testing.md#independent-expectations Without a dynamic operand, no-useless-concat owns the simplification rather than template migration; zero findings follows that responsibility.
+// @evidence contracts/testing.md#distinguishing-cases All-literal negative complements the dynamic greeting corpus and no-useless-concat positive.
+// @evidence contracts/testing.md#execution-ownership assertRuleSkipsSource executes this entry's authored source through the enabled engine rule and owns its zero-finding expectation. All execute in the lint Go process without installing consumers or building/launching a native product host.
+func TestPreferTemplateSkipsAllLiteralChain(t *testing.T) {
+  assertRuleSkipsSource(
+    t,
+    "prefer-template",
+    "const s = \"a\" + \"b\";\nJSON.stringify(s);\n",
+  )
+}

package/linthost/prefer_template_skips_numeric_only_chain_test.go

@@ -0,0 +1,28 @@
+package linthost
+
+import "testing"
+
+// TestPreferTemplateSkipsNumericOnlyChain verifies the rule stays
+// silent on a `+` chain with no string-like operand: `1 + 2 + n`.
+//
+// Without a string literal anywhere in the chain the addition may be
+// numeric, so there is nothing to convert to a template literal —
+// firing here (or worse, fixing) would wrap arithmetic in `${"" + (…)}` for
+// no reason. Pins the `hasString && hasOther` detection gate that the
+// new flattening gate leans on: the fixer only ever sees chains that
+// contain at least one string-like operand.
+//
+// 1. Feed a numeric-only `+` chain to the rule.
+// 2. Assert prefer-template reports no findings at all.
+//
+// @evidence contracts/testing.md#behavioral-verification Prefer-template leaves numeric-only additions unchanged.
+// @evidence contracts/testing.md#independent-expectations Replacing numeric + with string interpolation would change numeric meaning; the authored no-string chain independently requires zero findings.
+// @evidence contracts/testing.md#distinguishing-cases Numeric-only control complements numeric subchain followed by a string suffix.
+// @evidence contracts/testing.md#execution-ownership assertRuleSkipsSource executes this entry's authored source through the enabled engine rule and owns its zero-finding expectation. All execute in the lint Go process without installing consumers or building/launching a native product host.
+func TestPreferTemplateSkipsNumericOnlyChain(t *testing.T) {
+  assertRuleSkipsSource(
+    t,
+    "prefer-template",
+    "const n: any = 3;\nconst s = 1 + 2 + n;\nJSON.stringify(s);\n",
+  )
+}

package/linthost/prefer_user_event_setup_ignores_setup_call_test.go

@@ -0,0 +1,35 @@
+package linthost
+
+import "testing"
+
+// TestPreferUserEventSetupIgnoresSetupCall verifies testing-library prefer-user-event-setup: setup calls are not reported.
+//
+// Locks the distinction between creating a user-event instance and invoking an
+// interaction method. The rule should ask direct event calls to use the setup
+// result, not flag the `userEvent.setup()` call that creates that result.
+//
+// 1. Import the default user-event object.
+// 2. Call `userEvent.setup()`, then mix a direct user-event call with a setup-result call.
+// 3. Assert only the direct interaction is reported.
+//
+// @evidence contracts/testing.md#behavioral-verification The owning engine and Testing Library assertion helpers verify only the direct userEvent.click reports while setup and user.click remain clean; exact normalized findings reject extra or missing results.
+// @evidence contracts/testing.md#independent-expectations setup creates the supported interaction instance; creating it is not an event operation.
+// @evidence contracts/testing.md#distinguishing-cases The same source contains setup creation, direct interaction and setup-result interaction, separating all three shapes.
+// @evidence contracts/testing.md#execution-ownership TestPreferUserEventSetupIgnoresSetupCall assertTestingLibraryFindings parses the source as TSX under a virtual component.test.tsx path and runs NewEngineWithResolver over it with only prefer-user-event-setup enabled and requires exactly one triple, at the direct userEvent.click line, while the setup calls and the setup-instance click stay unreported. No DOM runtime, installed consumer, native build or product child host runs.
+func TestPreferUserEventSetupIgnoresSetupCall(t *testing.T) {
+  source := `
+import userEvent from "@testing-library/user-event";
+
+function testCase() {
+  const user = userEvent.setup();
+  userEvent.setup();
+  userEvent.click(document.body);
+  user.click(document.body);
+}
+`
+  assertTestingLibraryFindings(t, source, RuleConfig{
+    "testing-library/prefer-user-event-setup": SeverityError,
+  }, []ruleExpectation{
+    {Rule: "testing-library/prefer-user-event-setup", Severity: SeverityError, Line: 7},
+  })
+}

package/linthost/print_arg_list_emits_trailing_comma_when_mode_all_test.go

@@ -0,0 +1,38 @@
+package linthost
+
+import (
+  "testing"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+// TestPrintArgListEmitsTrailingCommaWhenModeAll verifies the broken
+// call-argument shape keeps its trailing comma under
+// `trailingComma: "all"`.
+//
+// This entry explicitly selects `"all"` and checks the final comma in
+// one overflowing three-argument call. The same input under `"es5"`
+// and `"none"` is checked by the neighboring mode entries.
+//
+//  1. Parse `process(aaaaaaaaa, bbbbbbbbb, ccccccccc);`.
+//  2. Print under PrintWidth=20 with TrailingComma="all".
+//  3. Assert the rendered output ends the broken list with `ccccccccc,\n)`.
+//
+// @evidence contracts/testing.md#behavioral-verification printCallExpression must break the long argument list and emit the final comma under trailingComma all.
+// @evidence contracts/testing.md#independent-expectations The full literal result retains process and all three identifiers in order, with an all-policy comma before the closing parenthesis.
+// @evidence contracts/testing.md#distinguishing-cases An overflowing call with all mode complements the same inputs in es5 and none modes.
+// @evidence contracts/testing.md#execution-ownership TestPrintArgListEmitsTrailingCommaWhenModeAll is one Go unit entry that parses a call in-process with the TypeScript-Go parser, calls printCallExpression under PrintWidth 20 and TrailingComma all, and renders the Doc with Print; it installs, builds and launches nothing.
+func TestPrintArgListEmitsTrailingCommaWhenModeAll(t *testing.T) {
+  file := parseTS(t, "process(aaaaaaaaa, bbbbbbbbb, ccccccccc);\n")
+  node := firstNodeOfKind(t, file, shimast.KindCallExpression)
+  opts := DefaultPrintOptions()
+  opts.PrintWidth = 20
+  opts.TrailingComma = "all"
+  ctx := NewPrintContext(file, opts)
+  doc, _ := printCallExpression(ctx, node)
+  got := Print(doc, ctx.Opts)
+  want := "process(\n  aaaaaaaaa,\n  bbbbbbbbb,\n  ccccccccc,\n)"
+  if got != want {
+    t.Fatalf("trailingComma=all call mismatch:\nwant %q\ngot  %q", want, got)
+  }
+}

package/linthost/print_arg_list_omits_trailing_comma_when_mode_es5_test.go

@@ -0,0 +1,39 @@
+package linthost
+
+import (
+  "testing"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+// TestPrintArgListOmitsTrailingCommaWhenModeEs5 verifies the broken
+// call-argument shape drops its trailing comma under
+// `trailingComma: "es5"`.
+//
+// Prettier's `es5` policy excludes call-argument trailing commas.
+// This entry explicitly selects that policy for an overflowing call
+// and checks the complete output, including the absent final comma.
+//
+//  1. Parse `process(aaaaaaaaa, bbbbbbbbb, ccccccccc);`.
+//  2. Print under PrintWidth=20 with TrailingComma="es5".
+//  3. Assert the rendered output ends the broken list with `ccccccccc\n)`
+//     — no trailing comma after the last argument.
+//
+// @evidence contracts/testing.md#behavioral-verification printCallExpression must break the long arguments without a final call comma under es5 policy.
+// @evidence contracts/testing.md#independent-expectations The literal output retains the callee and each argument; es5 excludes call-argument trailing commas independently of line width.
+// @evidence contracts/testing.md#distinguishing-cases The same overflowing call with es5 differs from all only in final punctuation; none is checked separately.
+// @evidence contracts/testing.md#execution-ownership TestPrintArgListOmitsTrailingCommaWhenModeEs5 is one Go unit entry that parses a call in-process with the TypeScript-Go parser, calls printCallExpression under PrintWidth 20 and TrailingComma es5, and renders the Doc with Print; it installs, builds and launches nothing.
+func TestPrintArgListOmitsTrailingCommaWhenModeEs5(t *testing.T) {
+  file := parseTS(t, "process(aaaaaaaaa, bbbbbbbbb, ccccccccc);\n")
+  node := firstNodeOfKind(t, file, shimast.KindCallExpression)
+  opts := DefaultPrintOptions()
+  opts.PrintWidth = 20
+  opts.TrailingComma = "es5"
+  ctx := NewPrintContext(file, opts)
+  doc, _ := printCallExpression(ctx, node)
+  got := Print(doc, ctx.Opts)
+  want := "process(\n  aaaaaaaaa,\n  bbbbbbbbb,\n  ccccccccc\n)"
+  if got != want {
+    t.Fatalf("trailingComma=es5 call mismatch:\nwant %q\ngot  %q", want, got)
+  }
+}

package/linthost/print_arg_list_omits_trailing_comma_when_mode_none_test.go

@@ -0,0 +1,39 @@
+package linthost
+
+import (
+  "testing"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+// TestPrintArgListOmitsTrailingCommaWhenModeNone verifies the broken
+// call-argument shape drops its trailing comma under
+// `trailingComma: "none"`.
+//
+// This entry explicitly selects the no-trailing-comma policy for one
+// overflowing call. It checks the complete result directly; other list
+// positions and command formatting cascades are outside this test.
+//
+//  1. Parse `process(aaaaaaaaa, bbbbbbbbb, ccccccccc);`.
+//  2. Print under PrintWidth=20 with TrailingComma="none".
+//  3. Assert the rendered output ends the broken list with `ccccccccc\n)`
+//     — no trailing comma after the last argument.
+//
+// @evidence contracts/testing.md#behavioral-verification printCallExpression must break the long argument list and omit a final comma under none policy.
+// @evidence contracts/testing.md#independent-expectations The full expected call source retains its three arguments and requires the explicit no-comma policy.
+// @evidence contracts/testing.md#distinguishing-cases None mode complements all and es5 on identical argument inputs.
+// @evidence contracts/testing.md#execution-ownership TestPrintArgListOmitsTrailingCommaWhenModeNone is one Go unit entry that parses a call in-process with the TypeScript-Go parser, calls printCallExpression under PrintWidth 20 and TrailingComma none, and renders the Doc with Print; it installs, builds and launches nothing.
+func TestPrintArgListOmitsTrailingCommaWhenModeNone(t *testing.T) {
+  file := parseTS(t, "process(aaaaaaaaa, bbbbbbbbb, ccccccccc);\n")
+  node := firstNodeOfKind(t, file, shimast.KindCallExpression)
+  opts := DefaultPrintOptions()
+  opts.PrintWidth = 20
+  opts.TrailingComma = "none"
+  ctx := NewPrintContext(file, opts)
+  doc, _ := printCallExpression(ctx, node)
+  got := Print(doc, ctx.Opts)
+  want := "process(\n  aaaaaaaaa,\n  bbbbbbbbb,\n  ccccccccc\n)"
+  if got != want {
+    t.Fatalf("trailingComma=none call mismatch:\nwant %q\ngot  %q", want, got)
+  }
+}

package/linthost/print_arg_list_returns_parens_for_nil_list_test.go

@@ -0,0 +1,30 @@
+package linthost
+
+import (
+  "testing"
+)
+
+// TestPrintArgListReturnsParensForNilList verifies that printArgList
+// returns the text `()` when given a nil NodeList.
+//
+// The direct nil-list path returns the empty delimiters without inspecting
+// argument elements. This entry supplies nil explicitly; the parsed source
+// only provides the PrintContext.
+//
+// 1. Call printArgList directly with a nil list pointer.
+// 2. Print the resulting Doc under default options.
+// 3. Assert the output is exactly `()`.
+//
+// @evidence contracts/testing.md#behavioral-verification printArgList must render the empty argument delimiters when its list is nil.
+// @evidence contracts/testing.md#independent-expectations The empty-call grammar requires the literal (), not missing punctuation or a stray comma.
+// @evidence contracts/testing.md#distinguishing-cases A nil argument list emits empty delimiters directly, complementing the nonempty flat/broken call cases.
+// @evidence contracts/testing.md#execution-ownership TestPrintArgListReturnsParensForNilList is one Go unit entry that parses a trivial source for a PrintContext, calls the unexported printArgList with a nil list and renders the Doc with Print in-process; it installs, builds and launches nothing.
+func TestPrintArgListReturnsParensForNilList(t *testing.T) {
+  file := parseTS(t, "foo();\n")
+  ctx := NewPrintContext(file, DefaultPrintOptions())
+  doc, _ := printArgList(ctx, nil, true, false, false)
+  got := Print(doc, ctx.Opts)
+  if got != "()" {
+    t.Fatalf("printArgList(nil): expected \"()\", got %q", got)
+  }
+}

package/linthost/print_call_expression_falls_back_verbatim_when_args_contain_nil_test.go

@@ -0,0 +1,43 @@
+package linthost
+
+import (
+  "testing"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+// TestPrintCallExpressionFallsBackVerbatimWhenArgsContainNil verifies that
+// printCallExpression emits verbatim source bytes when the argument list
+// contains a nil entry.
+//
+// hasNilEntry detects the deliberately malformed argument slice and selects
+// the verbatim node span. This entry checks the preserved source bytes rather
+// than attempting to reconstruct arguments from the injected nil child.
+//
+//  1. Parse `foo(a, b);` to get a real CallExpression.
+//  2. Inject a nil *Node into the Arguments.Nodes slice.
+//  3. Call printCallExpression and assert the output matches the verbatim
+//     source `foo(a, b)` (the fallback reproduces the original bytes).
+//
+// @evidence contracts/testing.md#behavioral-verification printCallExpression must preserve foo(a, b) when its public argument list contains a nil child.
+// @evidence contracts/testing.md#independent-expectations The independently authored parsed source supplies both binding names and punctuation; a corrupt reconstructed or empty call fails exact comparison.
+// @evidence contracts/testing.md#distinguishing-cases A malformed public child list complements absent-node safety and the intact flat call; private payload corruption is not required.
+// @evidence contracts/testing.md#execution-ownership TestPrintCallExpressionFallsBackVerbatimWhenArgsContainNil is one Go unit entry that parses a call in-process with the TypeScript-Go parser, replaces its argument slice with a single nil entry, calls printCallExpression and renders the Doc with Print; it installs, builds and launches nothing.
+func TestPrintCallExpressionFallsBackVerbatimWhenArgsContainNil(t *testing.T) {
+  src := "foo(a, b);\n"
+  file := parseTS(t, src)
+  node := firstNodeOfKind(t, file, shimast.KindCallExpression)
+  call := node.AsCallExpression()
+
+  // Inject a nil entry so hasNilEntry returns true.
+  call.Arguments.Nodes = []*shimast.Node{nil}
+
+  ctx := NewPrintContext(file, DefaultPrintOptions())
+  doc, _ := printCallExpression(ctx, node)
+  got := Print(doc, ctx.Opts)
+  // The verbatim fallback copies the original source bytes for the node.
+  // The node spans `foo(a, b)` (no trailing semicolon or newline).
+  if got != "foo(a, b)" {
+    t.Fatalf("verbatim fallback mismatch: %q", got)
+  }
+}

package/linthost/print_call_expression_includes_question_dot_token_test.go

@@ -0,0 +1,36 @@
+package linthost
+
+import (
+  "testing"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+// TestPrintCallExpressionIncludesQuestionDotToken verifies that an
+// optional-chain call (`foo?.(x)`) emits the `?.` token verbatim between
+// the callee and the argument list.
+//
+// The QuestionDotToken branch inside printCallExpression was uncovered by
+// the flat-/broken-call tests because those fixtures use ordinary calls
+// without the optional-chain syntax. A regression that silently dropped
+// `?.` would convert `foo?.(x)` to `foo(x)`, changing runtime behaviour
+// for nullish receivers.
+//
+// 1. Parse `foo?.(x);` — a CallExpression with a QuestionDotToken.
+// 2. Print under default options.
+// 3. Assert the output is `foo?.(x)`.
+//
+// @evidence contracts/testing.md#behavioral-verification printCallExpression must preserve the optional-call token in foo?.(x).
+// @evidence contracts/testing.md#independent-expectations The literal optional-call fixture supplies independently meaningful ?. punctuation; losing it changes conditional call behavior.
+// @evidence contracts/testing.md#distinguishing-cases The optional-call case complements the ordinary foo(a, b) flat call.
+// @evidence contracts/testing.md#execution-ownership TestPrintCallExpressionIncludesQuestionDotToken is one Go unit entry that parses an optional call in-process with the TypeScript-Go parser, calls printCallExpression and renders the Doc with Print; it installs, builds and launches nothing.
+func TestPrintCallExpressionIncludesQuestionDotToken(t *testing.T) {
+  file := parseTS(t, "foo?.(x);\n")
+  node := firstNodeOfKind(t, file, shimast.KindCallExpression)
+  ctx := NewPrintContext(file, DefaultPrintOptions())
+  doc, _ := printCallExpression(ctx, node)
+  got := Print(doc, ctx.Opts)
+  if got != "foo?.(x)" {
+    t.Fatalf("optional-chain call mismatch: %q", got)
+  }
+}

package/linthost/print_call_expression_includes_type_arguments_test.go

@@ -0,0 +1,34 @@
+package linthost
+
+import (
+  "testing"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+// TestPrintCallExpressionIncludesTypeArguments verifies that a call with
+// type arguments (`foo<A, B>(x)`) emits the `<A, B>` type-argument list
+// verbatim between the callee and the argument list.
+//
+// This fixture exercises the TypeArguments branch and its
+// typeArgsStart/typeArgsEnd boundaries with two explicit type arguments.
+// The full expected source distinguishes dropped names or delimiters.
+//
+// 1. Parse `foo<A, B>(x);` — a CallExpression with TypeArguments.
+// 2. Print under default options.
+// 3. Assert the output is `foo<A, B>(x)`.
+//
+// @evidence contracts/testing.md#behavioral-verification printCallExpression must retain both explicit type arguments in foo<A, B>(x).
+// @evidence contracts/testing.md#independent-expectations The source literal independently fixes generic argument names, order and delimiters as well as runtime x.
+// @evidence contracts/testing.md#distinguishing-cases A typed call complements ordinary and optional calls without type arguments.
+// @evidence contracts/testing.md#execution-ownership TestPrintCallExpressionIncludesTypeArguments is one Go unit entry that parses a generic call in-process with the TypeScript-Go parser, calls printCallExpression and renders the Doc with Print; it installs, builds and launches nothing.
+func TestPrintCallExpressionIncludesTypeArguments(t *testing.T) {
+  file := parseTS(t, "foo<A, B>(x);\n")
+  node := firstNodeOfKind(t, file, shimast.KindCallExpression)
+  ctx := NewPrintContext(file, DefaultPrintOptions())
+  doc, _ := printCallExpression(ctx, node)
+  got := Print(doc, ctx.Opts)
+  if got != "foo<A, B>(x)" {
+    t.Fatalf("type-argument call mismatch: %q", got)
+  }
+}

package/linthost/print_call_expression_returns_empty_for_nil_node_test.go

@@ -0,0 +1,29 @@
+package linthost
+
+import (
+  "testing"
+)
+
+// TestPrintCallExpressionReturnsEmptyForNilNode verifies that
+// printCallExpression returns an empty Doc when given a nil node.
+//
+// The nil guard at the top of printCallExpression (before the
+// AsCallExpression type assertion) prevents a nil-dereference panic
+// when a caller passes a nil AST node. Without that guard the type
+// assertion on n.data would panic before any other check could run.
+//
+// 1. Call printCallExpression with a nil node.
+// 2. Assert the returned Doc is the zero value (Kind == 0).
+//
+// @evidence contracts/testing.md#behavioral-verification printCallExpression must return the zero no-op Doc for an absent node.
+// @evidence contracts/testing.md#independent-expectations The missing-node identity contributes no expression; the zero Doc discriminant is part of the documented layout algebra.
+// @evidence contracts/testing.md#distinguishing-cases Nil node is the boundary opposite intact flat calls and malformed public child lists.
+// @evidence contracts/testing.md#execution-ownership TestPrintCallExpressionReturnsEmptyForNilNode is one Go unit entry that parses a trivial source for a PrintContext and calls the unexported printCallExpression with a nil node in-process; it installs, builds and launches nothing.
+func TestPrintCallExpressionReturnsEmptyForNilNode(t *testing.T) {
+  file := parseTS(t, "foo(a);\n")
+  ctx := NewPrintContext(file, DefaultPrintOptions())
+  got, _ := printCallExpression(ctx, nil)
+  if got.Kind != 0 {
+    t.Fatalf("expected empty Doc for nil node, got Doc.Kind=%d", got.Kind)
+  }
+}