@ttsc/lint 0.30.4 → 0.31.0

package/linthost/format_print_width_indents_relative_to_line_leading_indent_test.go

@@ -0,0 +1,42 @@
+package linthost
+
+import "testing"
+
+// TestFormatPrintWidthIndentsRelativeToLineLeadingIndent verifies that
+// a reflowed node nested inside an indented enclosing block aligns its
+// continuation lines to the *line's* leading indent, not the column
+// where the node itself begins.
+//
+// `const x = { … }` is the canonical exhibit. The `{` lives at column
+// 10 but the broken form should indent children to column 2
+// (lineLeadingIndent=0 + indentUnit=2), matching Prettier's output. A
+// regression that aligned children to the node's leading column would
+// emit `            aa: 1,` instead of `  aa: 1,`.
+//
+// The case nests one level deeper to make the difference unambiguous:
+// the enclosing function body indents `const x = {` to column 2, so
+// the broken children should land at column 4 — *not* column 12 (the
+// `{` column) and not column 0 (the file's left edge).
+//
+//  1. Feed a fixture where `const x = { … }` sits inside a function
+//     body and the literal would overflow the printWidth.
+//  2. Configure printWidth=28 so the literal must break (the literal
+//     starts at column 12 and is 23 chars wide flat, total 35 before
+//     the trailing semicolon; the complete line is 36 columns).
+//  3. Assert the children align under column 4.
+//
+// @evidence contracts/testing.md#behavioral-verification The registered format/print-width rule parses the indents relative to line leading indent 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 children align under column 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: Feed a fixture where `const x = { … }` sits inside a function body and the literal would overflow the printWidth. The asserted decision is: Assert the children align under column 4. Other fixture shapes remain in their separately named hosts.
+// @evidence contracts/testing.md#execution-ownership TestFormatPrintWidthIndentsRelativeToLineLeadingIndent is one Go unit entry through the registered rule engine, parser and fix applier; it uses no installed consumer or child product host.
+func TestFormatPrintWidthIndentsRelativeToLineLeadingIndent(t *testing.T) {
+  src := "function f() {\n  const x = { aa: 1, bb: 2, cc: 3 };\n}\n"
+  want := "function f() {\n  const x = {\n    aa: 1,\n    bb: 2,\n    cc: 3,\n  };\n}\n"
+  assertFixSnapshotWithOptions(
+    t,
+    "format/print-width",
+    src,
+    `{"printWidth": 28}`,
+    want,
+  )
+}

package/linthost/format_print_width_inserts_after_non_rest_object_assignment_target_test.go

@@ -0,0 +1,30 @@
+package linthost
+
+import "testing"
+
+// TestFormatPrintWidthInsertsAfterNonRestObjectAssignmentTarget is the
+// target-axis over-suppression twin for the reflow: a preserved multi-line
+// object assignment target WITHOUT a trailing rest (`({ a, b } = obj)`) must
+// still gain its trailing comma.
+//
+// The printer must suppress the comma only when the target ends in a rest,
+// not on every destructuring target. This pins that a plain `{ a, b } = obj`
+// reflow still appends the comma so the guard does not disable trailing
+// commas across all assignment targets.
+//
+// 1. Feed an already-broken object assignment target whose last member is not a rest.
+// 2. Run formatPrintWidth at the default width (objectWrap keeps it expanded).
+// 3. Assert the reflow adds the trailing comma after the last member.
+//
+// @evidence contracts/testing.md#behavioral-verification The registered format/print-width rule parses the inserts after non rest object assignment target 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 reflow adds the trailing comma after the last member.
+// @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: Feed an already-broken object assignment target whose last member is not a rest. The asserted decision is: Assert the reflow adds the trailing comma after the last member. Other fixture shapes remain in their separately named hosts.
+// @evidence contracts/testing.md#execution-ownership TestFormatPrintWidthInsertsAfterNonRestObjectAssignmentTarget is one Go unit entry through the registered rule engine, parser and fix applier; it uses no installed consumer or child product host.
+func TestFormatPrintWidthInsertsAfterNonRestObjectAssignmentTarget(t *testing.T) {
+  assertFixSnapshot(
+    t,
+    "format/print-width",
+    "({\n  a,\n  b\n} = obj);\n",
+    "({\n  a,\n  b,\n} = obj);\n",
+  )
+}

package/linthost/format_print_width_inserts_after_object_spread_in_value_literal_test.go

