@ttsc/lint 0.30.4 → 0.31.0

package/linthost/format_print_width_default_width_is_80_columns_test.go

@@ -0,0 +1,31 @@
+package linthost
+
+import "testing"
+
+// TestFormatPrintWidthDefaultWidthIs80Columns verifies the rule uses
+// 80 columns when no `printWidth` option is supplied.
+//
+// 80 is the Prettier default and the most common project setting; it
+// is what the rule advertises in `ITtscLintFormat.printWidth`.
+// The case feeds an input crafted to be 85 characters
+// flat — long enough that the default budget must reject it. A
+// regression that defaulted to 0 or omitted the fallback would let
+// the rule pass through unchanged.
+//
+//  1. Feed an object literal whose flat statement is 85 chars wide.
+//  2. Run the rule with NO options blob (severity-only).
+//  3. Assert the reflow lands.
+//  4. Compare authored 80/81-column twins to pin the exact default boundary.
+//
+// @evidence contracts/testing.md#behavioral-verification The original 85-column object must break with no options. An independently authored exact-80 statement must remain silent and its one-column-longer twin must break while preserving all properties and values.
+// @evidence contracts/testing.md#independent-expectations Official Prettier and the supported formatter contract default to eighty columns. Independently counted authored 80/81-column statements supply the unchanged/broken boundary expectations without an installed reference invocation. Literal full outputs preserve each value/property and statement suffix.
+// @evidence contracts/testing.md#distinguishing-cases The no-options 85-column positive is retained, and 80/81 twins distinguish the exact default threshold rather than any unspecified small budget. Custom-width and short-object hosts supply other options.
+// @evidence contracts/testing.md#execution-ownership TestFormatPrintWidthDefaultWidthIs80Columns owns its original no-options snapshot plus exact-threshold silent input and complete-output overflow twin in the selected public Go unit population. Owning operations, engine and fixture observations execute in one Go process without native builds, consumer installation or real product-host children.
+func TestFormatPrintWidthDefaultWidthIs80Columns(t *testing.T) {
+  // 85-char statement (counted manually).
+  src := "const x = { alpha: 1, bravo: 2, charlie: 3, delta: 4, echo: 5, foxtrot: 6, golf: 7 };\n"
+  want := "const x = {\n  alpha: 1,\n  bravo: 2,\n  charlie: 3,\n  delta: 4,\n  echo: 5,\n  foxtrot: 6,\n  golf: 7,\n};\n"
+  assertFixSnapshot(t, "format/print-width", src, want)
+  assertRuleSkipsSource(t, "format/print-width", "const x = { alpha: 1, bravo: 2, charlie: 3, delta: 4, echooooo: 5, foxtrot: 6 };\n")
+  assertFixSnapshot(t, "format/print-width", "const x = { alpha: 1, bravo: 2, charlie: 3, delta: 4, echoooooo: 5, foxtrot: 6 };\n", "const x = {\n  alpha: 1,\n  bravo: 2,\n  charlie: 3,\n  delta: 4,\n  echoooooo: 5,\n  foxtrot: 6,\n};\n")
+}

package/linthost/format_print_width_explodes_call_when_hugged_header_overflows_test.go

@@ -0,0 +1,26 @@
+package linthost
+
+import "testing"
+
+// TestFormatPrintWidthExplodesCallWhenHuggedHeaderOverflows exercises the
+// rule-level callback layout in one process. A hugged header with both leading
+// arguments exceeds width 30, so the complete output must put each argument
+// on its own line and preserve the callback's run statement.
+//
+//  1. Configure printWidth=30.
+//  2. Reflow register with two leading arguments and a block callback.
+//  3. Compare every argument, callback line and closing delimiter.
+//
+// @evidence contracts/testing.md#behavioral-verification The registered print-width rule must choose the exploded call rather than an overflowing hugged header, retaining alphaArg, betaArg, the callback and its run() body in order.
+// @evidence contracts/testing.md#independent-expectations The supported call-layout policy uses the exploded argument list when its hugged opening line cannot fit the configured budget. Literal equality catches missing arguments, body changes, incorrect commas or a still-flat header.
+// @evidence contracts/testing.md#distinguishing-cases This positive owns a callback header that cannot fit with preceding arguments. TestFormatPrintWidthKeepsShortCallWithCallbackHugged supplies the fitting hugged alternative; printer-level callback tests own individual document choices.
+// @evidence contracts/testing.md#execution-ownership TestFormatPrintWidthExplodesCallWhenHuggedHeaderOverflows reaches the rule through the same-process engine and snapshot helper. It is a public selected unit entry, not an installed CLI or real-host E2E execution.
+func TestFormatPrintWidthExplodesCallWhenHuggedHeaderOverflows(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/print-width",
+    "register(alphaArg, betaArg, () => { run(); });\n",
+    `{"printWidth": 30}`,
+    "register(\n  alphaArg,\n  betaArg,\n  () => {\n    run();\n  },\n);\n",
+  )
+}

package/linthost/format_print_width_hangs_broken_ternary_arm_under_arm_column_test.go

