@ttsc/lint 0.30.3 → 0.31.0

package/linthost/functional_no_let_rejects_let_declaration_test.go

@@ -0,0 +1,24 @@
+package linthost
+
+import "testing"
+
+// TestFunctionalNoLetRejectsLetDeclaration verifies functional/no-let rejects
+// mutable `let` declarations.
+//
+// Existing `prefer-const` only catches lets that are never reassigned. The
+// functional policy intentionally rejects the declaration form itself.
+//
+// 1. Parse a `let` declaration.
+// 2. Enable only functional/no-let.
+// 3. Assert the `let` keyword reports and offers no autofix.
+//
+// @evidence contracts/testing.md#behavioral-verification runFunctionalRule executes the actual engine and verifies let declaration reports despite subsequent assignment; 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 declaration policy rejects mutability even where prefer-const would not apply. The authored source states the policy case independently of rule output.
+// @evidence contracts/testing.md#distinguishing-cases Positive: `let value = 1; value = 2;` must yield exactly one functional/no-let finding (assertFunctionalFinding). Negative control run through the same rule via assertNoFunctionalFinding: `const value = 1;` must yield zero findings; a const declaration is accepted. No option-configured variant is exercised here.
+// @evidence contracts/testing.md#execution-ownership TestFunctionalNoLetRejectsLetDeclaration 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 TestFunctionalNoLetRejectsLetDeclaration(t *testing.T) {
+  const ruleName = "functional/no-let"
+  findings := runFunctionalRule(t, ruleName, `let value = 1; value = 2;`)
+  assertFunctionalFinding(t, ruleName, findings, "Unexpected let")
+  assertNoFunctionalFinding(t, ruleName, runFunctionalRule(t, ruleName, "const value = 1;"))
+}

package/linthost/functional_no_loop_statements_rejects_for_test.go

@@ -0,0 +1,23 @@
+package linthost
+
+import "testing"
+
+// TestFunctionalNoLoopStatementsRejectsFor verifies functional/no-loop-statements rejects loops.
+//
+// The policy expects collection transforms or recursion instead of imperative
+// loops, and a for statement is the representative AST-local branch.
+//
+// 1. Parse a for loop.
+// 2. Enable only functional/no-loop-statements.
+// 3. Assert the loop reports and offers no autofix.
+//
+// @evidence contracts/testing.md#behavioral-verification runFunctionalRule executes the actual engine and verifies for-of loop 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 Collection expressions do not introduce an imperative loop statement. The authored source states the policy case independently of rule output.
+// @evidence contracts/testing.md#distinguishing-cases Positive: `for (const item of items) { consume(item); }` must yield exactly one functional/no-loop-statements finding (assertFunctionalFinding). Negative control run through the same rule via assertNoFunctionalFinding: `const result = items.map(consume);` must yield zero findings; a collection map expression is accepted. No option-configured variant is exercised here.
+// @evidence contracts/testing.md#execution-ownership TestFunctionalNoLoopStatementsRejectsFor 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 TestFunctionalNoLoopStatementsRejectsFor(t *testing.T) {
+  const ruleName = "functional/no-loop-statements"
+  findings := runFunctionalRule(t, ruleName, `for (const item of items) { consume(item); }`)
+  assertFunctionalFinding(t, ruleName, findings, "loop")
+  assertNoFunctionalFinding(t, ruleName, runFunctionalRule(t, ruleName, "const result = items.map(consume);"))
+}

package/linthost/functional_no_mixed_types_check_interfaces_false_skips_interface_test.go

@@ -0,0 +1,28 @@
+package linthost
+
+import "testing"
+
+// TestFunctionalNoMixedTypesCheckInterfacesFalseSkipsInterface verifies functional/no-mixed-types honors checkInterfaces: false.
+//
+// The published interface switch controls this mixed interface without
+// changing the separate type-literal switch. This input observes the
+// interface arm of the configured gate.
+//
+// 1. Parse an interface that mixes a property and a method.
+// 2. Enable only functional/no-mixed-types with `checkInterfaces: false`.
+// 3. Assert the interface is skipped.
+//
+// @evidence contracts/testing.md#behavioral-verification runFunctionalRuleWithOptions executes the actual engine and verifies mixed interface is accepted with checkInterfaces false; an exact zero-finding comparison rejects both unwanted reports and recovered engine failures.
+// @evidence contracts/testing.md#independent-expectations The option disables interface containers, not type literals. The literal source and configured option express the supported policy independently of rule output.
+// @evidence contracts/testing.md#distinguishing-cases CheckInterfacesFalseStillChecksTypeLiteral owns the adjacent unaffected container.
+// @evidence contracts/testing.md#execution-ownership TestFunctionalNoMixedTypesCheckInterfacesFalseSkipsInterface 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 TestFunctionalNoMixedTypesCheckInterfacesFalseSkipsInterface(t *testing.T) {
+  const ruleName = "functional/no-mixed-types"
+  findings := runFunctionalRuleWithOptions(
+    t,
+    ruleName,
+    "interface Mixed { value: string; run(): void; }",
+    "{\"checkInterfaces\":false}",
+  )
+  assertNoFunctionalFinding(t, ruleName, findings)
+}

