@ttsc/lint 0.30.3 → 0.31.0

package/linthost/format_declaration_header_abstains_on_comment_in_header_test.go

@@ -0,0 +1,25 @@
+package linthost
+
+import "testing"
+
+// TestFormatDeclarationHeaderAbstainsOnCommentInHeader verifies the rule
+// abstains when the header carries a comment between the name and the
+// opening brace. The element-by-element rebuild has no slot for that
+// trivia, so reflowing would drop it; the rule leaves the source alone.
+//
+//  1. Parse an interface whose header holds a block comment and overflows.
+//  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 interface header carrying a block comment before extends, so its rebuilt header cannot discard the comment.
+// @evidence contracts/testing.md#independent-expectations The independently authored note comment must remain associated with the interface header; width fifty cannot override the source-preservation guard.
+// @evidence contracts/testing.md#distinguishing-cases This comment-bearing over-width negative complements the multi-type-interface positive reflow with unchanged member meaning; no transformed-output assertion is claimed here.
+// @evidence contracts/testing.md#execution-ownership TestFormatDeclarationHeaderAbstainsOnCommentInHeader is selected by the lint semantic-unit Evidence claim as a public Go unit. The owning formatter rule runs through the shared syntax-only rule harness on temporary fixture source; this entry owns its assertions and any named subtests without consumer installation, native product build or host process.
+func TestFormatDeclarationHeaderAbstainsOnCommentInHeader(t *testing.T) {
+  assertRuleSkipsSourceWithOptions(
+    t,
+    "format/declaration-header",
+    "interface Bbbbbbbbbbbb /* note */ extends FirstParentName, SecondParentName, Third {\n  a: number;\n}\n",
+    `{"printWidth":50,"tabWidth":2}`,
+  )
+}

package/linthost/format_declaration_header_abstains_on_type_params_with_multi_clause_test.go

@@ -0,0 +1,27 @@
+package linthost
+
+import "testing"
+
+// TestFormatDeclarationHeaderAbstainsOnTypeParamsWithMultiClause verifies
+// the rule abstains on a combination it has not verified against Prettier:
+// type parameters AND a breaking multi-clause heritage at once. Emitting a
+// header it cannot reproduce exactly risks corruption, so it leaves the
+// source verbatim.
+//
+//  1. Parse a class with type parameters plus extends + implements that
+//     overflows printWidth 50.
+//  2. Run format/declaration-header.
+//  3. Assert the rule reports nothing.
+//
+// @evidence contracts/testing.md#behavioral-verification format/declaration-header must decline an overflowing class combining constrained type parameters with extends and implements rather than applying an unsupported header rewrite.
+// @evidence contracts/testing.md#independent-expectations The literal TKeyVeryLong constraint and two heritage clauses specify the unsupported combination independently; this case expects zero findings, not an inferred snapshot.
+// @evidence contracts/testing.md#distinguishing-cases The generic-plus-multiple-clause negative complements separate type-parameter explosion and nongeneric multi-clause reflow positives; this host owns only the combined guard.
+// @evidence contracts/testing.md#execution-ownership TestFormatDeclarationHeaderAbstainsOnTypeParamsWithMultiClause is selected by the lint semantic-unit Evidence claim as a public Go unit. The owning formatter rule runs through the shared syntax-only rule harness on temporary fixture source; this entry owns its assertions and any named subtests without consumer installation, native product build or host process.
+func TestFormatDeclarationHeaderAbstainsOnTypeParamsWithMultiClause(t *testing.T) {
+  assertRuleSkipsSourceWithOptions(
+    t,
+    "format/declaration-header",
+    "class C<TKeyVeryLong extends string> extends Base implements First, Second {\n  a = 1;\n}\n",
+    `{"printWidth":50,"tabWidth":2}`,
+  )
+}

package/linthost/format_declaration_header_breaks_empty_body_at_width_boundary_test.go