@@ -0,0 +1,40 @@
+package linthost
+
+import "testing"
+
+// TestFormatPrintWidthHangsBrokenTernaryArmUnderArmColumn verifies that a
+// ternary arm which breaks internally hangs its continuation under the arm
+// expression's own column (one level past the `? ` marker), not under the
+// chain's rung indent. Matches Prettier 3.8.3: the broken call's arguments
+// indent from `props.reduce(`, and its closing paren returns to that arm
+// column.
+//
+//  1. Parse a return whose consequent is a call that overflows printWidth 80.
+//  2. Apply format/print-width.
+//  3. Assert the arguments hang at the arm column + one level and the close
+//     paren sits at the arm column.
+//
+// @evidence contracts/testing.md#behavioral-verification assertFixSnapshotWithOptions runs the registered format/print-width rule (printWidth 80, tabWidth 2) over a return whose ternary consequent `props.reduce(...)` exceeds the width, applies the collected fix to a real temp file and compares the whole file with an authored string: the call arguments sit at 8 spaces (arm column 6 plus one level) with a trailing comma, the closing paren returns to column 6, and the alternate `: props` is untouched.
+// @evidence contracts/testing.md#independent-expectations The expected text is a hand-written Prettier-style layout with literal indentation; printWidth and tabWidth are fixed in the options JSON, so the column arithmetic comes from the authored literal and not from the printer under test.
+// @evidence contracts/testing.md#distinguishing-cases One positive case only: an overflowing consequent call under a rung that must not receive the chain indent. The short alternate arm stays on its own line as the unchanged part; no non-overflowing ternary or other arm shape is checked here.
+// @evidence contracts/testing.md#execution-ownership TestFormatPrintWidthHangsBrokenTernaryArmUnderArmColumn is one Go unit entry that builds the format/print-width engine, parses the source in-process and applies the fix through applyFindingFixes to a t.TempDir file; it installs no consumer and starts no child host.
+func TestFormatPrintWidthHangsBrokenTernaryArmUnderArmColumn(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/print-width",
+    "function f() {\n"+
+      "  return isArray(props)\n"+
+      "    ? props.reduce((normalized, p) => ((normalized[p] = null), normalized), {} as ComponentObjectPropsOptions | ObjectEmitsOptions)\n"+
+      "    : props;\n"+
+      "}\n",
+    `{"printWidth":80,"tabWidth":2}`,
+    "function f() {\n"+
+      "  return isArray(props)\n"+
+      "    ? props.reduce(\n"+
+      "        (normalized, p) => ((normalized[p] = null), normalized),\n"+
+      "        {} as ComponentObjectPropsOptions | ObjectEmitsOptions,\n"+
+      "      )\n"+
+      "    : props;\n"+
+      "}\n",
+  )
+}

package/linthost/format_print_width_has_non_child_comments_returns_false_when_node_is_nil_test.go

@@ -0,0 +1,46 @@
+package linthost
+
+import (
+  "testing"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+// TestFormatPrintWidthHasNonChildCommentsReturnsFalseWhenNodeIsNil verifies
+// hasNonChildComments returns false immediately for a nil node without panicking.
+//
+// Locks the `if node == nil { return false }` guard at the top of
+// hasNonChildComments. This direct call must return before attempting child
+// traversal through an absent receiver.
+//
+//  1. Call hasNonChildComments(nil, "source", 0, 6).
+//  2. Assert the return value is false and no panic occurred.
+//
+// @evidence contracts/testing.md#behavioral-verification hasNonChildComments must identify a real sibling-gap comment while ignoring empty/plain objects and comment-like string bytes owned by a child.
+// @evidence contracts/testing.md#independent-expectations The literal block comment is trivia between property token ranges; the quoted lookalike is string content. Independent lexical meaning determines the expected booleans.
+// @evidence contracts/testing.md#distinguishing-cases Nil and empty objects, ordinary adjacent members, one actual gap comment and a quoted lookalike distinguish abstention from safe child-owned bytes; this host owns the named table rows.
+// @evidence contracts/testing.md#execution-ownership TestFormatPrintWidthHasNonChildCommentsReturnsFalseWhenNodeIsNil 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 TestFormatPrintWidthHasNonChildCommentsReturnsFalseWhenNodeIsNil(t *testing.T) {
+  if got := hasNonChildComments(nil, "source", 0, 6); got {
+    t.Fatalf("hasNonChildComments(nil, ...): want false, got true")
+  }
+  cases := []struct {
+    name   string
+    source string
+    want   bool
+  }{
+    {"empty-object", "const x = {};\n", false},
+    {"plain-members", "const x = { a: 1, b: 2 };\n", false},
+    {"sibling-comment", "const x = { a: 1, /* keep */ b: 2 };\n", true},
+    {"child-string", "const x = { text: \"/* not a comment */\" };\n", false},
+  }
+  for _, tc := range cases {
+    t.Run(tc.name, func(t *testing.T) {
+      file := parseTS(t, tc.source)
+      node := firstNodeOfKind(t, file, shimast.KindObjectLiteralExpression)
+      if got := hasNonChildComments(node, tc.source, node.Pos(), node.End()); got != tc.want {
+        t.Fatalf("comment ownership: want %v, got %v", tc.want, got)
+      }
+    })
+  }
+}