package/linthost/functional_no_mixed_types_check_interfaces_false_still_checks_type_literal_test.go

@@ -0,0 +1,28 @@
+package linthost
+
+import "testing"
+
+// TestFunctionalNoMixedTypesCheckInterfacesFalseStillChecksTypeLiteral verifies checkInterfaces: false leaves type literals checked.
+//
+// The reporting twin of the accepted interface gate checks its boundary.
+// An unconditional return for checkInterfaces:false would incorrectly
+// silence this mixed type literal as well.
+//
+// 1. Parse a type literal that mixes a property and a method.
+// 2. Enable only functional/no-mixed-types with `checkInterfaces: false`.
+// 3. Assert the type literal still reports.
+//
+// @evidence contracts/testing.md#behavioral-verification runFunctionalRuleWithOptions executes the actual engine and verifies mixed type literal reports with checkInterfaces false; 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 interface-only switch cannot exempt a type literal. The literal source and configured option express the supported policy independently of rule output.
+// @evidence contracts/testing.md#distinguishing-cases CheckInterfacesFalseSkipsInterface owns the accepted target container.
+// @evidence contracts/testing.md#execution-ownership TestFunctionalNoMixedTypesCheckInterfacesFalseStillChecksTypeLiteral 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 TestFunctionalNoMixedTypesCheckInterfacesFalseStillChecksTypeLiteral(t *testing.T) {
+  const ruleName = "functional/no-mixed-types"
+  findings := runFunctionalRuleWithOptions(
+    t,
+    ruleName,
+    "type Mixed = { value: string; run(): void };",
+    "{\"checkInterfaces\":false}",
+  )
+  assertFunctionalFinding(t, ruleName, findings, "same kind")
+}

package/linthost/functional_no_mixed_types_check_type_literals_false_skips_type_literal_test.go

@@ -0,0 +1,28 @@
+package linthost
+
+import "testing"
+
+// TestFunctionalNoMixedTypesCheckTypeLiteralsFalseSkipsTypeLiteral verifies functional/no-mixed-types honors checkTypeLiterals: false.
+//
+// The type-literal arm of the same gate. Both container kinds ship their own
+// key, so both need their own witness or one can silently take the other's
+// branch.
+//
+// 1. Parse a type literal that mixes a property and a method.
+// 2. Enable only functional/no-mixed-types with `checkTypeLiterals: false`.
+// 3. Assert the type literal is skipped.
+//
+// @evidence contracts/testing.md#behavioral-verification runFunctionalRuleWithOptions executes the actual engine and verifies mixed type literal is accepted with checkTypeLiterals false; an exact zero-finding comparison rejects both unwanted reports and recovered engine failures.
+// @evidence contracts/testing.md#independent-expectations The option disables type literals, not interfaces. The literal source and configured option express the supported policy independently of rule output.
+// @evidence contracts/testing.md#distinguishing-cases CheckTypeLiteralsFalseStillChecksInterface owns the adjacent unaffected container.
+// @evidence contracts/testing.md#execution-ownership TestFunctionalNoMixedTypesCheckTypeLiteralsFalseSkipsTypeLiteral 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 TestFunctionalNoMixedTypesCheckTypeLiteralsFalseSkipsTypeLiteral(t *testing.T) {
+  const ruleName = "functional/no-mixed-types"
+  findings := runFunctionalRuleWithOptions(
+    t,
+    ruleName,
+    "type Mixed = { value: string; run(): void };",
+    "{\"checkTypeLiterals\":false}",
+  )
+  assertNoFunctionalFinding(t, ruleName, findings)
+}

package/linthost/functional_no_mixed_types_check_type_literals_false_still_checks_interface_test.go

