@ttsc/lint 0.30.4 → 0.31.0

package/linthost/format_print_width_abstains_inside_template_substitution_test.go

@@ -0,0 +1,31 @@
+package linthost
+
+import "testing"
+
+// TestFormatPrintWidthAbstainsInsideTemplateSubstitution verifies the
+// rule leaves a call expression nested in a template-literal `${…}`
+// substitution byte-identical, never reflowing it across lines.
+//
+// Prettier renders template interpolations at printWidth:Infinity — it
+// only keeps a line break the source already had — so breaking a call
+// inside `${…}` would split the template and diverge from Prettier.
+// hasTemplateSubstitutionAncestor makes the rule abstain even when the
+// substitution's call would otherwise overflow the budget.
+//
+//  1. Configure printWidth=20 — the `${…}` call exceeds it.
+//  2. Feed a template literal whose substitution holds a call.
+//  3. Assert the rule reports nothing, leaving the template intact.
+//
+// @evidence contracts/testing.md#behavioral-verification The rule must leave the over-budget encodeURIComponent call inside the template substitution untouched, while the same call as an ordinary statement at width 20 must break and preserve the callee and value argument.
+// @evidence contracts/testing.md#independent-expectations The supported template policy keeps an originally flat interpolation intact, while the supported width and trailing-comma policy supplies the authored ordinary-call lines. The template contents /x/ and interpolation value are fixed input meaning, not expectations derived from the ancestor helper.
+// @evidence contracts/testing.md#distinguishing-cases The original template negative and ordinary-call positive differ by template ancestry, preventing an always-silent rule from satisfying this host. Existing multiline input behavior is owned by separate multiline and fixed-point tests; this host concerns an originally flat substitution.
+// @evidence contracts/testing.md#execution-ownership TestFormatPrintWidthAbstainsInsideTemplateSubstitution owns both literal cases through same-process registered-rule helpers and observes zero findings or complete rewritten source respectively. No installed consumer, native build or real host process is invoked.
+func TestFormatPrintWidthAbstainsInsideTemplateSubstitution(t *testing.T) {
+  assertRuleSkipsSourceWithOptions(
+    t,
+    "format/print-width",
+    "const u = `/x/${encodeURIComponent(value)}`;\n",
+    `{"printWidth": 20}`,
+  )
+  assertFixSnapshotWithOptions(t, "format/print-width", "encodeURIComponent(value);\n", `{"printWidth": 20}`, "encodeURIComponent(\n  value,\n);\n")
+}

package/linthost/format_print_width_abstains_when_callback_body_holds_uncovered_statement_test.go

@@ -0,0 +1,37 @@
+package linthost
+
+import "testing"
+
+// TestFormatPrintWidthAbstainsWhenCallbackBodyHoldsUncoveredStatement
+// verifies formatPrintWidth emits no edit when a reflow target buries
+// a multi-line node the dispatcher has no printer for.
+//
+// A statement the dispatcher has no printer for prints verbatim, and because it
+// spans several source lines its interior columns are frozen at whatever the
+// user wrote. Reflowing the enclosing call would re-indent everything around
+// that frozen slice and produce inconsistently indented output. The coverage
+// signal (`PrintNode`'s second return value) flips to false and the rule
+// abstains, leaving the file byte-identical. Abstaining is always safe; a
+// half-reflowed shape is corruption.
+//
+// The literal `do` statement has no structured dispatcher branch and spans
+// multiple lines, so its verbatim body makes the enclosing target uncovered.
+// This case asserts that current coverage boundary, not a historical printer
+// transition or a complete formatter's output.
+//
+//  1. Feed a `new` expression whose callback body holds a multi-line `do`
+//     statement.
+//  2. Run formatPrintWidth.
+//  3. Assert the rule reports zero findings — no edit, no diagnostic.
+//
+// @evidence contracts/testing.md#behavioral-verification Runs format/print-width (default options) on a `new Singleton(...)` whose arrow callback body holds a multi-line `do { ... } while (ready);` statement indented eight columns, and requires zero findings.
+// @evidence contracts/testing.md#independent-expectations The expected zero findings follows from the contract that the rule must abstain when a body holds a multi-line statement the printer would emit verbatim; it is an authored absence oracle, and the reflow of ordinary targets is verified by sibling tests.
+// @evidence contracts/testing.md#distinguishing-cases One abstention case where the enclosing call would otherwise be re-indented around a frozen multi-line `do` statement; no counterpart with a printable statement body is included here.
+// @evidence contracts/testing.md#execution-ownership In-process Go unit: calls assertRuleSkipsSource, which runs the engine with the single rule on a temp-dir file; no child process, built binary or installed consumer.
+func TestFormatPrintWidthAbstainsWhenCallbackBodyHoldsUncoveredStatement(t *testing.T) {
+  assertRuleSkipsSource(
+    t,
+    "format/print-width",
+    "const x = new Singleton(\n  () => {\n        do {\n          start();\n        } while (ready);\n  },\n);\n",
+  )
+}

