@ttsc/lint 0.30.3 → 0.31.0

package/linthost/format_declaration_header_keeps_single_heritage_type_inline_test.go

@@ -0,0 +1,26 @@
+package linthost
+
+import "testing"
+
+// TestFormatDeclarationHeaderKeepsSingleHeritageTypeInline verifies a
+// lone `extends X<Y>` with one argument remains inline even when it overflows.
+//
+// Prettier keeps a single heritage type inline (it has nothing to break
+// into a list), so the rule must abstain rather than invent a break.
+//
+//  1. Parse an interface with one long extends type (printWidth 50).
+//  2. Run format/declaration-header.
+//  3. Assert the rule reports nothing.
+//
+// @evidence contracts/testing.md#behavioral-verification format/declaration-header must emit no finding for an overflowing lone heritage type with one type argument rather than inventing a type-list break.
+// @evidence contracts/testing.md#independent-expectations The single SomeReallyLongBaseInterfaceName<WithArgs> fixture has no multi-argument list to explode; its unchanged-header layout follows the one-argument heritage convention.
+// @evidence contracts/testing.md#distinguishing-cases The overflowing one-argument negative complements the actual two-argument Serializer heritage explosion and multiple-type clause positives.
+// @evidence contracts/testing.md#execution-ownership TestFormatDeclarationHeaderKeepsSingleHeritageTypeInline is selected by the lint semantic-unit Evidence claim as a public Go unit. The shared syntax-only harness calls the owning declaration-header rule on temporary fixture source and observes zero findings without consumer installation, native product build or a host process.
+func TestFormatDeclarationHeaderKeepsSingleHeritageTypeInline(t *testing.T) {
+  assertRuleSkipsSourceWithOptions(
+    t,
+    "format/declaration-header",
+    "interface A extends SomeReallyLongBaseInterfaceName<WithArgs> {\n  a: number;\n}\n",
+    `{"printWidth":50,"tabWidth":2}`,
+  )
+}

package/linthost/format_declaration_header_multi_clause_honors_crlf_end_of_line_test.go

@@ -0,0 +1,30 @@
+package linthost
+
+import "testing"
+
+// TestFormatDeclarationHeaderMultiClauseHonorsCRLFEndOfLine verifies the
+// multi-clause header reflow synthesizes CRLF breaks under endOfLine:"crlf".
+//
+// The reflow builder must use the configured layout EOL instead of adding lone
+// LFs to this CRLF class header. The direct assertions do not reproduce a past
+// mixed-ending result. Bound to the CRLF oracle (the LF twin lives in
+// format_declaration_header_breaks_multiple_clauses_test.go), and the helper
+// additionally asserts every "\n" belongs to a "\r\n".
+//
+//  1. Parse a CRLF class whose extends+implements header overflows width 50.
+//  2. Apply format/declaration-header with {"endOfLine":"crlf"}.
+//  3. Assert each synthesized break is "\r\n" and no lone LF remains.
+//
+// @evidence contracts/testing.md#behavioral-verification format/declaration-header must break extends, implements and the class brace with CRLF while retaining Base, four implemented types and a=1.
+// @evidence contracts/testing.md#independent-expectations The full literal expected source and explicit crlf option independently determine exact separators; the additional no-lone-LF check rejects mixed output.
+// @evidence contracts/testing.md#distinguishing-cases This changed CRLF multi-clause class is the separator counterpart to the LF positive and canonical broken-clause no-op, exercising every synthesized clause/brace break.
+// @evidence contracts/testing.md#execution-ownership TestFormatDeclarationHeaderMultiClauseHonorsCRLFEndOfLine is selected by the lint semantic-unit Evidence claim as a public Go unit. The shared syntax-only harness calls the owning declaration-header rule on temporary fixture source and applies reported edits for the literal output assertion without consumer installation, native product build or a host process.
+func TestFormatDeclarationHeaderMultiClauseHonorsCRLFEndOfLine(t *testing.T) {
+  assertFixCRLFConsistentWithOptions(
+    t,
+    "format/declaration-header",
+    "class C extends Base implements First, Second, Third, Fourth {\r\n  a = 1;\r\n}\r\n",
+    `{"printWidth":50,"tabWidth":2,"endOfLine":"crlf"}`,
+    "class C\r\n  extends Base\r\n  implements First, Second, Third, Fourth\r\n{\r\n  a = 1;\r\n}\r\n",
+  )
+}

package/linthost/format_declaration_header_multi_type_honors_crlf_end_of_line_test.go