@@ -0,0 +1,28 @@
+package linthost
+
+import "testing"
+
+// TestFunctionalNoMixedTypesCheckTypeLiteralsFalseStillChecksInterface verifies checkTypeLiterals: false leaves interfaces checked.
+//
+// The reporting interface twin checks the type-literal switch's boundary.
+// The two keys select different container kinds, so disabling type literals
+// must not silence this mixed interface.
+//
+// 1. Parse an interface that mixes a property and a method.
+// 2. Enable only functional/no-mixed-types with `checkTypeLiterals: false`.
+// 3. Assert the interface still reports.
+//
+// @evidence contracts/testing.md#behavioral-verification runFunctionalRuleWithOptions executes the actual engine and verifies mixed interface reports with checkTypeLiterals false; 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 type-literal switch cannot exempt an interface. The literal source and configured option express the supported policy independently of rule output.
+// @evidence contracts/testing.md#distinguishing-cases CheckTypeLiteralsFalseSkipsTypeLiteral owns the accepted target container.
+// @evidence contracts/testing.md#execution-ownership TestFunctionalNoMixedTypesCheckTypeLiteralsFalseStillChecksInterface 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 TestFunctionalNoMixedTypesCheckTypeLiteralsFalseStillChecksInterface(t *testing.T) {
+  const ruleName = "functional/no-mixed-types"
+  findings := runFunctionalRuleWithOptions(
+    t,
+    ruleName,
+    "interface Mixed { value: string; run(): void; }",
+    "{\"checkTypeLiterals\":false}",
+  )
+  assertFunctionalFinding(t, ruleName, findings, "same kind")
+}

package/linthost/functional_no_mixed_types_rejects_method_and_property_test.go

@@ -0,0 +1,23 @@
+package linthost
+
+import "testing"
+
+// TestFunctionalNoMixedTypesRejectsMethodAndProperty verifies functional/no-mixed-types rejects mixed member shapes.
+//
+// The rule keeps structural type declarations uniform. A property plus a method
+// is the smallest case that would otherwise mix data and behavior in one type.
+//
+// 1. Parse an interface with a property and method.
+// 2. Enable only functional/no-mixed-types.
+// 3. Assert the mixed member reports and offers no autofix.
+//
+// @evidence contracts/testing.md#behavioral-verification runFunctionalRule executes the actual engine and verifies mixed property and method interface 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 requires uniform member kinds. The authored source states the policy case independently of rule output.
+// @evidence contracts/testing.md#distinguishing-cases Positive: `interface Mixed { value: string; run(): void; }` must yield exactly one functional/no-mixed-types finding (assertFunctionalFinding). Negative control run through the same rule via assertNoFunctionalFinding: `interface Data { value: string; label: string; }` must yield zero findings; an interface whose members are all properties is accepted. No option-configured variant is exercised here.
+// @evidence contracts/testing.md#execution-ownership TestFunctionalNoMixedTypesRejectsMethodAndProperty 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 TestFunctionalNoMixedTypesRejectsMethodAndProperty(t *testing.T) {
+  const ruleName = "functional/no-mixed-types"
+  findings := runFunctionalRule(t, ruleName, `interface Mixed { value: string; run(): void; }`)
+  assertFunctionalFinding(t, ruleName, findings, "same kind")
+  assertNoFunctionalFinding(t, ruleName, runFunctionalRule(t, ruleName, "interface Data { value: string; label: string; }"))
+}

package/linthost/functional_no_promise_reject_rejects_static_call_test.go

@@ -0,0 +1,23 @@
+package linthost
+
+import "testing"
+
+// TestFunctionalNoPromiseRejectRejectsStaticCall verifies functional/no-promise-reject rejects Promise.reject.
+//
+// Rejected promises encode exceptional control flow. The native rule pins the
+// common static call form before broader promise-flow analysis exists.
+//
+// 1. Parse a Promise.reject call.
+// 2. Enable only functional/no-promise-reject.
+// 3. Assert the call reports and offers no autofix.
+//
+// @evidence contracts/testing.md#behavioral-verification runFunctionalRule executes the actual engine and verifies Promise.reject 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 excludes rejected-promise control flow, not Promise.resolve. The authored source states the policy case independently of rule output.
+// @evidence contracts/testing.md#distinguishing-cases Positive: `Promise.reject(error);` must yield exactly one functional/no-promise-reject finding (assertFunctionalFinding). Negative control run through the same rule via assertNoFunctionalFinding: `Promise.resolve(value);` must yield zero findings; Promise.resolve is accepted. No option-configured variant is exercised here.
+// @evidence contracts/testing.md#execution-ownership TestFunctionalNoPromiseRejectRejectsStaticCall 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 TestFunctionalNoPromiseRejectRejectsStaticCall(t *testing.T) {
+  const ruleName = "functional/no-promise-reject"
+  findings := runFunctionalRule(t, ruleName, `Promise.reject(error);`)
+  assertFunctionalFinding(t, ruleName, findings, "rejection")
+  assertNoFunctionalFinding(t, ruleName, runFunctionalRule(t, ruleName, "Promise.resolve(value);"))
+}

package/linthost/functional_no_return_void_allow_null_false_rejects_null_return_type_test.go

