@ttsc/lint 0.30.3 → 0.31.0

package/linthost/functional_prefer_immutable_types_ignores_identifier_pattern_test.go

@@ -0,0 +1,28 @@
+package linthost
+
+import "testing"
+
+// TestFunctionalPreferImmutableTypesIgnoresIdentifierPattern verifies functional/prefer-immutable-types.
+//
+// The rule reports the mutable type node, but users configure identifier
+// patterns against the surrounding declaration name. This keeps that bridge
+// covered for declaration-based immutable-type checks.
+//
+// 1. Parse a mutable array annotation on a matching variable declaration.
+// 2. Enable only functional/prefer-immutable-types with `ignoreIdentifierPattern`.
+// 3. Assert the type is skipped.
+//
+// @evidence contracts/testing.md#behavioral-verification runFunctionalRuleWithOptions executes the actual engine and verifies mutableValues array annotation is accepted under its declaration-name exemption; an exact zero-finding comparison rejects both unwanted reports and recovered engine failures.
+// @evidence contracts/testing.md#independent-expectations The option refers to the owning declaration identifier despite the reported type node. The literal source and configured option express the supported policy independently of rule output.
+// @evidence contracts/testing.md#distinguishing-cases PreferImmutableTypesRejectsArrayType owns the default mutable annotation.
+// @evidence contracts/testing.md#execution-ownership TestFunctionalPreferImmutableTypesIgnoresIdentifierPattern 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 TestFunctionalPreferImmutableTypesIgnoresIdentifierPattern(t *testing.T) {
+  const ruleName = "functional/prefer-immutable-types"
+  findings := runFunctionalRuleWithOptions(
+    t,
+    ruleName,
+    `const mutableValues: string[] = [];`,
+    `{"ignoreIdentifierPattern":"^mutableValues$"}`,
+  )
+  assertNoFunctionalFinding(t, ruleName, findings)
+}

package/linthost/functional_prefer_immutable_types_rejects_array_type_test.go

@@ -0,0 +1,23 @@
+package linthost
+
+import "testing"
+
+// TestFunctionalPreferImmutableTypesRejectsArrayType verifies functional/prefer-immutable-types rejects mutable types.
+//
+// Mutable array annotations are the most common type-level mutability leak. The
+// rule reports the annotation without requiring checker expansion.
+//
+// 1. Parse a mutable array type annotation.
+// 2. Enable only functional/prefer-immutable-types.
+// 3. Assert the annotation reports and offers no autofix.
+//
+// @evidence contracts/testing.md#behavioral-verification runFunctionalRule executes the actual engine and verifies mutable variable array annotation 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 readonly array syntax expresses the required immutable declaration type. The authored source states the policy case independently of rule output.
+// @evidence contracts/testing.md#distinguishing-cases Positive: `const values: string[] = [];` must yield exactly one functional/prefer-immutable-types finding (assertFunctionalFinding). Negative control run through the same rule via assertNoFunctionalFinding: `const values: readonly string[] = [];` must yield zero findings; the readonly string[] annotation is accepted. No option-configured variant is exercised here.
+// @evidence contracts/testing.md#execution-ownership TestFunctionalPreferImmutableTypesRejectsArrayType 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 TestFunctionalPreferImmutableTypesRejectsArrayType(t *testing.T) {
+  const ruleName = "functional/prefer-immutable-types"
+  findings := runFunctionalRule(t, ruleName, `const values: string[] = [];`)
+  assertFunctionalFinding(t, ruleName, findings, "readonly")
+  assertNoFunctionalFinding(t, ruleName, runFunctionalRule(t, ruleName, "const values: readonly string[] = [];"))
+}

package/linthost/functional_prefer_immutable_types_rejects_mutable_parameter_array_test.go

@@ -0,0 +1,24 @@
+package linthost
+
+import "testing"
+
+// TestFunctionalPreferImmutableTypesRejectsMutableParameterArray verifies
+// functional/prefer-immutable-types rejects mutable parameter array types.
+//
+// This checker-free subset focuses on declared types whose syntax is clearly
+// mutable, giving projects a reliable migration gate without type services.
+//
+// 1. Parse a function parameter typed as `string[]`.
+// 2. Enable only functional/prefer-immutable-types.
+// 3. Assert the mutable array type reports and offers no autofix.
+//
+// @evidence contracts/testing.md#behavioral-verification runFunctionalRule executes the actual engine and verifies mutable parameter array annotation 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 parameter contract requires a readonly array annotation. The authored source states the policy case independently of rule output.
+// @evidence contracts/testing.md#distinguishing-cases Positive: `function read(values: string[]) { return values.length; }` must yield exactly one functional/prefer-immutable-types finding (assertFunctionalFinding). Negative control run through the same rule via assertNoFunctionalFinding: `function read(values: readonly string[]) { return values.length; }` must yield zero findings; the readonly string[] parameter annotation is accepted. No option-configured variant is exercised here.
+// @evidence contracts/testing.md#execution-ownership TestFunctionalPreferImmutableTypesRejectsMutableParameterArray 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 TestFunctionalPreferImmutableTypesRejectsMutableParameterArray(t *testing.T) {
+  const ruleName = "functional/prefer-immutable-types"
+  findings := runFunctionalRule(t, ruleName, `function read(values: string[]) { return values.length; }`)
+  assertFunctionalFinding(t, ruleName, findings, "readonly")
+  assertNoFunctionalFinding(t, ruleName, runFunctionalRule(t, ruleName, "function read(values: readonly string[]) { return values.length; }"))
+}