@@ -0,0 +1,30 @@
+package linthost
+
+import "testing"
+
+// TestFormatDeclarationHeaderMultiTypeHonorsCRLFEndOfLine verifies the
+// single-clause multi-type explode reflow synthesizes CRLF breaks under
+// endOfLine:"crlf".
+//
+// The multiTypeHeader builder must use the configured EOL per exploded type,
+// rather than inject lone LFs into this CRLF file. Bound
+// to the CRLF oracle (LF twin: format_declaration_header_breaks_multi_type_
+// interface_test.go); the helper asserts zero lone LFs.
+//
+//  1. Parse a CRLF interface whose extends list overflows width 50.
+//  2. Apply format/declaration-header with {"endOfLine":"crlf"}.
+//  3. Assert the keyword and each type break with "\r\n" and no lone LF remains.
+//
+// @evidence contracts/testing.md#behavioral-verification format/declaration-header must explode the six-type extends clause with CRLF separators and retain the number-typed member.
+// @evidence contracts/testing.md#independent-expectations The independently authored full CRLF output preserves the heritage order and annotation; the extra lone-LF rejection verifies consistency beyond visual layout.
+// @evidence contracts/testing.md#distinguishing-cases This changed CRLF multi-type interface complements the LF six-type positive and first-tier inline-types layout, covering keyword and each list-element break.
+// @evidence contracts/testing.md#execution-ownership TestFormatDeclarationHeaderMultiTypeHonorsCRLFEndOfLine is selected by the lint semantic-unit Evidence claim as a public Go unit. The shared syntax-only harness calls the owning declaration-header rule on temporary fixture source and applies reported edits for the literal output assertion without consumer installation, native product build or a host process.
+func TestFormatDeclarationHeaderMultiTypeHonorsCRLFEndOfLine(t *testing.T) {
+  assertFixCRLFConsistentWithOptions(
+    t,
+    "format/declaration-header",
+    "interface B extends First, Second, Third, Fourth, Fifth, Sixth {\r\n  a: number;\r\n}\r\n",
+    `{"printWidth":50,"tabWidth":2,"endOfLine":"crlf"}`,
+    "interface B\r\n  extends\r\n    First,\r\n    Second,\r\n    Third,\r\n    Fourth,\r\n    Fifth,\r\n    Sixth {\r\n  a: number;\r\n}\r\n",
+  )
+}

package/linthost/format_declaration_header_type_param_explode_honors_crlf_end_of_line_test.go

@@ -0,0 +1,32 @@
+package linthost
+
+import "testing"
+
+// TestFormatDeclarationHeaderTypeParamExplodeHonorsCRLFEndOfLine verifies the
+// type-parameter explode reflow (including the break-after-`=` default hang)
+// synthesizes CRLF breaks under endOfLine:"crlf".
+//
+// The typeParamExplodeHeader and renderExplodedTypeParam builders must use the
+// configured EOL for the `<`, per-parameter and default-hang breaks rather than
+// inject lone LFs into this CRLF file. Bound to the CRLF oracle
+// (LF twin: format_declaration_header_
+// breaks_type_param_default_after_equals_test.go); the helper asserts zero
+// lone LFs.
+//
+//  1. Parse a CRLF class with one long defaulted type parameter (width 50).
+//  2. Apply format/declaration-header with {"endOfLine":"crlf"}.
+//  3. Assert the list explodes and the default hangs with "\r\n", no lone LF.
+//
+// @evidence contracts/testing.md#behavioral-verification format/declaration-header must explode a long constrained/defaulted type parameter with CRLF at the angle-list and equals-default breaks while preserving a=1.
+// @evidence contracts/testing.md#independent-expectations The full independently authored escaped CRLF output specifies the default hang and trailing comma; the helper additionally rejects every lone LF.
+// @evidence contracts/testing.md#distinguishing-cases This changed CRLF defaulted-parameter case complements its LF positive and generic/multi-clause abstention, exercising both list explosion and nested default indentation.
+// @evidence contracts/testing.md#execution-ownership TestFormatDeclarationHeaderTypeParamExplodeHonorsCRLFEndOfLine is a public Go unit selected by the lint semantic-unit Evidence claim. The shared syntax-only fixture harness invokes the owning declaration-header rule and applies edits for complete literal output comparison in the same Go process without consumer installation, a native product build or a product host.
+func TestFormatDeclarationHeaderTypeParamExplodeHonorsCRLFEndOfLine(t *testing.T) {
+  assertFixCRLFConsistentWithOptions(
+    t,
+    "format/declaration-header",
+    "class E<TVeryLongTypeParam extends SomeConstraint = DefaultType> {\r\n  a = 1;\r\n}\r\n",
+    `{"printWidth":50,"tabWidth":2,"endOfLine":"crlf"}`,
+    "class E<\r\n  TVeryLongTypeParam extends SomeConstraint =\r\n    DefaultType,\r\n> {\r\n  a = 1;\r\n}\r\n",
+  )
+}

package/linthost/format_defaults_apply_without_format_config_test.go