@@ -0,0 +1,32 @@
+package linthost
+
+import "testing"
+
+// TestFormatDeclarationHeaderBreaksEmptyBodyAtWidthBoundary verifies the
+// flat-fit check charges the closing `}` of an empty body. The header below
+// is 81 columns including the trailing `{}`, so Prettier 3.8.3 breaks it;
+// without charging the `}` the rule would see 80 and wrongly keep it flat.
+//
+//  1. Parse an empty-body interface whose flat `… {}` form is 81 columns.
+//  2. Apply format/declaration-header at printWidth 80.
+//  3. Assert the keyword breaks (types stay inline, brace glued as `{}`).
+//
+// @evidence contracts/testing.md#behavioral-verification format/declaration-header must count the empty-body closing brace in its fit budget, breaking the eighty-one-column header while retaining heritage and the empty body.
+// @evidence contracts/testing.md#independent-expectations The literal complete line has eighty-one columns including both braces, while the adjacent shorter literal has exactly eighty; independently authored expected layout prevents a missing-brace fit charge.
+// @evidence contracts/testing.md#distinguishing-cases The over-limit changed header and exact-limit unchanged twin distinguish the one-column boundary rather than merely testing a broadly oversized declaration.
+// @evidence contracts/testing.md#execution-ownership TestFormatDeclarationHeaderBreaksEmptyBodyAtWidthBoundary is a public Go unit selected by the lint semantic-unit Evidence claim. Its shared syntax-only harness invokes the owning formatter on temporary fixture source and applies its reported edits for exact output assertions in the same process, without a consumer install, native product build or host execution.
+func TestFormatDeclarationHeaderBreaksEmptyBodyAtWidthBoundary(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/declaration-header",
+    "interface I extends Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, Bbbbbbbbbbbbbbbbbbbb {}\n",
+    `{"printWidth":80,"tabWidth":2}`,
+    "interface I\n  extends Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, Bbbbbbbbbbbbbbbbbbbb {}\n",
+  )
+  assertRuleSkipsSourceWithOptions(
+    t,
+    "format/declaration-header",
+    "interface I extends Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, Bbbbbbbbbbbbbbbbbbbb {}\n",
+    `{"printWidth":80,"tabWidth":2}`,
+  )
+}

package/linthost/format_declaration_header_breaks_generic_heritage_type_args_test.go

@@ -0,0 +1,28 @@
+package linthost
+
+import "testing"
+
+// TestFormatDeclarationHeaderBreaksGenericHeritageTypeArgs verifies a lone
+// heritage clause whose single generic type has two or more type arguments
+// breaks the argument list (not the clause), matching Prettier 3.8.3:
+// `implements Serializer<` stays inline, the arguments break one per line
+// with `>` back at the base indent and the brace glued.
+//
+//  1. Parse a class implementing one generic type with two type arguments,
+//     overflowing 80.
+//  2. Apply format/declaration-header.
+//  3. Assert the type-argument list breaks and the keyword stays inline.
+//
+// @evidence contracts/testing.md#behavioral-verification format/declaration-header must break the two Serializer type arguments while keeping implements inline and preserving export, the union argument and serialize method.
+// @evidence contracts/testing.md#independent-expectations The literal full output independently expresses the generic-heritage layout at width eighty; any, KafkaRequest and its Promise union retain their type relationships.
+// @evidence contracts/testing.md#distinguishing-cases This changed two-argument heritage list complements the single-argument no-op and already-broken generic-heritage no-finding twin.
+// @evidence contracts/testing.md#execution-ownership TestFormatDeclarationHeaderBreaksGenericHeritageTypeArgs 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 TestFormatDeclarationHeaderBreaksGenericHeritageTypeArgs(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/declaration-header",
+    "export class KafkaRequestSerializer implements Serializer<any, KafkaRequest | Promise<KafkaRequest>> {\n  serialize() {}\n}\n",
+    `{"printWidth":80,"tabWidth":2}`,
+    "export class KafkaRequestSerializer implements Serializer<\n  any,\n  KafkaRequest | Promise<KafkaRequest>\n> {\n  serialize() {}\n}\n",
+  )
+}

package/linthost/format_declaration_header_breaks_multi_type_interface_test.go

@@ -0,0 +1,29 @@
+package linthost
+
+import "testing"
+
+// TestFormatDeclarationHeaderBreaksMultiTypeInterface verifies a single
+// `extends` clause with multiple types breaks before the keyword and
+// lists one type per line, matching Prettier 3.
+//
+// The full independent output requires both the keyword break and all six
+// separate heritage lines. The rule reflows only the header up to `{`; the
+// body is untouched. This case does not reproduce a past formatter version.
+//
+//  1. Parse an interface whose extends list overflows printWidth 50.
+//  2. Apply format/declaration-header.
+//  3. Assert the keyword breaks and each type lands on its own line.
+//
+// @evidence contracts/testing.md#behavioral-verification format/declaration-header must expand the over-width six-type extends clause onto one type per line, preserving order and the number-typed member body.
+// @evidence contracts/testing.md#independent-expectations The literal output expresses the Prettier-three layout independently; the named First through Sixth heritage sequence and a:number remain identical in meaning.
+// @evidence contracts/testing.md#distinguishing-cases The changed overflowing multi-type clause complements fitting or singleton heritage layouts and the comment-bearing header guard; exact output verifies change plus body preservation.
+// @evidence contracts/testing.md#execution-ownership TestFormatDeclarationHeaderBreaksMultiTypeInterface is selected by the lint semantic-unit Evidence claim as a public Go unit. The owning formatter rule runs through the shared syntax-only rule harness on temporary fixture source; this entry owns its assertions and any named subtests without consumer installation, native product build or host process.
+func TestFormatDeclarationHeaderBreaksMultiTypeInterface(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/declaration-header",
+    "interface B extends First, Second, Third, Fourth, Fifth, Sixth {\n  a: number;\n}\n",
+    `{"printWidth":50,"tabWidth":2}`,
+    "interface B\n  extends\n    First,\n    Second,\n    Third,\n    Fourth,\n    Fifth,\n    Sixth {\n  a: number;\n}\n",
+  )
+}