@@ -0,0 +1,27 @@
+package linthost
+
+import "testing"
+
+// TestFunctionalNoReturnVoidAllowNullFalseRejectsNullReturnType verifies functional/no-return-void honors allowNull: false.
+//
+// `allowNull` defaults to true, so its only observable effect is the explicit
+// false: a declared `null` return type joins `void` in being rejected.
+//
+// 1. Parse a function whose declared return type is `null`.
+// 2. Enable only functional/no-return-void with `allowNull: false`.
+// 3. Assert the declaration reports.
+//
+// @evidence contracts/testing.md#behavioral-verification runFunctionalRuleWithOptions executes the actual engine and verifies declared null return reports with allowNull false; 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 explicit option adds null to rejected return kinds. The literal source and configured option express the supported policy independently of rule output.
+// @evidence contracts/testing.md#distinguishing-cases AllowsNullReturnTypeByDefault owns the accepted default.
+// @evidence contracts/testing.md#execution-ownership TestFunctionalNoReturnVoidAllowNullFalseRejectsNullReturnType 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 TestFunctionalNoReturnVoidAllowNullFalseRejectsNullReturnType(t *testing.T) {
+  const ruleName = "functional/no-return-void"
+  findings := runFunctionalRuleWithOptions(
+    t,
+    ruleName,
+    "function run(): null { return null; }",
+    "{\"allowNull\":false}",
+  )
+  assertFunctionalFinding(t, ruleName, findings, "return")
+}

package/linthost/functional_no_return_void_allow_undefined_false_rejects_undefined_return_type_test.go

@@ -0,0 +1,28 @@
+package linthost
+
+import "testing"
+
+// TestFunctionalNoReturnVoidAllowUndefinedFalseRejectsUndefinedReturnType verifies functional/no-return-void honors allowUndefined: false.
+//
+// The `undefined` twin of `allowNull`. The two keys select different declared
+// return types, so one implementation covering both would let a project
+// silence the wrong one.
+//
+// 1. Parse a function whose declared return type is `undefined`.
+// 2. Enable only functional/no-return-void with `allowUndefined: false`.
+// 3. Assert the declaration reports.
+//
+// @evidence contracts/testing.md#behavioral-verification runFunctionalRuleWithOptions executes the actual engine and verifies declared undefined return reports with allowUndefined false; 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 explicit option adds undefined to rejected return kinds. The literal source and configured option express the supported policy independently of rule output.
+// @evidence contracts/testing.md#distinguishing-cases AllowsUndefinedReturnTypeByDefault owns the accepted default.
+// @evidence contracts/testing.md#execution-ownership TestFunctionalNoReturnVoidAllowUndefinedFalseRejectsUndefinedReturnType 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 TestFunctionalNoReturnVoidAllowUndefinedFalseRejectsUndefinedReturnType(t *testing.T) {
+  const ruleName = "functional/no-return-void"
+  findings := runFunctionalRuleWithOptions(
+    t,
+    ruleName,
+    "function run(): undefined { return undefined; }",
+    "{\"allowUndefined\":false}",
+  )
+  assertFunctionalFinding(t, ruleName, findings, "return")
+}

package/linthost/functional_no_return_void_allows_null_return_type_by_default_test.go

@@ -0,0 +1,23 @@
+package linthost
+
+import "testing"
+
+// TestFunctionalNoReturnVoidAllowsNullReturnTypeByDefault verifies a declared null return type is accepted with no options.
+//
+// The negative twin of `allowNull: false`. Honoring the option must not turn
+// `null` into a rejected return type for every project that never set it,
+// which is the regression an option added on the reporting side would cause.
+//
+// 1. Parse a function whose declared return type is `null`.
+// 2. Enable only functional/no-return-void with no options.
+// 3. Assert nothing reports.
+//
+// @evidence contracts/testing.md#behavioral-verification runFunctionalRule executes the actual engine and verifies declared null return is accepted by default; an exact zero-finding comparison rejects both unwanted reports and recovered engine failures.
+// @evidence contracts/testing.md#independent-expectations allowNull defaults to true. The authored source states the policy case independently of rule output.
+// @evidence contracts/testing.md#distinguishing-cases AllowNullFalseRejectsNullReturnType owns the explicit-false rejection.
+// @evidence contracts/testing.md#execution-ownership TestFunctionalNoReturnVoidAllowsNullReturnTypeByDefault 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 TestFunctionalNoReturnVoidAllowsNullReturnTypeByDefault(t *testing.T) {
+  const ruleName = "functional/no-return-void"
+  findings := runFunctionalRule(t, ruleName, "function run(): null { return null; }")
+  assertNoFunctionalFinding(t, ruleName, findings)
+}

package/linthost/functional_no_return_void_allows_undefined_return_type_by_default_test.go