package/linthost/format_print_width_has_reflow_ancestor_returns_false_when_node_is_nil_test.go

@@ -0,0 +1,40 @@
+package linthost
+
+import (
+  "testing"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+// TestFormatPrintWidthHasReflowAncestorReturnsFalseWhenNodeIsNil verifies
+// hasReflowAncestor returns false immediately for a nil node without panicking.
+//
+// Locks the `if node == nil { return false }` guard at the top of
+// hasReflowAncestor. The parent walk begins by reading node.Parent and then
+// advances through parent.Parent. The nil guard protects the initial access
+// while the independently authored chains distinguish the later traversal.
+//
+//  1. Call hasReflowAncestor(nil).
+//  2. Assert the return value is false and no panic occurred.
+//
+// @evidence contracts/testing.md#behavioral-verification hasReflowAncestor must reject nil, unparented and non-reflow-only chains, and recognize a call ancestor beyond an intermediate statement.
+// @evidence contracts/testing.md#independent-expectations Public parent links and independently chosen statement/call kinds encode the documented duplicate-reflow ownership rule; expected booleans do not repeat the ancestry walk.
+// @evidence contracts/testing.md#distinguishing-cases Nil, empty ancestry, adjacent non-reflow parent and a qualifying grandparent distinguish safety, category and full-chain traversal.
+// @evidence contracts/testing.md#execution-ownership TestFormatPrintWidthHasReflowAncestorReturnsFalseWhenNodeIsNil 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 TestFormatPrintWidthHasReflowAncestorReturnsFalseWhenNodeIsNil(t *testing.T) {
+  if got := hasReflowAncestor(nil); got {
+    t.Fatalf("hasReflowAncestor(nil): want false, got true")
+  }
+  node := &shimast.Node{Kind: shimast.KindIdentifier}
+  if hasReflowAncestor(node) {
+    t.Fatal("an unparented node has no reflow ancestor")
+  }
+  node.Parent = &shimast.Node{Kind: shimast.KindExpressionStatement}
+  if hasReflowAncestor(node) {
+    t.Fatal("a non-reflow statement parent must not suppress its child")
+  }
+  node.Parent.Parent = &shimast.Node{Kind: shimast.KindCallExpression}
+  if !hasReflowAncestor(node) {
+    t.Fatal("a reflow call ancestor beyond a non-reflow parent must suppress duplicate child reflow")
+  }
+}

package/linthost/format_print_width_honors_crlf_end_of_line_test.go

@@ -0,0 +1,30 @@
+package linthost
+
+import "testing"
+
+// TestFormatPrintWidthHonorsCRLFEndOfLine verifies the `endOfLine:
+// "crlf"` option threads CRLF terminators through every newline the
+// reflow emits.
+//
+// Projects with mixed editor populations or Windows-origin tooling
+// rely on `endOfLine` to preserve their conventions. A regression
+// that hard-coded LF would silently rewrite CRLF terminators on every
+// `ttsc format` pass.
+//
+//  1. Configure printWidth=20, endOfLine="crlf".
+//  2. Feed `const x = { aa: 1, bb: 2, cc: 3 };`.
+//  3. Assert generated replacement newlines use `\r\n`, preserving the suffix LF.
+//
+// @evidence contracts/testing.md#behavioral-verification The owned object replacement must use CRLF for every synthesized child/closing-brace newline while preserving its properties, values and the original statement-suffix LF outside that edit.
+// @evidence contracts/testing.md#independent-expectations The explicit endOfLine option governs printer-generated line endings. The literal expected source independently limits the rewrite to its node range, retaining the original semicolon and following LF.
+// @evidence contracts/testing.md#distinguishing-cases Input uses LF and the broken replacement uses CRLF only inside the owned object. The default-width object positive supplies LF reflow, and separate whole-command cases own full-file newline normalization.
+// @evidence contracts/testing.md#execution-ownership TestFormatPrintWidthHonorsCRLFEndOfLine owns its literal LF source, node-local mixed-ending complete output and explicit width/crlf options in the selected public Go unit population. Owning operations, engine and fixture observations execute in one Go process without native builds, consumer installation or real product-host children.
+func TestFormatPrintWidthHonorsCRLFEndOfLine(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/print-width",
+    "const x = { aa: 1, bb: 2, cc: 3 };\n",
+    `{"printWidth": 20, "endOfLine": "crlf"}`,
+    "const x = {\r\n  aa: 1,\r\n  bb: 2,\r\n  cc: 3,\r\n};\n",
+  )
+}

package/linthost/format_print_width_honors_custom_tab_width_test.go