@@ -0,0 +1,30 @@
+package linthost
+
+import "testing"
+
+// TestFormatPrintWidthInsertsAfterObjectSpreadInValueLiteral is the
+// over-suppression twin for the reflow: a preserved multi-line object VALUE
+// literal ending in a spread (`{ a, ...o }`) must still gain its trailing
+// comma when reflowed.
+//
+// The printer's rest-target suppression keys on assignment-target position,
+// not on a trailing spread. A value-position spread is not a target, so the
+// reflow honors trailingComma:"all" and appends the comma — proving the
+// printer guard does not over-reach.
+//
+// 1. Feed an already-broken object value literal whose last member is a spread, no trailing comma.
+// 2. Run formatPrintWidth at the default width (objectWrap keeps it expanded).
+// 3. Assert the reflow adds the trailing comma after the spread.
+//
+// @evidence contracts/testing.md#behavioral-verification The registered format/print-width rule parses the inserts after object spread in value literal 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 reflow adds the trailing comma after the spread.
+// @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: Feed an already-broken object value literal whose last member is a spread, no trailing comma. The asserted decision is: Assert the reflow adds the trailing comma after the spread. Other fixture shapes remain in their separately named hosts.
+// @evidence contracts/testing.md#execution-ownership TestFormatPrintWidthInsertsAfterObjectSpreadInValueLiteral is one Go unit entry through the registered rule engine, parser and fix applier; it uses no installed consumer or child product host.
+func TestFormatPrintWidthInsertsAfterObjectSpreadInValueLiteral(t *testing.T) {
+  assertFixSnapshot(
+    t,
+    "format/print-width",
+    "const merged = {\n  a,\n  ...o\n};\n",
+    "const merged = {\n  a,\n  ...o,\n};\n",
+  )
+}

package/linthost/format_print_width_keeps_call_with_trailing_line_comment_inline_test.go

@@ -0,0 +1,24 @@
+package linthost
+
+import "testing"
+
+// TestFormatPrintWidthKeepsCallWithTrailingLineCommentInline prevents a
+// trailing line comment from spending the call's layout budget. The call
+// plus semicolon is 25 columns, whereas the complete comment line is 31;
+// width 30 must leave this fitting call unchanged.
+//
+//  1. Configure printWidth=30 for the call followed by // hi.
+//  2. Assert the rule reports no finding despite the comment-line overflow.
+//
+// @evidence contracts/testing.md#behavioral-verification format/print-width must emit zero findings for the fitting three-argument call whose trailing line comment alone extends past width 30. Charging the comment would spuriously break the call.
+// @evidence contracts/testing.md#independent-expectations The authored unchanged input fixes the supported comment-only overflow boundary. Independently counted literal input lengths establish the 25-column statement and 31-column comment line without deriving the expectation from trailingLineWidth.
+// @evidence contracts/testing.md#distinguishing-cases This host owns the comment-only overflow negative. TestFormatPrintWidthBreaksCallWhenTrailingSemicolonOverflows supplies a real suffix overflow positive and its exact-fit twin; direct suffix helpers distinguish line comments from block comments.
+// @evidence contracts/testing.md#execution-ownership TestFormatPrintWidthKeepsCallWithTrailingLineCommentInline owns the configured source through assertRuleSkipsSourceWithOptions and the in-process rule engine. No consumer install, native build or product-host child is used.
+func TestFormatPrintWidthKeepsCallWithTrailingLineCommentInline(t *testing.T) {
+  assertRuleSkipsSourceWithOptions(
+    t,
+    "format/print-width",
+    "myCall(arg1, arg2, arg3); // hi\n",
+    `{"printWidth": 30}`,
+  )
+}

package/linthost/format_print_width_keeps_empty_array_literal_flat_test.go

@@ -0,0 +1,25 @@
+package linthost
+
+import "testing"
+
+// TestFormatPrintWidthKeepsEmptyArrayLiteralFlat verifies zero findings
+// for an authored empty array at printWidth 1. The empty list renders
+// as [] with no internal whitespace; this no-edit assertion does not
+// observe which early return fired or prove guard-removal behavior.
+//
+//  1. Configure printWidth=1.
+//  2. Feed `const x = [];`.
+//  3. Assert the rule emits zero findings.
+//
+// @evidence contracts/testing.md#behavioral-verification The registered format/print-width rule runs on the keeps empty array literal flat 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 emits 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: Configure printWidth=1. The asserted decision is: Assert the rule emits zero findings. Other fixture shapes remain in their separately named hosts.
+// @evidence contracts/testing.md#execution-ownership TestFormatPrintWidthKeepsEmptyArrayLiteralFlat 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 TestFormatPrintWidthKeepsEmptyArrayLiteralFlat(t *testing.T) {
+  assertRuleSkipsSourceWithOptions(
+    t,
+    "format/print-width",
+    "const x = [];\n",
+    `{"printWidth": 1}`,
+  )
+}