@@ -0,0 +1,23 @@
+package linthost
+
+import "testing"
+
+// TestFunctionalNoReturnVoidAllowsUndefinedReturnTypeByDefault verifies a declared undefined return type is accepted with no options.
+//
+// The default twin of `allowUndefined: false`, matching the one `allowNull`
+// already carries. Honoring the option must not turn `undefined` into a rejected
+// return type for every project that never set it.
+//
+// 1. Parse a function whose declared return type is `undefined`.
+// 2. Enable only functional/no-return-void with no options.
+// 3. Assert nothing reports.
+//
+// @evidence contracts/testing.md#behavioral-verification runFunctionalRule executes the actual engine and verifies declared undefined return is accepted by default; an exact zero-finding comparison rejects both unwanted reports and recovered engine failures.
+// @evidence contracts/testing.md#independent-expectations allowUndefined defaults to true. The authored source states the policy case independently of rule output.
+// @evidence contracts/testing.md#distinguishing-cases AllowUndefinedFalseRejectsUndefinedReturnType owns the explicit-false rejection.
+// @evidence contracts/testing.md#execution-ownership TestFunctionalNoReturnVoidAllowsUndefinedReturnTypeByDefault 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 TestFunctionalNoReturnVoidAllowsUndefinedReturnTypeByDefault(t *testing.T) {
+  const ruleName = "functional/no-return-void"
+  findings := runFunctionalRule(t, ruleName, "function run(): undefined { return undefined; }")
+  assertNoFunctionalFinding(t, ruleName, findings)
+}

package/linthost/functional_no_return_void_ignore_inferred_types_keeps_annotated_bare_return_test.go

@@ -0,0 +1,28 @@
+package linthost
+
+import "testing"
+
+// TestFunctionalNoReturnVoidIgnoreInferredTypesKeepsAnnotatedBareReturn verifies ignoreInferredTypes spares only the unannotated bare return.
+//
+// The reporting twin. A gate that skipped every bare `return;` would read as
+// working against the positive case while quietly disabling the whole return
+// statement branch, which the annotation is what distinguishes.
+//
+// 1. Parse a function that declares a return type and still ends in a bare `return;`.
+// 2. Enable only functional/no-return-void with `ignoreInferredTypes: true`.
+// 3. Assert the bare return still reports.
+//
+// @evidence contracts/testing.md#behavioral-verification runFunctionalRuleWithOptions executes the actual engine and verifies bare return in a number-annotated function 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 An explicit return annotation is not inferred and remains checked. The literal source and configured option express the supported policy independently of rule output.
+// @evidence contracts/testing.md#distinguishing-cases IgnoreInferredTypesSkipsUnannotatedBareReturn owns the accepted inference-only case.
+// @evidence contracts/testing.md#execution-ownership TestFunctionalNoReturnVoidIgnoreInferredTypesKeepsAnnotatedBareReturn 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 TestFunctionalNoReturnVoidIgnoreInferredTypesKeepsAnnotatedBareReturn(t *testing.T) {
+  const ruleName = "functional/no-return-void"
+  findings := runFunctionalRuleWithOptions(
+    t,
+    ruleName,
+    "function run(): number { return; }",
+    "{\"ignoreInferredTypes\":true}",
+  )
+  assertFunctionalFinding(t, ruleName, findings, "return")
+}

package/linthost/functional_no_return_void_ignore_inferred_types_reads_a_get_accessor_annotation_test.go

@@ -0,0 +1,30 @@
+package linthost
+
+import "testing"
+
+// TestFunctionalNoReturnVoidIgnoreInferredTypesReadsAGetAccessorAnnotation
+// verifies a get accessor's declared return type counts as declared.
+//
+// A get accessor is the nearest function-like owner of its bare return.
+// Its explicit number annotation must prevent the inferred-only skip,
+// just as an explicit annotation on a function declaration does. The
+// input observes the getter boundary without asserting an earlier table.
+//
+// 1. Parse a get accessor that declares a return type and ends in a bare `return;`.
+// 2. Enable only functional/no-return-void with `ignoreInferredTypes: true`.
+// 3. Assert the bare return still reports.
+//
+// @evidence contracts/testing.md#behavioral-verification runFunctionalRuleWithOptions executes the actual engine and verifies bare return in a number-annotated get accessor 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 get accessor is function-like and its own explicit annotation must count. The literal source and configured option express the supported policy independently of rule output.
+// @evidence contracts/testing.md#distinguishing-cases The constructor-nearest test owns a function-like that cannot declare a return type.
+// @evidence contracts/testing.md#execution-ownership TestFunctionalNoReturnVoidIgnoreInferredTypesReadsAGetAccessorAnnotation 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 TestFunctionalNoReturnVoidIgnoreInferredTypesReadsAGetAccessorAnnotation(t *testing.T) {
+  const ruleName = "functional/no-return-void"
+  findings := runFunctionalRuleWithOptions(
+    t,
+    ruleName,
+    "class Store {\n  get value(): number {\n    return;\n  }\n}",
+    `{"ignoreInferredTypes":true}`,
+  )
+  assertFunctionalFinding(t, ruleName, findings, "return")
+}