package/linthost/format_declaration_header_breaks_multiple_clauses_test.go

@@ -0,0 +1,25 @@
+package linthost
+
+import "testing"
+
+// TestFormatDeclarationHeaderBreaksMultipleClauses verifies a class with
+// both `extends` and `implements` breaks each clause onto its own line
+// with the types inline and `{` on its own line, matching Prettier 3.
+//
+//  1. Parse a class whose extends+implements header overflows printWidth 50.
+//  2. Apply format/declaration-header.
+//  3. Assert each clause is on its own indented line and `{` stands alone.
+//
+// @evidence contracts/testing.md#behavioral-verification format/declaration-header must break extends and implements onto separate lines at width fifty while retaining Base, all four interface names and the a initializer.
+// @evidence contracts/testing.md#independent-expectations The full literal output records the documented Prettier-three multi-clause layout with a standalone brace; inheritance and class body tokens are independent semantic invariants.
+// @evidence contracts/testing.md#distinguishing-cases The overflowing nongeneric multi-clause header is the changed positive counterpart to the generic-plus-multiple-clause abstention and fitting-header canonicalization.
+// @evidence contracts/testing.md#execution-ownership TestFormatDeclarationHeaderBreaksMultipleClauses is selected by the lint semantic-unit Evidence claim as a public Go unit. The owning formatter rule runs through the shared syntax-only rule harness on temporary fixture source; this entry owns its assertions and any named subtests without consumer installation, native product build or host process.
+func TestFormatDeclarationHeaderBreaksMultipleClauses(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/declaration-header",
+    "class C extends Base implements First, Second, Third, Fourth {\n  a = 1;\n}\n",
+    `{"printWidth":50,"tabWidth":2}`,
+    "class C\n  extends Base\n  implements First, Second, Third, Fourth\n{\n  a = 1;\n}\n",
+  )
+}

package/linthost/format_declaration_header_breaks_single_type_clause_in_multi_clause_test.go

@@ -0,0 +1,73 @@
+package linthost
+
+import "testing"
+
+// TestFormatDeclarationHeaderBreaksSingleTypeClauseInMultiClause verifies the
+// supported multi-clause class layout when a singleton implements type exceeds
+// its keyword-line width. The generic and nongeneric over-width types break
+// after the keyword; a fitting singleton stays inline. These independently
+// authored cases do not measure past failures or external corpus frequency.
+//
+// @evidence contracts/testing.md#behavioral-verification The declaration-header rule must break generic and nongeneric over-width singleton implements types after the keyword while leaving fitting singleton clauses inline; the complete format cascade must retain each canonical result.
+// @evidence contracts/testing.md#independent-expectations The three independently authored complete canonical literals specify width-eighty singleton clause layout and preserve base types, implemented type arguments and x=1 bodies. Flat input fixtures make each expected canonical result an actual change.
+// @evidence contracts/testing.md#distinguishing-cases This host owns generic_single_type_breaks_after_keyword, non_generic_single_type_breaks_after_keyword and fitting_single_type_stays_inline. Every named case now verifies a rule-level transformation plus its original command-level unchanged result, distinguishing mere idempotency from correct reconstruction.
+// @evidence contracts/testing.md#execution-ownership TestFormatDeclarationHeaderBreaksSingleTypeClauseInMultiClause is a selected public Go unit under the lint semantic-unit Evidence claim. Each named case directly exercises the syntax-only declaration rule and additionally retains its in-process run(format) cascade/disk assertion on a temporary project, without a consumer install, native product build or external product-host process.
+func TestFormatDeclarationHeaderBreaksSingleTypeClauseInMultiClause(t *testing.T) {
+  // Generic single type that overflows: break after `implements`, type at +4.
+  t.Run("generic_single_type_breaks_after_keyword", func(t *testing.T) {
+    assertFixSnapshotWithOptions(t, "format/declaration-header", "class TestItemRenderer extends Disposable implements ITreeRenderer<TestItemTreeElement, FuzzyScore, ITestElementTemplateData> {\n  x = 1;\n}\n", `{"printWidth":80,"tabWidth":2}`, `class TestItemRenderer
+  extends Disposable
+  implements
+    ITreeRenderer<TestItemTreeElement, FuzzyScore, ITestElementTemplateData>
+{
+  x = 1;
+}
+`)
+    assertFormatUnchanged(t, `class TestItemRenderer
+  extends Disposable
+  implements
+    ITreeRenderer<TestItemTreeElement, FuzzyScore, ITestElementTemplateData>
+{
+  x = 1;
+}
+`)
+  })
+  // Non-generic single type that overflows breaks the same way.
+  t.Run("non_generic_single_type_breaks_after_keyword", func(t *testing.T) {
+    assertFixSnapshotWithOptions(t, "format/declaration-header", "class B extends Disposable implements VeryLongNonGenericInterfaceNameThatDefinitelyOverflowsEightyColumnsHereXX {\n  x = 1;\n}\n", `{"printWidth":80,"tabWidth":2}`, `class B
+  extends Disposable
+  implements
+    VeryLongNonGenericInterfaceNameThatDefinitelyOverflowsEightyColumnsHereXX
+{
+  x = 1;
+}
+`)
+    assertFormatUnchanged(t, `class B
+  extends Disposable
+  implements
+    VeryLongNonGenericInterfaceNameThatDefinitelyOverflowsEightyColumnsHereXX
+{
+  x = 1;
+}
+`)
+  })
+  // A multi-clause header whose flat form overflows but whose single-type
+  // clauses each fit on their own keyword line stays inline per clause (no
+  // spurious break after the keyword).
+  t.Run("fitting_single_type_stays_inline", func(t *testing.T) {
+    assertFixSnapshotWithOptions(t, "format/declaration-header", "class E extends SomeModeratelyLongBaseClassName implements ITreeRenderer<ElementType, ScoreType> {\n  x = 1;\n}\n", `{"printWidth":80,"tabWidth":2}`, `class E
+  extends SomeModeratelyLongBaseClassName
+  implements ITreeRenderer<ElementType, ScoreType>
+{
+  x = 1;
+}
+`)
+    assertFormatUnchanged(t, `class E
+  extends SomeModeratelyLongBaseClassName
+  implements ITreeRenderer<ElementType, ScoreType>
+{
+  x = 1;
+}
+`)
+  })
+}