package/linthost/format_print_width_abstains_when_inter_member_comment_present_test.go

@@ -0,0 +1,32 @@
+package linthost
+
+import "testing"
+
+// TestFormatPrintWidthAbstainsWhenInterMemberCommentPresent verifies
+// the rule does NOT reflow a node that carries comments between its
+// children.
+//
+// The v1 list printers join child docs with a freshly minted `,` and
+// have no slot for inter-sibling trivia. Reflowing the literal would
+// silently drop the comment — strictly worse than leaving the file
+// alone. The rule's safety check `hasNonChildComments` detects the
+// comment and abstains; the case feeds an object literal whose flat
+// width is well over `printWidth` and asserts the rule emits zero
+// findings.
+//
+//  1. Configure printWidth=10 (any non-trivial reflow would fire).
+//  2. Feed `const x = { aa: 1, /* keep */ bb: 2 };`.
+//  3. Assert the rule emits zero findings — the comment is preserved.
+//
+// @evidence contracts/testing.md#behavioral-verification Runs format/print-width at printWidth 10 on `const x = { aa: 1, /* keep */ bb: 2 };` and requires zero findings so the comment is not dropped by a reflow.
+// @evidence contracts/testing.md#independent-expectations The expected zero findings follows from the contract that reflow must never delete a comment between members; the source is an authored literal wide enough that a reflow would otherwise fire.
+// @evidence contracts/testing.md#distinguishing-cases One abstention case with a block comment between object members; a comment at the list edge is owned by the trailing-block-comment test and comment-free reflow by the reflow tests.
+// @evidence contracts/testing.md#execution-ownership In-process Go unit: calls assertRuleSkipsSourceWithOptions, which runs the engine with the single rule on a temp-dir file; no child process, built binary or installed consumer.
+func TestFormatPrintWidthAbstainsWhenInterMemberCommentPresent(t *testing.T) {
+  assertRuleSkipsSourceWithOptions(
+    t,
+    "format/print-width",
+    "const x = { aa: 1, /* keep */ bb: 2 };\n",
+    `{"printWidth": 10}`,
+  )
+}

package/linthost/format_print_width_abstains_when_trailing_block_comment_before_close_bracket_test.go

@@ -0,0 +1,35 @@
+package linthost
+
+import "testing"
+
+// TestFormatPrintWidthAbstainsWhenTrailingBlockCommentBeforeCloseBracket
+// verifies the rule abstains on a list whose last child carries a
+// trailing `/* … */` comment before the closing bracket.
+//
+// Trailing block comments live in the inter-child gap between
+// `lastChild.End()` and the closing token, which is exactly the
+// surface `hasNonChildComments` scans. Reflowing the list would
+// emit the close bracket immediately after the last child's render,
+// dropping the comment. The safety check must catch it. The
+// trailing-edge case is easy to miss because it does not look like
+// a "between-members" comment to a casual reader — it sits at the
+// edge of the list, not inside it.
+//
+//  1. Configure printWidth=10 so any reflow attempt would fire.
+//  2. Feed `foo(a, b /* tail */);` — comment sits after `b` and
+//     before `)`.
+//  3. Assert the rule emits zero findings — comment preserved by
+//     abstention.
+//
+// @evidence contracts/testing.md#behavioral-verification Runs format/print-width at printWidth 10 on `foo(a, b /* tail */);` and requires zero findings so the trailing comment before `)` is preserved.
+// @evidence contracts/testing.md#independent-expectations The expected zero findings follows from the contract that reflow must not drop a comment; the authored input exceeds the width so a reflow would otherwise fire.
+// @evidence contracts/testing.md#distinguishing-cases One abstention case with the comment after the last argument and before the closing bracket, the edge position that a between-members check could miss; a comment between members is owned by the inter-member test.
+// @evidence contracts/testing.md#execution-ownership In-process Go unit: calls assertRuleSkipsSourceWithOptions, which runs the engine with the single rule on a temp-dir file; no child process, built binary or installed consumer.
+func TestFormatPrintWidthAbstainsWhenTrailingBlockCommentBeforeCloseBracket(t *testing.T) {
+  assertRuleSkipsSourceWithOptions(
+    t,
+    "format/print-width",
+    "foo(a, b /* tail */);\n",
+    `{"printWidth": 10}`,
+  )
+}

package/linthost/format_print_width_breaks_array_rest_assignment_target_without_comma_test.go