package/linthost/format_print_width_keeps_empty_object_literal_flat_test.go

@@ -0,0 +1,28 @@
+package linthost
+
+import "testing"
+
+// TestFormatPrintWidthKeepsEmptyObjectLiteralFlat verifies an empty
+// `{}` is never reflowed.
+//
+// The listShape printer special-cases empty children to `{}` with no
+// internal whitespace. The case pins this branch: even at a tight
+// printWidth, an empty object has nothing to reflow and the rule must
+// emit zero findings.
+//
+//  1. Configure printWidth=1.
+//  2. Feed `const x = {};`.
+//  3. Assert the rule emits zero findings.
+//
+// @evidence contracts/testing.md#behavioral-verification The registered format/print-width rule runs on the keeps empty object literal flat 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 emits 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: Configure printWidth=1. The asserted decision is: Assert the rule emits zero findings. Other fixture shapes remain in their separately named hosts.
+// @evidence contracts/testing.md#execution-ownership TestFormatPrintWidthKeepsEmptyObjectLiteralFlat 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 TestFormatPrintWidthKeepsEmptyObjectLiteralFlat(t *testing.T) {
+  assertRuleSkipsSourceWithOptions(
+    t,
+    "format/print-width",
+    "const x = {};\n",
+    `{"printWidth": 1}`,
+  )
+}

package/linthost/format_print_width_keeps_nested_object_that_fits_test.go

@@ -0,0 +1,24 @@
+package linthost
+
+import "testing"
+
+// TestFormatPrintWidthKeepsNestedObjectThatFits is the width-preservation
+// twin of TestFormatPrintWidthReflowsCallWithNestedObjectArgument. The
+// same source keeps its nested object flat when it fits, distinguishing
+// the width decision from unconditional member expansion.
+//
+// The full expected layout is authored independently of the rule output.
+//
+// @evidence contracts/testing.md#behavioral-verification format/print-width must repair the outer indentation while leaving the nested opts object flat at width eighty.
+// @evidence contracts/testing.md#independent-expectations The expected source is an independently authored supported-layout literal, retaining both option values and their original property order.
+// @evidence contracts/testing.md#distinguishing-cases The same input at thirty columns breaks the nested object in the paired reflow case, distinguishing a budget-driven decision from unconditional breaking.
+// @evidence contracts/testing.md#execution-ownership TestFormatPrintWidthKeepsNestedObjectThatFits is a registered format/print-width rule unit. The snapshot harness calls the owning rule through the Go engine and applies real edits to isolated fixture source. It retains this case identity and does not start a consumer or native product host.
+func TestFormatPrintWidthKeepsNestedObjectThatFits(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/print-width",
+    "register(\"svc\", {\n      name: \"alpha\",\n  opts: { retries: 3, timeout: 1000 },\n});\n",
+    `{"printWidth": 80}`,
+    "register(\"svc\", {\n  name: \"alpha\",\n  opts: { retries: 3, timeout: 1000 },\n});\n",
+  )
+}

package/linthost/format_print_width_keeps_object_rest_assignment_target_without_comma_test.go

@@ -0,0 +1,29 @@
+package linthost
+
+import "testing"
+
+// TestFormatPrintWidthKeepsObjectRestAssignmentTargetWithoutComma verifies
+// the reflow does not add a trailing comma when it keeps a multi-line object
+// destructuring assignment target expanded (`({ a, ...rest } = obj)`).
+//
+// objectWrap:"preserve" keeps the newline-after-`{` object broken, and the
+// printer's AddComma would append a comma after the rest under
+// trailingComma:"all" — a syntax error. The printer must mirror the
+// trailing-comma rule's rest-target suppression, so the already-valid,
+// already-canonical source renders byte-identical and produces no finding.
+//
+// 1. Feed an already-broken object rest assignment target with no trailing comma.
+// 2. Run formatPrintWidth at the default width.
+// 3. Assert zero findings: the reflow leaves it untouched instead of adding a comma.
+//
+// @evidence contracts/testing.md#behavioral-verification The registered format/print-width rule runs on the keeps object rest assignment target without comma fixture and must report no findings, rejecting an unnecessary or unsafe edit rather than only comparing two formatter outputs. The owned result is: Assert zero findings: the reflow leaves it untouched instead of adding a comma.
+// @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-broken object rest assignment target with no trailing comma. The asserted decision is: Assert zero findings: the reflow leaves it untouched instead of adding a comma. Other fixture shapes remain in their separately named hosts.
+// @evidence contracts/testing.md#execution-ownership TestFormatPrintWidthKeepsObjectRestAssignmentTargetWithoutComma 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 TestFormatPrintWidthKeepsObjectRestAssignmentTargetWithoutComma(t *testing.T) {
+  assertRuleSkipsSource(
+    t,
+    "format/print-width",
+    "({\n  ra,\n  ...rrest\n} = obj);\n",
+  )
+}

