@ttsc/lint 0.30.4 → 0.31.1

package/linthost/format_print_width_preserves_multiline_object_test.go

@@ -0,0 +1,30 @@
+package linthost
+
+import "testing"
+
+// TestFormatPrintWidthPreservesMultilineObject verifies the rule leaves
+// a user-written multi-line object expanded even when the flat form
+// would fit the printWidth budget.
+//
+// The supported objectWrap:"preserve" policy treats a newline after
+// `{` as intentional structure:
+// `{\n  a: 1\n}` stays broken and never collapses to `{ a: 1 }`.
+// formatPrintWidth mirrors that through objectHasNewlineAfterBrace.
+// This direct rule assertion requires no finding on the authored
+// expanded object; it does not execute an earlier revision.
+//
+//  1. Default printWidth=80.
+//  2. Feed `const x = {\n  a: 1,\n};\n` — multi-line, fits flat.
+//  3. Assert the rule reports nothing, leaving the layout untouched.
+//
+// @evidence contracts/testing.md#behavioral-verification The registered format/print-width rule runs on the preserves multiline object 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, leaving the layout untouched.
+// @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: Default printWidth=80. The asserted decision is: Assert the rule reports nothing, leaving the layout untouched. Other fixture shapes remain in their separately named hosts.
+// @evidence contracts/testing.md#execution-ownership TestFormatPrintWidthPreservesMultilineObject 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 TestFormatPrintWidthPreservesMultilineObject(t *testing.T) {
+  assertRuleSkipsSource(
+    t,
+    "format/print-width",
+    "const x = {\n  a: 1,\n};\n",
+  )
+}

package/linthost/format_print_width_preserves_optional_call_token_test.go

@@ -0,0 +1,32 @@
+package linthost
+
+import "testing"
+
+// TestFormatPrintWidthPreservesOptionalCallToken verifies a call
+// expression with the optional-chain `?.` token (`foo?.(a, b)`)
+// keeps the marker on reflow.
+//
+// The token sits between the callee and the open paren of the
+// argument list. The CallExpression printer emits it via a verbatim
+// slice; a regression that elided the token would silently convert
+// `foo?.()` into `foo()` and change runtime semantics (the optional
+// short-circuit on a nullish callee would disappear).
+//
+//  1. Configure printWidth=20.
+//  2. Feed `foo?.(aaaaaa, bbbbbb, cccccc);` so the call must break.
+//  3. Assert the `?.` token survives between the callee and the
+//     argument list.
+//
+// @evidence contracts/testing.md#behavioral-verification The registered format/print-width rule parses the preserves optional call token 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 `?.` token survives between the callee and the argument list.
+// @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 asserted decision is: Assert the `?.` token survives between the callee and the argument list. Other fixture shapes remain in their separately named hosts.
+// @evidence contracts/testing.md#execution-ownership TestFormatPrintWidthPreservesOptionalCallToken is one Go unit entry through the registered rule engine, parser and fix applier; it uses no installed consumer or child product host.
+func TestFormatPrintWidthPreservesOptionalCallToken(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/print-width",
+    "foo?.(aaaaaa, bbbbbb, cccccc);\n",
+    `{"printWidth": 20}`,
+    "foo?.(\n  aaaaaa,\n  bbbbbb,\n  cccccc,\n);\n",
+  )
+}

package/linthost/format_print_width_preserves_terminator_decision_on_imports_test.go

@@ -0,0 +1,42 @@
+package linthost
+
+import "testing"
+
+// TestFormatPrintWidthPreservesTerminatorDecisionOnImports verifies the
+// import-declaration printer preserves the user's `;` decision rather
+// than appending one unconditionally.
+//
+// printImportDeclaration includes the terminator only when it exists
+// in the source. These two changing fixtures require preservation in
+// both directions. The combined semi/print-width command is owned by
+// the separate cascade host, not observed by this rule-only entry.
+//
+//  1. Configure printWidth=20 (the import would break either way).
+//  2. Feed the import without a trailing `;` — `import { … } from "x"\n`.
+//  3. Assert the rule's reflow still has no `;` after `"x"`. A second
+//     fixture covers the with-`;` arm to pin idempotence.
+//
+// @evidence contracts/testing.md#behavioral-verification Both overflowing imports must break while preserving the original absence or presence of a semicolon. Complete output comparisons detect either an invented terminator or a lost existing terminator, independently of a formatting fixed point.
+// @evidence contracts/testing.md#independent-expectations The two complete layout literals independently retain each authored source terminator decision. The rule itself receives only printWidth:20 and preserves source termination; semi policy belongs to the separate semi rule, so this is no claim that print-width applies Prettier default semicolon policy.
+// @evidence contracts/testing.md#distinguishing-cases The two inputs differ only in the source semicolon and both require a transformation. They distinguish terminator preservation in both directions; the command-format cascade host separately exercises combined print-width/semi/quote behavior.
+// @evidence contracts/testing.md#execution-ownership TestFormatPrintWidthPreservesTerminatorDecisionOnImports owns both named literal arms through the registered in-process rule engine and full applied-output helper. Its branches are directly reachable from one selected public Go Test without product-host children.
+func TestFormatPrintWidthPreservesTerminatorDecisionOnImports(t *testing.T) {
+  // No-semi arm.
+  assertFixSnapshotWithOptions(
+    t,
+    "format/print-width",
+    "import { alpha, bravo, charlie } from \"x\"\n",
+    `{"printWidth": 20}`,
+    "import {\n  alpha,\n  bravo,\n  charlie,\n} from \"x\"\n",
+  )
+  // With-semi arm — pin that the reflow does not strip the terminator
+  // either, so users running `ttsc format` without `format/semi`
+  // enabled do not lose the semicolons they wrote.
+  assertFixSnapshotWithOptions(
+    t,
+    "format/print-width",
+    "import { alpha, bravo, charlie } from \"x\";\n",
+    `{"printWidth": 20}`,
+    "import {\n  alpha,\n  bravo,\n  charlie,\n} from \"x\";\n",
+  )
+}