package/linthost/format_declaration_header_breaks_type_param_default_after_equals_test.go

@@ -0,0 +1,29 @@
+package linthost
+
+import "testing"
+
+// TestFormatDeclarationHeaderBreaksTypeParamDefaultAfterEquals verifies a
+// type parameter whose `extends C = Default` overflows breaks after `=`,
+// hanging the default one level deeper, matching Prettier 3.
+//
+// The complete independent output requires both list explosion and the extra
+// indentation after `=`. This direct case observes those edits, not a past
+// benchmark result or an external formatter invocation.
+//
+//  1. Parse a class with one long defaulted type parameter (printWidth 50).
+//  2. Apply format/declaration-header.
+//  3. Assert the default hangs on the next line and the list explodes.
+//
+// @evidence contracts/testing.md#behavioral-verification format/declaration-header must break a long constrained defaulted type parameter after equals while preserving its constraint, DefaultType default and a=1 body.
+// @evidence contracts/testing.md#independent-expectations The independently authored output literal places the default one extra indent deeper under width fifty without changing any generic or body token.
+// @evidence contracts/testing.md#distinguishing-cases The changed one-parameter over-width default distinguishes a long default expression from the separately tested two-parameter list explosion and canonical-header negatives.
+// @evidence contracts/testing.md#execution-ownership TestFormatDeclarationHeaderBreaksTypeParamDefaultAfterEquals 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 TestFormatDeclarationHeaderBreaksTypeParamDefaultAfterEquals(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/declaration-header",
+    "class E<TVeryLongTypeParam extends SomeConstraint = DefaultType> {\n  a = 1;\n}\n",
+    `{"printWidth":50,"tabWidth":2}`,
+    "class E<\n  TVeryLongTypeParam extends SomeConstraint =\n    DefaultType,\n> {\n  a = 1;\n}\n",
+  )
+}

package/linthost/format_declaration_header_collapses_fitting_header_test.go

@@ -0,0 +1,29 @@
+package linthost
+
+import "testing"
+
+// TestFormatDeclarationHeaderCollapsesFittingHeader verifies a header
+// broken across lines but short enough to fit is collapsed back to one
+// line, matching Prettier.
+//
+// The rule reconstructs the header canonically: when the flat form fits
+// printWidth it is the target, so a needlessly multi-line header is
+// rejoined.
+//
+//  1. Parse an interface with a needlessly broken short header.
+//  2. Apply format/declaration-header at printWidth 80.
+//  3. Assert the header collapses onto one line.
+//
+// @evidence contracts/testing.md#behavioral-verification format/declaration-header must collapse an unnecessarily split fitting extends header while leaving its a:number member body intact.
+// @evidence contracts/testing.md#independent-expectations The literal full output specifies the width-eighty flat-header preference independently; F, base A and the member annotation remain identical.
+// @evidence contracts/testing.md#distinguishing-cases The changed short multiline header contrasts with genuinely oversized break/explosion cases and canonical broken-header no-op cases.
+// @evidence contracts/testing.md#execution-ownership TestFormatDeclarationHeaderCollapsesFittingHeader is a public Go unit selected by the lint semantic-unit Evidence claim. Its shared syntax-only harness invokes the owning formatter on temporary fixture source and applies its reported edits for exact output assertions in the same process, without a consumer install, native product build or host execution.
+func TestFormatDeclarationHeaderCollapsesFittingHeader(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/declaration-header",
+    "interface F\n  extends A {\n  a: number;\n}\n",
+    `{"printWidth":80,"tabWidth":2}`,
+    "interface F extends A {\n  a: number;\n}\n",
+  )
+}