@@ -0,0 +1,27 @@
+package linthost
+
+import "testing"
+
+// TestFormatPrintWidthHonorsCustomTabWidth verifies `tabWidth: 4`
+// changes the per-indent column step.
+//
+// Prettier's default is 2; some teams use 4. The case asserts the
+// per-indent step uses the configured value rather than a hardcoded 2.
+//
+//  1. Configure printWidth=20, tabWidth=4.
+//  2. Feed `const x = { aa: 1, bb: 2, cc: 3 };`.
+//  3. Assert the broken form indents children by 4 spaces.
+//
+// @evidence contracts/testing.md#behavioral-verification The registered format/print-width rule parses the honors custom tab width fixture and applies its edit; complete authored output equality rejects lost source content or punctuation alongside incorrect line layout. The owned result is: Assert the broken form indents children by 4 spaces.
+// @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 The fixture is an overflowing one-line object at printWidth 20 with tabWidth 4, so the rule must break it and the only indentation unit that can satisfy the expected output is four spaces rather than the default two. The default-width two-space layout is owned by the sibling long-object test.
+// @evidence contracts/testing.md#execution-ownership TestFormatPrintWidthHonorsCustomTabWidth is one Go unit entry through the registered rule engine, parser and fix applier; it uses no installed consumer or child product host.
+func TestFormatPrintWidthHonorsCustomTabWidth(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/print-width",
+    "const x = { aa: 1, bb: 2, cc: 3 };\n",
+    `{"printWidth": 20, "tabWidth": 4}`,
+    "const x = {\n    aa: 1,\n    bb: 2,\n    cc: 3,\n};\n",
+  )
+}

package/linthost/format_print_width_honors_tab_leading_source_test.go

@@ -0,0 +1,27 @@
+package linthost
+
+import "testing"
+
+// TestFormatPrintWidthHonorsTabLeadingSource separates the source line's
+// eight-column indentation from the object's eighteen-column starting point.
+// With four-column tabs, a broken object must preserve the original line
+// prefix and indent children one additional tab. Treating tabs as single
+// columns or confusing node position with base indentation changes the output.
+//
+//  1. Configure printWidth=24, tabWidth=4 and useTabs=true.
+//  2. Reflow the object after two source tabs and the const declaration prefix.
+//  3. Require three tabs on child lines and two on the closing brace.
+//
+// @evidence contracts/testing.md#behavioral-verification The actual rule engine must preserve the two-tab declaration prefix and break the object with three-tab child and two-tab closing indentation, retaining all keys and values.
+// @evidence contracts/testing.md#independent-expectations Independent literal arithmetic gives two four-column tabs, base indentation eight and object start eighteen after the ten-character declaration prefix. The supported node-local layout preserves that prefix and adds one tab per child; no whole-file or installed-reference output is claimed.
+// @evidence contracts/testing.md#distinguishing-cases Existing source tabs distinguish input-column handling from TestFormatPrintWidthHonorsUseTabsOption's output-only option. Exact full text checks both unchanged prefix and changed child indentation; the direct leading-column host owns tab-stop boundaries.
+// @evidence contracts/testing.md#execution-ownership TestFormatPrintWidthHonorsTabLeadingSource owns this source/options pair through the in-process registered rule and literal snapshot helper. No native producer, installed consumer or child product host participates.
+func TestFormatPrintWidthHonorsTabLeadingSource(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/print-width",
+    "\t\tconst x = { aa: 1, bb: 2, cc: 3 };\n",
+    `{"printWidth": 24, "tabWidth": 4, "useTabs": true}`,
+    "\t\tconst x = {\n\t\t\taa: 1,\n\t\t\tbb: 2,\n\t\t\tcc: 3,\n\t\t};\n",
+  )
+}

package/linthost/format_print_width_honors_use_tabs_option_test.go

@@ -0,0 +1,25 @@
+package linthost
+
+import "testing"
+
+// TestFormatPrintWidthHonorsUseTabsOption pins tab output when useTabs is
+// enabled. The literal three-property output detects an ignored option while
+// preserving the same property values, ordering and commas as the space form.
+//
+//  1. Configure printWidth=20 and useTabs=true.
+//  2. Reflow the aa/bb/cc object.
+//  3. Compare the entire output with one tab per child line.
+//
+// @evidence contracts/testing.md#behavioral-verification format/print-width must emit tab-indented children for the overflowing three-property object while retaining its keys, values and statement suffix.
+// @evidence contracts/testing.md#independent-expectations The supported useTabs contract determines one literal tab for each child indentation level. Full-string equality distinguishes spaces, misplaced braces or lost members.
+// @evidence contracts/testing.md#distinguishing-cases This host owns the enabled-tab positive. TestFormatPrintWidthBreaksLongObjectLiteral supplies the identical source with default space indentation; TestFormatPrintWidthHonorsTabLeadingSource owns input tabs rather than only output tabs.
+// @evidence contracts/testing.md#execution-ownership TestFormatPrintWidthHonorsUseTabsOption invokes the registered owning rule through assertFixSnapshotWithOptions and the same-process engine. Its selected public Go entry owns the literal case without installation, native build or product-host children.
+func TestFormatPrintWidthHonorsUseTabsOption(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/print-width",
+    "const x = { aa: 1, bb: 2, cc: 3 };\n",
+    `{"printWidth": 20, "useTabs": true}`,
+    "const x = {\n\taa: 1,\n\tbb: 2,\n\tcc: 3,\n};\n",
+  )
+}