package/linthost/functional_no_return_void_ignore_inferred_types_skips_unannotated_bare_return_test.go

@@ -0,0 +1,28 @@
+package linthost
+
+import "testing"
+
+// TestFunctionalNoReturnVoidIgnoreInferredTypesSkipsUnannotatedBareReturn verifies functional/no-return-void honors ignoreInferredTypes.
+//
+// A bare `return;` in a function with no return annotation is the one place
+// the rule rejects a void-ness it inferred instead of reading. That is exactly
+// what the published option offers to skip.
+//
+// 1. Parse a function with no return annotation and a bare `return;`.
+// 2. Enable only functional/no-return-void with `ignoreInferredTypes: true`.
+// 3. Assert the bare return is skipped.
+//
+// @evidence contracts/testing.md#behavioral-verification runFunctionalRuleWithOptions executes the actual engine and verifies unannotated bare return is accepted when inferred types are ignored; an exact zero-finding comparison rejects both unwanted reports and recovered engine failures.
+// @evidence contracts/testing.md#independent-expectations The option exempts inferred void-ness, not explicit annotations. The literal source and configured option express the supported policy independently of rule output.
+// @evidence contracts/testing.md#distinguishing-cases IgnoreInferredTypesKeepsAnnotatedBareReturn owns the rejected declared case.
+// @evidence contracts/testing.md#execution-ownership TestFunctionalNoReturnVoidIgnoreInferredTypesSkipsUnannotatedBareReturn 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 TestFunctionalNoReturnVoidIgnoreInferredTypesSkipsUnannotatedBareReturn(t *testing.T) {
+  const ruleName = "functional/no-return-void"
+  findings := runFunctionalRuleWithOptions(
+    t,
+    ruleName,
+    "function run() { return; }",
+    "{\"ignoreInferredTypes\":true}",
+  )
+  assertNoFunctionalFinding(t, ruleName, findings)
+}

package/linthost/functional_no_return_void_ignore_inferred_types_stops_at_the_nearest_function_test.go

@@ -0,0 +1,29 @@
+package linthost
+
+import "testing"
+
+// TestFunctionalNoReturnVoidIgnoreInferredTypesStopsAtTheNearestFunction verifies ignoreInferredTypes reads the nearest function-like, including one that cannot declare a return type.
+//
+// A constructor cannot declare a return annotation, so its bare return
+// qualifies for the inferred-only skip. The enclosing function's number
+// annotation must not be attributed to that constructor statement. This
+// source distinguishes stopping at the nearest owner from walking past it.
+//
+// 1. Parse an annotated function containing a class whose constructor ends in a bare `return;`.
+// 2. Enable only functional/no-return-void with `ignoreInferredTypes: true`.
+// 3. Assert the constructor's bare return is skipped.
+//
+// @evidence contracts/testing.md#behavioral-verification runFunctionalRuleWithOptions executes the actual engine and verifies constructor bare return stays accepted despite an annotated outer function; an exact zero-finding comparison rejects both unwanted reports and recovered engine failures.
+// @evidence contracts/testing.md#independent-expectations A constructor cannot declare a return annotation; nearest function ownership prevents attributing the outer annotation. The literal source and configured option express the supported policy independently of rule output.
+// @evidence contracts/testing.md#distinguishing-cases The annotated getter case checks the other function-like boundary.
+// @evidence contracts/testing.md#execution-ownership TestFunctionalNoReturnVoidIgnoreInferredTypesStopsAtTheNearestFunction 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 TestFunctionalNoReturnVoidIgnoreInferredTypesStopsAtTheNearestFunction(t *testing.T) {
+  const ruleName = "functional/no-return-void"
+  findings := runFunctionalRuleWithOptions(
+    t,
+    ruleName,
+    "function outer(): number {\n  class Inner {\n    constructor() {\n      return;\n    }\n  }\n  return 1;\n}",
+    "{\"ignoreInferredTypes\":true}",
+  )
+  assertNoFunctionalFinding(t, ruleName, findings)
+}

package/linthost/functional_no_return_void_rejects_void_annotation_test.go