package/linthost/functional_prefer_property_signatures_rejects_method_signature_test.go

@@ -0,0 +1,23 @@
+package linthost
+
+import "testing"
+
+// TestFunctionalPreferPropertySignaturesRejectsMethodSignature verifies functional/prefer-property-signatures.
+//
+// Function-valued properties are easier to model as immutable data than method
+// shorthand signatures. This pins the interface method-signature branch.
+//
+// 1. Parse an interface method signature.
+// 2. Enable only functional/prefer-property-signatures.
+// 3. Assert the method signature reports and offers no autofix.
+//
+// @evidence contracts/testing.md#behavioral-verification runFunctionalRule executes the actual engine and verifies interface method signature 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 policy prefers an explicit function-valued property signature. The authored source states the policy case independently of rule output.
+// @evidence contracts/testing.md#distinguishing-cases Positive: `interface Api { run(): void; }` must yield exactly one functional/prefer-property-signatures finding (assertFunctionalFinding). Negative control run through the same rule via assertNoFunctionalFinding: `interface Api { run: () => void; }` must yield zero findings; a function-valued property signature is accepted. No option-configured variant is exercised here.
+// @evidence contracts/testing.md#execution-ownership TestFunctionalPreferPropertySignaturesRejectsMethodSignature 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 TestFunctionalPreferPropertySignaturesRejectsMethodSignature(t *testing.T) {
+  const ruleName = "functional/prefer-property-signatures"
+  findings := runFunctionalRule(t, ruleName, `interface Api { run(): void; }`)
+  assertFunctionalFinding(t, ruleName, findings, "property signature")
+  assertNoFunctionalFinding(t, ruleName, runFunctionalRule(t, ruleName, "interface Api { run: () => void; }"))
+}

package/linthost/functional_prefer_readonly_type_allow_mutable_return_type_covers_call_signature_test.go

@@ -0,0 +1,29 @@
+package linthost
+
+import "testing"
+
+// TestFunctionalPreferReadonlyTypeAllowMutableReturnTypeCoversCallSignature verifies allowMutableReturnType covers a call signature's return type.
+//
+// The interface's bare call signature owns its string-array return type.
+// The return exemption must recognize that annotation without disabling
+// parameter annotations. This fixture observes only the call-signature
+// return owner, not other signature kinds or an earlier implementation.
+//
+// 1. Parse an interface whose call signature returns a mutable array.
+// 2. Enable only functional/prefer-readonly-type with `allowMutableReturnType: true`.
+// 3. Assert the return annotation is skipped.
+//
+// @evidence contracts/testing.md#behavioral-verification runFunctionalRuleWithOptions executes the actual engine and verifies mutable call-signature return is accepted with allowMutableReturnType; an exact zero-finding comparison rejects both unwanted reports and recovered engine failures.
+// @evidence contracts/testing.md#independent-expectations Return-position exemptions also apply to interface call signatures. The literal source and configured option express the supported policy independently of rule output.
+// @evidence contracts/testing.md#distinguishing-cases AllowMutableReturnTypeKeepsParameterAnnotation owns the unaffected parameter position.
+// @evidence contracts/testing.md#execution-ownership TestFunctionalPreferReadonlyTypeAllowMutableReturnTypeCoversCallSignature 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 TestFunctionalPreferReadonlyTypeAllowMutableReturnTypeCoversCallSignature(t *testing.T) {
+  const ruleName = "functional/prefer-readonly-type"
+  findings := runFunctionalRuleWithOptions(
+    t,
+    ruleName,
+    "interface Factory {\n  (): string[];\n}",
+    "{\"allowMutableReturnType\":true}",
+  )
+  assertNoFunctionalFinding(t, ruleName, findings)
+}

package/linthost/functional_prefer_readonly_type_allow_mutable_return_type_keeps_parameter_annotation_test.go