package/linthost/format_print_width_hugs_arrow_with_object_body_test.go

@@ -0,0 +1,32 @@
+package linthost
+
+import "testing"
+
+// TestFormatPrintWidthHugsArrowWithObjectBody verifies the rule hugs a
+// trailing arrow argument whose body is a parenthesized object literal
+// — `foo((x) => ({ … }))` — keeping the callback attached to the parens
+// instead of exploding the argument list.
+//
+// Prettier's couldExpandArg treats an arrow whose body is an object,
+// array or block as expandable; shouldHugLastArgument mirrors that by
+// unwrapping the `(…)` around the object body. forceBreakFirstGroup
+// then commits the inner object to its multi-line shape so the hugged
+// option is genuinely distinct from the all-flat one.
+//
+//  1. Configure printWidth=25 — the all-flat call overflows.
+//  2. Feed an exploded call with an arrow-object-body argument.
+//  3. Assert the arrow hugs the parens and the object breaks.
+//
+// @evidence contracts/testing.md#behavioral-verification The registered format/print-width rule parses the hugs arrow with object body fixture and applies its edit; complete authored output equality rejects lost source content or punctuation alongside incorrect line layout. The owned result is: Assert the arrow hugs the parens and the object breaks.
+// @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 The authored scenario begins with: Configure printWidth=25 — the all-flat call overflows. The asserted decision is: Assert the arrow hugs the parens and the object breaks. Other fixture shapes remain in their separately named hosts.
+// @evidence contracts/testing.md#execution-ownership TestFormatPrintWidthHugsArrowWithObjectBody is one Go unit entry through the registered rule engine, parser and fix applier; it uses no installed consumer or child product host.
+func TestFormatPrintWidthHugsArrowWithObjectBody(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/print-width",
+    "collect(\n  (item) => ({ id: item }),\n);\n",
+    `{"printWidth": 25}`,
+    "collect((item) => ({\n  id: item,\n}));\n",
+  )
+}

package/linthost/format_print_width_hugs_first_callback_argument_test.go

@@ -0,0 +1,31 @@
+package linthost
+
+import "testing"
+
+// TestFormatPrintWidthHugsFirstCallbackArgument verifies Prettier's
+// first-argument hugging: `foo(() => { … }, target)` keeps the callback
+// attached to the open paren and flows `, target)` after its closing
+// brace, instead of exploding both arguments onto their own lines.
+//
+// shouldHugFirstArgument selects the two-argument block-callback plus
+// simple trailing identifier shape. This fixture owns the resulting
+// layout, without measuring an earlier printer or framework consumer.
+//
+//  1. Parse an over-width call whose first arg is a block callback and
+//     second is a plain identifier (printWidth 40).
+//  2. Apply format/print-width.
+//  3. Assert the callback hugs the parens and `, target)` trails.
+//
+// @evidence contracts/testing.md#behavioral-verification The registered format/print-width rule parses the hugs first callback argument fixture and applies its edit; complete authored output equality rejects lost source content or punctuation alongside incorrect line layout. The owned result is: Assert the callback hugs the parens and `, target)` trails.
+// @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 The authored scenario begins with: Parse an over-width call whose first arg is a block callback and second is a plain identifier (printWidth 40). The asserted decision is: Assert the callback hugs the parens and `, target)` trails. Other fixture shapes remain in their separately named hosts.
+// @evidence contracts/testing.md#execution-ownership TestFormatPrintWidthHugsFirstCallbackArgument is one Go unit entry through the registered rule engine, parser and fix applier; it uses no installed consumer or child product host.
+func TestFormatPrintWidthHugsFirstCallbackArgument(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/print-width",
+    "onUnmounted(() => { cleanupTheThing(); resetAll(); }, target);\n",
+    `{"printWidth":40,"tabWidth":2}`,
+    "onUnmounted(() => {\n  cleanupTheThing();\n  resetAll();\n}, target);\n",
+  )
+}

package/linthost/format_print_width_hugs_first_callback_with_array_arg_test.go

@@ -0,0 +1,27 @@
+package linthost
+
+import "testing"
+
+// TestFormatPrintWidthHugsFirstCallbackWithArrayArg verifies first-argument
+// hugging fires when the trailing argument is an array literal — the
+// canonical `useEffect(() => { … }, [deps])` idiom. Prettier 3.8.3 keeps
+// the leading callback attached to the open paren and flows `, [deps])`
+// after its closing brace rather than exploding both arguments.
+//
+//  1. Parse a two-argument call (block callback, array) that overflows 80.
+//  2. Apply format/print-width.
+//  3. Assert the callback hugs and the array trails its closing brace.
+//
+// @evidence contracts/testing.md#behavioral-verification The registered format/print-width rule parses the hugs first callback with array arg fixture and applies its edit; complete authored output equality rejects lost source content or punctuation alongside incorrect line layout. The owned result is: Assert the callback hugs and the array trails its closing brace.
+// @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 The authored scenario begins with: Parse a two-argument call (block callback, array) that overflows. The asserted decision is: Assert the callback hugs and the array trails its closing brace. Other fixture shapes remain in their separately named hosts.
+// @evidence contracts/testing.md#execution-ownership TestFormatPrintWidthHugsFirstCallbackWithArrayArg is one Go unit entry through the registered rule engine, parser and fix applier; it uses no installed consumer or child product host.
+func TestFormatPrintWidthHugsFirstCallbackWithArrayArg(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/print-width",
+    "useEffect(() => { doThing(); doMoreStuffHereToOverflowTheWidthForSure(); }, [aaaa, bbbb, cccc]);\n",
+    `{"printWidth":80,"tabWidth":2}`,
+    "useEffect(() => {\n  doThing();\n  doMoreStuffHereToOverflowTheWidthForSure();\n}, [aaaa, bbbb, cccc]);\n",
+  )
+}