package/linthost/format_declaration_header_drops_brace_for_class_body_test.go

@@ -0,0 +1,28 @@
+package linthost
+
+import "testing"
+
+// TestFormatDeclarationHeaderDropsBraceForClassBody verifies the opening
+// brace lands on its own line for a class with a non-empty body whose
+// header breaks, matching Prettier 3. The single `implements` clause keeps
+// its types inline on the keyword's continuation line (two-tier tier one),
+// followed by a separate opening-brace line.
+//
+//  1. Parse a class whose flat implements header overflows 80, with a
+//     non-empty body.
+//  2. Apply format/declaration-header.
+//  3. Assert the types stay inline and `{` is on its own line.
+//
+// @evidence contracts/testing.md#behavioral-verification format/declaration-header must place the nonempty class opening brace on its own line after a broken implements header, retaining all three types and x=1.
+// @evidence contracts/testing.md#independent-expectations The independently authored full output follows nonempty-class brace layout; type order and the initializer/body delimiters are unchanged semantic payload.
+// @evidence contracts/testing.md#distinguishing-cases This changed first-tier inline-types class contrasts with empty-body glued braces and second-tier one-type-per-line explosion.
+// @evidence contracts/testing.md#execution-ownership TestFormatDeclarationHeaderDropsBraceForClassBody is a public Go unit selected by the lint semantic-unit Evidence claim. Its shared syntax-only harness invokes the owning formatter on temporary fixture source and applies its reported edits for exact output assertions in the same process, without a consumer install, native product build or host execution.
+func TestFormatDeclarationHeaderDropsBraceForClassBody(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/declaration-header",
+    "class Booooooooooooooo implements Firstttttttttttttttt, Secondddddddddddddddd, Third {\n  x = 1;\n}\n",
+    `{"printWidth":80,"tabWidth":2}`,
+    "class Booooooooooooooo\n  implements Firstttttttttttttttt, Secondddddddddddddddd, Third\n{\n  x = 1;\n}\n",
+  )
+}

package/linthost/format_declaration_header_explodes_and_drops_brace_for_class_body_test.go

@@ -0,0 +1,27 @@
+package linthost
+
+import "testing"
+
+// TestFormatDeclarationHeaderExplodesAndDropsBraceForClassBody verifies the
+// two most complex header pieces compose: tier-two (one type per line, when
+// the inline-after-break line still overflows) AND a class non-empty body's
+// brace on its own line. Matches Prettier 3.8.3.
+//
+//  1. Parse a class whose implements list overflows even inline-after-break,
+//     with a non-empty body.
+//  2. Apply format/declaration-header at printWidth 80.
+//  3. Assert each type is on its own line and `{` stands alone.
+//
+// @evidence contracts/testing.md#behavioral-verification format/declaration-header must compose one-type-per-line heritage explosion with a standalone brace for a nonempty class, retaining four implemented types and x=1.
+// @evidence contracts/testing.md#independent-expectations The literal full output independently specifies the second-tier width-eighty class layout and unchanged declaration/body payload, without using the implementation to generate an oracle.
+// @evidence contracts/testing.md#distinguishing-cases This changed header still exceeds width after a simple clause break; the three-type first-tier case and empty-class brace case own adjacent layout decisions.
+// @evidence contracts/testing.md#execution-ownership TestFormatDeclarationHeaderExplodesAndDropsBraceForClassBody is a public Go unit selected by the lint semantic-unit Evidence claim. Its shared syntax-only harness invokes the owning formatter on temporary fixture source and applies its reported edits for exact output assertions in the same process, without a consumer install, native product build or host execution.
+func TestFormatDeclarationHeaderExplodesAndDropsBraceForClassBody(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/declaration-header",
+    "class Booooooooooooooo implements Firstttttttttttttttt, Secondddddddddddddddd, Thirddddddddddddddddd, Fourthhhhhhhhhhhhhhh {\n  x = 1;\n}\n",
+    `{"printWidth":80,"tabWidth":2}`,
+    "class Booooooooooooooo\n  implements\n    Firstttttttttttttttt,\n    Secondddddddddddddddd,\n    Thirddddddddddddddddd,\n    Fourthhhhhhhhhhhhhhh\n{\n  x = 1;\n}\n",
+  )
+}

package/linthost/format_declaration_header_explodes_type_parameters_test.go