@@ -0,0 +1,46 @@
+package linthost
+
+import (
+  "testing"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+// TestFormatDefaultsApplyWithoutFormatConfig verifies the format resolver admits
+// the documented default semi rule without configured format rules.
+//
+// With an empty resolver, newFormatCommandResolver loads the always-on defaults.
+// This direct Engine case requires a fix-bearing format/semi finding. LSP and
+// format command consumers use the same constructor, but this body does not
+// execute an editor save or assert the final rewritten source.
+//
+// 1. Build a format resolver over an empty config from a temp dir.
+// 2. Run the engine on a source missing its statement terminator.
+// 3. Assert the default format/semi rule fires.
+//
+// @evidence contracts/testing.md#behavioral-verification An empty format resolver still runs the rule engine on const x = 1 without a terminator and must report a format/semi finding.
+// @evidence contracts/testing.md#independent-expectations The authored unterminated declaration and the documented always-on semi rule independently require the named finding; this host asserts admission, while fix snapshots own the edited text.
+// @evidence contracts/testing.md#distinguishing-cases One positive case: an empty rule config yields the always-on default format rules, so an unterminated `const x = 1` produces a format/semi finding. Only the presence of the finding is asserted, not its edit text; the rewritten output is owned by the command format tests.
+// @evidence contracts/testing.md#execution-ownership TestFormatDefaultsApplyWithoutFormatConfig owns its empty resolver, parsed source and direct Engine finding assertions in the public Go unit population. It starts no consumer install, native build, editor session or separately built product host.
+func TestFormatDefaultsApplyWithoutFormatConfig(t *testing.T) {
+  resolver, err := newFormatCommandResolver(RuleConfig{}, t.TempDir(), "")
+  if err != nil {
+    t.Fatalf("newFormatCommandResolver: %v", err)
+  }
+  file := parseTS(t, "const x = 1\n")
+  findings := filterFormatFindings(
+    NewEngineWithResolver(resolver).Run([]*shimast.SourceFile{file}, nil),
+  )
+  if len(findings) == 0 {
+    t.Fatalf("expected default format rules to fire without a format block")
+  }
+  found := false
+  for _, finding := range findings {
+    if finding.Rule == "format/semi" {
+      found = true
+    }
+  }
+  if !found {
+    t.Fatalf("expected default format/semi to fire; got %d findings", len(findings))
+  }
+}

package/linthost/format_indent_case_block_body_matches_case_depth_test.go

@@ -0,0 +1,30 @@
+package linthost
+
+import "testing"
+
+// TestFormatIndentCaseBlockBodyMatchesCaseDepth verifies a statement
+// inside an explicit `case X: { ... }` block is indented to the case
+// body's depth, not one level deeper.
+//
+// The supported layout gives a block opened on the case-label line no
+// additional body level. This literal positive distinguishes counting
+// both the case clause and that same-line block as separate levels.
+//
+//  1. Parse a switch whose case body is a block with an over-indented
+//     statement.
+//  2. Apply format/indent (tabWidth 2).
+//  3. Assert the statement lands at the case-body depth (4), not 6.
+//
+// @evidence contracts/testing.md#behavioral-verification format/indent must move the over-indented doThing statement to four spaces inside a block opened on the case-label line. Complete source distinguishes counting that same-line block as an extra indentation level and retains all switch/call tokens.
+// @evidence contracts/testing.md#independent-expectations The supported same-line case-block layout puts its statements at the ordinary case-body column. This dedicated rule oracle retains the original missing call semicolon because terminator spelling belongs to a different rule.
+// @evidence contracts/testing.md#distinguishing-cases This positive opens the explicit block on the case label line and starts its statement eight spaces deep. NormalizesSwitchCaseBodyDepth covers an unbraced case body; this host does not claim all separately opened nested blocks have the same depth.
+// @evidence contracts/testing.md#execution-ownership TestFormatIndentCaseBlockBodyMatchesCaseDepth owns its literal input/options/output in the public Go unit population. The syntax-only harness calls the owning rule and applies edits in process without installing a consumer, building native artifacts or starting a real product host.
+func TestFormatIndentCaseBlockBodyMatchesCaseDepth(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/indent",
+    "switch (s) {\n  case A: {\n        doThing()\n  }\n}\n",
+    `{"tabWidth":2}`,
+    "switch (s) {\n  case A: {\n    doThing()\n  }\n}\n",
+  )
+}

package/linthost/format_indent_cedes_body_under_multiline_arrow_head_test.go