package/linthost/format_print_width_hugs_object_argument_despite_long_trailing_suffix_test.go

@@ -0,0 +1,32 @@
+package linthost
+
+import "testing"
+
+// TestFormatPrintWidthHugsObjectArgumentDespiteLongTrailingSuffix
+// verifies a multi-line reflow keeps hugging its object argument even
+// when a long un-movable suffix (` satisfies T;`) follows the call.
+//
+// The suffix lands on the reflow's short last line, never on the hugged
+// opening line. The rule renders at the full printWidth budget and
+// re-renders with a suffix-reduced budget only for an overflowing flat
+// result. This authored multiline result distinguishes charging the
+// suffix against every interior line; it does not execute an earlier
+// revision or an external formatter.
+//
+//  1. Configure printWidth=30; the suffix ` satisfies …;` is 28 wide.
+//  2. Feed an exploded call followed by the long suffix.
+//  3. Assert the object hugs the parens instead of exploding.
+//
+// @evidence contracts/testing.md#behavioral-verification The registered format/print-width rule parses the hugs object argument despite long trailing suffix fixture and applies its edit; complete authored output equality rejects lost source content or punctuation alongside incorrect line layout. The owned result is: Assert the object hugs the parens instead of exploding.
+// @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 The authored scenario begins with: Configure printWidth=30; the suffix ` satisfies …;` is 28 wide. The asserted decision is: Assert the object hugs the parens instead of exploding. Other fixture shapes remain in their separately named hosts.
+// @evidence contracts/testing.md#execution-ownership TestFormatPrintWidthHugsObjectArgumentDespiteLongTrailingSuffix is one Go unit entry through the registered rule engine, parser and fix applier; it uses no installed consumer or child product host.
+func TestFormatPrintWidthHugsObjectArgumentDespiteLongTrailingSuffix(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/print-width",
+    "wrap(\n  {\n    a: 1,\n  },\n) satisfies VeryLongTypeName;\n",
+    `{"printWidth": 30}`,
+    "wrap({\n  a: 1,\n}) satisfies VeryLongTypeName;\n",
+  )
+}

package/linthost/format_print_width_idempotent_on_already_reflowed_input_test.go

@@ -0,0 +1,26 @@
+package linthost
+
+import "testing"
+
+// TestFormatPrintWidthIdempotentOnAlreadyReflowedInput verifies the
+// registered rule reports no findings on the authored broken object.
+// This direct rule boundary does not execute a second format command
+// or prove convergence of the whole formatter cascade.
+//
+//  1. Use printWidth=20, the same width that breaks the source-form
+//     test fixture.
+//  2. Feed an already-broken object literal as the input.
+//  3. Assert the rule reports zero findings — no edit, no diagnostic.
+//
+// @evidence contracts/testing.md#behavioral-verification The registered format/print-width rule runs on the idempotent on already reflowed input fixture and must report no findings, rejecting an unnecessary or unsafe edit rather than only comparing two formatter outputs. The owned result is: Assert the rule reports zero findings — no edit, no diagnostic.
+// @evidence contracts/testing.md#independent-expectations The literal unchanged input and zero-finding expectation follow the preservation boundary described above, independently of printer output. This host proves abstention, while changing fixtures in sibling rule tests prove formatting correctness.
+// @evidence contracts/testing.md#distinguishing-cases The authored scenario begins with: Use printWidth=20, the same width that breaks the source-form test fixture. The asserted decision is: Assert the rule reports zero findings — no edit, no diagnostic. Other fixture shapes remain in their separately named hosts.
+// @evidence contracts/testing.md#execution-ownership TestFormatPrintWidthIdempotentOnAlreadyReflowedInput is one Go unit entry through the fixture parser and rule engine; its zero-findings assertion uses no installed consumer, formatter subprocess or native build.
+func TestFormatPrintWidthIdempotentOnAlreadyReflowedInput(t *testing.T) {
+  assertRuleSkipsSourceWithOptions(
+    t,
+    "format/print-width",
+    "const x = {\n  aa: 1,\n  bb: 2,\n  cc: 3,\n};\n",
+    `{"printWidth": 20}`,
+  )
+}