@@ -0,0 +1,28 @@
+package linthost
+
+import "testing"
+
+// TestFunctionalPreferReadonlyTypeAllowMutableReturnTypeKeepsParameterAnnotation verifies allowMutableReturnType leaves parameter annotations checked.
+//
+// The reporting twin, and the one the key's own wording depends on: parameters
+// stay readonly while the return type is permitted to be mutable. A position
+// test that matched any annotation on a function would erase that difference.
+//
+// 1. Parse a function that takes a mutable array parameter.
+// 2. Enable only functional/prefer-readonly-type with `allowMutableReturnType: true`.
+// 3. Assert the parameter annotation still reports.
+//
+// @evidence contracts/testing.md#behavioral-verification runFunctionalRuleWithOptions executes the actual engine and verifies mutable function parameter reports with return exemption enabled; 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 option exempts returns only, not every annotation in a function. The literal source and configured option express the supported policy independently of rule output.
+// @evidence contracts/testing.md#distinguishing-cases AllowMutableReturnTypeSkipsReturnAnnotation owns the accepted return position.
+// @evidence contracts/testing.md#execution-ownership TestFunctionalPreferReadonlyTypeAllowMutableReturnTypeKeepsParameterAnnotation 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 TestFunctionalPreferReadonlyTypeAllowMutableReturnTypeKeepsParameterAnnotation(t *testing.T) {
+  const ruleName = "functional/prefer-readonly-type"
+  findings := runFunctionalRuleWithOptions(
+    t,
+    ruleName,
+    "function run(values: string[]): void {}",
+    "{\"allowMutableReturnType\":true}",
+  )
+  assertFunctionalFinding(t, ruleName, findings, "readonly")
+}

package/linthost/functional_prefer_readonly_type_allow_mutable_return_type_skips_return_annotation_test.go

@@ -0,0 +1,28 @@
+package linthost
+
+import "testing"
+
+// TestFunctionalPreferReadonlyTypeAllowMutableReturnTypeSkipsReturnAnnotation verifies functional/prefer-readonly-type honors allowMutableReturnType.
+//
+// The option exempts this function's declared mutable array return type.
+// The authored body returns a fresh array, while parameter positions
+// remain checked by the separately owned reporting twin.
+//
+// 1. Parse a function whose declared return type is a mutable array.
+// 2. Enable only functional/prefer-readonly-type with `allowMutableReturnType: true`.
+// 3. Assert the return annotation is skipped.
+//
+// @evidence contracts/testing.md#behavioral-verification runFunctionalRuleWithOptions executes the actual engine and verifies mutable declared function return is accepted with the return exemption; an exact zero-finding comparison rejects both unwanted reports and recovered engine failures.
+// @evidence contracts/testing.md#independent-expectations The function may hand back a mutable value while parameters remain readonly. The literal source and configured option express the supported policy independently of rule output.
+// @evidence contracts/testing.md#distinguishing-cases AllowMutableReturnTypeKeepsParameterAnnotation owns the unaffected parameter.
+// @evidence contracts/testing.md#execution-ownership TestFunctionalPreferReadonlyTypeAllowMutableReturnTypeSkipsReturnAnnotation 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 TestFunctionalPreferReadonlyTypeAllowMutableReturnTypeSkipsReturnAnnotation(t *testing.T) {
+  const ruleName = "functional/prefer-readonly-type"
+  findings := runFunctionalRuleWithOptions(
+    t,
+    ruleName,
+    "function run(): string[] { return []; }",
+    "{\"allowMutableReturnType\":true}",
+  )
+  assertNoFunctionalFinding(t, ruleName, findings)
+}

package/linthost/functional_prefer_readonly_type_ignore_class_fields_only_keeps_method_parameter_test.go

@@ -0,0 +1,34 @@
+package linthost
+
+import "testing"
+
+// TestFunctionalPreferReadonlyTypeIgnoreClassFieldsOnlyKeepsMethodParameter verifies ignoreClass: "fieldsOnly" spares fields and keeps other class members checked.
+//
+// The reporting twin distinguishes the field-only and whole-class options. A gate
+// that treated any truthy value as the whole-body skip would silence the method
+// parameter too, and the published type would then be a lie in its own second
+// value.
+//
+// 1. Parse a class with a mutable array field and a mutable array parameter.
+// 2. Enable only functional/prefer-readonly-type with `ignoreClass: "fieldsOnly"`.
+// 3. Assert only the method parameter reports.
+//
+// @evidence contracts/testing.md#behavioral-verification runFunctionalRuleWithOptions executes the actual engine and verifies class field is skipped but mutable method parameter still reports; assertFunctionalFinding requires exactly one finding carrying this rule identity, no autofix and a readonly message; the independently specified parameter-type range prevents accepting a report on the skipped field instead.
+// @evidence contracts/testing.md#independent-expectations fieldsOnly narrows the exemption to fields rather than the whole class body. The literal source and configured option express the supported policy independently of rule output.
+// @evidence contracts/testing.md#distinguishing-cases IgnoreClassSkipsClassBody owns the whole-body switch.
+// @evidence contracts/testing.md#execution-ownership TestFunctionalPreferReadonlyTypeIgnoreClassFieldsOnlyKeepsMethodParameter 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 TestFunctionalPreferReadonlyTypeIgnoreClassFieldsOnlyKeepsMethodParameter(t *testing.T) {
+  const ruleName = "functional/prefer-readonly-type"
+  findings := runFunctionalRuleWithOptions(
+    t,
+    ruleName,
+    "class A {\n  values: string[] = [];\n  run(items: string[]): void {}\n}",
+    "{\"ignoreClass\":\"fieldsOnly\"}",
+  )
+  assertFunctionalFinding(t, ruleName, findings, "readonly")
+  const parameterTypeStart = len("class A {\n  values: string[] = [];\n  run(items: ")
+  if findings[0].Pos != parameterTypeStart || findings[0].End != parameterTypeStart+len("string[]") {
+    t.Fatalf("want method parameter type range [%d,%d), got [%d,%d)",
+      parameterTypeStart, parameterTypeStart+len("string[]"), findings[0].Pos, findings[0].End)
+  }
+}

