@ttsc/lint 0.30.4 → 0.31.0

package/linthost/format_whitespace_inserts_missing_final_newline_test.go

@@ -0,0 +1,28 @@
+package linthost
+
+import "testing"
+
+// TestFormatWhitespaceInsertsMissingFinalNewline verifies
+// formatWhitespace appends a final newline to a file that ends without
+// one.
+//
+// Prettier guarantees a trailing newline. This pins the no-newline arm
+// of operation (d): a file whose last byte is a statement terminator
+// gains exactly one EOL.
+//
+//  1. Parse a single statement with no terminating newline.
+//  2. Apply the rule's finding through the disk-backed fixer.
+//  3. Assert the file now ends with one newline.
+//
+// @evidence contracts/testing.md#behavioral-verification format/whitespace must append exactly one LF to content ending at its statement semicolon.
+// @evidence contracts/testing.md#independent-expectations The complete literal output differs only by its required terminal LF and retains the declaration.
+// @evidence contracts/testing.md#distinguishing-cases This changed EOF boundary complements trailing-space-plus-missing-EOL normalization, clean sources and the empty-file negative.
+// @evidence contracts/testing.md#execution-ownership TestFormatWhitespaceInsertsMissingFinalNewline is a public Go unit selected by the lint semantic-unit Evidence claim. This host owns every literal input and assertion; the shared syntax-only harness invokes the whitespace rule and applies edits for complete output comparisons in the same process without a consumer install, native product build or product host.
+func TestFormatWhitespaceInsertsMissingFinalNewline(t *testing.T) {
+  assertFixSnapshot(
+    t,
+    "format/whitespace",
+    "const a = 1;",
+    "const a = 1;\n",
+  )
+}

package/linthost/format_whitespace_keeps_blank_line_inside_template_test.go

@@ -0,0 +1,27 @@
+package linthost
+
+import "testing"
+
+// TestFormatWhitespaceKeepsBlankLineInsideTemplate verifies a blank line
+// inside a template literal is not collapsed by the blank-run rule.
+//
+// Blank lines inside a template are part of the string value. The
+// collapse pass skips template-interior lines, so two consecutive blank
+// lines inside backticks survive while the same run in real source would
+// reduce to one. This pins that the collapse honors the template guard.
+//
+//  1. Parse a template literal containing two consecutive blank lines.
+//  2. Run the rule.
+//  3. Assert it emits no finding (the blank run is preserved).
+//
+// @evidence contracts/testing.md#behavioral-verification format/whitespace must offer no collapse of two blank lines inside a multiline template.
+// @evidence contracts/testing.md#independent-expectations The independent a/newlines/b literal fixes its string value, making the template blank run meaningful payload.
+// @evidence contracts/testing.md#distinguishing-cases The protected blank-run negative contrasts with the changed three-blank-line source collapse and template space preservation.
+// @evidence contracts/testing.md#execution-ownership TestFormatWhitespaceKeepsBlankLineInsideTemplate is a public Go unit selected by the lint semantic-unit Evidence claim. This host owns every literal input and assertion; the shared syntax-only harness invokes the whitespace rule and observes zero findings in the same process without a consumer install, native product build or product host.
+func TestFormatWhitespaceKeepsBlankLineInsideTemplate(t *testing.T) {
+  assertRuleSkipsSource(
+    t,
+    "format/whitespace",
+    "const t = `a\n\n\nb`;\n",
+  )
+}

package/linthost/format_whitespace_normalizes_crlf_to_lf_by_default_test.go

@@ -0,0 +1,28 @@
+package linthost
+
+import "testing"
+
+// TestFormatWhitespaceNormalizesCRLFToLFByDefault verifies the rule
+// strips interior `\r` when the effective EOL is LF (the default).
+//
+// Under LF EOL a `\r` before `\n` is a stray carriage return and counts
+// as trailing whitespace, so a CRLF file normalizes to LF. This pins the
+// LF arm of the EOL-gated `\r` handling, the counterpart to the CRLF
+// preservation case.
+//
+//  1. Parse a CRLF file with no options (default LF EOL).
+//  2. Apply the rule through the disk-backed fixer.
+//  3. Assert every `\r\n` becomes `\n`.
+//
+// @evidence contracts/testing.md#behavioral-verification format/whitespace must convert both CRLF separators to LF under default EOL while preserving both declarations.
+// @evidence contracts/testing.md#independent-expectations The independent escaped output specifies the exact LF separators and unchanged a=1/b=2 payload.
+// @evidence contracts/testing.md#distinguishing-cases This changed default-CRLF source complements explicit crlf preservation and canonical LF negatives.
+// @evidence contracts/testing.md#execution-ownership TestFormatWhitespaceNormalizesCRLFToLFByDefault is a public Go unit selected by the lint semantic-unit Evidence claim. This host owns every literal input and assertion; the shared syntax-only harness invokes the whitespace rule and applies edits for complete output comparisons in the same process without a consumer install, native product build or product host.
+func TestFormatWhitespaceNormalizesCRLFToLFByDefault(t *testing.T) {
+  assertFixSnapshot(
+    t,
+    "format/whitespace",
+    "const a = 1;\r\nconst b = 2;\r\n",
+    "const a = 1;\nconst b = 2;\n",
+  )
+}