@@ -0,0 +1,39 @@
+package linthost
+
+import "testing"
+
+// TestFormatIndentCedesBodyUnderMultilineArrowHead verifies format/indent
+// does NOT de-indent a block body whose enclosing block opens on a wrapped
+// continuation line. The curried arrow's `): void => {` head sits
+// at a non-zero indent. The body hangs under that head's indent, not under
+// depth*tabWidth from column 0, so format/indent must cede. The literal
+// no-finding oracle protects the nested `if` and `injectHook` columns
+// without running a complete formatter or an external reference.
+//
+//  1. Parse a curried arrow with a correctly-indented multi-line body.
+//  2. Run format/indent.
+//  3. Assert the rule reports nothing (the source is already correct).
+//
+// @evidence contracts/testing.md#behavioral-verification format/indent must return no findings for the correctly laid-out curried arrow body and its nested if. The no-finding assertion catches depth-based de-indentation of a continuation-owned body or its inner block.
+// @evidence contracts/testing.md#independent-expectations The supported formatter ownership policy leaves chained and wrapped arrow indentation to the continuation layout. The authored body, condition, injectHook call and closing columns remain unchanged expected source rather than reconstructed depth results.
+// @evidence contracts/testing.md#distinguishing-cases The negative includes a generic outer arrow, a wrapped inner arrow header and nested multiline if. StillFixesSingleLineHeadArrowBody supplies an ordinary one-head arrow positive so ceding every arrow would fail the family.
+// @evidence contracts/testing.md#execution-ownership TestFormatIndentCedesBodyUnderMultilineArrowHead owns its parsed source and no-finding oracle in the public Go unit population. The syntax-only owning operation runs in process without a consumer install, native artifact build or real product host.
+func TestFormatIndentCedesBodyUnderMultilineArrowHead(t *testing.T) {
+  assertRuleSkipsSourceWithOptions(
+    t,
+    "format/indent",
+    "export const createHook =\n"+
+      "  <T extends Function = () => any>(lifecycle: LifecycleHooks) =>\n"+
+      "  (\n"+
+      "    hook: T,\n"+
+      "  ): void => {\n"+
+      "    if (\n"+
+      "      a ||\n"+
+      "      b\n"+
+      "    ) {\n"+
+      "      injectHook(c)\n"+
+      "    }\n"+
+      "  }\n",
+    `{"tabWidth":2}`,
+  )
+}

package/linthost/format_indent_cedes_callback_argument_body_test.go

@@ -0,0 +1,31 @@
+package linthost
+
+import "testing"
+
+// TestFormatIndentCedesCallbackArgumentBody verifies format/indent does
+// not re-indent a statement that lives inside a call-argument callback,
+// ceding its indentation to format/print-width.
+//
+// format/indent measures depth by block nesting only; a callback body
+// hung under its call-argument column sits deeper than that depth, so
+// this dedicated rule cannot derive that expression-owned column.
+// The indentCededToReflow guard makes the rule abstain here. This body
+// does not run print-width or assert convergence of a format cascade.
+//
+//  1. Parse a call whose arrow argument body is indented past its block
+//     depth.
+//  2. Run format/indent.
+//  3. Assert the rule reports nothing (the body is left to print-width).
+//
+// @evidence contracts/testing.md#behavioral-verification format/indent must produce no findings for the call-argument arrow body, preserving an expression-owned indentation column rather than forcing its statement to block depth.
+// @evidence contracts/testing.md#independent-expectations Callback layout belongs to the printer/reflow owner, so the dedicated indentation rule must abstain even when its simple block-depth model would choose another column. This local-rule oracle does not assert that a complete formatter leaves the deliberately deeper source unchanged.
+// @evidence contracts/testing.md#distinguishing-cases The callback body is six spaces deep and remains outside this rule ownership. StillFixesSingleLineHeadArrowBody covers the adjacent standalone arrow initializer that the rule does own.
+// @evidence contracts/testing.md#execution-ownership TestFormatIndentCedesCallbackArgumentBody owns the no-finding callback fixture in the public Go unit population. The shared syntax-only harness executes the owning rule in process with no consumer installation, native build or real product host.
+func TestFormatIndentCedesCallbackArgumentBody(t *testing.T) {
+  assertRuleSkipsSourceWithOptions(
+    t,
+    "format/indent",
+    "register(() => {\n      doThing()\n})\n",
+    `{"tabWidth":2}`,
+  )
+}

package/linthost/format_indent_defers_shared_line_to_statement_split_test.go

@@ -0,0 +1,32 @@
+package linthost
+
+import "testing"
+
+// TestFormatIndentDefersSharedLineToStatementSplit verifies the rule
+// abstains on a statement that shares a line with a preceding statement.
+//
+// A statement that is not the first token on its line is
+// `format/statement-split`'s surface; reindenting it here would overlap
+// that rule's edit on one cascade pass. Keeping the two rules disjoint
+// leaves the later statement untouched while the line-leading statement can
+// still have its indentation corrected. This pins that ownership boundary.
+//
+//  1. Parse correctly indented and over-indented shared lines inside a block.
+//  2. Run the rule.
+//  3. Assert the correct input emits no findings and only the other line's
+//     leading indentation changes, retaining its second statement.
+//
+// @evidence contracts/testing.md#behavioral-verification format/indent must leave the original correctly indented shared line alone and correct only its leading indentation when the same first statement is over-indented. Complete output preserves the second statement on that line for statement-split ownership.
+// @evidence contracts/testing.md#independent-expectations The supported two-space function-body layout determines the leading replacement independently of edit calculations. Splitting the second const declaration belongs to the sibling rule, so its literal token sequence and separating gap remain unchanged.
+// @evidence contracts/testing.md#distinguishing-cases The original no-finding case stays, and an otherwise identical six-space line is a positive requiring two spaces. Together they distinguish ceding the later statement from incorrectly skipping the whole shared line.
+// @evidence contracts/testing.md#execution-ownership TestFormatIndentDefersSharedLineToStatementSplit owns both literal fixtures and their separate skip/output assertions in the public Go unit population. The syntax-only harness runs the owning rule and edit application in process without consumer installation, native building or a real product host.
+func TestFormatIndentDefersSharedLineToStatementSplit(t *testing.T) {
+  assertRuleSkipsSource(
+    t,
+    "format/indent",
+    "function f() {\n  const a = 1; const b = 2;\n}\n",
+  )
+  assertFixSnapshot(t, "format/indent",
+    "function f() {\n      const a = 1; const b = 2;\n}\n",
+    "function f() {\n  const a = 1; const b = 2;\n}\n")
+}