@@ -0,0 +1,23 @@
+package linthost
+
+import "testing"
+
+// TestFunctionalNoReturnVoidRejectsVoidAnnotation verifies functional/no-return-void rejects void functions.
+//
+// An explicit void annotation is rejected by this configured policy. The
+// empty body isolates that declaration check from return statement traversal.
+//
+// 1. Parse a function annotated as void.
+// 2. Enable only functional/no-return-void.
+// 3. Assert the function reports and offers no autofix.
+//
+// @evidence contracts/testing.md#behavioral-verification runFunctionalRule executes the actual engine and verifies void return 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 policy forbids an explicit void return annotation, irrespective of whether this empty function performs a side effect. The authored source states the policy case independently of rule output.
+// @evidence contracts/testing.md#distinguishing-cases Positive: `function run(): void {}` must yield exactly one functional/no-return-void finding (assertFunctionalFinding). Negative control run through the same rule via assertNoFunctionalFinding: `function run(): number { return 1; }` must yield zero findings; a function declared to return number and returning a value is accepted. No option-configured variant is exercised here.
+// @evidence contracts/testing.md#execution-ownership TestFunctionalNoReturnVoidRejectsVoidAnnotation 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 TestFunctionalNoReturnVoidRejectsVoidAnnotation(t *testing.T) {
+  const ruleName = "functional/no-return-void"
+  findings := runFunctionalRule(t, ruleName, `function run(): void {}`)
+  assertFunctionalFinding(t, ruleName, findings, "return")
+  assertNoFunctionalFinding(t, ruleName, runFunctionalRule(t, ruleName, "function run(): number { return 1; }"))
+}

package/linthost/functional_no_this_expressions_rejects_this_test.go

@@ -0,0 +1,23 @@
+package linthost
+
+import "testing"
+
+// TestFunctionalNoThisExpressionsRejectsThis verifies functional/no-this-expressions rejects this.
+//
+// `this` binds behavior to ambient object state. The rule reports the keyword
+// directly so class and object-method cases share one AST path.
+//
+// 1. Parse a this expression.
+// 2. Enable only functional/no-this-expressions.
+// 3. Assert the expression reports and offers no autofix.
+//
+// @evidence contracts/testing.md#behavioral-verification runFunctionalRule executes the actual engine and verifies this.value 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 rejects ambient object receiver state, not explicit inputs. The authored source states the policy case independently of rule output.
+// @evidence contracts/testing.md#distinguishing-cases Positive: `this.value;` must yield exactly one functional/no-this-expressions finding (assertFunctionalFinding). Negative control run through the same rule via assertNoFunctionalFinding: `const result = value;` must yield zero findings; a plain identifier read is accepted. No option-configured variant is exercised here.
+// @evidence contracts/testing.md#execution-ownership TestFunctionalNoThisExpressionsRejectsThis 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 TestFunctionalNoThisExpressionsRejectsThis(t *testing.T) {
+  const ruleName = "functional/no-this-expressions"
+  findings := runFunctionalRule(t, ruleName, `this.value;`)
+  assertFunctionalFinding(t, ruleName, findings, "this")
+  assertNoFunctionalFinding(t, ruleName, runFunctionalRule(t, ruleName, "const result = value;"))
+}

package/linthost/functional_no_throw_statements_rejects_throw_test.go

@@ -0,0 +1,23 @@
+package linthost
+
+import "testing"
+
+// TestFunctionalNoThrowStatementsRejectsThrow verifies functional/no-throw-statements rejects throw.
+//
+// Throw statements are exceptional control flow. The policy reports the
+// statement itself and leaves result/error modeling to user code.
+//
+// 1. Parse a throw statement.
+// 2. Enable only functional/no-throw-statements.
+// 3. Assert the statement reports and offers no autofix.
+//
+// @evidence contracts/testing.md#behavioral-verification runFunctionalRule executes the actual engine and verifies throw 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 The policy excludes exceptional throw control flow, not an error value. The authored source states the policy case independently of rule output.
+// @evidence contracts/testing.md#distinguishing-cases Positive: `throw new Error("boom");` must yield exactly one functional/no-throw-statements finding (assertFunctionalFinding). Negative control run through the same rule via assertNoFunctionalFinding: `const result = { error: "boom" };` must yield zero findings; an object carrying an error value is accepted. No option-configured variant is exercised here.
+// @evidence contracts/testing.md#execution-ownership TestFunctionalNoThrowStatementsRejectsThrow 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 TestFunctionalNoThrowStatementsRejectsThrow(t *testing.T) {
+  const ruleName = "functional/no-throw-statements"
+  findings := runFunctionalRule(t, ruleName, `throw new Error("boom");`)
+  assertFunctionalFinding(t, ruleName, findings, "throw")
+  assertNoFunctionalFinding(t, ruleName, runFunctionalRule(t, ruleName, "const result = { error: \"boom\" };"))
+}

package/linthost/functional_no_try_statements_rejects_try_test.go