package/linthost/format_whitespace_preserves_crlf_under_crlf_end_of_line_test.go

@@ -0,0 +1,28 @@
+package linthost
+
+import "testing"
+
+// TestFormatWhitespacePreservesCRLFUnderCRLFEndOfLine verifies the rule
+// keeps interior `\r\n` line endings when `endOfLine` is `crlf`.
+//
+// Under CRLF the `\r` is part of the preserved terminator, so the
+// trailing-space deletion must end before it. The complete output keeps
+// both `\r\n` pairs while removing only the first line's stray space.
+//
+//  1. Parse a CRLF file whose first line carries a trailing space.
+//  2. Apply the rule with `{"endOfLine":"crlf"}` through the fixer.
+//  3. Assert every line keeps its `\r\n` terminator.
+//
+// @evidence contracts/testing.md#behavioral-verification format/whitespace must remove the first-line stray space while retaining every CRLF pair under crlf.
+// @evidence contracts/testing.md#independent-expectations The escaped full output literal preserves both declarations and all CRLF bytes, deleting only the pre-terminator space.
+// @evidence contracts/testing.md#distinguishing-cases The changed CRLF tail contrasts with default CRLF-to-LF conversion and ordinary LF trimming.
+// @evidence contracts/testing.md#execution-ownership TestFormatWhitespacePreservesCRLFUnderCRLFEndOfLine is a public Go unit selected by the lint semantic-unit Evidence claim. This host owns every literal input and assertion; the shared syntax-only harness invokes the whitespace rule and applies edits for complete output comparisons in the same process without a consumer install, native product build or product host.
+func TestFormatWhitespacePreservesCRLFUnderCRLFEndOfLine(t *testing.T) {
+  assertFixSnapshotWithOptions(
+    t,
+    "format/whitespace",
+    "const a = 1; \r\nconst b = 2;\r\n",
+    `{"endOfLine":"crlf"}`,
+    "const a = 1;\r\nconst b = 2;\r\n",
+  )
+}

package/linthost/format_whitespace_preserves_nested_template_content_test.go

@@ -0,0 +1,28 @@
+package linthost
+
+import "testing"
+
+// TestFormatWhitespacePreservesNestedTemplateContent verifies trailing
+// spaces inside a template nested in another template's `${}` survive.
+//
+// The inner template's trailing space is string content. This source
+// requires preserving that payload; the enclosing full template range
+// already covers it, so absence of a finding does not independently
+// prove that the range collection visited the inner template.
+//
+//  1. Parse an outer template whose interpolation holds a multi-line
+//     inner template with a trailing space.
+//  2. Run the rule.
+//  3. Assert it emits no finding.
+//
+// @evidence contracts/testing.md#behavioral-verification format/whitespace must emit no finding for a trailing space in an inner template nested in an outer substitution.
+// @evidence contracts/testing.md#independent-expectations The independently authored inner x-space-newline-y bytes belong to the composed string value and cannot be trimmed.
+// @evidence contracts/testing.md#distinguishing-cases Nested-template payload protection complements simple templates and real-source trimming. This negative distinguishes protection of the nested payload from head-only protection, but does not distinguish recursive inner-range collection from protection by the enclosing full range.
+// @evidence contracts/testing.md#execution-ownership TestFormatWhitespacePreservesNestedTemplateContent is a public Go unit selected by the lint semantic-unit Evidence claim. This host owns every literal input and assertion; the shared syntax-only harness invokes the whitespace rule and observes zero findings in the same process without a consumer install, native product build or product host.
+func TestFormatWhitespacePreservesNestedTemplateContent(t *testing.T) {
+  assertRuleSkipsSource(
+    t,
+    "format/whitespace",
+    "const t = `a${`x \ny`}b`;\n",
+  )
+}

package/linthost/format_whitespace_preserves_trailing_space_across_template_substitution_test.go