@@ -0,0 +1,26 @@
+package linthost
+
+import "testing"
+
+// TestFormatDeclarationHeaderExplodesTypeParameters verifies an
+// over-width type-parameter list explodes one parameter per line with a
+// trailing comma and the `>` at the base indent, the heritage clause
+// staying inline after `>`, following the supported generic declaration layout.
+//
+//  1. Parse an interface whose `<...>` list overflows printWidth 50.
+//  2. Apply format/declaration-header.
+//  3. Assert the type params explode and `> extends Base<TKey> {` trails.
+//
+// @evidence contracts/testing.md#behavioral-verification format/declaration-header must split the oversized two constrained type parameters with a trailing comma, then keep extends Base<TKey> after the closing angle bracket and preserve a:number.
+// @evidence contracts/testing.md#independent-expectations The independently authored output literal specifies the generic declaration layout at width fifty and retains both constraints plus the heritage argument and body.
+// @evidence contracts/testing.md#distinguishing-cases The changed generic singleton-heritage case complements generic-plus-multiple-clause abstention and generic heritage argument explosion; exact bytes prove rewrite and retained type meaning.
+// @evidence contracts/testing.md#execution-ownership TestFormatDeclarationHeaderExplodesTypeParameters is a public Go unit selected by the lint semantic-unit Evidence claim. Its shared syntax-only harness invokes the owning formatter on temporary fixture source and applies its reported edits for exact output assertions in the same process, without a consumer install, native product build or host execution.
+func TestFormatDeclarationHeaderExplodesTypeParameters(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/declaration-header",
+    "interface D<TKey extends string, TValue extends object> extends Base<TKey> {\n  a: number;\n}\n",
+    `{"printWidth":50,"tabWidth":2}`,
+    "interface D<\n  TKey extends string,\n  TValue extends object,\n> extends Base<TKey> {\n  a: number;\n}\n",
+  )
+}

package/linthost/format_declaration_header_generic_heritage_honors_crlf_end_of_line_test.go

@@ -0,0 +1,32 @@
+package linthost
+
+import "testing"
+
+// TestFormatDeclarationHeaderGenericHeritageHonorsCRLFEndOfLine verifies the
+// single-generic-heritage type-argument explode reflow synthesizes CRLF breaks
+// under endOfLine:"crlf".
+//
+// The singleGenericHeritageHeader builder must use the configured layout EOL
+// after `<` and per type argument rather than inject literal LFs into a CRLF
+// file. Bound to the CRLF oracle (LF twin: format_declaration_
+// header_breaks_generic_heritage_type_args_test.go); the helper asserts zero
+// lone LFs.
+//
+//  1. Parse a CRLF class implementing one generic type with two type arguments
+//     that overflows width 80.
+//  2. Apply format/declaration-header with {"endOfLine":"crlf"}.
+//  3. Assert the type-argument list breaks with "\r\n" and no lone LF remains.
+//
+// @evidence contracts/testing.md#behavioral-verification format/declaration-header must break both Serializer type arguments using CRLF while preserving the generic union argument and serialize method.
+// @evidence contracts/testing.md#independent-expectations The configured crlf contract and full escaped literal establish every line separator independently; the helper additionally rejects any LF lacking its CR prefix.
+// @evidence contracts/testing.md#distinguishing-cases This changed CRLF generic-heritage list complements its LF positive and already-broken generic no-op, including argument-internal and closing-angle separators.
+// @evidence contracts/testing.md#execution-ownership TestFormatDeclarationHeaderGenericHeritageHonorsCRLFEndOfLine 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 TestFormatDeclarationHeaderGenericHeritageHonorsCRLFEndOfLine(t *testing.T) {
+  assertFixCRLFConsistentWithOptions(
+    t,
+    "format/declaration-header",
+    "export class KafkaRequestSerializer implements Serializer<any, KafkaRequest | Promise<KafkaRequest>> {\r\n  serialize() {}\r\n}\r\n",
+    `{"printWidth":80,"tabWidth":2,"endOfLine":"crlf"}`,
+    "export class KafkaRequestSerializer implements Serializer<\r\n  any,\r\n  KafkaRequest | Promise<KafkaRequest>\r\n> {\r\n  serialize() {}\r\n}\r\n",
+  )
+}

package/linthost/format_declaration_header_glues_brace_for_empty_body_test.go