package/linthost/format_print_width_idempotent_on_first_hugged_call_test.go

@@ -0,0 +1,25 @@
+package linthost
+
+import "testing"
+
+// TestFormatPrintWidthIdempotentOnFirstHuggedCall verifies no findings
+// on the authored first-hugged callback plus trailing identifier.
+// This is the registered rule preservation boundary, not an executed
+// round-trip or convergence assertion for the whole format command.
+//
+//  1. Parse an already first-hugged call (printWidth 40).
+//  2. Run format/print-width.
+//  3. Assert the rule reports nothing.
+//
+// @evidence contracts/testing.md#behavioral-verification The registered format/print-width rule runs on the idempotent on first hugged call fixture and must report no findings, rejecting an unnecessary or unsafe edit rather than only comparing two formatter outputs. The owned result is: Assert the rule reports nothing.
+// @evidence contracts/testing.md#independent-expectations The literal unchanged input and zero-finding expectation follow the preservation boundary described above, independently of printer output. This host proves abstention, while changing fixtures in sibling rule tests prove formatting correctness.
+// @evidence contracts/testing.md#distinguishing-cases The authored scenario begins with: Parse an already first-hugged call (printWidth 40). The asserted decision is: Assert the rule reports nothing. Other fixture shapes remain in their separately named hosts.
+// @evidence contracts/testing.md#execution-ownership TestFormatPrintWidthIdempotentOnFirstHuggedCall is one Go unit entry through the fixture parser and rule engine; its zero-findings assertion uses no installed consumer, formatter subprocess or native build.
+func TestFormatPrintWidthIdempotentOnFirstHuggedCall(t *testing.T) {
+  assertRuleSkipsSourceWithOptions(
+    t,
+    "format/print-width",
+    "onUnmounted(() => {\n  cleanupTheThing();\n  resetAll();\n}, target);\n",
+    `{"printWidth":40,"tabWidth":2}`,
+  )
+}

package/linthost/format_print_width_idempotent_on_hugged_callback_call_test.go

@@ -0,0 +1,25 @@
+package linthost
+
+import "testing"
+
+// TestFormatPrintWidthIdempotentOnHuggedCallbackCall verifies zero
+// findings on the authored already-hugged constructor callback.
+// Its no-edit assertion owns this single-rule preservation boundary;
+// it does not run the format cascade or compare a returned printer doc.
+//
+//  1. Feed an already-hugged `new Singleton(() => { … })` whose body is
+//     correctly indented two spaces.
+//  2. Run formatPrintWidth at the default width.
+//  3. Assert the rule reports zero findings.
+//
+// @evidence contracts/testing.md#behavioral-verification The registered format/print-width rule runs on the idempotent on hugged callback call fixture and must report no findings, rejecting an unnecessary or unsafe edit rather than only comparing two formatter outputs. The owned result is: Assert the rule reports zero findings.
+// @evidence contracts/testing.md#independent-expectations The literal unchanged input and zero-finding expectation follow the preservation boundary described above, independently of printer output. This host proves abstention, while changing fixtures in sibling rule tests prove formatting correctness.
+// @evidence contracts/testing.md#distinguishing-cases The authored scenario begins with: Feed an already-hugged `new Singleton(() => { … })` whose body is correctly indented two spaces. The asserted decision is: Assert the rule reports zero findings. Other fixture shapes remain in their separately named hosts.
+// @evidence contracts/testing.md#execution-ownership TestFormatPrintWidthIdempotentOnHuggedCallbackCall is one Go unit entry through the fixture parser and rule engine; its zero-findings assertion uses no installed consumer, formatter subprocess or native build.
+func TestFormatPrintWidthIdempotentOnHuggedCallbackCall(t *testing.T) {
+  assertRuleSkipsSource(
+    t,
+    "format/print-width",
+    "const x = new Singleton(() => {\n  doStuff();\n  return 1;\n});\n",
+  )
+}

package/linthost/format_print_width_idempotent_on_nested_ternary_staircase_test.go

@@ -0,0 +1,25 @@
+package linthost
+
+import "testing"
+
+// TestFormatPrintWidthIdempotentOnNestedTernaryStaircase verifies zero
+// findings on the authored nested-alternate staircase.
+// This direct rule preservation assertion does not execute the whole
+// format cascade or separately compare a returned printer doc.
+//
+//  1. Parse a correctly-staircased ternary chain (printWidth 40).
+//  2. Run format/print-width.
+//  3. Assert the rule reports nothing.
+//
+// @evidence contracts/testing.md#behavioral-verification The registered format/print-width rule runs on the idempotent on nested ternary staircase fixture and must report no findings, rejecting an unnecessary or unsafe edit rather than only comparing two formatter outputs. The owned result is: Assert the rule reports nothing.
+// @evidence contracts/testing.md#independent-expectations The literal unchanged input and zero-finding expectation follow the preservation boundary described above, independently of printer output. This host proves abstention, while changing fixtures in sibling rule tests prove formatting correctness.
+// @evidence contracts/testing.md#distinguishing-cases The authored scenario begins with: Parse a correctly-staircased ternary chain (printWidth 40). The asserted decision is: Assert the rule reports nothing. Other fixture shapes remain in their separately named hosts.
+// @evidence contracts/testing.md#execution-ownership TestFormatPrintWidthIdempotentOnNestedTernaryStaircase is one Go unit entry through the fixture parser and rule engine; its zero-findings assertion uses no installed consumer, formatter subprocess or native build.
+func TestFormatPrintWidthIdempotentOnNestedTernaryStaircase(t *testing.T) {
+  assertRuleSkipsSourceWithOptions(
+    t,
+    "format/print-width",
+    "const x = aaaaaaaaaa\n  ? bbbbbbbbbb\n  : cccccccccc\n    ? dddddddddd\n    : eeeeeeeeee;\n",
+    `{"printWidth":40,"tabWidth":2}`,
+  )
+}