@@ -0,0 +1,29 @@
+package linthost
+
+import "testing"
+
+// TestFormatWhitespacePreservesTrailingSpaceAcrossTemplateSubstitution
+// verifies trailing spaces survive in the head and tail around one
+// `${x}` substitution.
+//
+// Both authored spaces are template string payload. Preserving the
+// head's space and the tail's space after `${x}` distinguishes protection
+// of this complete literal from protection of its head alone. This
+// input does not contain a separate middle span or multiline expression.
+//
+//  1. Parse a multi-line template with `${x}` and trailing spaces on its
+//     interior lines.
+//  2. Run the rule.
+//  3. Assert it emits no finding (template content is untouched).
+//
+// @evidence contracts/testing.md#behavioral-verification format/whitespace must offer no edit for template head/tail trailing spaces around the x substitution.
+// @evidence contracts/testing.md#independent-expectations The literal template whitespace contributes to its string value and must remain independently of formatting preferences.
+// @evidence contracts/testing.md#distinguishing-cases One interpolated head/tail negative complements no-substitution/nested-template guards and real-source trimming positives.
+// @evidence contracts/testing.md#execution-ownership TestFormatWhitespacePreservesTrailingSpaceAcrossTemplateSubstitution is a public Go unit selected by the lint semantic-unit Evidence claim. This host owns every literal input and assertion; the shared syntax-only harness invokes the whitespace rule and observes zero findings in the same process without a consumer install, native product build or product host.
+func TestFormatWhitespacePreservesTrailingSpaceAcrossTemplateSubstitution(t *testing.T) {
+  assertRuleSkipsSource(
+    t,
+    "format/whitespace",
+    "const t = `a \n${x} \nb`;\n",
+  )
+}

package/linthost/format_whitespace_preserves_trailing_spaces_inside_template_literal_test.go

@@ -0,0 +1,35 @@
+package linthost
+
+import "testing"
+
+// TestFormatWhitespacePreservesTrailingSpacesInsideTemplateLiteral
+// verifies formatWhitespace never trims whitespace that lives inside a
+// template literal, while still trimming the trailing whitespace of the
+// real source line that follows.
+//
+// Template-literal bytes are significant: trailing spaces before a
+// newline inside a “ `...` “ are part of the string value, and
+// deleting them would silently change runtime output. This pins the
+// template-safety guard — the rule skips any line whose newline falls
+// inside a collected template range, yet the trailing spaces after the
+// statement's `;` on a later, non-template line are still removed.
+//
+//  1. Parse a multi-line template whose first line ends in two spaces,
+//     followed by a statement that itself has trailing spaces.
+//  2. Apply the rule's finding through the disk-backed fixer.
+//  3. Assert the in-template spaces survive and the post-`;` spaces are
+//     trimmed.
+//
+// @evidence contracts/testing.md#behavioral-verification format/whitespace must retain space/tab bytes inside the template while trimming matching whitespace after a separate const declaration.
+// @evidence contracts/testing.md#independent-expectations Independent full output literals preserve the entire template string value and modify only the external source tail.
+// @evidence contracts/testing.md#distinguishing-cases The original spaces and added mixed-tab/space twin each require an external change and unchanged template payload.
+// @evidence contracts/testing.md#execution-ownership TestFormatWhitespacePreservesTrailingSpacesInsideTemplateLiteral is a public Go unit selected by the lint semantic-unit Evidence claim. This host owns every literal input and assertion; the shared syntax-only harness invokes the whitespace rule and applies edits for complete output comparisons in the same process without a consumer install, native product build or product host.
+func TestFormatWhitespacePreservesTrailingSpacesInsideTemplateLiteral(t *testing.T) {
+  assertFixSnapshot(
+    t,
+    "format/whitespace",
+    "const t = `line  \nnext`;\nconst a = 1;  \n",
+    "const t = `line  \nnext`;\nconst a = 1;\n",
+  )
+  assertFixSnapshot(t, "format/whitespace", "const t = `line\t \nnext`;\nconst a = 1;\t \n", "const t = `line\t \nnext`;\nconst a = 1;\n")
+}

package/linthost/format_whitespace_skips_empty_file_test.go

@@ -0,0 +1,26 @@
+package linthost
+
+import "testing"
+
+// TestFormatWhitespaceSkipsEmptyFile verifies the rule emits no finding
+// for an empty source file.
+//
+// An empty file has no whitespace to normalize and no content to anchor a
+// final newline against, so the rule returns early. This pins that the
+// zero-length guard produces no spurious edit.
+//
+//  1. Parse an empty source file.
+//  2. Run the rule.
+//  3. Assert it emits no finding.
+//
+// @evidence contracts/testing.md#behavioral-verification format/whitespace must offer no edit for zero-length source rather than inventing a final newline.
+// @evidence contracts/testing.md#independent-expectations An independently specified truly empty file has no content or whitespace to normalize; zero findings is its observable oracle.
+// @evidence contracts/testing.md#distinguishing-cases The empty negative contrasts with nonempty whitespace-only LF/CRLF sources that must change and visible content requiring an EOL.
+// @evidence contracts/testing.md#execution-ownership TestFormatWhitespaceSkipsEmptyFile is a public Go unit selected by the lint semantic-unit Evidence claim. This host owns every literal input and assertion; the shared syntax-only harness invokes the whitespace rule and observes zero findings in the same process without a consumer install, native product build or product host.
+func TestFormatWhitespaceSkipsEmptyFile(t *testing.T) {
+  assertRuleSkipsSource(
+    t,
+    "format/whitespace",
+    "",
+  )
+}