package/linthost/functional_prefer_readonly_type_ignore_class_keeps_module_scope_checked_test.go

@@ -0,0 +1,29 @@
+package linthost
+
+import "testing"
+
+// TestFunctionalPreferReadonlyTypeIgnoreClassKeepsModuleScopeChecked verifies
+// ignoreClass leaves everything outside a class checked.
+//
+// This reporting alias is outside every class. An unconditional class
+// exemption would incorrectly silence it, whereas the configured policy
+// must leave this module-scope array annotation checked.
+//
+// 1. Parse a module-scope mutable array type alias.
+// 2. Enable only functional/prefer-readonly-type with `ignoreClass: true`.
+// 3. Assert the alias still reports.
+//
+// @evidence contracts/testing.md#behavioral-verification runFunctionalRuleWithOptions executes the actual engine and verifies mutable module alias still reports with ignoreClass true; 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 class-only exemption cannot suppress module-scope types. The literal source and configured option express the supported policy independently of rule output.
+// @evidence contracts/testing.md#distinguishing-cases IgnoreClassSkipsClassBody owns accepted class members.
+// @evidence contracts/testing.md#execution-ownership TestFunctionalPreferReadonlyTypeIgnoreClassKeepsModuleScopeChecked 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 TestFunctionalPreferReadonlyTypeIgnoreClassKeepsModuleScopeChecked(t *testing.T) {
+  const ruleName = "functional/prefer-readonly-type"
+  findings := runFunctionalRuleWithOptions(
+    t,
+    ruleName,
+    "type Values = string[];",
+    `{"ignoreClass":true}`,
+  )
+  assertFunctionalFinding(t, ruleName, findings, "readonly")
+}

package/linthost/functional_prefer_readonly_type_ignore_class_skips_class_body_test.go

@@ -0,0 +1,29 @@
+package linthost
+
+import "testing"
+
+// TestFunctionalPreferReadonlyTypeIgnoreClassSkipsClassBody verifies functional/prefer-readonly-type honors ignoreClass: true.
+//
+// The configured class exemption covers both the mutable field type and
+// the mutable method-parameter type in this authored class. Its complete
+// zero-finding comparison observes both accepted positions without
+// claiming their absence from an earlier implementation.
+//
+// 1. Parse a class with a mutable array field and a mutable array parameter.
+// 2. Enable only functional/prefer-readonly-type with `ignoreClass: true`.
+// 3. Assert the whole class body is skipped.
+//
+// @evidence contracts/testing.md#behavioral-verification runFunctionalRuleWithOptions executes the actual engine and verifies mutable field and method parameter stay accepted with ignoreClass true; an exact zero-finding comparison rejects both unwanted reports and recovered engine failures.
+// @evidence contracts/testing.md#independent-expectations The boolean class exemption includes the entire class body. The literal source and configured option express the supported policy independently of rule output.
+// @evidence contracts/testing.md#distinguishing-cases FieldsOnlyKeepsMethodParameter and KeepsModuleScopeChecked own the narrower/outside distinctions.
+// @evidence contracts/testing.md#execution-ownership TestFunctionalPreferReadonlyTypeIgnoreClassSkipsClassBody 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 TestFunctionalPreferReadonlyTypeIgnoreClassSkipsClassBody(t *testing.T) {
+  const ruleName = "functional/prefer-readonly-type"
+  findings := runFunctionalRuleWithOptions(
+    t,
+    ruleName,
+    "class A {\n  values: string[] = [];\n  run(items: string[]): void {}\n}",
+    "{\"ignoreClass\":true}",
+  )
+  assertNoFunctionalFinding(t, ruleName, findings)
+}

package/linthost/functional_prefer_readonly_type_ignore_collections_keeps_property_signature_test.go