package/linthost/format_print_width_reflows_call_with_nested_object_argument_test.go

@@ -0,0 +1,33 @@
+package linthost
+
+import "testing"
+
+// TestFormatPrintWidthReflowsCallWithNestedObjectArgument verifies a call whose
+// last argument is an object literal reflows with the object hugging the
+// parens, and that a nested object too wide for the budget breaks with it.
+//
+// The independently authored output fixes both outer indentation and
+// the nested object layout. Its flat opts line is 38 columns, exceeding
+// width 30; TestFormatPrintWidthKeepsNestedObjectThatFits uses the same
+// source at width 80 and keeps that nested object flat. This body does
+// not execute an earlier dispatcher or an external formatter.
+//
+//  1. Feed `register("svc", { name: …, opts: { … } });` mis-indented across
+//     several lines so the outer object must be reflowed.
+//  2. Run formatPrintWidth at printWidth=30.
+//  3. Assert the object hugs the parens and the over-wide nested object breaks
+//     under it, both matching the oracle.
+//
+// @evidence contracts/testing.md#behavioral-verification format/print-width must fix the outer object indentation and break its nested opts object at width thirty.
+// @evidence contracts/testing.md#independent-expectations The full expected source is independently authored for the supported width-thirty layout; it retains the svc argument, property names and numeric values while changing only layout.
+// @evidence contracts/testing.md#distinguishing-cases The changed width-thirty case complements the identical source at width eighty, where the nested object must remain flat.
+// @evidence contracts/testing.md#execution-ownership TestFormatPrintWidthReflowsCallWithNestedObjectArgument 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 TestFormatPrintWidthReflowsCallWithNestedObjectArgument(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/print-width",
+    "register(\"svc\", {\n      name: \"alpha\",\n  opts: { retries: 3, timeout: 1000 },\n});\n",
+    `{"printWidth": 30}`,
+    "register(\"svc\", {\n  name: \"alpha\",\n  opts: {\n    retries: 3,\n    timeout: 1000,\n  },\n});\n",
+  )
+}

package/linthost/format_print_width_reflows_wide_array_with_slash_strings_test.go

@@ -0,0 +1,34 @@
+package linthost
+
+import "testing"
+
+// TestFormatPrintWidthReflowsWideArrayWithSlashStrings locks the reflow output
+// of a wide array literal whose string children contain `//` byte sequences,
+// pinning the byte-identical result the `inChild` binary-search predicate must
+// preserve.
+//
+// `hasNonChildComments` scans the node's byte range for `//`/`/*` and abstains
+// when one falls OUTSIDE every child range, so `inChild` must correctly mask
+// the `//` inside each `"http://…"` string element (those are children). The
+// current predicate binary-searches source-ordered child ranges. This
+// changing fixture distinguishes masked string bytes from a comment
+// that would suppress reflow; the full authored layout preserves every
+// URL. It does not measure an earlier scanner or a speed improvement.
+//
+//  1. Configure printWidth=40 so the 3-element array overflows.
+//  2. Run formatPrintWidth on an array of `"http://…"` strings.
+//  3. Assert the canonical one-element-per-line reflow with a trailing comma.
+//
+// @evidence contracts/testing.md#behavioral-verification The registered format/print-width rule parses the reflows wide array with slash strings 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 canonical one-element-per-line reflow with a trailing comma.
+// @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=40 so the 3-element array overflows. The asserted decision is: Assert the canonical one-element-per-line reflow with a trailing comma. Other fixture shapes remain in their separately named hosts.
+// @evidence contracts/testing.md#execution-ownership TestFormatPrintWidthReflowsWideArrayWithSlashStrings is one Go unit entry through the registered rule engine, parser and fix applier; it uses no installed consumer or child product host.
+func TestFormatPrintWidthReflowsWideArrayWithSlashStrings(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/print-width",
+    "const urls = [\"http://a.example.com/x\", \"http://b.example.com/y\", \"http://c.example.com/z\"];\n",
+    `{"printWidth": 40}`,
+    "const urls = [\n  \"http://a.example.com/x\",\n  \"http://b.example.com/y\",\n  \"http://c.example.com/z\",\n];\n",
+  )
+}