package/linthost/format_whitespace_skips_single_blank_line_test.go

@@ -0,0 +1,26 @@
+package linthost
+
+import "testing"
+
+// TestFormatWhitespaceSkipsSingleBlankLine verifies the rule preserves a
+// single interior blank line between two statements.
+//
+// Prettier keeps at most one consecutive blank line; exactly one is
+// allowed, so the collapse pass must not fire. This pins that a file with
+// one interior blank line is a fixed point.
+//
+//  1. Parse two statements separated by one blank line.
+//  2. Run the rule.
+//  3. Assert it emits no finding.
+//
+// @evidence contracts/testing.md#behavioral-verification format/whitespace must emit no finding for exactly one interior blank line between two clean declarations.
+// @evidence contracts/testing.md#independent-expectations The literal input independently satisfies the allowed interior blank-line and final-LF contract.
+// @evidence contracts/testing.md#distinguishing-cases This canonical threshold negative complements the actual three-blank-line collapse positive, so idempotency is not the sole oracle.
+// @evidence contracts/testing.md#execution-ownership TestFormatWhitespaceSkipsSingleBlankLine is a public Go unit selected by the lint semantic-unit Evidence claim. This host owns every literal input and assertion; the shared syntax-only harness invokes the whitespace rule and observes zero findings in the same process without a consumer install, native product build or product host.
+func TestFormatWhitespaceSkipsSingleBlankLine(t *testing.T) {
+  assertRuleSkipsSource(
+    t,
+    "format/whitespace",
+    "const a = 1;\n\nconst b = 2;\n",
+  )
+}

package/linthost/format_whitespace_strips_leading_blank_lines_test.go

@@ -0,0 +1,27 @@
+package linthost
+
+import "testing"
+
+// TestFormatWhitespaceStripsLeadingBlankLines verifies formatWhitespace
+// removes blank lines at the start of the file.
+//
+// Prettier never keeps leading blank lines before the first token. This
+// pins operation (c): the two empty lines preceding the first statement
+// are removed.
+//
+//  1. Parse a file that opens with two blank lines.
+//  2. Apply the rule's finding through the disk-backed fixer.
+//  3. Assert the file now starts with the first statement.
+//
+// @evidence contracts/testing.md#behavioral-verification format/whitespace must remove two initial blank lines without changing the first declaration or final LF.
+// @evidence contracts/testing.md#independent-expectations The independent output literal begins directly with const a=1 and preserves its terminator.
+// @evidence contracts/testing.md#distinguishing-cases This changed leading block complements interior one-blank-line preservation and trailing/all-blank normalization.
+// @evidence contracts/testing.md#execution-ownership TestFormatWhitespaceStripsLeadingBlankLines is a public Go unit selected by the lint semantic-unit Evidence claim. This host owns every literal input and assertion; the shared syntax-only harness invokes the whitespace rule and applies edits for complete output comparisons in the same process without a consumer install, native product build or product host.
+func TestFormatWhitespaceStripsLeadingBlankLines(t *testing.T) {
+  assertFixSnapshot(
+    t,
+    "format/whitespace",
+    "\n\nconst a = 1;\n",
+    "const a = 1;\n",
+  )
+}

package/linthost/format_whitespace_strips_trailing_blank_lines_test.go

@@ -0,0 +1,27 @@
+package linthost
+
+import "testing"
+
+// TestFormatWhitespaceStripsTrailingBlankLines verifies formatWhitespace
+// removes trailing blank lines and leaves exactly one final newline.
+//
+// Prettier ends a file with a single newline. This pins operation (d):
+// the trailing blank lines and stray whitespace after the last statement
+// collapse to one EOL.
+//
+//  1. Parse a statement followed by several blank/whitespace-only lines.
+//  2. Apply the rule's finding through the disk-backed fixer.
+//  3. Assert the file ends with one newline after the statement.
+//
+// @evidence contracts/testing.md#behavioral-verification format/whitespace must reduce trailing empty/space-only lines to one final LF while keeping the declaration intact.
+// @evidence contracts/testing.md#independent-expectations The complete literal output independently specifies exactly one terminal newline after const a=1.
+// @evidence contracts/testing.md#distinguishing-cases Multiple empty lines and a whitespace-only final line change; missing-EOL and all-blank sources own the neighboring EOF decisions.
+// @evidence contracts/testing.md#execution-ownership TestFormatWhitespaceStripsTrailingBlankLines is a public Go unit selected by the lint semantic-unit Evidence claim. This host owns every literal input and assertion; the shared syntax-only harness invokes the whitespace rule and applies edits for complete output comparisons in the same process without a consumer install, native product build or product host.
+func TestFormatWhitespaceStripsTrailingBlankLines(t *testing.T) {
+  assertFixSnapshot(
+    t,
+    "format/whitespace",
+    "const a = 1;\n\n\n  \n",
+    "const a = 1;\n",
+  )
+}