package/linthost/format_print_width_keeps_react_hook_hugged_past_open_line_test.go

@@ -0,0 +1,26 @@
+package linthost
+
+import "testing"
+
+// TestFormatPrintWidthKeepsReactHookHuggedPastOpenLine pins the over-break fix:
+// a genuine React-hook deps call (zero-parameter block-bodied arrow + array)
+// keeps its callback hugged even when the hook name pushes the open `name(() => {`
+// line past printWidth. Prettier's isReactHookCallWithDepsArray path never
+// explodes the arguments (no fallback) — it lets the open line overflow.
+// HugFirstForce removes that fallback for this recognized callback+array shape.
+//
+//  1. Seed a project with one already-hugged hook call whose name pushes the
+//     open line past 80 columns.
+//  2. Run the in-process format command with a default format block.
+//  3. Require the file on disk to be byte-identical to the source.
+//
+// @evidence contracts/testing.md#behavioral-verification The in-process format command runs over one hook-with-deps call whose open line overflows 80 columns and the complete file text must equal the authored source, so exploding the arguments one per line (the defect) fails the equality.
+// @evidence contracts/testing.md#independent-expectations The expected text is an independently authored literal of the supported callback-with-deps-array hugging policy and equals the input; it is not derived from the command result. This is a preservation assertion on one canonical input and does not establish correctness for arbitrary layouts.
+// @evidence contracts/testing.md#distinguishing-cases This case owns the single overflow-tolerated hug: a zero-parameter block-bodied arrow plus a deps array stays hugged although the open line is past printWidth. Ordinary over-width calls that must break are owned by the sibling print-width reflow tests.
+// @evidence contracts/testing.md#execution-ownership TestFormatPrintWidthKeepsReactHookHuggedPastOpenLine is one Go unit entry that calls the in-process format command through assertFormatUnchanged on a temporary project; it spawns no child product host and installs no consumer.
+func TestFormatPrintWidthKeepsReactHookHuggedPastOpenLine(t *testing.T) {
+  assertFormatUnchanged(t, `useAnExtremelyLongCustomHookNameThatDefinitelyPushesTheOpenParenLineWayPastEighty(() => {
+  doStuff();
+}, [firstDep]);
+`)
+}

package/linthost/format_print_width_keeps_short_call_with_callback_hugged_test.go

@@ -0,0 +1,32 @@
+package linthost
+
+import "testing"
+
+// TestFormatPrintWidthKeepsShortCallWithCallbackHugged verifies a call
+// whose only argument is a multi-line arrow callback keeps the callback
+// hugging the parens — it is reflowed for consistent indentation but
+// the argument list is not exploded.
+//
+// The constructor argument printer and structured arrow block compose
+// the supported hugged layout. The authored result requires each body
+// statement to use two spaces despite different original indents; it
+// does not execute an earlier printer or a subsequent type-check pass.
+//
+//  1. Feed a `new` expression whose argument is an arrow callback whose
+//     block body is mis-indented in the source.
+//  2. Run formatPrintWidth at the default 80-column width.
+//  3. Assert the callback hugs the parens and every body line lands at
+//     a consistent two-space indent.
+//
+// @evidence contracts/testing.md#behavioral-verification The registered format/print-width rule parses the keeps short call with callback hugged 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 every body line lands at a consistent two-space indent.
+// @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: Feed a `new` expression whose argument is an arrow callback whose block body is mis-indented in the source. The asserted decision is: Assert the callback hugs the parens and every body line lands at a consistent two-space indent. Other fixture shapes remain in their separately named hosts.
+// @evidence contracts/testing.md#execution-ownership TestFormatPrintWidthKeepsShortCallWithCallbackHugged is one Go unit entry through the registered rule engine, parser and fix applier; it uses no installed consumer or child product host.
+func TestFormatPrintWidthKeepsShortCallWithCallbackHugged(t *testing.T) {
+  assertFixSnapshot(
+    t,
+    "format/print-width",
+    "const x = new Singleton(\n      () => {\n  doStuff();\n        return 1;\n});\n",
+    "const x = new Singleton(() => {\n  doStuff();\n  return 1;\n});\n",
+  )
+}