package/linthost/format_print_width_reindents_callback_body_inside_indented_block_test.go

@@ -0,0 +1,33 @@
+package linthost
+
+import "testing"
+
+// TestFormatPrintWidthReindentsCallbackBodyInsideIndentedBlock verifies
+// a callback call nested inside an indented block reflows with the
+// callback body indented relative to the call's own line, not relative
+// to wherever the body bytes started in the source.
+//
+// The structured block printer re-emits each callback statement using
+// the call line's base indent. This authored result fixes the callback
+// header at two spaces and its body at four despite different original
+// columns; it does not measure an earlier verbatim implementation.
+//
+//  1. Feed a `new` call inside a function body whose callback body
+//     statements are deliberately mis-indented in the source.
+//  2. Run formatPrintWidth at the default width.
+//  3. Assert the call's `=>` header sits at the block indent and the
+//     body statements indent exactly two spaces deeper — consistent at
+//     every level.
+//
+// @evidence contracts/testing.md#behavioral-verification The registered format/print-width rule parses the reindents callback body inside indented block 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 call's `=>` header sits at the block indent and the body statements indent exactly two spaces deeper — consistent at every level.
+// @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` call inside a function body whose callback body statements are deliberately mis-indented in the source. The asserted decision is: Assert the call's `=>` header sits at the block indent and the body statements indent exactly two spaces deeper — consistent at every level. Other fixture shapes remain in their separately named hosts.
+// @evidence contracts/testing.md#execution-ownership TestFormatPrintWidthReindentsCallbackBodyInsideIndentedBlock is one Go unit entry through the registered rule engine, parser and fix applier; it uses no installed consumer or child product host.
+func TestFormatPrintWidthReindentsCallbackBodyInsideIndentedBlock(t *testing.T) {
+  assertFixSnapshot(
+    t,
+    "format/print-width",
+    "function boot() {\n  const x = new Singleton(\n() => {\n          register();\n  return x;\n});\n}\n",
+    "function boot() {\n  const x = new Singleton(() => {\n    register();\n    return x;\n  });\n}\n",
+  )
+}

package/linthost/format_print_width_skips_namespace_import_shape_test.go

@@ -0,0 +1,28 @@
+package linthost
+
+import "testing"
+
+// TestFormatPrintWidthSkipsNamespaceImportShape verifies the rule
+// passes through `import * as ns from "x"` declarations untouched.
+//
+// Namespace imports have no internal reflow surface — the `* as ns`
+// clause is a single specifier, not a comma-separated list. The
+// ImportDeclaration printer detects this shape and returns verbatim;
+// the case asserts the rule does not act on this shape at width 10.
+//
+//  1. Configure printWidth=10.
+//  2. Feed `import * as someVeryLongNamespaceAlias from "x";`.
+//  3. Assert the rule reports zero findings.
+//
+// @evidence contracts/testing.md#behavioral-verification The rule must report no findings for a namespace import whose single alias exceeds width 10. The zero-findings assertion forbids inserting a break into its indivisible star-as clause.
+// @evidence contracts/testing.md#independent-expectations The authored unchanged input fixes the supported namespace-import boundary at width 10. Its star-as binding has no comma-delimited member surface; print width does not permit changing the identifier or import syntax.
+// @evidence contracts/testing.md#distinguishing-cases This negative distinguishes an overflowing but indivisible namespace import from TestFormatPrintWidthBreaksDefaultPlusNamedImportShape at the same width. It owns this syntax-shape boundary rather than a general claim about every budget.
+// @evidence contracts/testing.md#execution-ownership TestFormatPrintWidthSkipsNamespaceImportShape parses its literal source and invokes the same-process registered rule via assertRuleSkipsSourceWithOptions. It is a selected public Go unit without install, native build or real-host children.
+func TestFormatPrintWidthSkipsNamespaceImportShape(t *testing.T) {
+  assertRuleSkipsSourceWithOptions(
+    t,
+    "format/print-width",
+    "import * as someVeryLongNamespaceAlias from \"x\";\n",
+    `{"printWidth": 10}`,
+  )
+}

package/linthost/format_print_width_skips_nested_target_when_ancestor_covers_it_test.go