package/linthost/format_indent_honors_custom_tab_width_test.go

@@ -0,0 +1,28 @@
+package linthost
+
+import "testing"
+
+// TestFormatIndentHonorsCustomTabWidth verifies the rule scales the
+// space indent by a custom `tabWidth`.
+//
+// Under tabWidth 4 a depth-1 statement sits at four spaces, not the
+// default two. This pins that `format/indent` multiplies depth by the
+// configured tabWidth.
+//
+//  1. Parse a function whose body statement is flush left.
+//  2. Apply the rule with `{"tabWidth":4}` through the disk-backed fixer.
+//  3. Assert the body statement is indented to four spaces.
+//
+// @evidence contracts/testing.md#behavioral-verification format/indent must indent the flush-left return by four spaces when tabWidth is four. The complete source snapshot distinguishes ignoring the custom option and preserves the return value and function structure.
+// @evidence contracts/testing.md#independent-expectations The supported tabWidth option sets the space count for one ordinary block level. The literal four-space output is authored from that option contract without calling the implementation layout renderer.
+// @evidence contracts/testing.md#distinguishing-cases This positive owns custom four-space indentation; NormalizesOverIndentedBlockStatement supplies default two-space behavior and HonorsUseTabsOption supplies the distinct tab character mode.
+// @evidence contracts/testing.md#execution-ownership TestFormatIndentHonorsCustomTabWidth owns its source, option and expected bytes in the public Go unit population. The syntax-only owning rule and disk-backed edit application run in the same process without consumer installation, native artifact production or a product host.
+func TestFormatIndentHonorsCustomTabWidth(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/indent",
+    "function f() {\nreturn 1;\n}\n",
+    `{"tabWidth":4}`,
+    "function f() {\n    return 1;\n}\n",
+  )
+}

package/linthost/format_indent_honors_use_tabs_option_test.go

@@ -0,0 +1,28 @@
+package linthost
+
+import "testing"
+
+// TestFormatIndentHonorsUseTabsOption verifies the rule indents with tab
+// characters when `useTabs` is set.
+//
+// Under useTabs the depth-N indent is N tab characters, not N*tabWidth
+// spaces. This pins that `format/indent` reads the shared layout's
+// useTabs flag rather than always emitting spaces.
+//
+//  1. Parse a function whose body statement is flush left.
+//  2. Apply the rule with `{"useTabs":true}` through the disk-backed fixer.
+//  3. Assert the body statement is indented with one tab.
+//
+// @evidence contracts/testing.md#behavioral-verification format/indent must insert one tab before the flush-left function return under useTabs. The literal byte comparison distinguishes silently rendering spaces and retains the return value.
+// @evidence contracts/testing.md#independent-expectations The supported useTabs mode uses one tab per block indentation level. The expected tab byte is independent of the shared layout computation, while the ordinary function header and closing brace remain unchanged.
+// @evidence contracts/testing.md#distinguishing-cases This positive changes the one-level body to a tab; HonorsCustomTabWidth and the default two-space host cover adjacent space-based option behavior.
+// @evidence contracts/testing.md#execution-ownership TestFormatIndentHonorsUseTabsOption owns its literal fixture and useTabs option in the public Go unit population. The owning rule/edit harness works in the same process without installing a consumer, building native artifacts or launching a real product host.
+func TestFormatIndentHonorsUseTabsOption(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/indent",
+    "function f() {\nreturn 1;\n}\n",
+    `{"useTabs":true}`,
+    "function f() {\n\treturn 1;\n}\n",
+  )
+}

package/linthost/format_indent_idempotent_on_correct_class_body_test.go