package/linthost/format_print_width_keeps_short_ternary_flat_test.go

@@ -0,0 +1,27 @@
+package linthost
+
+import "testing"
+
+// TestFormatPrintWidthKeepsShortTernaryFlat verifies a ternary that fits
+// printWidth is left on one line.
+//
+// The chain only breaks when its flat form overflows; a short ternary
+// must stay flat so the rule does not gratuitously stairstep every
+// `a ? b : c`. The fast path returns before the printer is even built.
+//
+//  1. Parse a short ternary that fits 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 keeps short ternary flat 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 short ternary that fits printWidth. The asserted decision is: Assert the rule reports nothing. Other fixture shapes remain in their separately named hosts.
+// @evidence contracts/testing.md#execution-ownership TestFormatPrintWidthKeepsShortTernaryFlat 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 TestFormatPrintWidthKeepsShortTernaryFlat(t *testing.T) {
+  assertRuleSkipsSourceWithOptions(
+    t,
+    "format/print-width",
+    "const x = a ? b : c;\n",
+    `{"printWidth":40,"tabWidth":2}`,
+  )
+}

package/linthost/format_print_width_leading_column_returns_zero_when_pos_is_nonpositive_test.go

@@ -0,0 +1,51 @@
+package linthost
+
+import "testing"
+
+// TestFormatPrintWidthLeadingColumnReturnsZeroWhenPosIsNonpositive verifies
+// leadingColumn returns 0 immediately when pos is 0 or negative, and falls back
+// to tabWidth=2 when a non-positive tabWidth is supplied.
+//
+// Locks two guards inside leadingColumn:
+//
+//   - `if pos <= 0 { return 0 }` — prevents out-of-range indexing and
+//     gives the caller the correct column (0) for file-start positions.
+//
+//   - `if tabWidth <= 0 { tabWidth = 2 }` — mirrors the Prettier default
+//     so a zero-valued PrintOptions.TabWidth never corrupts column counts.
+//
+//     1. Call leadingColumn with pos=0 — expects 0 (early return).
+//     2. Call leadingColumn with pos=-1 — expects 0 (early return).
+//     3. Call leadingColumn with a positive pos and tabWidth=0 — expects the
+//     column computed using the default tabWidth of 2.
+//
+// @evidence contracts/testing.md#behavioral-verification leadingColumn must return file-start column zero, default nonpositive tab widths to two and measure the current line using actual tab stops.
+// @evidence contracts/testing.md#independent-expectations Literal byte offsets identify two tabs, one space followed by a tab, and two spaces after LF; their expected visual columns follow tab-stop and line-origin contracts.
+// @evidence contracts/testing.md#distinguishing-cases Zero/negative position, zero/negative tab width, explicit four-column stops and a second-line origin distinguish early guards from valid nonzero results.
+// @evidence contracts/testing.md#execution-ownership TestFormatPrintWidthLeadingColumnReturnsZeroWhenPosIsNonpositive 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 TestFormatPrintWidthLeadingColumnReturnsZeroWhenPosIsNonpositive(t *testing.T) {
+  src := "const x = 1;\n"
+  if got := leadingColumn(src, 0, 2); got != 0 {
+    t.Fatalf("leadingColumn(src, 0, 2): want 0, got %d", got)
+  }
+  if got := leadingColumn(src, -1, 2); got != 0 {
+    t.Fatalf("leadingColumn(src, -1, 2): want 0, got %d", got)
+  }
+
+  // tabWidth=0 must fall back to 2. The source "\t\tconst" has two leading
+  // tabs; with the default tabWidth=2 each tab steps to the next 2-column
+  // boundary, giving a starting column of 4 for pos=2.
+  tabSrc := "\t\tconst x = 1;\n"
+  if got := leadingColumn(tabSrc, 2, 0); got != 4 {
+    t.Fatalf("leadingColumn(tabSrc, 2, 0): want 4 (tabWidth fallback=2), got %d", got)
+  }
+  if got := leadingColumn(tabSrc, 2, -1); got != 4 {
+    t.Fatalf("negative tab width must default to two-column stops, got %d", got)
+  }
+  if got := leadingColumn(" \tvalue", 2, 4); got != 4 {
+    t.Fatalf("a tab after one space must reach the next four-column stop, got %d", got)
+  }
+  if got := leadingColumn("prior\n  value", 8, 2); got != 2 {
+    t.Fatalf("column starts after the last newline, got %d", got)
+  }
+}