@@ -0,0 +1,58 @@
+package linthost
+
+import (
+  "encoding/json"
+  "path/filepath"
+  "testing"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+// TestFormatPrintWidthSkipsNestedTargetWhenAncestorCoversIt verifies the
+// rule emits a finding only for the outermost reflow target; nested
+// visits abstain when a reflow ancestor already owns the edit.
+//
+// Nested reflow targets must have one edit owner. Counting only the original
+// short array cannot distinguish ancestor suppression from its fitting fast
+// path, so a second fixture uses an independently overflowing nested object.
+// Its diagnostic must cover exactly the outer call, and its complete edited
+// source must retain every argument, property and value.
+//
+// 1. Retain the original short-array outer-call count and rule assertions.
+// 2. Run a call containing a wide object at printWidth=24.
+// 3. Assert one complete outer-call range and the independent full output.
+//
+// @evidence contracts/testing.md#behavioral-verification The original outer-call count/rule checks remain. A long nested object must yield exactly one complete outer-call range, and the applied full output must preserve all values, argument order and use syntax.
+// @evidence contracts/testing.md#independent-expectations Independent source literals define the complete outer-call byte range. A complete independently authored width24 layout fixes the nested-object whole output; neither oracle derives ownership or bytes from the rule walker.
+// @evidence contracts/testing.md#distinguishing-cases The original short nested array can fit independently and is not alone a distinguishing guard case. The added nested object itself overflows, so duplicate reflow would create an extra finding; flat-short and direct ancestor predicates are complementary.
+// @evidence contracts/testing.md#execution-ownership TestFormatPrintWidthSkipsNestedTargetWhenAncestorCoversIt owns its original direct engine assertions plus nested-object exact-range and literal full-output cases 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 TestFormatPrintWidthSkipsNestedTargetWhenAncestorCoversIt(t *testing.T) {
+  source := "process([1, 2, 3], \"hello\", \"world\");\n"
+  root := t.TempDir()
+  filePath := filepath.Join(root, "src", "main.ts")
+  writeFile(t, filePath, source)
+  file := parseTSFile(t, filePath, source)
+  resolver := InlineRuleResolver{
+    Rules: RuleConfig{"format/print-width": SeverityError},
+    Options: RuleOptionsMap{
+      "format/print-width": json.RawMessage(`{"printWidth": 24}`),
+    },
+  }
+  findings := NewEngineWithResolver(resolver).Run(
+    []*shimast.SourceFile{file}, nil,
+  )
+  if len(findings) != 1 {
+    t.Fatalf("expected exactly one finding (outer call), got %d: %+v",
+      len(findings), findings)
+  }
+  if findings[0].Rule != "format/print-width" {
+    t.Fatalf("unexpected finding rule: %q", findings[0].Rule)
+  }
+  nestedSource := "process({ alpha: 1, bravo: 2, charlie: 3 }, \"hello\", \"world\");\n"
+  _, _, nestedFindings := runRuleFindingsSnapshot(t, "format/print-width", nestedSource, json.RawMessage(`{"printWidth":24}`))
+  marker := "process({ alpha: 1, bravo: 2, charlie: 3 }, \"hello\", \"world\")"
+  if len(nestedFindings) != 1 || nestedFindings[0].Pos != 0 || nestedFindings[0].End != len(marker) {
+    t.Fatalf("nested overflowing object must belong to one complete outer call: %+v", nestedFindings)
+  }
+  assertFixSnapshotWithOptions(t, "format/print-width", nestedSource, `{"printWidth":24}`, "process(\n  {\n    alpha: 1,\n    bravo: 2,\n    charlie: 3,\n  },\n  \"hello\",\n  \"world\",\n);\n")
+}

package/linthost/format_print_width_skips_short_object_literal_test.go

@@ -0,0 +1,29 @@
+package linthost
+
+import "testing"
+
+// TestFormatPrintWidthSkipsShortObjectLiteral verifies formatPrintWidth
+// abstains when the flat form already fits the configured budget.
+//
+// "No diff → no edit" is the load-bearing invariant that keeps
+// `ttsc format` idempotent. A rule that emitted an edit on every visit
+// (even a noop edit) would either churn the cascade or expand into
+// overlapping edits with other format rules. The case pins the abstain
+// branch by feeding a short object that already conforms.
+//
+//  1. Configure default printWidth=80.
+//  2. Feed `const x = { a: 1 };`.
+//  3. Assert the rule reports zero findings — the rule has nothing to
+//     say about a conforming literal.
+//
+// @evidence contracts/testing.md#behavioral-verification The registered format/print-width rule runs on the skips short object literal 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 rule has nothing to say about a conforming literal.
+// @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 default printWidth=80. The asserted decision is: Assert the rule reports zero findings — the rule has nothing to say about a conforming literal. Other fixture shapes remain in their separately named hosts.
+// @evidence contracts/testing.md#execution-ownership TestFormatPrintWidthSkipsShortObjectLiteral 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 TestFormatPrintWidthSkipsShortObjectLiteral(t *testing.T) {
+  assertRuleSkipsSource(
+    t,
+    "format/print-width",
+    "const x = { a: 1 };\n",
+  )
+}