@@ -0,0 +1,31 @@
+package linthost
+
+import "testing"
+
+// TestFormatPrintWidthBreaksArrayRestAssignmentTargetWithoutComma verifies
+// the reflow breaks an overflowing array destructuring assignment target
+// ending in a rest (`[a, ...rest] = arr`) WITHOUT appending a trailing comma.
+//
+// Arrays have no objectWrap:"preserve", so the suppression must be exercised
+// through a genuine width-driven break: the flat form overflows printWidth,
+// the reflow explodes it one element per line, and the printer's AddComma
+// would otherwise put a comma after the AssignmentRestElement (a syntax
+// error). The rest-target guard keeps the exploded shape valid.
+//
+// 1. Configure printWidth=20 and feed a single-line array rest target that overflows.
+// 2. Run formatPrintWidth so the array breaks one element per line.
+// 3. Assert the broken output has no trailing comma after the rest element.
+//
+// @evidence contracts/testing.md#behavioral-verification Applies format/print-width at printWidth 20 to `[alpha, ...restItems] = sourceArray;` and requires the exact output `[\n  alpha,\n  ...restItems\n] = sourceArray;\n` with no comma after the rest element.
+// @evidence contracts/testing.md#independent-expectations The expected text is an authored literal; a trailing comma after a rest element in an assignment target is a syntax error, so omitting it is required rather than derived from the printer.
+// @evidence contracts/testing.md#distinguishing-cases One changing case where a width-driven break would normally add a trailing comma; the rest-target guard distinguishes the valid output from `...restItems,`. Object-pattern rest targets are owned by a separate test.
+// @evidence contracts/testing.md#execution-ownership In-process Go unit: calls assertFixSnapshotWithOptions, applying the rule's edits to a temp-dir file; no child process, built binary or installed consumer.
+func TestFormatPrintWidthBreaksArrayRestAssignmentTargetWithoutComma(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/print-width",
+    "[alpha, ...restItems] = sourceArray;\n",
+    `{"printWidth": 20}`,
+    "[\n  alpha,\n  ...restItems\n] = sourceArray;\n",
+  )
+}

package/linthost/format_print_width_breaks_call_when_trailing_semicolon_overflows_test.go

@@ -0,0 +1,26 @@
+package linthost
+
+import "testing"
+
+// TestFormatPrintWidthBreaksCallWhenTrailingSemicolonOverflows charges the
+// statement suffix against the call budget. The flat call ends at column 26
+// and its semicolon lands at 27; ignoring the untouched suffix would miss
+// the required break at width 26.
+//
+//  1. Reflow the statement at width 26 and compare the complete argument layout.
+//  2. Preserve the same statement when width 27 admits its terminator.
+//
+// @evidence contracts/testing.md#behavioral-verification The owning rule must break run's arrow argument at width 26 while preserving v.ok, the declaration and semicolon. The same input at width 27 must remain silent.
+// @evidence contracts/testing.md#independent-expectations The supported call-layout policy breaks the argument list when the complete statement exceeds the budget. The input's call/declaration prefix is 26 columns and semicolon makes 27, so adjacent budgets test suffix charging independently of the helper implementation.
+// @evidence contracts/testing.md#distinguishing-cases Widths 26/27 with identical source distinguish suffix overflow from a fitting call. The trailing-line-comment host supplies an excluded comment suffix, while this host requires the real terminator to count.
+// @evidence contracts/testing.md#execution-ownership TestFormatPrintWidthBreaksCallWhenTrailingSemicolonOverflows owns both literal cases via same-process rule-engine helpers. This selected public Go unit starts no product process and builds or installs no artifact.
+func TestFormatPrintWidthBreaksCallWhenTrailingSemicolonOverflows(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/print-width",
+    "const x = run((v) => v.ok);\n",
+    `{"printWidth": 26}`,
+    "const x = run(\n  (v) => v.ok,\n);\n",
+  )
+  assertRuleSkipsSourceWithOptions(t, "format/print-width", "const x = run((v) => v.ok);\n", `{"printWidth": 27}`)
+}

package/linthost/format_print_width_breaks_default_plus_named_import_shape_test.go

@@ -0,0 +1,29 @@
+package linthost
+
+import "testing"
+
+// TestFormatPrintWidthBreaksDefaultPlusNamedImportShape verifies a
+// default-combined import now reflows. The whole declaration renders as one
+// group (Prefix `import D, ` + Suffix ` from "x"`), so an overflowing
+// `import D, { … } from "x"` breaks its named brace — the default binding
+// stays on the `import D, {` line. This literal complete-output oracle
+// protects that combined declaration layout without a historical result
+// or an installed reference-formatter invocation.
+//
+//  1. Configure printWidth=10 (forces the reflow).
+//  2. Feed `import D, { alpha, bravo, charlie } from "x";`.
+//  3. Assert the broken Prettier shape.
+//
+// @evidence contracts/testing.md#behavioral-verification The overflowing combined import must retain D on the import opening line and break alpha/bravo/charlie into the named clause, preserving the module and semicolon. Losing the default binding or splitting declaration ownership fails the full snapshot.
+// @evidence contracts/testing.md#independent-expectations The supported combined-import policy preserves the default binding prefix and module suffix around the broken named list. Print width is a layout preference rather than a hard guarantee for indivisible module/identifier text; the oracle preserves those tokens even when a line still exceeds ten.
+// @evidence contracts/testing.md#distinguishing-cases This host owns the combined default-and-named positive at a narrow budget. The named-only import host distinguishes an absent default prefix; the namespace negative owns the indivisible clause that must not be split.
+// @evidence contracts/testing.md#execution-ownership TestFormatPrintWidthBreaksDefaultPlusNamedImportShape owns the options-bearing literal fixture and complete applied output through the in-process Go rule engine. No consumer import, native artifact production or product process is required.
+func TestFormatPrintWidthBreaksDefaultPlusNamedImportShape(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/print-width",
+    "import D, { alpha, bravo, charlie } from \"x\";\n",
+    `{"printWidth": 10}`,
+    "import D, {\n  alpha,\n  bravo,\n  charlie,\n} from \"x\";\n",
+  )
+}