package/linthost/format_print_width_line_leading_indent_uses_two_when_tab_width_nonpositive_test.go

@@ -0,0 +1,47 @@
+package linthost
+
+import "testing"
+
+// TestFormatPrintWidthLineLeadingIndentUsesTwoWhenTabWidthNonpositive verifies
+// lineLeadingIndent falls back to tabWidth=2 when the caller passes 0 or a
+// negative value.
+//
+// Locks the fallback `if tabWidth <= 0 { tabWidth = 2 }` branch inside
+// lineLeadingIndent. The fallback mirrors the Prettier default so a zero-valued
+// PrintOptions.TabWidth does not silently produce incorrect indent measurements.
+//
+//  1. Build a source line indented with two tabs.
+//  2. Call lineLeadingIndent with tabWidth=0 (should use 2 as fallback).
+//  3. Assert the returned column equals 4 (two tabs × 2 columns each).
+//  4. Call lineLeadingIndent with tabWidth=-1 (also triggers the fallback).
+//  5. Assert the returned column equals 4.
+//
+// @evidence contracts/testing.md#behavioral-verification lineLeadingIndent must default nonpositive tab widths, honor explicit tab stops and count indentation rather than all text before the node.
+// @evidence contracts/testing.md#independent-expectations Two literal tabs imply four columns under the documented default or eight under explicit width four; one space then tab lands at the next stop, and two initial spaces remain the indent after text starts.
+// @evidence contracts/testing.md#distinguishing-cases Zero/negative widths contrast with explicit width four, mixed spaces/tabs, a position inside content and the file-start empty indent.
+// @evidence contracts/testing.md#execution-ownership TestFormatPrintWidthLineLeadingIndentUsesTwoWhenTabWidthNonpositive is a selected public Go unit under the lint semantic-unit Evidence claim. This entry owns every local assertion and table row, invoking the column or source predicate in the shared process without consumer installation, a native product build or host execution.
+func TestFormatPrintWidthLineLeadingIndentUsesTwoWhenTabWidthNonpositive(t *testing.T) {
+  // "\t\tconst x = 1;\n" — two leading tabs, then the statement.
+  src := "\t\tconst x = 1;\n"
+  // pos points at 'c' in "const" (after the two tabs at positions 0 and 1).
+  pos := 2
+
+  if got := lineLeadingIndent(src, pos, 0); got != 4 {
+    t.Fatalf("lineLeadingIndent(tabWidth=0): want 4, got %d", got)
+  }
+  if got := lineLeadingIndent(src, pos, -1); got != 4 {
+    t.Fatalf("lineLeadingIndent(tabWidth=-1): want 4, got %d", got)
+  }
+  if got := lineLeadingIndent(src, pos, 4); got != 8 {
+    t.Fatalf("explicit four-column stops must give eight, got %d", got)
+  }
+  if got := lineLeadingIndent(" \tvalue", 2, 4); got != 4 {
+    t.Fatalf("mixed indentation must reach the next stop, got %d", got)
+  }
+  if got := lineLeadingIndent("  value + other", 10, 2); got != 2 {
+    t.Fatalf("indent excludes nonblank text before the node, got %d", got)
+  }
+  if got := lineLeadingIndent("value", 0, 2); got != 0 {
+    t.Fatalf("file-start indentation is zero, got %d", got)
+  }
+}

package/linthost/format_print_width_max_line_width_uses_two_when_tab_width_nonpositive_test.go