package/linthost/format_print_width_slice_contains_newline_clamps_out_of_range_bounds_test.go

@@ -0,0 +1,57 @@
+package linthost
+
+import "testing"
+
+// TestFormatPrintWidthSliceContainsNewlineClampOutOfRangeBounds verifies that
+// sliceContainsNewline handles out-of-range start and end parameters safely by
+// clamping them to valid positions rather than panicking.
+//
+// Locks the two clamping guards inside sliceContainsNewline:
+//   - `if start < 0 { start = 0 }` prevents a negative slice bound.
+//   - `if end > len(src) { end = len(src) }` prevents a slice-bounds panic.
+//
+// Check derives start from SkipTrivia and end from node.End(), validating
+// their bounds before this helper. Direct defensive clamping
+// keeps the helper safe for future callers that may pass unchecked values.
+//
+//  1. Call sliceContainsNewline with start=-5 on a source that contains a newline.
+//     The clamped start=0 must include the newline, so the result is true.
+//  2. Call sliceContainsNewline with end=9999 (beyond len(src)).
+//     The clamped end=len(src) must still find the newline, so the result is true.
+//  3. Call sliceContainsNewline with start=-5 on a single-line source.
+//     No newline exists in the valid range, so the result is false.
+//
+// @evidence contracts/testing.md#behavioral-verification sliceContainsNewline must clamp out-of-bounds ranges while detecting supported line separators only within the half-open slice.
+// @evidence contracts/testing.md#independent-expectations Literal LF at byte five and CR/U+2028/U+2029 fixtures supply lexical newline expectations independently; range endpoints five and six distinguish exclusion and inclusion.
+// @evidence contracts/testing.md#distinguishing-cases Negative start, excessive end, flat text, empty/reversed spans, adjacent LF endpoint and three other supported separators expose safety and actual classification.
+// @evidence contracts/testing.md#execution-ownership TestFormatPrintWidthSliceContainsNewlineClampOutOfRangeBounds 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 TestFormatPrintWidthSliceContainsNewlineClampOutOfRangeBounds(t *testing.T) {
+  src := "hello\nworld"
+
+  // Negative start: clamped to 0, newline at offset 5 is within [0, len(src)).
+  if got := sliceContainsNewline(src, -5, len(src)); !got {
+    t.Fatalf("sliceContainsNewline(src, -5, len): want true (clamped start=0 covers \\n), got false")
+  }
+
+  // End beyond bounds: clamped to len(src), newline still found.
+  if got := sliceContainsNewline(src, 0, 9999); !got {
+    t.Fatalf("sliceContainsNewline(src, 0, 9999): want true (clamped end=len covers \\n), got false")
+  }
+
+  // Negative start on a no-newline source: clamped start=0, no newline in [0, end).
+  srcFlat := "hello world"
+  if got := sliceContainsNewline(srcFlat, -3, len(srcFlat)); got {
+    t.Fatalf("sliceContainsNewline(flat, -3, len): want false, got true")
+  }
+  if sliceContainsNewline(src, 5, 5) || sliceContainsNewline(src, 6, 5) {
+    t.Fatal("empty and reversed ranges contain no newline")
+  }
+  if sliceContainsNewline(src, 0, 5) || !sliceContainsNewline(src, 0, 6) {
+    t.Fatal("half-open range must exclude then include the adjacent LF")
+  }
+  for _, source := range []string{"a\rb", "a\u2028b", "a\u2029b"} {
+    if !sliceContainsNewline(source, 0, len(source)) {
+      t.Fatalf("supported line separator must be detected in %q", source)
+    }
+  }
+}

package/linthost/format_print_width_ternary_arm_indent_bonus_test.go