@@ -0,0 +1,27 @@
+package linthost
+
+import "testing"
+
+// TestFormatIndentIdempotentOnCorrectClassBody verifies an
+// already-correct class method body produces zero edits.
+//
+// The class frame and the method block each contribute one level, so
+// the literal four-space return must remain unchanged. This pins a
+// fixed point of the dedicated rule, without running a formatter cascade
+// or an external reference.
+//
+//  1. Parse a class whose method body is already at four spaces.
+//  2. Run the rule.
+//  3. Assert it emits no finding.
+//
+// @evidence contracts/testing.md#behavioral-verification format/indent must emit no findings for an already canonical class method return at four spaces. This assertion detects incorrectly forgetting the class-body level and de-indenting valid source.
+// @evidence contracts/testing.md#independent-expectations The supported two-level class/method block layout independently puts the return at four spaces with the member header at two. No-finding is required because every owned leading run already matches that literal layout.
+// @evidence contracts/testing.md#distinguishing-cases This canonical negative complements NormalizesClassMethodBodyDepth, whose flush-left return must change to the same four-space column. Idempotency here does not stand in for the positive repair.
+// @evidence contracts/testing.md#execution-ownership TestFormatIndentIdempotentOnCorrectClassBody owns its canonical no-finding fixture in the public Go unit population. The syntax-only harness directly runs the owning rule in process without consumer installation, native production or a real product host.
+func TestFormatIndentIdempotentOnCorrectClassBody(t *testing.T) {
+  assertRuleSkipsSource(
+    t,
+    "format/indent",
+    "class C {\n  m() {\n    return 1;\n  }\n}\n",
+  )
+}

package/linthost/format_indent_idempotent_on_correct_nested_block_test.go

@@ -0,0 +1,26 @@
+package linthost
+
+import "testing"
+
+// TestFormatIndentIdempotentOnCorrectNestedBlock verifies the rule emits
+// no finding when nested block statements are already correctly indented.
+//
+// A statement at the right column compares equal to its desired indent
+// and must produce nothing. This pins that a canonically-indented file is
+// a fixed point of `format/indent`, including a two-deep block nest.
+//
+//  1. Parse a function holding an if-block, all at canonical indent.
+//  2. Run the rule.
+//  3. Assert it emits no finding.
+//
+// @evidence contracts/testing.md#behavioral-verification format/indent must emit no findings for the function containing a correctly indented if block, including its nested return and closing braces. This catches changing a valid nested-block fixed point.
+// @evidence contracts/testing.md#independent-expectations The supported ordinary block layout uses two spaces for the if and four for its return. The literal canonical input independently establishes those columns and the required absence of edits.
+// @evidence contracts/testing.md#distinguishing-cases This negative has two nested block levels with each owned line already correct. NormalizesOverIndentedBlockStatement supplies an incorrect ordinary body positive; class and decorated-member fixed-point hosts cover other frames.
+// @evidence contracts/testing.md#execution-ownership TestFormatIndentIdempotentOnCorrectNestedBlock owns its full parsed source and no-finding assertion in the public Go unit population. The direct syntax-only rule executes in process without a consumer install, native artifact build or real product host.
+func TestFormatIndentIdempotentOnCorrectNestedBlock(t *testing.T) {
+  assertRuleSkipsSource(
+    t,
+    "format/indent",
+    "function f() {\n  if (x) {\n    return 1;\n  }\n}\n",
+  )
+}

package/linthost/format_indent_idempotent_on_decorated_member_test.go

@@ -0,0 +1,29 @@
+package linthost
+
+import "testing"
+
+// TestFormatIndentIdempotentOnDecoratedMember verifies an already-correct
+// decorated member is a fixed point.
+//
+// The decorated-member declaration-line pass must not fight a canonical
+// layout: when the decorator line and the declaration line both already sit
+// at member depth, the rule must emit nothing. This literal no-finding
+// oracle protects both lines without asserting a formatter cascade's
+// pass sequence or convergence.
+//
+//  1. Parse a class whose decorator and declaration lines are both at two
+//     spaces.
+//  2. Run the rule.
+//  3. Assert it emits no finding.
+//
+// @evidence contracts/testing.md#behavioral-verification format/indent must return no findings when both the decorator and its separate declaration line already have two spaces. This catches an unnecessary second declaration edit that could prevent formatter convergence.
+// @evidence contracts/testing.md#independent-expectations The supported class-member layout puts both leading decorator and member declaration at the same member column. The literal input already meets that contract independently of member position scanning.
+// @evidence contracts/testing.md#distinguishing-cases This canonical single-decorator negative complements NormalizesDecoratedMemberDeclarationLine, where both lines are flush left, and NormalizesMultipleDecoratorLines, which owns the final-decorator boundary.
+// @evidence contracts/testing.md#execution-ownership TestFormatIndentIdempotentOnDecoratedMember owns its canonical fixture in the public Go unit population. The syntax-only harness calls the owning rule in process without consumer installation, native artifact production or starting a product host.
+func TestFormatIndentIdempotentOnDecoratedMember(t *testing.T) {
+  assertRuleSkipsSource(
+    t,
+    "format/indent",
+    "class User {\n  @Column()\n  name: string = \"\";\n}\n",
+  )
+}