package/linthost/format_print_width_breaks_long_call_arguments_test.go

@@ -0,0 +1,31 @@
+package linthost
+
+import "testing"
+
+// TestFormatPrintWidthBreaksLongCallArguments verifies the rule reflows
+// a long call expression by placing each argument on its own line.
+//
+// Call expressions exercise a different path through the dispatcher
+// than object literals: the printer first emits the callee verbatim
+// and then defers to the shared list printer for arguments. A
+// regression in that glue would either lose the callee, duplicate it,
+// or produce a malformed paren pair.
+//
+//  1. Configure printWidth=24.
+//  2. Feed `process(aaaaaa, bbbbbb, cccccc);`.
+//  3. Assert each argument occupies its own indented line with a
+//     trailing comma after the last.
+//
+// @evidence contracts/testing.md#behavioral-verification Applies format/print-width at printWidth 24 to `process(aaaaaa, bbbbbb, cccccc);` and requires the exact output with each argument on its own two-space-indented line and a trailing comma after the last.
+// @evidence contracts/testing.md#independent-expectations The expected text is an authored literal for a width-24 break of three short arguments; the callee, arguments and punctuation are preserved and nothing is derived from the printer.
+// @evidence contracts/testing.md#distinguishing-cases One changing case through the call-arguments path of the printer (a different path from object literals), where a lost callee, duplicated callee or malformed parentheses would change the output text; a fitting call is not included here.
+// @evidence contracts/testing.md#execution-ownership In-process Go unit: calls assertFixSnapshotWithOptions, applying the rule's edits to a temp-dir file; no child process, built binary or installed consumer.
+func TestFormatPrintWidthBreaksLongCallArguments(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/print-width",
+    "process(aaaaaa, bbbbbb, cccccc);\n",
+    `{"printWidth": 24}`,
+    "process(\n  aaaaaa,\n  bbbbbb,\n  cccccc,\n);\n",
+  )
+}

package/linthost/format_print_width_breaks_long_named_exports_test.go

@@ -0,0 +1,30 @@
+package linthost
+
+import "testing"
+
+// TestFormatPrintWidthBreaksLongNamedExports verifies `export { … };`
+// local exports reflow when the clause overflows the budget.
+//
+// NamedExports shares listShape with NamedImports, but the surrounding
+// declaration is different (no `from` clause when exporting from
+// the local scope). The case keeps NamedExports honest by exercising
+// the standalone form, since a regression specific to NamedExports
+// wouldn't surface through the import-side tests.
+//
+//  1. Configure printWidth=20.
+//  2. Feed `export { alpha, bravo, charlie };`.
+//  3. Assert the rewrite breaks the specifier clause across lines.
+//
+// @evidence contracts/testing.md#behavioral-verification The print-width rule must break a local named export at width 20 without losing any export name, its order or its terminator. The complete output also detects accidentally adding an import-like from clause.
+// @evidence contracts/testing.md#independent-expectations The supported named-list layout breaks these local export specifiers when the complete declaration exceeds the budget. The literal retains the original local bindings and no module source, following the fixture syntax rather than the owning renderer.
+// @evidence contracts/testing.md#distinguishing-cases This host owns the overflowing local named-export form, distinct from named imports that carry a module suffix. Short and already formatted targets are covered by the exact-fit and fixed-point hosts; this case is a required transformation.
+// @evidence contracts/testing.md#execution-ownership TestFormatPrintWidthBreaksLongNamedExports is a selected public Go unit invoking the owning registered rule and full applied-output helper in one process. Its local export need not resolve actual exported values for syntax-layout verification.
+func TestFormatPrintWidthBreaksLongNamedExports(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/print-width",
+    "export { alpha, bravo, charlie };\n",
+    `{"printWidth": 20}`,
+    "export {\n  alpha,\n  bravo,\n  charlie,\n};\n",
+  )
+}

package/linthost/format_print_width_breaks_long_named_imports_test.go