@@ -0,0 +1,44 @@
+package linthost
+
+import "testing"
+
+// TestFormatPrintWidthTernaryArmIndentBonus verifies ternaryArmIndentBonus
+// reports a two-column bonus only for a line that opens a ternary arm.
+//
+// A node reflowed inside a ternary arm must hang its broken continuation
+// under the arm's expression, two columns past the `?`/`:` marker. The
+// bonus feeds BaseIndent; it must fire for `? ` and `: ` arm lines and
+// stay zero when an ordinary line has no marker-plus-space prefix.
+//
+//  1. Build a source with a `? ` arm line, a `: ` arm line and a plain
+//     line.
+//  2. Call ternaryArmIndentBonus at a position on each.
+//  3. Assert 2 for the arm lines and 0 otherwise.
+//
+// @evidence contracts/testing.md#behavioral-verification ternaryArmIndentBonus must recognize a leading question/colon marker followed by a space and assign exactly two columns, leaving ordinary or differently followed markers unchanged.
+// @evidence contracts/testing.md#independent-expectations Literal arm prefixes define the continuation-indent convention; expected zero/two values are specified independently from the scanning algorithm.
+// @evidence contracts/testing.md#distinguishing-cases Both marker kinds, ordinary/first lines, missing or tab separators, whitespace-prefixed ordinary text, empty text and a tab-indented valid arm distinguish the literal-prefix condition.
+// @evidence contracts/testing.md#execution-ownership TestFormatPrintWidthTernaryArmIndentBonus 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 TestFormatPrintWidthTernaryArmIndentBonus(t *testing.T) {
+  src := "x\n  ? foo()\n  : bar()\nplain\n"
+  if got := ternaryArmIndentBonus(src, 6); got != 2 {
+    t.Fatalf("`? ` arm line: want bonus 2, got %d", got)
+  }
+  if got := ternaryArmIndentBonus(src, 14); got != 2 {
+    t.Fatalf("`: ` arm line: want bonus 2, got %d", got)
+  }
+  if got := ternaryArmIndentBonus(src, 23); got != 0 {
+    t.Fatalf("plain line: want bonus 0, got %d", got)
+  }
+  if got := ternaryArmIndentBonus(src, 0); got != 0 {
+    t.Fatalf("first line: want bonus 0, got %d", got)
+  }
+  for _, source := range []string{"?foo", ":bar", "?\tfoo", "  plain", ""} {
+    if got := ternaryArmIndentBonus(source, 0); got != 0 {
+      t.Fatalf("only a marker followed by a literal space receives a bonus: %q gave %d", source, got)
+    }
+  }
+  if got := ternaryArmIndentBonus("\t? value", 3); got != 2 {
+    t.Fatalf("a tab-indented marker plus space must receive two, got %d", got)
+  }
+}

package/linthost/format_print_width_trailing_line_width_excludes_trailing_line_comment_test.go

@@ -0,0 +1,38 @@
+package linthost
+
+import "testing"
+
+// TestFormatPrintWidthTrailingLineWidthExcludesTrailingLineComment
+// verifies trailingLineWidth stops at a `//` line comment instead of
+// charging the comment bytes against the suffix budget.
+//
+// A trailing line attachment does not spend the supported suffix
+// budget. This accounting is consumed by the rule's fast-path fit
+// check and flat-only suffix-reduced rendering. The direct helper
+// cases contrast line comments with counted block comments and a
+// newline boundary, without observing a benchmark branch or consumer.
+//
+//  1. Call trailingLineWidth across a `;` + trailing line comment.
+//  2. Assert the returned width covers only the un-movable `;`.
+//  3. Spot-check a leading-whitespace + comment case to lock the
+//     trimming branch.
+//  4. Contrast a counted block-comment suffix and the next-line stopping boundary.
+//
+// @evidence contracts/testing.md#behavioral-verification trailingLineWidth must exclude trailing line-comment bytes and whitespace, still charge twelve columns for the authored block-comment suffix, and stop at LF.
+// @evidence contracts/testing.md#independent-expectations Independent literal suffix lengths distinguish the free line attachment from the counted block-comment payload. Explicit one/zero/twelve results enforce the supported suffix budget without reading rule-generated output.
+// @evidence contracts/testing.md#distinguishing-cases Original semicolon/comment and whitespace/comment cases are retained; adjacent block-comment and newline-ending suffixes prevent treating all comments or later-line text as free.
+// @evidence contracts/testing.md#execution-ownership TestFormatPrintWidthTrailingLineWidthExcludesTrailingLineComment owns the original suffix assertions and added block-comment/newline boundaries through direct trailingLineWidth calls in the selected public Go unit population. Direct trailingLineWidth calls execute in one Go process without native builds, consumer installation or real product-host children.
+func TestFormatPrintWidthTrailingLineWidthExcludesTrailingLineComment(t *testing.T) {
+  if got := trailingLineWidth("; // trailing\n", 0, 2); got != 1 {
+    t.Fatalf("semi + line comment: want 1, got %d", got)
+  }
+  if got := trailingLineWidth("   // only a comment\n", 0, 2); got != 0 {
+    t.Fatalf("whitespace + line comment: want 0, got %d", got)
+  }
+  if got := trailingLineWidth("; /* tail */\n", 0, 2); got != 12 {
+    t.Fatalf("block comment remains charged: want 12, got %d", got)
+  }
+  if got := trailingLineWidth(";\nnext", 0, 2); got != 1 {
+    t.Fatalf("newline ends suffix: want 1, got %d", got)
+  }
+}

package/linthost/format_print_width_trailing_line_width_handles_guards_and_tabs_test.go