package/linthost/format_indent_normalizes_class_method_body_depth_test.go

@@ -0,0 +1,29 @@
+package linthost
+
+import "testing"
+
+// TestFormatIndentNormalizesClassMethodBodyDepth verifies a class method
+// body statement lands at depth 2 (four spaces) under the default
+// tabWidth.
+//
+// A class body is a descend-only +1 frame: it is not a statement list,
+// but a method's Block nests inside it, adding another +1, so a
+// method-body statement sits at depth 2. Without counting the class-body
+// frame the statement would land one indentation level short. This pins that fix.
+//
+//  1. Parse a class whose method body statement is flush left.
+//  2. Apply the rule's finding through the disk-backed fixer.
+//  3. Assert the body statement is re-indented to four spaces.
+//
+// @evidence contracts/testing.md#behavioral-verification format/indent must move the flush-left class method return to four spaces while leaving the two-space member header intact. Complete source catches omitting the class frame and choosing the ordinary function-body column.
+// @evidence contracts/testing.md#independent-expectations The supported two-space class layout nests the method body one level below the member, so the literal return indentation is four spaces. The expected source retains the return value and braces independently of the depth walk.
+// @evidence contracts/testing.md#distinguishing-cases This positive repairs a flush-left return under an already correctly positioned method header. IdempotentOnCorrectClassBody supplies the canonical no-finding counterpart.
+// @evidence contracts/testing.md#execution-ownership TestFormatIndentNormalizesClassMethodBodyDepth owns its literal source/output in the public Go unit population. The owning rule and syntax-only disk-backed edit harness execute in process without installing a consumer, producing a native artifact or starting a product host.
+func TestFormatIndentNormalizesClassMethodBodyDepth(t *testing.T) {
+  assertFixSnapshot(
+    t,
+    "format/indent",
+    "class C {\n  m() {\nreturn 1;\n  }\n}\n",
+    "class C {\n  m() {\n    return 1;\n  }\n}\n",
+  )
+}

package/linthost/format_indent_normalizes_decorated_member_declaration_line_test.go

@@ -0,0 +1,31 @@
+package linthost
+
+import "testing"
+
+// TestFormatIndentNormalizesDecoratedMemberDeclarationLine verifies a
+// decorated class member's DECLARATION line is re-indented alongside its
+// decorator line.
+//
+// The header pass re-indents lineStart(SkipTrivia(member.Pos())), but for a
+// decorated member member.Pos() is the leading `@`. Handling only that
+// position would leave the `name: type` declaration at its original column.
+// The rule must also re-indent the declaration line, the first token past
+// the last decorator, to the member's nesting depth. This literal oracle
+// does not run an external formatter or certify a historical output.
+//
+//  1. Parse a class whose decorator and declaration lines are flush left.
+//  2. Apply the format/indent finding through the disk-backed fixer.
+//  3. Assert BOTH lines land at two-space member depth.
+//
+// @evidence contracts/testing.md#behavioral-verification format/indent must indent both the decorator line and the following property declaration to two spaces. Complete source distinguishes fixing only the first decorator while leaving a half-indented member.
+// @evidence contracts/testing.md#independent-expectations The supported class-member layout aligns leading decorators and the actual declaration at the member column. Literal expected source retains Column(), the property type and empty-string initializer independently of AST position helpers.
+// @evidence contracts/testing.md#distinguishing-cases This positive starts both lines at column zero. The canonical decorated-member negative, multiple-decorator positive and same-line decorator exact-edit host cover adjacent declaration-position decisions.
+// @evidence contracts/testing.md#execution-ownership TestFormatIndentNormalizesDecoratedMemberDeclarationLine owns its source and complete output in the public Go unit population. The syntax-only owning rule/edit application runs in process without consumer installation, native compilation or a real product host.
+func TestFormatIndentNormalizesDecoratedMemberDeclarationLine(t *testing.T) {
+  assertFixSnapshot(
+    t,
+    "format/indent",
+    "class User {\n@Column()\nname: string = \"\";\n}\n",
+    "class User {\n  @Column()\n  name: string = \"\";\n}\n",
+  )
+}

package/linthost/format_indent_normalizes_multiple_decorator_lines_test.go