@@ -0,0 +1,47 @@
+package linthost
+
+import "testing"
+
+// TestFormatPrintWidthMaxLineWidthUsesTwoWhenTabWidthNonpositive verifies
+// maxLineWidth falls back to a tab width of two columns when the supplied
+// tabWidth is non-positive.
+//
+// maxLineWidth is the rule's safety-floor measurement. Its caller always
+// passes the resolved print options, so the `tabWidth <= 0` fallback is
+// never reached from the rule itself and needs a direct exercise.
+//
+//  1. Call maxLineWidth with a leading tab and tabWidth = 0.
+//  2. Assert the tab expanded to two columns (tab + "ab" = 4).
+//  3. Check named empty, prefix/suffix, line-separator and explicit-tab-stop rows.
+//
+// @evidence contracts/testing.md#behavioral-verification maxLineWidth must retain the original zero-tab-width result, charge prefix/suffix on their proper lines and return the widest effective line across supported terminators and actual tab stops.
+// @evidence contracts/testing.md#independent-expectations Literal text, fixed prefix/suffix columns and independently counted tab-stop positions determine expected zero/four/six/eight/nine values. Named cases specify measurements without reusing the implementation scan.
+// @evidence contracts/testing.md#distinguishing-cases Empty, one/two lines, LF/CRLF/LS/PS, zero/negative width, explicit four-column tabs and a space-before-tab distinguish guards, line charging and tab-stop behavior.
+// @evidence contracts/testing.md#execution-ownership TestFormatPrintWidthMaxLineWidthUsesTwoWhenTabWidthNonpositive owns the original assertion and every named measurement row through direct maxLineWidth calls in the selected public Go unit population. Direct maxLineWidth calls for every named row execute in one Go process without native builds, consumer installation or real product-host children.
+func TestFormatPrintWidthMaxLineWidthUsesTwoWhenTabWidthNonpositive(t *testing.T) {
+  if got := maxLineWidth("\tab", 0, 0, 0); got != 4 {
+    t.Fatalf("tab with default tabWidth: want 4, got %d", got)
+  }
+  cases := []struct {
+    name                           string
+    text                           string
+    prefix, suffix, tabWidth, want int
+  }{
+    {"empty", "", 0, 0, 2, 0},
+    {"one-line-charges-both", "ab", 3, 4, 2, 9},
+    {"lf-first-and-last", "abc\nx", 2, 7, 2, 8},
+    {"crlf-first-and-last", "abc\r\nx", 2, 7, 2, 8},
+    {"line-separator", "abc\u2028x", 2, 7, 2, 8},
+    {"paragraph-separator", "abc\u2029x", 2, 7, 2, 8},
+    {"negative-width-default", "\tab", 0, 0, -1, 4},
+    {"four-column-tab", "\tab", 0, 0, 4, 6},
+    {"space-then-tab", " \tab", 0, 0, 4, 6},
+  }
+  for _, tc := range cases {
+    t.Run(tc.name, func(t *testing.T) {
+      if got := maxLineWidth(tc.text, tc.prefix, tc.suffix, tc.tabWidth); got != tc.want {
+        t.Fatalf("effective widest line: want %d, got %d", tc.want, got)
+      }
+    })
+  }
+}

package/linthost/format_print_width_preserves_blank_line_in_reflowed_callback_body_test.go

@@ -0,0 +1,29 @@
+package linthost
+
+import "testing"
+
+// TestFormatPrintWidthPreservesBlankLineInReflowedCallbackBody verifies
+// the rule keeps a user-authored blank line inside a hugged callback
+// body instead of deleting it.
+//
+// The block printer uses fresh statement separators and preserves a
+// single authored blank line. This direct rule assertion requires no
+// finding on that layout; it does not execute an earlier revision or
+// a full format pass, or separately compare a returned printer doc.
+//
+//  1. Feed a `new Singleton(() => { … })` whose body has a blank line
+//     between two statements.
+//  2. Run formatPrintWidth at the default width.
+//  3. Assert the rule reports zero findings — the blank line survives.
+//
+// @evidence contracts/testing.md#behavioral-verification The registered format/print-width rule runs on the preserves blank line in reflowed callback body 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 — the blank line survives.
+// @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 a `new Singleton(() => { … })` whose body has a blank line between two statements. The asserted decision is: Assert the rule reports zero findings — the blank line survives. Other fixture shapes remain in their separately named hosts.
+// @evidence contracts/testing.md#execution-ownership TestFormatPrintWidthPreservesBlankLineInReflowedCallbackBody 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 TestFormatPrintWidthPreservesBlankLineInReflowedCallbackBody(t *testing.T) {
+  assertRuleSkipsSource(
+    t,
+    "format/print-width",
+    "const x = new Singleton(() => {\n  setup();\n\n  teardown();\n});\n",
+  )
+}

package/linthost/format_print_width_preserves_call_type_arguments_test.go