@@ -0,0 +1,51 @@
+package linthost
+
+import "testing"
+
+// TestFormatPrintWidthTrailingLineWidthHandlesGuardsAndTabs verifies
+// trailingLineWidth across its guard and tab-handling branches.
+//
+// The suffix budget must reject invalid offsets, trim trailing blank bytes and
+// expand tabs to actual stops. Direct calls distinguish those measurements
+// from formatter layout choices and include supported source line endings.
+//
+// 1. Retain invalid-offset, default-tab and trimmed-punctuation assertions.
+// 2. Check empty/exact-end suffixes and negative/explicit tab widths.
+// 3. Assert CR, CRLF, U+2028 and U+2029 terminate the measured suffix.
+//
+// @evidence contracts/testing.md#behavioral-verification trailingLineWidth must preserve original invalid-range/default-tab/trim results, handle empty/exact-end suffixes and measure four-column stops while ending at every supported line separator.
+// @evidence contracts/testing.md#independent-expectations Literal positions and manually counted tab stops independently fix suffix widths. Empty and invalid ranges have no suffix; CR/CRLF/LS/PS terminators separate the next-line payload from the measured x.
+// @evidence contracts/testing.md#distinguishing-cases Negative/past/end offsets, empty input, zero/negative tab widths, explicit mixed-space/tab stops, trimmed punctuation and four line-ending fixtures expose each meaningful boundary.
+// @evidence contracts/testing.md#execution-ownership TestFormatPrintWidthTrailingLineWidthHandlesGuardsAndTabs owns the original direct assertions and all added suffix/line-separator cases in the selected public Go unit population. Direct trailingLineWidth calls for the original and added cases execute in one Go process without native builds, consumer installation or real product-host children.
+func TestFormatPrintWidthTrailingLineWidthHandlesGuardsAndTabs(t *testing.T) {
+  if got := trailingLineWidth("abc", -1, 2); got != 0 {
+    t.Fatalf("negative end: want 0, got %d", got)
+  }
+  if got := trailingLineWidth("abc", 99, 2); got != 0 {
+    t.Fatalf("end past length: want 0, got %d", got)
+  }
+  // tabWidth<=0 falls back to 2; the leading tab then expands to a
+  // two-column stop and the trailing `x` adds one.
+  if got := trailingLineWidth("\tx", 0, 0); got != 3 {
+    t.Fatalf("tab suffix with default tabWidth: want 3, got %d", got)
+  }
+  // Trailing whitespace after `);` is trimmed before the width is
+  // measured, so only the two non-space columns count.
+  if got := trailingLineWidth(");   \n", 0, 2); got != 2 {
+    t.Fatalf("trailing whitespace trimmed: want 2, got %d", got)
+  }
+  if trailingLineWidth("", 0, 2) != 0 || trailingLineWidth("abc", 3, 2) != 0 {
+    t.Fatal("empty and exact-end suffixes have zero columns")
+  }
+  if got := trailingLineWidth("\tx", 0, -1); got != 3 {
+    t.Fatalf("negative width uses default stops: want 3, got %d", got)
+  }
+  if got := trailingLineWidth(" \tx", 0, 4); got != 5 {
+    t.Fatalf("space then tab reaches four-column stop: want 5, got %d", got)
+  }
+  for _, source := range []string{"x\rnext", "x\r\nnext", "x\u2028next", "x\u2029next"} {
+    if got := trailingLineWidth(source, 0, 2); got != 1 {
+      t.Fatalf("line separator ends suffix in %q: want 1, got %d", source, got)
+    }
+  }
+}

package/linthost/format_quote_props_consistent_preserves_cooked_identifier_keys_test.go

@@ -0,0 +1,37 @@
+package linthost
+
+import "testing"
+
+// TestFormatQuotePropsConsistentPreservesCookedIdentifierKeys verifies that
+// adding quotes preserves the identifier's property name rather than its raw
+// escape spelling.
+//
+// Identifier escapes are decoded by the language before selecting the key.
+// Quoting a raw backslash with another backslash instead creates a different
+// property. A neighboring key requiring quotes activates consistent mode.
+//
+// 1. Run the real consistent quote-props fixer on two escaped identifiers.
+// 2. Require quoted output to contain their decoded property names.
+// 3. Keep ordinary ASCII and literal Unicode identifier controls equivalent.
+//
+// @evidence contracts/testing.md#behavioral-verification assertFixSnapshotWithOptions runs format/quote-props under consistent mode, applies its real edits and compares complete output for fixed-width and braced identifier escapes plus plain ASCII and literal Unicode controls.
+// @evidence contracts/testing.md#independent-expectations ECMAScript decodes identifier Unicode escapes before defining the property; the authored quoted foo and alpha keys independently name those decoded values. Doubling a raw backslash would define an unrelated key.
+// @evidence contracts/testing.md#distinguishing-cases Fixed-width and braced escapes both need decoding; ordinary ASCII and literal Unicode spellings need no decoding. A bar-baz sibling requires consistent quoting in every row, while the untouched surrounding source detects accidental edits.
+// @evidence contracts/testing.md#execution-ownership This discoverable Go Test and four named subtests call assertFixSnapshotWithOptions, which executes the owning Engine and applies actual fixes to private fixture files in the same process. No consumer installation, native build or real product host runs.
+func TestFormatQuotePropsConsistentPreservesCookedIdentifierKeys(t *testing.T) {
+  rows := []struct {
+    name     string
+    source   string
+    expected string
+  }{
+    {"fixed-width", "const value = { f\\u006fo: 1, \"bar-baz\": 2 };\n", "const value = { \"foo\": 1, \"bar-baz\": 2 };\n"},
+    {"braced", "const value = { \\u{66}oo: 1, \"bar-baz\": 2 };\n", "const value = { \"foo\": 1, \"bar-baz\": 2 };\n"},
+    {"plain-ascii", "const value = { foo: 1, \"bar-baz\": 2 };\n", "const value = { \"foo\": 1, \"bar-baz\": 2 };\n"},
+    {"literal-unicode", "const value = { α: 1, \"bar-baz\": 2 };\n", "const value = { \"α\": 1, \"bar-baz\": 2 };\n"},
+  }
+  for _, row := range rows {
+    t.Run(row.name, func(t *testing.T) {
+      assertFixSnapshotWithOptions(t, "format/quote-props", row.source, `{"mode":"consistent"}`, row.expected)
+    })
+  }
+}