@@ -0,0 +1,28 @@
+package linthost
+
+import "testing"
+
+// TestFunctionalPreferReadonlyTypeIgnoreCollectionsKeepsPropertySignature verifies ignoreCollections leaves non-collection positions checked.
+//
+// The reporting twin. The key names a set of type shapes, so a mutable property
+// signature whose type is not a collection must still require its readonly
+// modifier.
+//
+// 1. Parse a type literal with a non-readonly string property.
+// 2. Enable only functional/prefer-readonly-type with `ignoreCollections: true`.
+// 3. Assert the property signature still reports.
+//
+// @evidence contracts/testing.md#behavioral-verification runFunctionalRuleWithOptions executes the actual engine and verifies a mutable scalar property still reports when collections are ignored; 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 string property is not an array, tuple or collection reference. The literal source and configured option express the supported policy independently of rule output.
+// @evidence contracts/testing.md#distinguishing-cases IgnoreCollectionsSkipsArrayType owns the accepted collection shape.
+// @evidence contracts/testing.md#execution-ownership TestFunctionalPreferReadonlyTypeIgnoreCollectionsKeepsPropertySignature 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 TestFunctionalPreferReadonlyTypeIgnoreCollectionsKeepsPropertySignature(t *testing.T) {
+  const ruleName = "functional/prefer-readonly-type"
+  findings := runFunctionalRuleWithOptions(
+    t,
+    ruleName,
+    "type Shape = { value: string };",
+    "{\"ignoreCollections\":true}",
+  )
+  assertFunctionalFinding(t, ruleName, findings, "readonly")
+}

package/linthost/functional_prefer_readonly_type_ignore_collections_skips_array_type_test.go

@@ -0,0 +1,28 @@
+package linthost
+
+import "testing"
+
+// TestFunctionalPreferReadonlyTypeIgnoreCollectionsSkipsArrayType verifies functional/prefer-readonly-type honors ignoreCollections.
+//
+// This array alias belongs to the published collection exemption. The
+// configured zero-finding comparison observes that array shape; tuples
+// and collection references are not present in this fixture.
+//
+// 1. Parse a mutable array type alias.
+// 2. Enable only functional/prefer-readonly-type with `ignoreCollections: true`.
+// 3. Assert the array type is skipped.
+//
+// @evidence contracts/testing.md#behavioral-verification runFunctionalRuleWithOptions executes the actual engine and verifies mutable array alias stays accepted when collections are ignored; an exact zero-finding comparison rejects both unwanted reports and recovered engine failures.
+// @evidence contracts/testing.md#independent-expectations Array annotations belong to the published collection exemption. The literal source and configured option express the supported policy independently of rule output.
+// @evidence contracts/testing.md#distinguishing-cases IgnoreCollectionsKeepsPropertySignature owns the non-collection position.
+// @evidence contracts/testing.md#execution-ownership TestFunctionalPreferReadonlyTypeIgnoreCollectionsSkipsArrayType 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 TestFunctionalPreferReadonlyTypeIgnoreCollectionsSkipsArrayType(t *testing.T) {
+  const ruleName = "functional/prefer-readonly-type"
+  findings := runFunctionalRuleWithOptions(
+    t,
+    ruleName,
+    "type Values = string[];",
+    "{\"ignoreCollections\":true}",
+  )
+  assertNoFunctionalFinding(t, ruleName, findings)
+}

package/linthost/functional_prefer_readonly_type_ignore_interface_keeps_type_alias_member_test.go

@@ -0,0 +1,28 @@
+package linthost
+
+import "testing"
+
+// TestFunctionalPreferReadonlyTypeIgnoreInterfaceKeepsTypeAliasMember verifies ignoreInterface leaves type-alias members checked.
+//
+// The reporting alias twin has the same property shape as the accepted
+// interface fixture. An exemption that matched every declaration instead
+// of an interface ancestor would incorrectly silence this alias member.
+//
+// 1. Parse a type alias with a non-readonly string property.
+// 2. Enable only functional/prefer-readonly-type with `ignoreInterface: true`.
+// 3. Assert the member still reports.
+//
+// @evidence contracts/testing.md#behavioral-verification runFunctionalRuleWithOptions executes the actual engine and verifies mutable type-alias member still reports with ignoreInterface true; 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 structurally similar type alias is not an interface ancestor. The literal source and configured option express the supported policy independently of rule output.
+// @evidence contracts/testing.md#distinguishing-cases IgnoreInterfaceSkipsInterfaceMember owns the accepted interface.
+// @evidence contracts/testing.md#execution-ownership TestFunctionalPreferReadonlyTypeIgnoreInterfaceKeepsTypeAliasMember 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 TestFunctionalPreferReadonlyTypeIgnoreInterfaceKeepsTypeAliasMember(t *testing.T) {
+  const ruleName = "functional/prefer-readonly-type"
+  findings := runFunctionalRuleWithOptions(
+    t,
+    ruleName,
+    "type Shape = { value: string };",
+    "{\"ignoreInterface\":true}",
+  )
+  assertFunctionalFinding(t, ruleName, findings, "readonly")
+}