@@ -0,0 +1,32 @@
+package linthost
+
+import "testing"
+
+// TestFormatPrintWidthPreservesCallTypeArguments verifies a call
+// expression with type arguments (`foo<A>(…)`) keeps its
+// `<A>` segment on reflow.
+//
+// Type arguments live in a node-list distinct from the value
+// arguments, and the CallExpression printer emits them via a
+// verbatim slice. A regression that swapped the order, dropped the
+// segment, or duplicated it would corrupt the call's contract with the
+// TypeScript-Go type checker on the next pass.
+//
+//  1. Configure printWidth=24.
+//  2. Feed `foo<Alpha>(aaaaaa, bbbbbb, cccccc);` — the call breaks
+//     because its flat form is ~35 chars wide.
+//  3. Assert `<Alpha>` survives in the output.
+//
+// @evidence contracts/testing.md#behavioral-verification The registered format/print-width rule parses the preserves call type arguments fixture and applies its edit; complete authored output equality rejects lost source content or punctuation alongside incorrect line layout. The owned result is: Assert `<Alpha>` survives in the output.
+// @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=24. The asserted decision is: Assert `<Alpha>` survives in the output. Other fixture shapes remain in their separately named hosts.
+// @evidence contracts/testing.md#execution-ownership TestFormatPrintWidthPreservesCallTypeArguments is one Go unit entry through the registered rule engine, parser and fix applier; it uses no installed consumer or child product host.
+func TestFormatPrintWidthPreservesCallTypeArguments(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/print-width",
+    "foo<Alpha>(aaaaaa, bbbbbb, cccccc);\n",
+    `{"printWidth": 24}`,
+    "foo<Alpha>(\n  aaaaaa,\n  bbbbbb,\n  cccccc,\n);\n",
+  )
+}

package/linthost/format_print_width_preserves_leading_jsdoc_above_reflowed_node_test.go

@@ -0,0 +1,44 @@
+package linthost
+
+import "testing"
+
+// TestFormatPrintWidthPreservesLeadingJSDocAboveReflowedNode verifies
+// the rule does not touch leading JSDoc that sits above the reflowed
+// node.
+//
+// The rule's edit range starts at `shimscanner.SkipTrivia(node.Pos())`
+// — leading trivia is intentionally outside the replaced range.
+// A future refactor that swapped `SkipTrivia` for the raw `node.Pos()`
+// would silently swallow JSDoc and any other leading comments. The
+// original case preserves declaration-leading JSDoc. The second case
+// puts a comment immediately before the object, where raw node.Pos()
+// would include that trivia in the replacement.
+//
+//  1. Configure printWidth=20.
+//  2. Feed `/** doc */\nconst x = { aaaa: 1, bbbb: 2, cccc: 3 };` —
+//     the object literal would reflow regardless of the comment.
+//  3. Assert the JSDoc survives in the output, sitting above the
+//     reflowed declaration.
+//
+// @evidence contracts/testing.md#behavioral-verification The registered format/print-width rule parses the preserves leading jsdoc above reflowed node 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 JSDoc survives in the output, sitting above the reflowed declaration.
+// @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=20. The declaration-leading case preserves an outer comment, while a second complete output puts a comment directly before the object to distinguish SkipTrivia from raw node.Pos(). Both require changing the object layout.
+// @evidence contracts/testing.md#execution-ownership TestFormatPrintWidthPreservesLeadingJSDocAboveReflowedNode is one Go unit entry through the registered rule engine, parser and fix applier; it uses no installed consumer or child product host.
+func TestFormatPrintWidthPreservesLeadingJSDocAboveReflowedNode(t *testing.T) {
+  src := "/** doc */\nconst x = { aaaa: 1, bbbb: 2, cccc: 3 };\n"
+  want := "/** doc */\nconst x = {\n  aaaa: 1,\n  bbbb: 2,\n  cccc: 3,\n};\n"
+  assertFixSnapshotWithOptions(
+    t,
+    "format/print-width",
+    src,
+    `{"printWidth": 20}`,
+    want,
+  )
+  assertFixSnapshotWithOptions(
+    t,
+    "format/print-width",
+    "const x = /** value doc */ { aaaa: 1, bbbb: 2, cccc: 3 };\n",
+    `{"printWidth": 20}`,
+    "const x = /** value doc */ {\n  aaaa: 1,\n  bbbb: 2,\n  cccc: 3,\n};\n",
+  )
+}