package/linthost/format_whitespace_trims_trailing_spaces_test.go

@@ -0,0 +1,28 @@
+package linthost
+
+import "testing"
+
+// TestFormatWhitespaceTrimsTrailingSpaces verifies formatWhitespace
+// deletes spaces and tabs left before a line's newline.
+//
+// Trailing whitespace is invisible noise Prettier always strips. This
+// pins operation (a): the run after the statement's `;` and before the
+// `\n` is removed without touching the statement.
+//
+//  1. Parse a statement followed by two trailing spaces.
+//  2. Apply the rule's finding through the disk-backed fixer.
+//  3. Assert the trailing spaces are gone.
+//
+// @evidence contracts/testing.md#behavioral-verification format/whitespace must trim real source-line spaces and tabs while retaining both const declarations and LF endings.
+// @evidence contracts/testing.md#independent-expectations Complete literal outputs preserve a=1 and b=2 and remove only their source-tail whitespace; template payload has a separate preservation oracle.
+// @evidence contracts/testing.md#distinguishing-cases The original space-only and added mixed tab/space tails change; clean-source negatives and template-owned tails distinguish where trimming is forbidden.
+// @evidence contracts/testing.md#execution-ownership TestFormatWhitespaceTrimsTrailingSpaces is a public Go unit selected by the lint semantic-unit Evidence claim. This host owns every literal input and assertion; the shared syntax-only harness invokes the whitespace rule and applies edits for complete output comparisons in the same process without a consumer install, native product build or product host.
+func TestFormatWhitespaceTrimsTrailingSpaces(t *testing.T) {
+  assertFixSnapshot(
+    t,
+    "format/whitespace",
+    "const a = 1;  \nconst b = 2;\n",
+    "const a = 1;\nconst b = 2;\n",
+  )
+  assertFixSnapshot(t, "format/whitespace", "const a = 1;\t \nconst b = 2;\n", "const a = 1;\nconst b = 2;\n")
+}

package/linthost/functional_helpers_test.go