package/linthost/functional_prefer_readonly_type_ignore_interface_skips_interface_member_test.go

@@ -0,0 +1,28 @@
+package linthost
+
+import "testing"
+
+// TestFunctionalPreferReadonlyTypeIgnoreInterfaceSkipsInterfaceMember verifies functional/prefer-readonly-type honors ignoreInterface.
+//
+// The published interface exemption follows the member's actual ancestor.
+// This fixture observes a non-readonly property inside an interface,
+// rather than a report on the interface node itself.
+//
+// 1. Parse an interface with a non-readonly string property.
+// 2. Enable only functional/prefer-readonly-type with `ignoreInterface: true`.
+// 3. Assert the member is skipped.
+//
+// @evidence contracts/testing.md#behavioral-verification runFunctionalRuleWithOptions executes the actual engine and verifies mutable interface member stays accepted with ignoreInterface true; an exact zero-finding comparison rejects both unwanted reports and recovered engine failures.
+// @evidence contracts/testing.md#independent-expectations The exemption follows the interface ancestor through its member. The literal source and configured option express the supported policy independently of rule output.
+// @evidence contracts/testing.md#distinguishing-cases IgnoreInterfaceKeepsTypeAliasMember owns the unaffected alias member.
+// @evidence contracts/testing.md#execution-ownership TestFunctionalPreferReadonlyTypeIgnoreInterfaceSkipsInterfaceMember 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 TestFunctionalPreferReadonlyTypeIgnoreInterfaceSkipsInterfaceMember(t *testing.T) {
+  const ruleName = "functional/prefer-readonly-type"
+  findings := runFunctionalRuleWithOptions(
+    t,
+    ruleName,
+    "interface Shape { value: string; }",
+    "{\"ignoreInterface\":true}",
+  )
+  assertNoFunctionalFinding(t, ruleName, findings)
+}

package/linthost/functional_prefer_readonly_type_ignores_code_pattern_test.go

@@ -0,0 +1,27 @@
+package linthost
+
+import "testing"
+
+// TestFunctionalPreferReadonlyTypeIgnoresCodePattern verifies functional/prefer-readonly-type.
+//
+// Array-type diagnostics do not have a useful declaration identifier at the
+// reported node. This locks the source-code pattern escape hatch for that path.
+//
+// 1. Parse a mutable array type alias.
+// 2. Enable only functional/prefer-readonly-type with `ignoreCodePattern`.
+// 3. Assert the array type is skipped.
+//
+// @evidence contracts/testing.md#behavioral-verification runFunctionalRuleWithOptions executes the actual engine and verifies mutable array alias is accepted with matching source pattern; an exact zero-finding comparison rejects both unwanted reports and recovered engine failures.
+// @evidence contracts/testing.md#independent-expectations The code-pattern exemption selects the string[] annotation itself. The literal source and configured option express the supported policy independently of rule output.
+// @evidence contracts/testing.md#distinguishing-cases PreferReadonlyTypeRejectsArrayType owns the unconfigured rejection.
+// @evidence contracts/testing.md#execution-ownership TestFunctionalPreferReadonlyTypeIgnoresCodePattern 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 TestFunctionalPreferReadonlyTypeIgnoresCodePattern(t *testing.T) {
+  const ruleName = "functional/prefer-readonly-type"
+  findings := runFunctionalRuleWithOptions(
+    t,
+    ruleName,
+    `type Values = string[];`,
+    `{"ignoreCodePattern":"string\\[\\]"}`,
+  )
+  assertNoFunctionalFinding(t, ruleName, findings)
+}

package/linthost/functional_prefer_readonly_type_rejects_array_type_test.go

@@ -0,0 +1,23 @@
+package linthost
+
+import "testing"
+
+// TestFunctionalPreferReadonlyTypeRejectsArrayType verifies functional/prefer-readonly-type rejects mutable arrays.
+//
+// The rule is a type-syntax policy. A plain array type is the smallest mutable
+// shape that should be replaced with readonly syntax.
+//
+// 1. Parse a mutable array type alias.
+// 2. Enable only functional/prefer-readonly-type.
+// 3. Assert the array type reports and offers no autofix.
+//
+// @evidence contracts/testing.md#behavioral-verification runFunctionalRule executes the actual engine and verifies mutable string[] alias 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 readonly keyword syntax gives the accepted immutable array form. The authored source states the policy case independently of rule output.
+// @evidence contracts/testing.md#distinguishing-cases The positive case `type Values = string[];` must report exactly once, and the adjacent negative case `type Values = readonly string[];` is run through the same rule and must produce zero findings, so the rule cannot pass by flagging every array alias; no option-configured variant is covered here.
+// @evidence contracts/testing.md#execution-ownership TestFunctionalPreferReadonlyTypeRejectsArrayType 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 TestFunctionalPreferReadonlyTypeRejectsArrayType(t *testing.T) {
+  const ruleName = "functional/prefer-readonly-type"
+  findings := runFunctionalRule(t, ruleName, `type Values = string[];`)
+  assertFunctionalFinding(t, ruleName, findings, "readonly")
+  assertNoFunctionalFinding(t, ruleName, runFunctionalRule(t, ruleName, "type Values = readonly string[];"))
+}