@@ -0,0 +1,27 @@
+package linthost
+
+import "testing"
+
+// TestFormatDeclarationHeaderGluesBraceForEmptyBody verifies an empty body
+// keeps `{}` glued to the last header line even for a class, matching
+// Prettier 3 (it drops `{` onto its own line only for a class with a
+// non-empty body).
+//
+//  1. Parse a class whose multi-clause header overflows 80, with an empty
+//     body.
+//  2. Apply format/declaration-header.
+//  3. Assert each clause breaks and the brace stays glued to the last one.
+//
+// @evidence contracts/testing.md#behavioral-verification format/declaration-header must break the exported class heritage clauses while keeping empty-body braces attached to the last implements line.
+// @evidence contracts/testing.md#independent-expectations The complete expected source literal records empty-body brace ownership independently and retains export, class name, base and both implemented types.
+// @evidence contracts/testing.md#distinguishing-cases The changed overflowing empty class contrasts with the nonempty-class standalone-brace positive and the empty-body eighty-column boundary.
+// @evidence contracts/testing.md#execution-ownership TestFormatDeclarationHeaderGluesBraceForEmptyBody is a public Go unit selected by the lint semantic-unit Evidence claim. Its shared syntax-only harness invokes the owning formatter on temporary fixture source and applies its reported edits for exact output assertions in the same process, without a consumer install, native product build or host execution.
+func TestFormatDeclarationHeaderGluesBraceForEmptyBody(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/declaration-header",
+    "export class Fooooooooooo extends Baaaaaaaaaar implements Iiiiiiiiii, Jjjjjjjjjj {}\n",
+    `{"printWidth":80,"tabWidth":2}`,
+    "export class Fooooooooooo\n  extends Baaaaaaaaaar\n  implements Iiiiiiiiii, Jjjjjjjjjj {}\n",
+  )
+}

package/linthost/format_declaration_header_idempotent_on_broken_clauses_test.go

@@ -0,0 +1,24 @@
+package linthost
+
+import "testing"
+
+// TestFormatDeclarationHeaderIdempotentOnBrokenClauses verifies the rule
+// reports no finding for an already-correct multi-clause header. This direct
+// canonical-input case does not run or certify the complete cascade.
+//
+//  1. Parse a class header already in the Prettier multi-clause shape.
+//  2. Run format/declaration-header at printWidth 50.
+//  3. Assert the rule reports nothing.
+//
+// @evidence contracts/testing.md#behavioral-verification format/declaration-header must emit no finding for the correctly broken extends/implements class header at width fifty.
+// @evidence contracts/testing.md#independent-expectations The independently authored canonical literal retains Base, four interfaces and the body; no prior implementation output is used to build this input.
+// @evidence contracts/testing.md#distinguishing-cases This canonical no-op is paired with the flat-to-broken multi-clause transformation; together they distinguish convergence from an unconditional no-op.
+// @evidence contracts/testing.md#execution-ownership TestFormatDeclarationHeaderIdempotentOnBrokenClauses 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 TestFormatDeclarationHeaderIdempotentOnBrokenClauses(t *testing.T) {
+  assertRuleSkipsSourceWithOptions(
+    t,
+    "format/declaration-header",
+    "class C\n  extends Base\n  implements First, Second, Third, Fourth\n{\n  a = 1;\n}\n",
+    `{"printWidth":50,"tabWidth":2}`,
+  )
+}

package/linthost/format_declaration_header_idempotent_on_broken_heritage_type_args_test.go

@@ -0,0 +1,25 @@
+package linthost
+
+import "testing"
+
+// TestFormatDeclarationHeaderIdempotentOnBrokenHeritageTypeArgs verifies the
+// rule abstains on the already-multiline generic heritage. The element-text
+// guard returns before rebuilding a header; this direct canonical-input case
+// observes no finding rather than a second pass or complete cascade run.
+//
+//  1. Parse a class header already in the broken-type-argument shape.
+//  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 already-broken Serializer type arguments rather than disturbing the multiline generic heritage.
+// @evidence contracts/testing.md#independent-expectations The independently authored canonical literal supplies the preserved union argument and method body; zero findings is the documented abstention for this already-multiline structure.
+// @evidence contracts/testing.md#distinguishing-cases This unchanged generic-heritage layout is paired with the actual flat-to-broken two-argument transformation and its CRLF counterpart.
+// @evidence contracts/testing.md#execution-ownership TestFormatDeclarationHeaderIdempotentOnBrokenHeritageTypeArgs 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 TestFormatDeclarationHeaderIdempotentOnBrokenHeritageTypeArgs(t *testing.T) {
+  assertRuleSkipsSourceWithOptions(
+    t,
+    "format/declaration-header",
+    "export class KafkaRequestSerializer implements Serializer<\n  any,\n  KafkaRequest | Promise<KafkaRequest>\n> {\n  serialize() {}\n}\n",
+    `{"printWidth":80,"tabWidth":2}`,
+  )
+}

package/linthost/format_declaration_header_idempotent_on_exploded_class_body_test.go