@@ -0,0 +1,88 @@
+package linthost
+
+import (
+  "encoding/json"
+  "strings"
+  "testing"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+func runFunctionalRule(t *testing.T, ruleName, source string) []*Finding {
+  t.Helper()
+  return runFunctionalRuleWithResolver(
+    t,
+    source,
+    RuleConfig{ruleName: SeverityError},
+    nil,
+  )
+}
+
+func runFunctionalRuleWithOptions(t *testing.T, ruleName, source, optsJSON string) []*Finding {
+  t.Helper()
+  options := RuleOptionsMap{ruleName: json.RawMessage(optsJSON)}
+  return runFunctionalRuleWithResolver(
+    t,
+    source,
+    InlineRuleResolver{
+      Rules:   RuleConfig{ruleName: SeverityError},
+      Options: options,
+    },
+    options,
+  )
+}
+
+func runFunctionalRuleWithResolver(
+  t *testing.T,
+  source string,
+  resolver RuleResolver,
+  options RuleOptionsMap,
+) []*Finding {
+  t.Helper()
+  file := parseTSFile(t, "/virtual/functional.ts", source)
+  engine := NewEngineWithResolver(resolver)
+  if unknown := engine.UnknownRules(); len(unknown) != 0 {
+    t.Fatalf("unknown functional rules: %v", unknown)
+  }
+  findings := engine.Run([]*shimast.SourceFile{file}, nil)
+  if err := validateSemanticRuleFindings(engine.EnabledRules(), findings); err != nil {
+    t.Fatalf("invalid functional findings: %v", err)
+  }
+  recordFindingBehavioralWitnessesByRule(t, findings, func(ruleName string) behavioralWitnessKind {
+    return behavioralWitnessKindForOptions(ruleName, options)
+  })
+  return findings
+}
+
+func assertFunctionalFinding(t *testing.T, ruleName string, findings []*Finding, messagePart string) {
+  t.Helper()
+  if len(findings) != 1 {
+    // Multi-finding regressions used to slip past the older
+    // "at least one finding" check — a rule misfiring on every
+    // identifier still passed. Require exactly one finding so
+    // regressions surface immediately. Tests legitimately
+    // expecting multiple findings should call a different helper.
+    messages := make([]string, 0, len(findings))
+    for _, finding := range findings {
+      messages = append(messages, finding.Message)
+    }
+    t.Fatalf("%s: expected exactly one finding, got %d: %q", ruleName, len(findings), messages)
+  }
+  finding := findings[0]
+  if finding.Rule != ruleName {
+    t.Fatalf("want rule %q, got %q", ruleName, finding.Rule)
+  }
+  if len(finding.Fix) != 0 {
+    t.Fatalf("%s: functional policy diagnostics must not offer autofixes", ruleName)
+  }
+  if messagePart != "" && !strings.Contains(finding.Message, messagePart) {
+    t.Fatalf("%s: finding message %q does not contain %q", ruleName, finding.Message, messagePart)
+  }
+}
+
+func assertNoFunctionalFinding(t *testing.T, ruleName string, findings []*Finding) {
+  t.Helper()
+  if len(findings) != 0 {
+    t.Fatalf("%s: expected no findings, got %#v", ruleName, findings)
+  }
+}

package/linthost/functional_immutable_data_ignores_code_pattern_test.go

@@ -0,0 +1,28 @@
+package linthost
+
+import "testing"
+
+// TestFunctionalImmutableDataIgnoresCodePattern verifies functional/immutable-data honors ignoreCodePattern.
+//
+// The mutation rule reports member-access nodes instead of declarations, so the
+// source-code pattern skip is the compatible escape hatch for generated or
+// framework-owned write sites.
+//
+// 1. Parse a property assignment that the rule normally rejects.
+// 2. Enable only functional/immutable-data with a matching `ignoreCodePattern`.
+// 3. Assert the mutation is skipped.
+//
+// @evidence contracts/testing.md#behavioral-verification runFunctionalRuleWithOptions executes the actual engine and verifies state.count write is accepted under a matching code pattern; an exact zero-finding comparison rejects both unwanted reports and recovered engine failures.
+// @evidence contracts/testing.md#independent-expectations The published ignoreCodePattern exempts this exact write expression. The literal source and configured option express the supported policy independently of rule output.
+// @evidence contracts/testing.md#distinguishing-cases The default rejection is owned by ImmutableDataRejectsPropertyAssignment.
+// @evidence contracts/testing.md#execution-ownership TestFunctionalImmutableDataIgnoresCodePattern is a named Go unit entry running actual TypeScript AST policy operations in the shared engine process; no consumer install, native build or real product host is used.
+func TestFunctionalImmutableDataIgnoresCodePattern(t *testing.T) {
+  const ruleName = "functional/immutable-data"
+  findings := runFunctionalRuleWithOptions(
+    t,
+    ruleName,
+    `const state = { count: 0 }; state.count = 1;`,
+    `{"ignoreCodePattern":["state\\.count"]}`,
+  )
+  assertNoFunctionalFinding(t, ruleName, findings)
+}

package/linthost/functional_immutable_data_rejects_property_assignment_test.go

@@ -0,0 +1,25 @@
+package linthost
+
+import "testing"
+
+// TestFunctionalImmutableDataRejectsPropertyAssignment verifies
+// functional/immutable-data rejects writes through object properties.
+//
+// Property assignment is the core mutation shape this policy must catch before
+// broader collection helpers matter, and it is AST-local enough to enforce
+// without checker state.
+//
+// 1. Parse an assignment to `state.count`.
+// 2. Enable only functional/immutable-data.
+// 3. Assert the property write reports and offers no autofix.
+//
+// @evidence contracts/testing.md#behavioral-verification runFunctionalRule executes the actual engine and verifies state.count write reports; assertFunctionalFinding requires exactly one finding carrying this rule identity, no autofix and a message containing the expected fragment, which separates the policy report from duplicate or unrelated findings.
+// @evidence contracts/testing.md#independent-expectations Immutable data policy rejects member writes but allows reading the property. The authored source states the policy case independently of rule output.
+// @evidence contracts/testing.md#distinguishing-cases Positive: `const state = { count: 0 }; state.count = 1;` must yield exactly one functional/immutable-data finding (assertFunctionalFinding). Negative control run through the same rule via assertNoFunctionalFinding: `const state = { count: 0 }; const current = state.count;` must yield zero findings; reading the property is accepted while writing it is reported. No option-configured variant is exercised here.
+// @evidence contracts/testing.md#execution-ownership TestFunctionalImmutableDataRejectsPropertyAssignment is a named Go unit entry running actual TypeScript AST policy operations in the shared engine process; no consumer install, native build or real product host is used.
+func TestFunctionalImmutableDataRejectsPropertyAssignment(t *testing.T) {
+  const ruleName = "functional/immutable-data"
+  findings := runFunctionalRule(t, ruleName, `const state = { count: 0 }; state.count = 1;`)
+  assertFunctionalFinding(t, ruleName, findings, "Modifying")
+  assertNoFunctionalFinding(t, ruleName, runFunctionalRule(t, ruleName, "const state = { count: 0 }; const current = state.count;"))
+}

package/linthost/functional_no_class_inheritance_rejects_extends_test.go

@@ -0,0 +1,24 @@
+package linthost
+
+import "testing"
+
+// TestFunctionalNoClassInheritanceRejectsExtends verifies
+// functional/no-class-inheritance rejects `extends` clauses.
+//
+// The rule is narrower than functional/no-classes: projects can ban inheritance
+// while still temporarily allowing class declarations during migration.
+//
+// 1. Parse a base class and a subclass.
+// 2. Enable only functional/no-class-inheritance.
+// 3. Assert the subclass inheritance reports and offers no autofix.
+//
+// @evidence contracts/testing.md#behavioral-verification runFunctionalRule executes the actual engine and verifies only Child extends Base reports; assertFunctionalFinding requires exactly one finding carrying this rule identity, no autofix and a message containing the expected fragment, which separates the policy report from duplicate or unrelated findings.
+// @evidence contracts/testing.md#independent-expectations The inheritance policy is narrower than the class policy; a class without extends is accepted. The authored source states the policy case independently of rule output.
+// @evidence contracts/testing.md#distinguishing-cases Positive: `class Base {} class Child extends Base {}` must yield exactly one functional/no-class-inheritance finding (assertFunctionalFinding). Negative control run through the same rule via assertNoFunctionalFinding: `class Store { value = 1; }` must yield zero findings; a class declaration without an extends clause is accepted, so only the inheriting class Child is reported. No option-configured variant is exercised here.
+// @evidence contracts/testing.md#execution-ownership TestFunctionalNoClassInheritanceRejectsExtends is a named Go unit entry running actual TypeScript AST policy operations in the shared engine process; no consumer install, native build or real product host is used.
+func TestFunctionalNoClassInheritanceRejectsExtends(t *testing.T) {
+  const ruleName = "functional/no-class-inheritance"
+  findings := runFunctionalRule(t, ruleName, `class Base {} class Child extends Base {}`)
+  assertFunctionalFinding(t, ruleName, findings, "inheritance")
+  assertNoFunctionalFinding(t, ruleName, runFunctionalRule(t, ruleName, "class Store { value = 1; }"))
+}

package/linthost/functional_no_classes_rejects_class_declaration_test.go

@@ -0,0 +1,24 @@
+package linthost
+
+import "testing"
+
+// TestFunctionalNoClassesRejectsClassDeclaration verifies functional/no-classes
+// rejects class declarations.
+//
+// Classes introduce identity and `this` state; the opt-in functional pack needs
+// a direct syntax gate that does not depend on inheritance or member analysis.
+//
+// 1. Parse a class declaration.
+// 2. Enable only functional/no-classes.
+// 3. Assert the class reports and offers no autofix.
+//
+// @evidence contracts/testing.md#behavioral-verification runFunctionalRule executes the actual engine and verifies class Store reports; assertFunctionalFinding requires exactly one finding carrying this rule identity, no autofix and a message containing the expected fragment, which separates the policy report from duplicate or unrelated findings.
+// @evidence contracts/testing.md#independent-expectations The opt-in policy forbids class syntax; a data record has no class declaration. The authored source states the policy case independently of rule output.
+// @evidence contracts/testing.md#distinguishing-cases Positive: `class Store { value = 1; }` must yield exactly one functional/no-classes finding (assertFunctionalFinding). Negative control run through the same rule via assertNoFunctionalFinding: `const store = { value: 1 };` must yield zero findings; an object literal carrying the same data is accepted. No option-configured variant is exercised here.
+// @evidence contracts/testing.md#execution-ownership TestFunctionalNoClassesRejectsClassDeclaration is a named Go unit entry running actual TypeScript AST policy operations in the shared engine process; no consumer install, native build or real product host is used.
+func TestFunctionalNoClassesRejectsClassDeclaration(t *testing.T) {
+  const ruleName = "functional/no-classes"
+  findings := runFunctionalRule(t, ruleName, `class Store { value = 1; }`)
+  assertFunctionalFinding(t, ruleName, findings, "Unexpected class")
+  assertNoFunctionalFinding(t, ruleName, runFunctionalRule(t, ruleName, "const store = { value: 1 };"))
+}

package/linthost/functional_no_conditional_statements_rejects_if_test.go

@@ -0,0 +1,23 @@
+package linthost
+
+import "testing"
+
+// TestFunctionalNoConditionalStatementsRejectsIf verifies functional/no-conditional-statements rejects if statements.
+//
+// The policy prefers expression-level branching over statement-level control
+// flow, so the AST-local if statement is the simplest regression target.
+//
+// 1. Parse an if statement.
+// 2. Enable only functional/no-conditional-statements.
+// 3. Assert the if statement reports and offers no autofix.
+//
+// @evidence contracts/testing.md#behavioral-verification runFunctionalRule executes the actual engine and verifies if statement reports; assertFunctionalFinding requires exactly one finding carrying this rule identity, no autofix and a message containing the expected fragment, which separates the policy report from duplicate or unrelated findings.
+// @evidence contracts/testing.md#independent-expectations Expression-level branching is accepted by this statement policy. The authored source states the policy case independently of rule output.
+// @evidence contracts/testing.md#distinguishing-cases Positive: `if (flag) { run(); }` must yield exactly one functional/no-conditional-statements finding (assertFunctionalFinding). Negative control run through the same rule via assertNoFunctionalFinding: `const result = flag ? left : right;` must yield zero findings; an expression-level conditional is accepted. No option-configured variant is exercised here.
+// @evidence contracts/testing.md#execution-ownership TestFunctionalNoConditionalStatementsRejectsIf is a named Go unit entry running actual TypeScript AST policy operations in the shared engine process; no consumer install, native build or real product host is used.
+func TestFunctionalNoConditionalStatementsRejectsIf(t *testing.T) {
+  const ruleName = "functional/no-conditional-statements"
+  findings := runFunctionalRule(t, ruleName, `if (flag) { run(); }`)
+  assertFunctionalFinding(t, ruleName, findings, "if")
+  assertNoFunctionalFinding(t, ruleName, runFunctionalRule(t, ruleName, "const result = flag ? left : right;"))
+}

package/linthost/functional_no_expression_statements_rejects_call_test.go

@@ -0,0 +1,23 @@
+package linthost
+
+import "testing"
+
+// TestFunctionalNoExpressionStatementsRejectsCall verifies functional/no-expression-statements rejects side-effect calls.
+//
+// This policy rejects ordinary expression-statement syntax. The rule
+// keeps directive prologues aside and reports ordinary call statements.
+//
+// 1. Parse a call expression statement.
+// 2. Enable only functional/no-expression-statements.
+// 3. Assert the statement reports and offers no autofix.
+//
+// @evidence contracts/testing.md#behavioral-verification runFunctionalRule executes the actual engine and verifies commit() as a statement reports; assertFunctionalFinding requires exactly one finding carrying this rule identity, no autofix and a message containing the expected fragment, which separates the policy report from duplicate or unrelated findings.
+// @evidence contracts/testing.md#independent-expectations A value-producing declaration avoids the forbidden side-effect statement form. The authored source states the policy case independently of rule output.
+// @evidence contracts/testing.md#distinguishing-cases Positive: `commit();` must yield exactly one functional/no-expression-statements finding (assertFunctionalFinding). Negative control run through the same rule via assertNoFunctionalFinding: `const result = compute();` must yield zero findings; a call used as a declaration initializer is accepted. No option-configured variant is exercised here.
+// @evidence contracts/testing.md#execution-ownership TestFunctionalNoExpressionStatementsRejectsCall is a named Go unit entry running actual TypeScript AST policy operations in the shared engine process; no consumer install, native build or real product host is used.
+func TestFunctionalNoExpressionStatementsRejectsCall(t *testing.T) {
+  const ruleName = "functional/no-expression-statements"
+  findings := runFunctionalRule(t, ruleName, `commit();`)
+  assertFunctionalFinding(t, ruleName, findings, "side effects")
+  assertNoFunctionalFinding(t, ruleName, runFunctionalRule(t, ruleName, "const result = compute();"))
+}

package/linthost/functional_no_let_ignores_identifier_pattern_test.go

@@ -0,0 +1,28 @@
+package linthost
+
+import "testing"
+
+// TestFunctionalNoLetIgnoresIdentifierPattern verifies functional/no-let honors ignoreIdentifierPattern.
+//
+// The public rule options expose identifier-pattern skips for functional rules.
+// This pins the native decoder path so a configured binding-name exception does
+// not still report the shared `let` keyword.
+//
+// 1. Parse a `let` declaration whose binding name matches the configured pattern.
+// 2. Enable only functional/no-let with `ignoreIdentifierPattern`.
+// 3. Assert the declaration is skipped.
+//
+// @evidence contracts/testing.md#behavioral-verification runFunctionalRuleWithOptions executes the actual engine and verifies mutableValue let is accepted with its name pattern; an exact zero-finding comparison rejects both unwanted reports and recovered engine failures.
+// @evidence contracts/testing.md#independent-expectations The exact identifier-pattern exemption selects this binding. The literal source and configured option express the supported policy independently of rule output.
+// @evidence contracts/testing.md#distinguishing-cases NoLetRejectsLetDeclaration owns the unconfigured rejection.
+// @evidence contracts/testing.md#execution-ownership TestFunctionalNoLetIgnoresIdentifierPattern is a named Go unit entry running actual TypeScript AST policy operations in the shared engine process; no consumer install, native build or real product host is used.
+func TestFunctionalNoLetIgnoresIdentifierPattern(t *testing.T) {
+  const ruleName = "functional/no-let"
+  findings := runFunctionalRuleWithOptions(
+    t,
+    ruleName,
+    `let mutableValue = 1;`,
+    `{"ignoreIdentifierPattern":"^mutableValue$"}`,
+  )
+  assertNoFunctionalFinding(t, ruleName, findings)
+}