package/linthost/functional_prefer_tacit_check_member_expressions_false_keeps_identifier_callee_test.go

@@ -0,0 +1,27 @@
+package linthost
+
+import "testing"
+
+// TestFunctionalPreferTacitCheckMemberExpressionsFalseKeepsIdentifierCallee verifies checkMemberExpressions: false leaves a bare callee checked.
+//
+// The reporting twin. The key narrows the callee shape, not the rule, so a
+// wrapper around a plain identifier must still report while the key is off.
+//
+// 1. Parse an arrow that forwards its parameter to a bare identifier call.
+// 2. Enable only functional/prefer-tacit with `checkMemberExpressions: false`.
+// 3. Assert the wrapper still reports.
+//
+// @evidence contracts/testing.md#behavioral-verification runFunctionalRuleWithOptions executes the actual engine and verifies identifier forwarding wrapper still reports with member checking disabled; 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 member-only switch cannot exempt bare identifier callees. The literal source and configured option express the supported policy independently of rule output.
+// @evidence contracts/testing.md#distinguishing-cases CheckMemberExpressionsFalseSkipsMemberCallee owns the accepted receiver shape.
+// @evidence contracts/testing.md#execution-ownership TestFunctionalPreferTacitCheckMemberExpressionsFalseKeepsIdentifierCallee 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 TestFunctionalPreferTacitCheckMemberExpressionsFalseKeepsIdentifierCallee(t *testing.T) {
+  const ruleName = "functional/prefer-tacit"
+  findings := runFunctionalRuleWithOptions(
+    t,
+    ruleName,
+    "const wrap = (value: string) => handler(value);",
+    "{\"checkMemberExpressions\":false}",
+  )
+  assertFunctionalFinding(t, ruleName, findings, "wrapper")
+}

package/linthost/functional_prefer_tacit_check_member_expressions_false_skips_member_callee_test.go

@@ -0,0 +1,28 @@
+package linthost
+
+import "testing"
+
+// TestFunctionalPreferTacitCheckMemberExpressionsFalseSkipsMemberCallee verifies functional/prefer-tacit honors checkMemberExpressions: false.
+//
+// Removing a member-call wrapper can lose its receiver binding. The
+// published switch exempts this service.handler wrapper while leaving
+// the separately owned bare-identifier wrapper checked.
+//
+// 1. Parse an arrow that forwards its parameter to a member call.
+// 2. Enable only functional/prefer-tacit with `checkMemberExpressions: false`.
+// 3. Assert the wrapper is skipped.
+//
+// @evidence contracts/testing.md#behavioral-verification runFunctionalRuleWithOptions executes the actual engine and verifies service.handler forwarding wrapper stays accepted when members are excluded; an exact zero-finding comparison rejects both unwanted reports and recovered engine failures.
+// @evidence contracts/testing.md#independent-expectations Removing a receiver-preserving wrapper can lose this binding, so this option exempts member callees. The literal source and configured option express the supported policy independently of rule output.
+// @evidence contracts/testing.md#distinguishing-cases CheckMemberExpressionsFalseKeepsIdentifierCallee owns the unaffected identifier call.
+// @evidence contracts/testing.md#execution-ownership TestFunctionalPreferTacitCheckMemberExpressionsFalseSkipsMemberCallee 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 TestFunctionalPreferTacitCheckMemberExpressionsFalseSkipsMemberCallee(t *testing.T) {
+  const ruleName = "functional/prefer-tacit"
+  findings := runFunctionalRuleWithOptions(
+    t,
+    ruleName,
+    "const wrap = (value: string) => service.handler(value);",
+    "{\"checkMemberExpressions\":false}",
+  )
+  assertNoFunctionalFinding(t, ruleName, findings)
+}

package/linthost/functional_prefer_tacit_rejects_single_argument_wrapper_test.go