@@ -0,0 +1,25 @@
+package linthost
+
+import "testing"
+
+// TestFormatDeclarationHeaderIdempotentOnExplodedClassBody verifies the rule
+// emits no finding for the canonical tier-two one-type-per-line header with a
+// class brace on its own line. This direct case does not run the full cascade
+// or compare transformed output bytes.
+//
+//  1. Parse a class header already in the exploded + own-line-brace shape.
+//  2. Run format/declaration-header at printWidth 80.
+//  3. Assert the rule reports nothing.
+//
+// @evidence contracts/testing.md#behavioral-verification format/declaration-header must emit no finding for a canonical one-type-per-line implements class with a standalone opening brace.
+// @evidence contracts/testing.md#independent-expectations The independent canonical source literal specifies the four-interface second-tier layout and intact x=1 body without computing an expectation through the rule.
+// @evidence contracts/testing.md#distinguishing-cases This unchanged complex layout complements its actual flat-to-exploded positive and the first-tier inline-types case; no output-read comparison is claimed here.
+// @evidence contracts/testing.md#execution-ownership TestFormatDeclarationHeaderIdempotentOnExplodedClassBody 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 TestFormatDeclarationHeaderIdempotentOnExplodedClassBody(t *testing.T) {
+  assertRuleSkipsSourceWithOptions(
+    t,
+    "format/declaration-header",
+    "class Booooooooooooooo\n  implements\n    Firstttttttttttttttt,\n    Secondddddddddddddddd,\n    Thirddddddddddddddddd,\n    Fourthhhhhhhhhhhhhhh\n{\n  x = 1;\n}\n",
+    `{"printWidth":80,"tabWidth":2}`,
+  )
+}

package/linthost/format_declaration_header_keeps_multi_type_inline_after_break_test.go

@@ -0,0 +1,30 @@
+package linthost
+
+import "testing"
+
+// TestFormatDeclarationHeaderKeepsMultiTypeInlineAfterBreak verifies the
+// two-tier layout of a single multi-type heritage clause: Prettier 3
+// breaks before the keyword but keeps the types inline on that line, and
+// only explodes them one-per-line when the inline line itself overflows.
+//
+// Here the flat header overflows printWidth 80 but the broken
+// `  extends A, B, C {` line fits, so the types stay inline.
+//
+//  1. Parse an interface whose flat extends header overflows 80 but whose
+//     broken-keyword line fits.
+//  2. Apply format/declaration-header.
+//  3. Assert the keyword breaks once and the types stay inline.
+//
+// @evidence contracts/testing.md#behavioral-verification format/declaration-header must break before extends but keep its three heritage types inline when the new keyword line fits, preserving x:number.
+// @evidence contracts/testing.md#independent-expectations The independently authored width-eighty output literal specifies the first-tier layout and unchanged declaration/heritage/member payload.
+// @evidence contracts/testing.md#distinguishing-cases This changed flat-overflow but keyword-line-fit case contrasts with the six-type second-tier explosion and already-fitting flat-header collapse.
+// @evidence contracts/testing.md#execution-ownership TestFormatDeclarationHeaderKeepsMultiTypeInlineAfterBreak 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 TestFormatDeclarationHeaderKeepsMultiTypeInlineAfterBreak(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/declaration-header",
+    "interface Iiiiiiiiiiiiiiiiii extends Firstttttttttttttttt, Secondddddddddddddddd, Third {\n  x: number;\n}\n",
+    `{"printWidth":80,"tabWidth":2}`,
+    "interface Iiiiiiiiiiiiiiiiii\n  extends Firstttttttttttttttt, Secondddddddddddddddd, Third {\n  x: number;\n}\n",
+  )
+}

package/linthost/format_declaration_header_keeps_single_generic_heritage_arg_inline_test.go

@@ -0,0 +1,25 @@
+package linthost
+
+import "testing"
+
+// TestFormatDeclarationHeaderKeepsSingleGenericHeritageArgInline verifies a
+// heritage type with a single type argument is left inline even when it
+// overflows, matching Prettier 3.8.3 (it breaks a heritage type-argument
+// list only when there are two or more arguments).
+//
+//  1. Parse an interface extending one generic type with one long argument.
+//  2. Run format/declaration-header.
+//  3. Assert the rule reports nothing (kept inline).
+//
+// @evidence contracts/testing.md#behavioral-verification format/declaration-header must emit no finding for an overflowing exported interface heritage with exactly one generic argument.
+// @evidence contracts/testing.md#independent-expectations The independently authored single-argument Base heritage has no argument list division to explode; the supported singleton-heritage convention leaves it inline even above width eighty.
+// @evidence contracts/testing.md#distinguishing-cases This over-width one-argument negative complements the changed two-argument Serializer heritage explosion and the other one-argument long-base case.
+// @evidence contracts/testing.md#execution-ownership TestFormatDeclarationHeaderKeepsSingleGenericHeritageArgInline 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 observes zero findings in the same Go process without consumer installation, a native product build or a product host.
+func TestFormatDeclarationHeaderKeepsSingleGenericHeritageArgInline(t *testing.T) {
+  assertRuleSkipsSourceWithOptions(
+    t,
+    "format/declaration-header",
+    "export interface Foo extends Baseeeeeeeeeeeeeeeee<SomeVeryLongSingleTypeArgumentNameHere> {}\n",
+    `{"printWidth":80,"tabWidth":2}`,
+  )
+}