package/linthost/format_print_width_indents_nested_alternate_ternary_test.go

@@ -0,0 +1,30 @@
+package linthost
+
+import "testing"
+
+// TestFormatPrintWidthIndentsNestedAlternateTernary verifies an
+// overflowing ternary chain breaks into Prettier 3's staircase, with the
+// nested conditional in the alternate position indented one level deeper.
+//
+// `a ? b : c ? d : e` is a chain whose alternate is itself a conditional.
+// The supported staircase policy breaks the chain together and steps
+// the inner rungs in by tabWidth. This fixture owns the authored
+// current layout, without executing earlier printer versions.
+//
+//  1. Parse an over-width single-line ternary chain (printWidth 40).
+//  2. Apply format/print-width.
+//  3. Assert the staircase: outer rungs at indent 2, inner at indent 4.
+//
+// @evidence contracts/testing.md#behavioral-verification The registered format/print-width rule parses the indents nested alternate ternary fixture and applies its edit; complete authored output equality rejects lost source content or punctuation alongside incorrect line layout. The owned result is: Assert the staircase: outer rungs at indent 2, inner at indent 4.
+// @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 The authored scenario begins with: Parse an over-width single-line ternary chain (printWidth 40). The asserted decision is: Assert the staircase: outer rungs at indent 2, inner at indent 4. Other fixture shapes remain in their separately named hosts.
+// @evidence contracts/testing.md#execution-ownership TestFormatPrintWidthIndentsNestedAlternateTernary is one Go unit entry through the registered rule engine, parser and fix applier; it uses no installed consumer or child product host.
+func TestFormatPrintWidthIndentsNestedAlternateTernary(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/print-width",
+    "const x = aaaaaaaaaa ? bbbbbbbbbb : cccccccccc ? dddddddddd : eeeeeeeeee;\n",
+    `{"printWidth":40,"tabWidth":2}`,
+    "const x = aaaaaaaaaa\n  ? bbbbbbbbbb\n  : cccccccccc\n    ? dddddddddd\n    : eeeeeeeeee;\n",
+  )
+}

package/linthost/format_print_width_indents_nested_consequent_ternary_test.go

@@ -0,0 +1,30 @@
+package linthost
+
+import "testing"
+
+// TestFormatPrintWidthIndentsNestedConsequentTernary verifies a ternary
+// whose CONSEQUENT is itself a conditional steps the inner rungs in by
+// one level, then returns the outer alternate to the outer indent.
+//
+// `a ? (b ? c : d) : e` prints with the inner `? c`/`: d` at indent 4 and
+// the outer `: e` back at indent 2. The recursion composes the Doc
+// engine's Indent stack rather than wrapping the nested conditional in
+// its own group, so the chain shares one break decision.
+//
+//  1. Parse an over-width consequent-nested ternary (printWidth 40).
+//  2. Apply format/print-width.
+//  3. Assert the inner rungs indent to 4 and the outer `: e` to 2.
+//
+// @evidence contracts/testing.md#behavioral-verification The registered format/print-width rule parses the indents nested consequent ternary fixture and applies its edit; complete authored output equality rejects lost source content or punctuation alongside incorrect line layout. The owned result is: Assert the inner rungs indent to 4 and the outer `: e` to 2.
+// @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 The fixture is a single-line ternary whose consequent is itself a conditional and whose flat form exceeds printWidth 40. The asserted decision is that the inner `? c` and `: d` rungs step to indent 4 while the outer `: e` returns to indent 2; the nested-alternate shape is owned by the sibling alternate-ternary test.
+// @evidence contracts/testing.md#execution-ownership TestFormatPrintWidthIndentsNestedConsequentTernary is one Go unit entry through the registered rule engine, parser and fix applier; it uses no installed consumer or child product host.
+func TestFormatPrintWidthIndentsNestedConsequentTernary(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/print-width",
+    "const r = aaaaaaaaaa ? bbbbbbbbbb ? cccccccccc : dddddddddd : eeeeeeeeee;\n",
+    `{"printWidth":40,"tabWidth":2}`,
+    "const r = aaaaaaaaaa\n  ? bbbbbbbbbb\n    ? cccccccccc\n    : dddddddddd\n  : eeeeeeeeee;\n",
+  )
+}