package/linthost/format_quote_props_consistent_quotes_mixed_object_test.go

@@ -0,0 +1,28 @@
+package linthost
+
+import "testing"
+
+// TestFormatQuotePropsConsistentQuotesMixedObject verifies that `consistent`
+// quotes an unquoted object key when a sibling requires quotes.
+//
+// This changing fixture distinguishes the add-quote direction from a
+// no-op on an already quoted group. The supported consistent policy
+// chooses one spelling for the entire object key group.
+//
+// 1. Parse an object with an identifier key and a punctuation-bearing key.
+// 2. Apply format/quote-props with mode `consistent`.
+// 3. Assert the identifier key is quoted with its sibling.
+//
+// @evidence contracts/testing.md#behavioral-verification format/quote-props consistent mode must quote the bare foo key when bar-baz requires quotes, preserving both values and property names.
+// @evidence contracts/testing.md#independent-expectations The complete literal output follows the supported object-wide consistency policy: bar-baz cannot be an IdentifierName, so foo gains quotes while retaining its string property key and value.
+// @evidence contracts/testing.md#distinguishing-cases This add-quote positive starts with a genuinely mixed group; all-identifier consistent unquoting owns the opposite direction, and as-needed keeps-non-identifier owns the same input under a different mode.
+// @evidence contracts/testing.md#execution-ownership TestFormatQuotePropsConsistentQuotesMixedObject is a public Go unit selected by the lint semantic-unit Evidence claim. The shared syntax-only harness invokes the owning rule and applies edits in process for this host's literal inputs and complete output comparisons. No consumer install, native product build or product host is started.
+func TestFormatQuotePropsConsistentQuotesMixedObject(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/quote-props",
+    "const c = { foo: 1, \"bar-baz\": 2 };\n",
+    `{"mode":"consistent"}`,
+    "const c = { \"foo\": 1, \"bar-baz\": 2 };\n",
+  )
+}

package/linthost/format_quote_props_consistent_unquotes_all_identifier_keys_test.go

@@ -0,0 +1,24 @@
+package linthost
+
+import "testing"
+
+// Test_format_quote_props_consistent_unquotes_all_identifier_keys verifies
+// the "consistent" mode positive path: when every key is a plain
+// identifier, all redundant quotes are removed together.
+//
+//  1. Provide an object literal whose keys are all quoted identifiers.
+//  2. Run the format/quote-props rule in "consistent" mode.
+//  3. Expect both keys to lose their quotes, since unquoting keeps the
+//     object consistent.
+//
+// @evidence contracts/testing.md#behavioral-verification format/quote-props consistent mode must remove both a and b key quotes when every object key can use an identifier spelling.
+// @evidence contracts/testing.md#independent-expectations The complete output literal follows the all-removable object-group policy and retains property keys a and b, their numeric values and the const declaration.
+// @evidence contracts/testing.md#distinguishing-cases This remove-quote positive owns two removable siblings; consistent mixed-object quoting distinguishes the other group decision and preserve mode owns the option that forbids changes.
+// @evidence contracts/testing.md#execution-ownership Test_format_quote_props_consistent_unquotes_all_identifier_keys is a public Go unit selected by the lint semantic-unit Evidence claim. The shared syntax-only harness invokes the owning rule and applies edits in process for this host's literal inputs and complete output comparisons. No consumer install, native product build or product host is started.
+func Test_format_quote_props_consistent_unquotes_all_identifier_keys(t *testing.T) {
+  const ruleID = "format/quote-props"
+  const source = "const a = { \"a\": 1, \"b\": 2 };\n"
+  const optionsJSON = "{\"mode\":\"consistent\"}"
+  const expected = "const a = { a: 1, b: 2 };\n"
+  assertFixSnapshotWithOptions(t, ruleID, source, optionsJSON, expected)
+}