@@ -0,0 +1,24 @@
+package linthost
+
+import "testing"
+
+// TestFunctionalPreferTacitRejectsSingleArgumentWrapper verifies functional/prefer-tacit rejects needless wrappers.
+//
+// This single-argument arrow forwards to Number and is reported as a
+// potential style simplification. No autofix is offered, and the syntax
+// comparison does not certify replacing arbitrary arity-sensitive callees.
+//
+// 1. Parse a forwarding arrow function.
+// 2. Enable only functional/prefer-tacit.
+// 3. Assert the arrow reports and offers no autofix.
+//
+// @evidence contracts/testing.md#behavioral-verification runFunctionalRule executes the actual engine and verifies single-argument Number forwarding wrapper 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 policy prefers the directly referenced callee over a trivial forwarding arrow. The authored source states the policy case independently of rule output.
+// @evidence contracts/testing.md#distinguishing-cases The positive case `const parse = (value) => Number(value);` must report once, and the adjacent negative case `const parse = Number;` (no arrow wrapper) must produce zero findings; wrappers with member callees, typed parameters or multiple arguments are not exercised here.
+// @evidence contracts/testing.md#execution-ownership TestFunctionalPreferTacitRejectsSingleArgumentWrapper 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 TestFunctionalPreferTacitRejectsSingleArgumentWrapper(t *testing.T) {
+  const ruleName = "functional/prefer-tacit"
+  findings := runFunctionalRule(t, ruleName, `const parse = (value) => Number(value);`)
+  assertFunctionalFinding(t, ruleName, findings, "wrapper")
+  assertNoFunctionalFinding(t, ruleName, runFunctionalRule(t, ruleName, "const parse = Number;"))
+}

package/linthost/functional_readonly_type_rejects_readonly_array_generic_test.go

@@ -0,0 +1,23 @@
+package linthost
+
+import "testing"
+
+// TestFunctionalReadonlyTypeRejectsReadonlyArrayGeneric verifies functional/readonly-type prefers keyword form.
+//
+// The default option favors `readonly T[]` over `ReadonlyArray<T>`. This keeps
+// the option-decoding branch separate from mutable-type detection.
+//
+// 1. Parse a ReadonlyArray type alias.
+// 2. Enable only functional/readonly-type.
+// 3. Assert the generic type reports and offers no autofix.
+//
+// @evidence contracts/testing.md#behavioral-verification runFunctionalRule executes the actual engine and verifies ReadonlyArray generic reports under default keyword style; 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 default style policy selects readonly T[] while preserving readonly meaning. The authored source states the policy case independently of rule output.
+// @evidence contracts/testing.md#distinguishing-cases The positive case `type Values = ReadonlyArray<string>;` must report once with a message naming the readonly keyword, and the adjacent negative case `type Values = readonly string[];` must produce zero findings; the `prefer: "generic"` direction is not exercised here.
+// @evidence contracts/testing.md#execution-ownership TestFunctionalReadonlyTypeRejectsReadonlyArrayGeneric 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 TestFunctionalReadonlyTypeRejectsReadonlyArrayGeneric(t *testing.T) {
+  const ruleName = "functional/readonly-type"
+  findings := runFunctionalRule(t, ruleName, `type Values = ReadonlyArray<string>;`)
+  assertFunctionalFinding(t, ruleName, findings, "readonly keyword")
+  assertNoFunctionalFinding(t, ruleName, runFunctionalRule(t, ruleName, "type Values = readonly string[];"))
+}

package/linthost/functional_type_declaration_immutability_ignores_identifier_pattern_test.go

@@ -0,0 +1,27 @@
+package linthost
+
+import "testing"
+
+// TestFunctionalTypeDeclarationImmutabilityIgnoresIdentifierPattern verifies functional/type-declaration-immutability.
+//
+// Type declarations already have name-scoped `rules`; this locks the shared
+// `ignoreIdentifierPattern` path layered over that local policy surface.
+//
+// 1. Parse a mutable interface whose name matches the configured ignore pattern.
+// 2. Enable only functional/type-declaration-immutability with `ignoreIdentifierPattern`.
+// 3. Assert the declaration is skipped.
+//
+// @evidence contracts/testing.md#behavioral-verification runFunctionalRuleWithOptions executes the actual engine and verifies MutableSnapshot interface stays accepted under its name exemption; an exact zero-finding comparison rejects both unwanted reports and recovered engine failures.
+// @evidence contracts/testing.md#independent-expectations The declaration-name pattern exempts this authored interface from immutability policy. The literal source and configured option express the supported policy independently of rule output.
+// @evidence contracts/testing.md#distinguishing-cases TypeDeclarationImmutabilityRejectsMutableInterface owns the default rejection.
+// @evidence contracts/testing.md#execution-ownership TestFunctionalTypeDeclarationImmutabilityIgnoresIdentifierPattern 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 TestFunctionalTypeDeclarationImmutabilityIgnoresIdentifierPattern(t *testing.T) {
+  const ruleName = "functional/type-declaration-immutability"
+  findings := runFunctionalRuleWithOptions(
+    t,
+    ruleName,
+    `interface MutableSnapshot { value: string[]; }`,
+    `{"ignoreIdentifierPattern":"^MutableSnapshot$"}`,
+  )
+  assertNoFunctionalFinding(t, ruleName, findings)
+}