@@ -0,0 +1,23 @@
+package linthost
+
+import "testing"
+
+// TestFunctionalNoTryStatementsRejectsTry verifies functional/no-try-statements rejects try/catch.
+//
+// The rule treats try statements as exceptional control flow. This pins the
+// default catch-rejection branch; this input contains no finally block.
+//
+// 1. Parse a try/catch statement.
+// 2. Enable only functional/no-try-statements.
+// 3. Assert the statement reports and offers no autofix.
+//
+// @evidence contracts/testing.md#behavioral-verification runFunctionalRule executes the actual engine and verifies try/catch 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 The policy excludes exception-oriented control statements. The authored source states the policy case independently of rule output.
+// @evidence contracts/testing.md#distinguishing-cases Positive: `try { run(); } catch (error) { recover(error); }` must yield exactly one functional/no-try-statements finding (assertFunctionalFinding). Negative control run through the same rule via assertNoFunctionalFinding: `const result = run();` must yield zero findings; a plain call without try is accepted. No option-configured variant is exercised here.
+// @evidence contracts/testing.md#execution-ownership TestFunctionalNoTryStatementsRejectsTry 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 TestFunctionalNoTryStatementsRejectsTry(t *testing.T) {
+  const ruleName = "functional/no-try-statements"
+  findings := runFunctionalRule(t, ruleName, `try { run(); } catch (error) { recover(error); }`)
+  assertFunctionalFinding(t, ruleName, findings, "try")
+  assertNoFunctionalFinding(t, ruleName, runFunctionalRule(t, ruleName, "const result = run();"))
+}

package/linthost/functional_parameters_ignores_identifier_pattern_test.go

@@ -0,0 +1,27 @@
+package linthost
+
+import "testing"
+
+// TestFunctionalParametersIgnoresIdentifierPattern verifies functional/functional-parameters.
+//
+// Rest-parameter diagnostics are anchored to the parameter node. This pins the
+// shared identifier-pattern skip for the functional parameter option decoder.
+//
+// 1. Parse a rest parameter whose name matches the configured pattern.
+// 2. Enable only functional/functional-parameters with `ignoreIdentifierPattern`.
+// 3. Assert the parameter is skipped.
+//
+// @evidence contracts/testing.md#behavioral-verification runFunctionalRuleWithOptions executes the actual engine and verifies rest items parameter 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 ignoreIdentifierPattern applies to the reported parameter binding. The literal source and configured option express the supported policy independently of rule output.
+// @evidence contracts/testing.md#distinguishing-cases ParametersRejectsRestParameter owns the same source with default policy.
+// @evidence contracts/testing.md#execution-ownership TestFunctionalParametersIgnoresIdentifierPattern 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 TestFunctionalParametersIgnoresIdentifierPattern(t *testing.T) {
+  const ruleName = "functional/functional-parameters"
+  findings := runFunctionalRuleWithOptions(
+    t,
+    ruleName,
+    `function collect(...items: string[]) { return items; }`,
+    `{"ignoreIdentifierPattern":"^items$"}`,
+  )
+  assertNoFunctionalFinding(t, ruleName, findings)
+}

package/linthost/functional_parameters_rejects_rest_parameter_test.go

@@ -0,0 +1,25 @@
+package linthost
+
+import "testing"
+
+// TestFunctionalParametersRejectsRestParameter verifies functional/functional-parameters
+// rejects rest parameters by default.
+//
+// Rest parameters are often used as mutable argument bags. The native policy
+// keeps the first slice conservative by flagging the syntax directly without
+// needing type information.
+//
+// 1. Parse a function with a rest parameter.
+// 2. Enable only functional/functional-parameters.
+// 3. Assert the rest parameter reports and offers no autofix.
+//
+// @evidence contracts/testing.md#behavioral-verification runFunctionalRule executes the actual engine and verifies rest items parameter 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 Default functional-parameters policy excludes variadic rest syntax. The authored source states the policy case independently of rule output.
+// @evidence contracts/testing.md#distinguishing-cases Positive: `function collect(...items: string[]) { return items; }` must yield exactly one functional/functional-parameters finding (assertFunctionalFinding). Negative control run through the same rule via assertNoFunctionalFinding: `function collect(items: readonly string[]) { return items; }` must yield zero findings; the same function taking an ordinary readonly array parameter is accepted. No option-configured variant is exercised here.
+// @evidence contracts/testing.md#execution-ownership TestFunctionalParametersRejectsRestParameter 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 TestFunctionalParametersRejectsRestParameter(t *testing.T) {
+  const ruleName = "functional/functional-parameters"
+  findings := runFunctionalRule(t, ruleName, `function collect(...items: string[]) { return items; }`)
+  assertFunctionalFinding(t, ruleName, findings, "rest parameter")
+  assertNoFunctionalFinding(t, ruleName, runFunctionalRule(t, ruleName, "function collect(items: readonly string[]) { return items; }"))
+}