@@ -0,0 +1,30 @@
+package linthost
+
+import "testing"
+
+// TestFormatPrintWidthBreaksLongNamedImports verifies a wide
+// `import { … } from "x";` declaration reflows to a multi-line clause.
+//
+// The ImportDeclaration printer owns the keyword, named-list brackets,
+// `from`, module specifier and semicolon in one list group. The nested
+// NamedImports target does not fire separately. Dropping either the
+// module suffix or the named brackets would change the complete literal
+// oracle, which preserves every binding and declaration token.
+//
+//  1. Configure printWidth=30.
+//  2. Feed `import { alpha, bravo, charlie } from "x";`.
+//  3. Assert the rewrite is the canonical broken clause.
+//
+// @evidence contracts/testing.md#behavioral-verification The rule must break the three named bindings at width 30 while preserving their order, the from clause, module string and semicolon. Complete output equality detects lost bindings or declaration punctuation.
+// @evidence contracts/testing.md#independent-expectations The supported named-import layout breaks its specifier list while preserving the module suffix; the complete expected identifiers, punctuation and module are authored directly from the fixture, not reconstructed from the printer.
+// @evidence contracts/testing.md#distinguishing-cases This host owns the named-only overflowing import. The default-plus-named host owns its additional binding prefix, and the namespace host supplies a long but indivisible no-reflow alternative.
+// @evidence contracts/testing.md#execution-ownership TestFormatPrintWidthBreaksLongNamedImports owns one complete source rewrite through the registered rule engine, fixture parser and fix applier in the Go test process. No installed consumer, native build or real host child participates.
+func TestFormatPrintWidthBreaksLongNamedImports(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/print-width",
+    "import { alpha, bravo, charlie } from \"x\";\n",
+    `{"printWidth": 30}`,
+    "import {\n  alpha,\n  bravo,\n  charlie,\n} from \"x\";\n",
+  )
+}

package/linthost/format_print_width_breaks_long_new_expression_arguments_test.go

@@ -0,0 +1,31 @@
+package linthost
+
+import "testing"
+
+// TestFormatPrintWidthBreaksLongNewExpressionArguments verifies the
+// rule reflows `new Foo(a, b, c)` when the flat form overflows.
+//
+// NewExpression travels a sibling-but-distinct path through the
+// dispatcher from CallExpression: it prepends `new ` and has an
+// optional argument list. This present-arguments fixture protects the
+// constructor prefix and the argument-list join; it does not exercise
+// an absent argument list. The keyword must survive while arguments break.
+//
+//  1. Configure printWidth=20.
+//  2. Feed `new Foo(aaaaaa, bbbbbb, cccccc);`.
+//  3. Assert the rewrite keeps `new Foo(` on the head line and breaks
+//     the arguments onto indented lines with trailing comma.
+//
+// @evidence contracts/testing.md#behavioral-verification Applies format/print-width at printWidth 20 to `new Foo(aaaaaa, bbbbbb, cccccc);` and requires the exact output `new Foo(` followed by three indented arguments with a trailing comma and `);`.
+// @evidence contracts/testing.md#independent-expectations The expected text is an authored literal; the `new` keyword, constructor name, arguments and punctuation are preserved and nothing is derived from the printer.
+// @evidence contracts/testing.md#distinguishing-cases One changing case through the NewExpression path (keyword glue plus the argument list), the `new` counterpart of the call-arguments case; a fitting `new` call is not included here.
+// @evidence contracts/testing.md#execution-ownership In-process Go unit: calls assertFixSnapshotWithOptions, applying the rule's edits to a temp-dir file; no child process, built binary or installed consumer.
+func TestFormatPrintWidthBreaksLongNewExpressionArguments(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/print-width",
+    "new Foo(aaaaaa, bbbbbb, cccccc);\n",
+    `{"printWidth": 20}`,
+    "new Foo(\n  aaaaaa,\n  bbbbbb,\n  cccccc,\n);\n",
+  )
+}

package/linthost/format_print_width_breaks_long_object_literal_test.go

@@ -0,0 +1,27 @@
+package linthost
+
+import "testing"
+
+// TestFormatPrintWidthBreaksLongObjectLiteral pins a complete object rewrite
+// when its 34-column statement exceeds printWidth=20. Every key/value stays
+// in order; indentation and the last-member comma distinguish a real layout
+// correction from deletion or a skipped rewrite.
+//
+//  1. Reflow the three-property statement at width 20.
+//  2. Compare the complete two-space vertical output.
+//  3. Retain the same canonical statement at its exact width of 34.
+//
+// @evidence contracts/testing.md#behavioral-verification The rule must break the three-property object at width 20 without changing aa/bb/cc values or their order; the same source at width 34 must produce no finding.
+// @evidence contracts/testing.md#independent-expectations The supported object-list layout breaks these three properties when their complete statement exceeds the budget. The authored statement has 34 columns including its semicolon; the silent boundary is counted from that input, not the rule's measurement.
+// @evidence contracts/testing.md#distinguishing-cases Identical source at widths 20 and 34 distinguishes overflow from exact-fit behavior. The complete positive output pins indent, member separators and statement termination; the default-width host owns no-options 80/81 limits.
+// @evidence contracts/testing.md#execution-ownership TestFormatPrintWidthBreaksLongObjectLiteral owns its configured rewrite and exact-fit negative through the in-process rule engine and literal source fixtures. It is a selected public Go unit, with no install, native build or product-host child.
+func TestFormatPrintWidthBreaksLongObjectLiteral(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/print-width",
+    "const x = { aa: 1, bb: 2, cc: 3 };\n",
+    `{"printWidth": 20}`,
+    "const x = {\n  aa: 1,\n  bb: 2,\n  cc: 3,\n};\n",
+  )
+  assertRuleSkipsSourceWithOptions(t, "format/print-width", "const x = { aa: 1, bb: 2, cc: 3 };\n", `{"printWidth": 34}`)
+}