@@ -0,0 +1,30 @@
+package linthost
+
+import "testing"
+
+// TestFormatIndentNormalizesMultipleDecoratorLines verifies a member with
+// several decorators on their own lines lands the declaration line at member
+// depth past the LAST decorator.
+//
+// The declaration start is computed from the final decorator's End(), not
+// the first, so a multi-decorator member must still re-indent the real
+// declaration line (and each decorator line is handled by the same header
+// pass). This guards the "last decorator" boundary in the fix.
+//
+//  1. Parse a class with two decorators and a declaration, all flush left.
+//  2. Apply the format/indent finding through the disk-backed fixer.
+//  3. Assert every decorator line and the declaration line land at two
+//     spaces.
+//
+// @evidence contracts/testing.md#behavioral-verification format/indent must indent both separate decorator lines and the property declaration after the last decorator. Complete output catches taking the first decorator boundary and forgetting the actual declaration line.
+// @evidence contracts/testing.md#independent-expectations The supported member layout aligns all leading decorators and the declaration at two spaces. Literal Index(), Column options, optional email marker and type remain unchanged program content.
+// @evidence contracts/testing.md#distinguishing-cases This positive owns two decorators and the declaration following the final one. The single-decorator and same-line hosts distinguish singleton and shared-line declaration boundaries.
+// @evidence contracts/testing.md#execution-ownership TestFormatIndentNormalizesMultipleDecoratorLines owns its entire fixture and expected source in the public Go unit population. The syntax-only owning rule and edit application execute in the same process without a consumer install, native artifact build or actual product host.
+func TestFormatIndentNormalizesMultipleDecoratorLines(t *testing.T) {
+  assertFixSnapshot(
+    t,
+    "format/indent",
+    "class User {\n@Index()\n@Column({ nullable: true })\nemail?: string;\n}\n",
+    "class User {\n  @Index()\n  @Column({ nullable: true })\n  email?: string;\n}\n",
+  )
+}

package/linthost/format_indent_normalizes_over_indented_block_statement_test.go

@@ -0,0 +1,27 @@
+package linthost
+
+import "testing"
+
+// TestFormatIndentNormalizesOverIndentedBlockStatement verifies
+// formatIndent re-indents a block statement to its depth-1 indent.
+//
+// A statement six spaces deep inside a single block should sit at two
+// spaces (depth 1, tabWidth 2). This pins that the rule computes the
+// target column from nesting depth and rewrites the over-indented run.
+//
+//  1. Parse a function whose body statement is indented six spaces.
+//  2. Apply the rule's finding through the disk-backed fixer.
+//  3. Assert the statement is re-indented to two spaces.
+//
+// @evidence contracts/testing.md#behavioral-verification format/indent must reduce a six-space function-body const statement to two spaces. Complete source detects preserving an incorrect run or computing the wrong block column while retaining the assignment.
+// @evidence contracts/testing.md#independent-expectations The supported default two-space indentation places an ordinary function-body statement one level inside its braces. Literal expected bytes derive from that policy independently of the depth walk.
+// @evidence contracts/testing.md#distinguishing-cases This positive reduces excessive indentation rather than merely inserting missing whitespace. The top-level host removes indentation to zero and the canonical nested-block host supplies a no-finding case.
+// @evidence contracts/testing.md#execution-ownership TestFormatIndentNormalizesOverIndentedBlockStatement owns its source/output fixture in the public Go unit population. The syntax-only owning rule/edit harness runs in process without consumer installation, native artifact production or starting a real product host.
+func TestFormatIndentNormalizesOverIndentedBlockStatement(t *testing.T) {
+  assertFixSnapshot(
+    t,
+    "format/indent",
+    "function f() {\n      const x = 1;\n}\n",
+    "function f() {\n  const x = 1;\n}\n",
+  )
+}

package/linthost/format_indent_normalizes_plain_member_header_test.go

@@ -0,0 +1,29 @@
+package linthost
+
+import "testing"
+
+// TestFormatIndentNormalizesPlainMemberHeader verifies a plain (undecorated)
+// class member header still indents to member depth after the decorator path
+// was added.
+//
+// A member without decorators takes the header pass's direct declaration
+// position branch; it does not need memberDeclarationStart. The literal
+// flush-left property must land at two spaces, independently of the
+// separate decorator and declaration positions in the sibling cases.
+//
+//  1. Parse a class with a flush-left plain property.
+//  2. Apply the format/indent finding through the disk-backed fixer.
+//  3. Assert the property header lands at two spaces.
+//
+// @evidence contracts/testing.md#behavioral-verification format/indent must indent a plain flush-left class property to two spaces. The literal full output detects a decorator-specific change accidentally removing ordinary member-header handling.
+// @evidence contracts/testing.md#independent-expectations The supported class-member column is one default indentation level, regardless of whether decorators exist. Expected source preserves the name, string type and empty initializer independently of decorator helpers.
+// @evidence contracts/testing.md#distinguishing-cases The property has no decorators, contrasting with separate-line, same-line and multiple-decorator positives. The canonical class-member/body hosts cover unchanged already-correct layout.
+// @evidence contracts/testing.md#execution-ownership TestFormatIndentNormalizesPlainMemberHeader owns its literal source and output in the public Go unit population. The owning syntax-only operation and edit application execute in process without installing a consumer, building native artifacts or starting a product host.
+func TestFormatIndentNormalizesPlainMemberHeader(t *testing.T) {
+  assertFixSnapshot(
+    t,
+    "format/indent",
+    "class User {\nname: string = \"\";\n}\n",
+    "class User {\n  name: string = \"\";\n}\n",
+  )
+}