package/linthost/format_print_width_breaks_overflowing_react_hook_deps_array_test.go

@@ -0,0 +1,29 @@
+package linthost
+
+import "testing"
+
+// TestFormatPrintWidthBreaksOverflowingReactHookDepsArray verifies the negative
+// twin of the first-argument deps-array hug: when the deps array overflows the close
+// line, the supported hook layout keeps the callback hugged and the deps array
+// one element per line. The short-deps changing companion owns the nearby
+// flat-array layout; this command fixture pins only the broken fixed point.
+//
+//  1. Seed a `useEffect` call whose callback is hugged and whose deps array is
+//     already broken one element per line.
+//  2. Run `ttsc format` with the default format block.
+//  3. Require the file byte-identical.
+//
+// @evidence contracts/testing.md#behavioral-verification Runs the in-process `format` command on a `useEffect(() => {...}, [...])` call whose callback body is hugged and whose deps array is already broken one element per line (the flat array would overflow), and requires the file byte-identical.
+// @evidence contracts/testing.md#independent-expectations The supported hook layout keeps the block callback attached and preserves an overflowing dependency array on separate lines. The complete authored source is its own expected output; this fixed point does not show a flat input changing or certify an installed formatter result.
+// @evidence contracts/testing.md#distinguishing-cases This fixed-point case rejects exploding the call or flattening its overflowing array. Alone it cannot reject a formatter that does nothing; HugsFirstCallbackWithArrayArg separately requires a changed callback layout with a short array.
+// @evidence contracts/testing.md#execution-ownership In-process Go unit: calls run with the format subcommand on a temp-dir project via assertFormatUnchanged; no child process, built binary or installed consumer.
+func TestFormatPrintWidthBreaksOverflowingReactHookDepsArray(t *testing.T) {
+  assertFormatUnchanged(t, `useEffect(() => {
+  doSomethingWithTheValues();
+}, [
+  firstDependencyValueHere,
+  secondDependencyValueHere,
+  thirdDependencyValueHere,
+]);
+`)
+}

package/linthost/format_print_width_check_abstains_when_ctx_is_nil_test.go

@@ -0,0 +1,24 @@
+package linthost
+
+import "testing"
+
+// TestFormatPrintWidthCheckAbstainsWhenCtxIsNil verifies the Check method
+// returns immediately without panicking when ctx is nil.
+//
+// Locks the nil-guard at the top of Check. The rule is invoked by the engine
+// dispatch loop which guarantees a non-nil context, but the guard exists as a
+// safety net for callers that invoke Check directly (tests, future tooling).
+// Without the guard a nil-pointer dereference would crash the process.
+//
+//  1. Call Check directly with a nil *Context.
+//  2. Assert the call returns without panicking.
+//
+// @evidence contracts/testing.md#behavioral-verification formatPrintWidth.Check must safely return when its Context is absent rather than attempting AST or source access.
+// @evidence contracts/testing.md#independent-expectations The direct-call safety contract admits a nil Context; normal return is the observable oracle because there is no context or collector to receive findings.
+// @evidence contracts/testing.md#distinguishing-cases This missing-context guard complements real-context nil-node and invalid-source-range checks; only the nil/nil input executes here and no finding-count assertion is claimed.
+// @evidence contracts/testing.md#execution-ownership TestFormatPrintWidthCheckAbstainsWhenCtxIsNil is selected as a public Go unit by the lint semantic-unit Evidence claim; its local cases call the owning operation in the shared process without a consumer install, native artifact build or product host.
+func TestFormatPrintWidthCheckAbstainsWhenCtxIsNil(t *testing.T) {
+  var rule formatPrintWidth
+  // Must not panic — the nil guard returns immediately.
+  rule.Check(nil, nil)
+}

package/linthost/format_print_width_check_abstains_when_node_is_nil_test.go

@@ -0,0 +1,48 @@
+package linthost
+
+import (
+  "path/filepath"
+  "testing"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+// TestFormatPrintWidthCheckAbstainsWhenNodeIsNil verifies that passing a nil
+// node to Check does not panic and emits no findings.
+//
+// The nil-guard `if ctx == nil || ctx.File == nil || node == nil` at the top of
+// Check covers the nil-ctx, nil-File, and nil-node cases in a single condition.
+// This host exercises nil node and nil File; a sibling exercises nil Context.
+// Without those guards direct invocation could dereference absent state.
+//
+//  1. Parse a minimal source to obtain a real SourceFile.
+//  2. Construct a Context with the parsed file.
+//  3. Call Check with a nil *shimast.Node.
+//  4. Assert no panic or finding occurs.
+//  5. Call Check with a parsed node but absent File and assert the same result.
+//
+// @evidence contracts/testing.md#behavioral-verification formatPrintWidth.Check must return without panicking or collecting a finding for a nil node in a real source context and for a parsed node when Context.File is absent.
+// @evidence contracts/testing.md#independent-expectations The absent-node safety contract requires an empty finding population; a collector observes any unexpected emission.
+// @evidence contracts/testing.md#distinguishing-cases This host executes nil node and absent File arms; nil Context and out-of-range source guards have separate hosts.
+// @evidence contracts/testing.md#execution-ownership TestFormatPrintWidthCheckAbstainsWhenNodeIsNil is a public Go unit selected by the lint semantic-unit Evidence claim. It calls Check directly with isolated fixture source and a collector, without installing a consumer or starting a host.
+func TestFormatPrintWidthCheckAbstainsWhenNodeIsNil(t *testing.T) {
+  root := t.TempDir()
+  filePath := filepath.Join(root, "src", "main.ts")
+  source := "const x = 1;\n"
+  writeFile(t, filePath, source)
+  file := parseTSFile(t, filePath, source)
+  var findings []*Finding
+  ctx := &Context{File: file, Severity: SeverityError, collect: func(f *Finding) { findings = append(findings, f) }}
+  var rule formatPrintWidth
+  var node *shimast.Node
+  // Must not panic — the nil-node arm of the guard fires and returns.
+  rule.Check(ctx, node)
+  if len(findings) != 0 {
+    t.Fatalf("nil node must emit no findings, got %d", len(findings))
+  }
+  missingFile := &Context{Severity: SeverityError, collect: func(f *Finding) { findings = append(findings, f) }}
+  rule.Check(missingFile, file.AsNode())
+  if len(findings) != 0 {
+    t.Fatalf("absent File must emit no findings, got %d", len(findings))
+  }
+}

package/linthost/format_print_width_check_abstains_when_node_range_exceeds_context_source_test.go

@@ -0,0 +1,71 @@
+package linthost
+
+import (
+  "path/filepath"
+  "testing"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+// TestFormatPrintWidthCheckAbstainsWhenNodeRangeExceedsContextSource verifies
+// Check returns without emitting a finding when the node's byte range falls
+// outside the Context's source string.
+//
+// Locks the safety guard `if start < 0 || end <= start || end > len(src)` in
+// Check. The guard defends against a mismatch between the context's source
+// file and the visiting node: if the node's End offset exceeds the source
+// length, slicing src[start:end] would panic. The guard makes the rule
+// byte-safe even when caller invariants are violated.
+//
+// The scenario uses two parsed files: a short one (file1) and a longer one
+// (file2). A node from file2 whose End offset exceeds len(file1.Text()) is
+// passed to Check with a context wired to file1. The `end > len(src)` branch
+// fires and Check returns without emitting a finding.
+//
+//  1. Parse a short file (file1, 13 bytes) as the context's source.
+//  2. Parse a longer file (file2, 46 bytes) and locate an object literal
+//     whose End offset overflows file1's byte length.
+//  3. Call Check directly with ctx.File=file1, node from file2.
+//  4. Assert no findings are collected (the guard fires and returns early).
+//
+// @evidence contracts/testing.md#behavioral-verification formatPrintWidth.Check must abstain when a parsed object ends beyond the separate context source length.
+// @evidence contracts/testing.md#independent-expectations The independently constructed short and long source literals establish the invalid range; zero findings is the safety contract.
+// @evidence contracts/testing.md#distinguishing-cases The fixture range is required rather than skipped if construction changes; valid reflows and other missing-context guards live in sibling cases.
+// @evidence contracts/testing.md#execution-ownership TestFormatPrintWidthCheckAbstainsWhenNodeRangeExceedsContextSource is a public Go unit selected by the lint semantic-unit Evidence claim. It calls Check directly with isolated fixture source and a collector, without installing a consumer or starting a host.
+func TestFormatPrintWidthCheckAbstainsWhenNodeRangeExceedsContextSource(t *testing.T) {
+  root := t.TempDir()
+
+  // file1 is short — 13 bytes total.
+  file1Path := filepath.Join(root, "short.ts")
+  file1Src := "const x = 1;\n"
+  writeFile(t, file1Path, file1Src)
+  file1 := parseTSFile(t, file1Path, file1Src)
+
+  // file2 is longer; its object literal's End offset exceeds len(file1Src).
+  file2Path := filepath.Join(root, "long.ts")
+  file2Src := "const y = { alpha: 1, bravo: 2, charlie: 3 };\n"
+  writeFile(t, file2Path, file2Src)
+  file2 := parseTSFile(t, file2Path, file2Src)
+
+  node := firstNodeOfKind(t, file2, shimast.KindObjectLiteralExpression)
+  if node.End() <= len(file1Src) {
+    t.Fatalf("fixture must exceed the context source: file2 node End=%d does not exceed len(file1)=%d", node.End(), len(file1Src))
+  }
+
+  // Build a context pointing at file1 but visiting a node from file2.
+  // The guard end > len(src) must fire — no findings expected.
+  var collected []*Finding
+  ctx := &Context{
+    File:     file1,
+    Severity: SeverityError,
+    rule:     formatPrintWidth{},
+    collect:  func(f *Finding) { collected = append(collected, f) },
+  }
+
+  var rule formatPrintWidth
+  rule.Check(ctx, node)
+
+  if len(collected) != 0 {
+    t.Fatalf("expected zero findings when node range exceeds source; got %d", len(collected))
+  }
+}

package/linthost/format_print_width_declines_last_arg_hug_after_arrow_lead_test.go

@@ -0,0 +1,29 @@
+package linthost
+
+import "testing"
+
+// TestFormatPrintWidthDeclinesLastArgHugAfterArrowLead verifies last-argument
+// hugging declines when a leading argument is an arrow with an expression
+// body. The supported two-argument arrow-and-array layout explodes the
+// arguments rather than hugging the trailing array. This expression-body
+// arrow carries no hard break, so the hard-break guard alone does not select
+// that decision; the dedicated arrow-and-array shape guard does.
+//
+//  1. Parse a useMemo call whose first arg is an expression-body arrow and
+//     last arg is an array, overflowing 80.
+//  2. Apply format/print-width.
+//  3. Assert both arguments explode onto their own lines.
+//
+// @evidence contracts/testing.md#behavioral-verification The registered format/print-width rule parses the declines last arg hug after arrow lead fixture and applies its edit; complete authored output equality rejects lost source content or punctuation alongside incorrect line layout. The owned result is: Assert both arguments explode onto their own lines.
+// @evidence contracts/testing.md#independent-expectations The source operands and literal expected layout are authored independently of the rule printer. The fixture fixes printWidth and indentation, so expected line placement does not come from rendering the implementation under test.
+// @evidence contracts/testing.md#distinguishing-cases One changing case where a leading expression-bodied arrow (which has no hard break) must still stop the trailing array from being hugged; the output explodes both arguments, whereas hugging would keep `[dependencyOneHere, ...]` on the call line.
+// @evidence contracts/testing.md#execution-ownership TestFormatPrintWidthDeclinesLastArgHugAfterArrowLead is one Go unit entry through the registered rule engine, parser and fix applier; it uses no installed consumer or child product host.
+func TestFormatPrintWidthDeclinesLastArgHugAfterArrowLead(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/print-width",
+    "useMemo(() => computeExpensiveValueHere(), [dependencyOneHere, dependencyTwoHere]);\n",
+    `{"printWidth":80,"tabWidth":2}`,
+    "useMemo(\n  () => computeExpensiveValueHere(),\n  [dependencyOneHere, dependencyTwoHere],\n);\n",
+  )
+}

package/linthost/format_print_width_declines_last_arg_hug_after_callback_test.go

@@ -0,0 +1,28 @@
+package linthost
+
+import "testing"
+
+// TestFormatPrintWidthDeclinesLastArgHugAfterCallback verifies last-argument
+// hugging declines when a leading argument is a block-bodied callback. The
+// callback has a nonempty block body, so this supported plain-call layout
+// places each argument on its own line instead of hugging the trailing
+// object literal. The fixture owns this two-argument shape.
+//
+//  1. Parse a call whose first argument is a block callback and whose last
+//     is an object literal, overflowing 80.
+//  2. Apply format/print-width.
+//  3. Assert both arguments explode onto their own indented lines.
+//
+// @evidence contracts/testing.md#behavioral-verification The registered format/print-width rule parses the declines last arg hug after callback fixture and applies its edit; complete authored output equality rejects lost source content or punctuation alongside incorrect line layout. The owned result is: Assert both arguments explode onto their own indented lines.
+// @evidence contracts/testing.md#independent-expectations The source operands and literal expected layout are authored independently of the rule printer. The fixture fixes printWidth and indentation, so expected line placement does not come from rendering the implementation under test.
+// @evidence contracts/testing.md#distinguishing-cases One changing case where a leading block-bodied callback must stop the trailing object from being hugged; the output explodes both arguments with the object kept flat on its own line, whereas hugging would attach the object to the closing of the callback.
+// @evidence contracts/testing.md#execution-ownership TestFormatPrintWidthDeclinesLastArgHugAfterCallback is one Go unit entry through the registered rule engine, parser and fix applier; it uses no installed consumer or child product host.
+func TestFormatPrintWidthDeclinesLastArgHugAfterCallback(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/print-width",
+    "registerHandlerForSomething(() => { doThing(); doMoreStuff(); }, { key: 1, other: 2 });\n",
+    `{"printWidth":80,"tabWidth":2}`,
+    "registerHandlerForSomething(\n  () => {\n    doThing();\n    doMoreStuff();\n  },\n  { key: 1, other: 2 },\n);\n",
+  )
+}