@ttsc/lint 0.30.4 → 0.31.0

package/linthost/no_fallthrough_rejects_infinite_loop_broken_by_own_label_test.go

@@ -0,0 +1,32 @@
+package linthost
+
+import "testing"
+
+// TestNoFallthroughRejectsInfiniteLoopBrokenByOwnLabel verifies `loop: while (true) { break loop; }` exits the loop.
+//
+// The labeled break targets the infinite loop itself, so the loop exit is
+// reachable and the case falls through — identical to an unlabeled break, but
+// exercised through the labeled-statement wrapper. Locks the cooperation
+// between labeledCompletion and loopCompletion for self-targeted breaks.
+//
+// 1. End a case with a labeled infinite loop broken by its own label.
+// 2. Run the engine with no-fallthrough enabled.
+// 3. Assert exactly one finding at the next case label.
+//
+// @evidence contracts/testing.md#behavioral-verification Exactly one no-fallthrough error reports on target line seven after a self-labeled infinite-loop break.
+// @evidence contracts/testing.md#independent-expectations The label belongs to the inner loop, making its normal exit reachable inside the case.
+// @evidence contracts/testing.md#distinguishing-cases AcceptsInfiniteLoopWithLabeledBreakToOuter targets an enclosing loop beyond the switch.
+// @evidence contracts/testing.md#execution-ownership TestNoFallthroughRejectsInfiniteLoopBrokenByOwnLabel is selected in the shared Go unit population and invokes assertNoFallthroughReportsAtLines and the owning AST Engine. Every original source/options/expected line/message and in-source counterpart remains owned by this declaration; no CLI child, installed consumer, native artifact build or real product host runs.
+func TestNoFallthroughRejectsInfiniteLoopBrokenByOwnLabel(t *testing.T) {
+  assertNoFallthroughReportsAtLines(t, `declare const foo: number;
+switch (foo) {
+  case 0:
+    loop: while (true) {
+      break loop;
+    }
+  case 1:
+    console.log(1);
+    break;
+}
+`, "", 7)
+}

package/linthost/no_fallthrough_rejects_infinite_while_containing_break_test.go

@@ -0,0 +1,32 @@
+package linthost
+
+import "testing"
+
+// TestNoFallthroughRejectsInfiniteWhileContainingBreak verifies a break inside `while (true)` reopens the loop exit.
+//
+// Negative twin of the infinite-while acceptance, one property away (a break
+// added): the break targets the loop, so control can resume after it and fall
+// into the next case. Locks the break-absorption rule that distinguishes
+// loop-targeted breaks from switch-targeted breaks.
+//
+// 1. End a case with `while (true) { break; }`.
+// 2. Run the engine with no-fallthrough enabled.
+// 3. Assert exactly one finding at the next case label.
+//
+// @evidence contracts/testing.md#behavioral-verification Exactly one no-fallthrough error reports on target line seven after a reachable inner-loop break.
+// @evidence contracts/testing.md#independent-expectations Literal true alone does not guarantee non-completion when the body has a reachable break consumed by that loop.
+// @evidence contracts/testing.md#distinguishing-cases AcceptsInfiniteWhileWithoutBreak and IgnoresUnreachableBreakInInfiniteLoop retain both clean boundaries.
+// @evidence contracts/testing.md#execution-ownership TestNoFallthroughRejectsInfiniteWhileContainingBreak is selected in the shared Go unit population and invokes assertNoFallthroughReportsAtLines and the owning AST Engine. Every original source/options/expected line/message and in-source counterpart remains owned by this declaration; no CLI child, installed consumer, native artifact build or real product host runs.
+func TestNoFallthroughRejectsInfiniteWhileContainingBreak(t *testing.T) {
+  assertNoFallthroughReportsAtLines(t, `declare const foo: number;
+switch (foo) {
+  case 0:
+    while (true) {
+      break;
+    }
+  case 1:
+    console.log(1);
+    break;
+}
+`, "", 7)
+}

package/linthost/no_fallthrough_rejects_labeled_block_broken_by_own_label_test.go

@@ -0,0 +1,33 @@
+package linthost
+
+import "testing"
+
+// TestNoFallthroughRejectsLabeledBlockBrokenByOwnLabel verifies `label: { break label; }` completes normally.
+//
+// A break targeting the labeled block resumes right after that block, still
+// inside the case, so the transition falls through. Negative twin of the
+// labeled-break-to-outer-loop acceptance: the same syntax, but the label sits
+// inside the case instead of outside the switch. Locks the label-absorption
+// rule of labeledCompletion.
+//
+// 1. End a case with a labeled block that breaks out of itself.
+// 2. Run the engine with no-fallthrough enabled.
+// 3. Assert exactly one finding at the next case label.
+//
+// @evidence contracts/testing.md#behavioral-verification Exactly one no-fallthrough error reports on target line seven after a self-targeted block break.
+// @evidence contracts/testing.md#independent-expectations The authored label lies inside the case; leaving its block resumes before the next label rather than leaving the switch.
+// @evidence contracts/testing.md#distinguishing-cases AcceptsLabeledBreakToOuterLoop targets beyond the switch and remains clean.
+// @evidence contracts/testing.md#execution-ownership TestNoFallthroughRejectsLabeledBlockBrokenByOwnLabel is selected in the shared Go unit population and invokes assertNoFallthroughReportsAtLines and the owning AST Engine. Every original source/options/expected line/message and in-source counterpart remains owned by this declaration; no CLI child, installed consumer, native artifact build or real product host runs.
+func TestNoFallthroughRejectsLabeledBlockBrokenByOwnLabel(t *testing.T) {
+  assertNoFallthroughReportsAtLines(t, `declare const foo: number;
+switch (foo) {
+  case 0:
+    block: {
+      break block;
+    }
+  case 1:
+    console.log(1);
+    break;
+}
+`, "", 7)
+}

package/linthost/no_fallthrough_rejects_lint_directive_comment_as_marker_test.go

@@ -0,0 +1,31 @@
+package linthost
+
+import "testing"
+
+// TestNoFallthroughRejectsLintDirectiveCommentAsMarker verifies the host's own lint-* directive family never counts as a marker.
+//
+// This host also recognizes `lint-enable` / `lint-disable*` comments as
+// directives (directives.go), so they get the same exclusion as the eslint-*
+// family: a directive naming no-fallthrough must not read as an intentional
+// fallthrough. Locks the lint-* extension of noFallthroughDirectivePattern.
+//
+// 1. Put `// lint-enable no-fallthrough` in the trailing comment position.
+// 2. Run the engine with no-fallthrough enabled.
+// 3. Assert exactly one finding at the next case label.
+//
+// @evidence contracts/testing.md#behavioral-verification Exactly one no-fallthrough error reports on target line six despite lint-enable wording.
+// @evidence contracts/testing.md#independent-expectations The host-specific lint directive family configures filtering rather than intentional fallthrough, even when naming this rule.
+// @evidence contracts/testing.md#distinguishing-cases RejectsDirectiveCommentAsMarker retains the ESLint directive counterpart; suppression tests own actual disable behavior.
+// @evidence contracts/testing.md#execution-ownership TestNoFallthroughRejectsLintDirectiveCommentAsMarker is selected in the shared Go unit population and invokes assertNoFallthroughReportsAtLines and the owning AST Engine. Every original source/options/expected line/message and in-source counterpart remains owned by this declaration; no CLI child, installed consumer, native artifact build or real product host runs.
+func TestNoFallthroughRejectsLintDirectiveCommentAsMarker(t *testing.T) {
+  assertNoFallthroughReportsAtLines(t, `declare const foo: number;
+switch (foo) {
+  case 0:
+    console.log(0);
+    // lint-enable no-fallthrough
+  case 1:
+    console.log(1);
+    break;
+}
+`, "", 6)
+}

package/linthost/no_fallthrough_rejects_marker_before_last_statement_test.go

@@ -0,0 +1,32 @@
+package linthost
+
+import "testing"
+
+// TestNoFallthroughRejectsMarkerBeforeLastStatement verifies a marker above the case's last statement does not suppress.
+//
+// The eligible trailing range starts after the case's final token; a
+// `// falls through` that precedes another statement documents nothing about
+// the transition. Locks against whole-case-text scanning (an explicitly
+// forbidden shortcut in issue #411).
+//
+// 1. Place the marker between two statements of the falling-through case.
+// 2. Run the engine with no-fallthrough enabled.
+// 3. Assert exactly one finding at the next case label.
+//
+// @evidence contracts/testing.md#behavioral-verification Exactly one no-fallthrough error reports on target line seven when a marker precedes later logging.
+// @evidence contracts/testing.md#independent-expectations A marker above a remaining consequent statement is outside the independently eligible transition trivia gap.
+// @evidence contracts/testing.md#distinguishing-cases MarkedFallthroughVariants places the same policy markers after the last statement and stays clean.
+// @evidence contracts/testing.md#execution-ownership TestNoFallthroughRejectsMarkerBeforeLastStatement is selected in the shared Go unit population and invokes assertNoFallthroughReportsAtLines and the owning AST Engine. Every original source/options/expected line/message and in-source counterpart remains owned by this declaration; no CLI child, installed consumer, native artifact build or real product host runs.
+func TestNoFallthroughRejectsMarkerBeforeLastStatement(t *testing.T) {
+  assertNoFallthroughReportsAtLines(t, `declare const foo: number;
+switch (foo) {
+  case 0:
+    console.log(0);
+    // falls through
+    console.log("still runs");
+  case 1:
+    console.log(1);
+    break;
+}
+`, "", 7)
+}

package/linthost/no_fallthrough_rejects_marker_in_block_that_is_not_sole_statement_test.go

@@ -0,0 +1,31 @@
+package linthost
+
+import "testing"
+
+// TestNoFallthroughRejectsMarkerInBlockThatIsNotSoleStatement verifies the in-block marker position requires the block to be the only statement.
+//
+// ESLint applies the block-interior check only when the case body is exactly
+// one block statement. A marker inside a block that follows another statement
+// is not in an eligible position and must not suppress. Negative twin of the
+// sole-block acceptance, one property away (an extra preceding statement).
+//
+// 1. Put `console.log(0);` then a block containing only the marker comment.
+// 2. Run the engine with no-fallthrough enabled.
+// 3. Assert exactly one finding at the next case label.
+//
+// @evidence contracts/testing.md#behavioral-verification Exactly one no-fallthrough error reports on target line six when a preceding statement makes the marked block non-sole.
+// @evidence contracts/testing.md#independent-expectations The block-interior exemption requires the whole case body to be that block; the authored extra statement defeats that ownership.
+// @evidence contracts/testing.md#distinguishing-cases AcceptsMarkerInSoleEmptyBlock preserves identical block-contained wording without the extra statement.
+// @evidence contracts/testing.md#execution-ownership TestNoFallthroughRejectsMarkerInBlockThatIsNotSoleStatement is selected in the shared Go unit population and invokes assertNoFallthroughReportsAtLines and the owning AST Engine. Every original source/options/expected line/message and in-source counterpart remains owned by this declaration; no CLI child, installed consumer, native artifact build or real product host runs.
+func TestNoFallthroughRejectsMarkerInBlockThatIsNotSoleStatement(t *testing.T) {
+  assertNoFallthroughReportsAtLines(t, `declare const foo: number;
+switch (foo) {
+  case 0:
+    console.log(0);
+    { /* falls through */ }
+  case 1:
+    console.log(1);
+    break;
+}
+`, "", 6)
+}

package/linthost/no_fallthrough_rejects_marker_inside_nested_inner_block_test.go

@@ -0,0 +1,31 @@
+package linthost
+
+import "testing"
+
+// TestNoFallthroughRejectsMarkerInsideNestedInnerBlock verifies the in-block marker must sit directly before the outer block's closing brace.
+//
+// ESLint reads the comments between the block's last token and its own
+// closing brace. A marker buried one block deeper belongs to the inner brace
+// and must not suppress (upstream regression:
+// `case 0: { { /* falls through */ } } default:`).
+//
+// 1. Nest the marker inside an inner block within the sole outer block.
+// 2. Run the engine with no-fallthrough enabled.
+// 3. Assert exactly one finding at the next case label.
+//
+// @evidence contracts/testing.md#behavioral-verification Exactly one no-fallthrough error reports on target line six for an inner-block marker.
+// @evidence contracts/testing.md#independent-expectations The authored marker belongs to a nested closing brace, not to the sole outer block's final trivia position.
+// @evidence contracts/testing.md#distinguishing-cases AcceptsMarkerInsideSoleBlockStatement retains the directly eligible block marker.
+// @evidence contracts/testing.md#execution-ownership TestNoFallthroughRejectsMarkerInsideNestedInnerBlock is selected in the shared Go unit population and invokes assertNoFallthroughReportsAtLines and the owning AST Engine. Every original source/options/expected line/message and in-source counterpart remains owned by this declaration; no CLI child, installed consumer, native artifact build or real product host runs.
+func TestNoFallthroughRejectsMarkerInsideNestedInnerBlock(t *testing.T) {
+  assertNoFallthroughReportsAtLines(t, `declare const foo: number;
+switch (foo) {
+  case 0: {
+    { /* falls through */ }
+  }
+  case 1:
+    console.log(1);
+    break;
+}
+`, "", 6)
+}

package/linthost/no_fallthrough_rejects_nested_switch_exited_by_inner_break_test.go

@@ -0,0 +1,34 @@
+package linthost
+
+import "testing"
+
+// TestNoFallthroughRejectsNestedSwitchExitedByInnerBreak verifies an inner break targets the inner switch, not the outer one.
+//
+// `switch (bar) { default: break; }` completes normally — the break merely
+// exits the inner switch — so the outer case still falls through. If the
+// inner break leaked outward it would wrongly terminate the outer case and
+// hide the report. Locks the unlabeled-break absorption of switchCompletion.
+//
+// 1. End an outer case with a nested switch whose default clause breaks.
+// 2. Run the engine with no-fallthrough enabled.
+// 3. Assert exactly one finding at the outer next-case label.
+//
+// @evidence contracts/testing.md#behavioral-verification Exactly one no-fallthrough error reports on outer target line nine after the nested switch break.
+// @evidence contracts/testing.md#independent-expectations The authored break is consumed by the inner switch and resumes inside the outer case.
+// @evidence contracts/testing.md#distinguishing-cases AcceptsNestedSwitchTerminatingOnEveryPath retains return/throw paths escaping both switch bodies.
+// @evidence contracts/testing.md#execution-ownership TestNoFallthroughRejectsNestedSwitchExitedByInnerBreak is selected in the shared Go unit population and invokes assertNoFallthroughReportsAtLines and the owning AST Engine. Every original source/options/expected line/message and in-source counterpart remains owned by this declaration; no CLI child, installed consumer, native artifact build or real product host runs.
+func TestNoFallthroughRejectsNestedSwitchExitedByInnerBreak(t *testing.T) {
+  assertNoFallthroughReportsAtLines(t, `declare const foo: number;
+declare const bar: number;
+switch (foo) {
+  case 0:
+    switch (bar) {
+      default:
+        break;
+    }
+  case 1:
+    console.log(1);
+    break;
+}
+`, "", 9)
+}

package/linthost/no_fallthrough_rejects_nested_switch_without_default_test.go

@@ -0,0 +1,36 @@
+package linthost
+
+import "testing"
+
+// TestNoFallthroughRejectsNestedSwitchWithoutDefault verifies a default-less nested switch cannot terminate the outer case.
+//
+// Without a default clause the discriminant may match nothing, in which case
+// the inner switch completes normally and the outer case falls through —
+// even though its only clause returns. Negative twin of the exhaustive
+// nested switch, one property away (the default clause removed).
+//
+// 1. End an outer case with a nested switch whose single case returns.
+// 2. Run the engine with no-fallthrough enabled.
+// 3. Assert exactly one finding at the outer next-case label.
+//
+// @evidence contracts/testing.md#behavioral-verification Exactly one no-fallthrough error reports on outer target line ten for the default-less inner switch.
+// @evidence contracts/testing.md#independent-expectations An independently possible unmatched discriminant skips the inner returning arm and reaches the outer case end.
+// @evidence contracts/testing.md#distinguishing-cases AcceptsNestedSwitchTerminatingOnEveryPath retains an exhaustive default-bearing inner switch.
+// @evidence contracts/testing.md#execution-ownership TestNoFallthroughRejectsNestedSwitchWithoutDefault is selected in the shared Go unit population and invokes assertNoFallthroughReportsAtLines and the owning AST Engine. Every original source/options/expected line/message and in-source counterpart remains owned by this declaration; no CLI child, installed consumer, native artifact build or real product host runs.
+func TestNoFallthroughRejectsNestedSwitchWithoutDefault(t *testing.T) {
+  assertNoFallthroughReportsAtLines(t, `declare const foo: number;
+declare const bar: number;
+function f(): void {
+  switch (foo) {
+    case 0:
+      switch (bar) {
+        case 1:
+          return;
+      }
+    case 1:
+      console.log(1);
+  }
+}
+JSON.stringify(f);
+`, "", 10)
+}

package/linthost/no_fallthrough_rejects_non_literal_constant_condition_test.go

@@ -0,0 +1,33 @@
+package linthost
+
+import "testing"
+
+// TestNoFallthroughRejectsNonLiteralConstantCondition verifies `while (!0)` is not constant-folded.
+//
+// ESLint's getBooleanValueIfSimpleConstant folds bare Literal nodes only —
+// `!0` is a unary expression, so the loop is treated as exitable and the case
+// falls through. The `while (1)` acceptance uses a bare truthy literal, while
+// this input uses a truthy unary expression. Locks the supported folding
+// boundary rather than proving the loop can terminate at runtime.
+//
+// 1. End a case with `while (!0) { console.log(0); }`.
+// 2. Run the engine with no-fallthrough enabled.
+// 3. Assert exactly one finding at the next case label.
+//
+// @evidence contracts/testing.md#behavioral-verification Exactly one no-fallthrough error reports on target line seven for while !0.
+// @evidence contracts/testing.md#independent-expectations Supported literal-only folding deliberately treats a unary expression as unknown even if JavaScript can evaluate it statically; this is a compatibility limit, not runtime reachability proof.
+// @evidence contracts/testing.md#distinguishing-cases AcceptsWhileNumericOneLiteral retains a bare truthy literal and stays clean.
+// @evidence contracts/testing.md#execution-ownership TestNoFallthroughRejectsNonLiteralConstantCondition is selected in the shared Go unit population and invokes assertNoFallthroughReportsAtLines and the owning AST Engine. Every original source/options/expected line/message and in-source counterpart remains owned by this declaration; no CLI child, installed consumer, native artifact build or real product host runs.
+func TestNoFallthroughRejectsNonLiteralConstantCondition(t *testing.T) {
+  assertNoFallthroughReportsAtLines(t, `declare const foo: number;
+switch (foo) {
+  case 0:
+    while (!0) {
+      console.log(0);
+    }
+  case 1:
+    console.log(1);
+    break;
+}
+`, "", 7)
+}

package/linthost/no_fallthrough_rejects_normally_completing_catch_test.go

@@ -0,0 +1,34 @@
+package linthost
+
+import "testing"
+
+// TestNoFallthroughRejectsNormallyCompletingCatch verifies a catch that swallows the exception keeps the case falling through.
+//
+// Upstream invalid case `try { throw 0; } catch (err) {}`: the catch block
+// completes normally, so control reaches the case end even though the try
+// block always throws. Negative twin of the breaking-catch acceptance, one
+// property away (the break removed from catch).
+//
+// 1. End a case with a throwing try and a normally-completing catch.
+// 2. Run the engine with no-fallthrough enabled.
+// 3. Assert exactly one finding at the next case label.
+//
+// @evidence contracts/testing.md#behavioral-verification Exactly one no-fallthrough error reports on target line nine after a swallowed throw.
+// @evidence contracts/testing.md#independent-expectations The authored explicit throw reaches a catch whose logging completes normally; abrupt try completion alone cannot close this join.
+// @evidence contracts/testing.md#distinguishing-cases AcceptsBreakingCatchAfterThrowingTry retains the same reached catch with a terminating break.
+// @evidence contracts/testing.md#execution-ownership TestNoFallthroughRejectsNormallyCompletingCatch is selected in the shared Go unit population and invokes assertNoFallthroughReportsAtLines and the owning AST Engine. Every original source/options/expected line/message and in-source counterpart remains owned by this declaration; no CLI child, installed consumer, native artifact build or real product host runs.
+func TestNoFallthroughRejectsNormallyCompletingCatch(t *testing.T) {
+  assertNoFallthroughReportsAtLines(t, `declare const foo: number;
+switch (foo) {
+  case 0:
+    try {
+      throw new Error("boom");
+    } catch {
+      console.log("swallowed");
+    }
+  case 1:
+    console.log(1);
+    break;
+}
+`, "", 9)
+}

package/linthost/no_fallthrough_rejects_open_try_with_normal_finally_test.go

@@ -0,0 +1,34 @@
+package linthost
+
+import "testing"
+
+// TestNoFallthroughRejectsOpenTryWithNormalFinally verifies a try/finally where both blocks complete normally still falls through.
+//
+// Negative twin of the terminating-finally acceptance, one property away (the
+// break removed from finally): nothing exits, so the case end stays reachable.
+// Locks against treating every try statement as terminating (a forbidden
+// shortcut in issue #411).
+//
+// 1. End a case with a try/finally that only logs.
+// 2. Run the engine with no-fallthrough enabled.
+// 3. Assert exactly one finding at the next case label.
+//
+// @evidence contracts/testing.md#behavioral-verification Exactly one no-fallthrough error reports on target line nine after try and finally both log.
+// @evidence contracts/testing.md#independent-expectations Both independently authored blocks complete normally; presence of try/finally alone does not imply termination.
+// @evidence contracts/testing.md#distinguishing-cases AcceptsTerminatingFinally adds the unconditional finalizer break and stays clean.
+// @evidence contracts/testing.md#execution-ownership TestNoFallthroughRejectsOpenTryWithNormalFinally is selected in the shared Go unit population and invokes assertNoFallthroughReportsAtLines and the owning AST Engine. Every original source/options/expected line/message and in-source counterpart remains owned by this declaration; no CLI child, installed consumer, native artifact build or real product host runs.
+func TestNoFallthroughRejectsOpenTryWithNormalFinally(t *testing.T) {
+  assertNoFallthroughReportsAtLines(t, `declare const foo: number;
+switch (foo) {
+  case 0:
+    try {
+      console.log(0);
+    } finally {
+      console.log("cleanup");
+    }
+  case 1:
+    console.log(1);
+    break;
+}
+`, "", 9)
+}

package/linthost/no_fallthrough_rejects_return_inside_arrow_test.go

@@ -0,0 +1,32 @@
+package linthost
+
+import "testing"
+
+// TestNoFallthroughRejectsReturnInsideArrow verifies a nested arrow's return does not terminate the case.
+//
+// Same function-boundary rule as the function-expression twin, but through an
+// arrow with a block body passed to the authored run call. The case
+// retains a normal path after that call; the callback return does not exit it.
+//
+// 1. End a case by passing an arrow whose body returns to run.
+// 2. Run the engine with no-fallthrough enabled.
+// 3. Assert exactly one finding at the next case label.
+//
+// @evidence contracts/testing.md#behavioral-verification Exactly one no-fallthrough error reports on target line eight after passing an arrow callback.
+// @evidence contracts/testing.md#independent-expectations The authored return belongs to the nested arrow, so defining/passing that callback does not terminate the enclosing case.
+// @evidence contracts/testing.md#distinguishing-cases Function-expression and function-declaration rejection twins retain the two other nested execution boundaries.
+// @evidence contracts/testing.md#execution-ownership TestNoFallthroughRejectsReturnInsideArrow is selected in the shared Go unit population and invokes assertNoFallthroughReportsAtLines and the owning AST Engine. Every original source/options/expected line/message and in-source counterpart remains owned by this declaration; no CLI child, installed consumer, native artifact build or real product host runs.
+func TestNoFallthroughRejectsReturnInsideArrow(t *testing.T) {
+  assertNoFallthroughReportsAtLines(t, `declare const foo: number;
+declare function run(callback: () => void): void;
+switch (foo) {
+  case 0:
+    run(() => {
+      return;
+    });
+  case 1:
+    console.log(1);
+    break;
+}
+`, "", 8)
+}

package/linthost/no_fallthrough_rejects_return_inside_function_declaration_test.go

@@ -0,0 +1,33 @@
+package linthost
+
+import "testing"
+
+// TestNoFallthroughRejectsReturnInsideFunctionDeclaration verifies a nested function declaration's return does not terminate the case.
+//
+// A function declaration IS a statement in the case body, so this pins the
+// statement-level boundary: the declaration completes normally without its
+// body being analyzed. Complements the expression-level twins (function
+// expression, arrow).
+//
+// 1. End a case with a function declaration whose body returns, plus a call.
+// 2. Run the engine with no-fallthrough enabled.
+// 3. Assert exactly one finding at the next case label.
+//
+// @evidence contracts/testing.md#behavioral-verification Exactly one no-fallthrough error reports on target line eight after a nested function declaration and call.
+// @evidence contracts/testing.md#independent-expectations The declaration's return belongs to the nested function and the following invocation completes back into the enclosing case.
+// @evidence contracts/testing.md#distinguishing-cases Arrow and function-expression rejection twins preserve expression-level function boundaries.
+// @evidence contracts/testing.md#execution-ownership TestNoFallthroughRejectsReturnInsideFunctionDeclaration is selected in the shared Go unit population and invokes assertNoFallthroughReportsAtLines and the owning AST Engine. Every original source/options/expected line/message and in-source counterpart remains owned by this declaration; no CLI child, installed consumer, native artifact build or real product host runs.
+func TestNoFallthroughRejectsReturnInsideFunctionDeclaration(t *testing.T) {
+  assertNoFallthroughReportsAtLines(t, `declare const foo: number;
+switch (foo) {
+  case 0:
+    function helper(): void {
+      return;
+    }
+    helper();
+  case 1:
+    console.log(1);
+    break;
+}
+`, "", 8)
+}

package/linthost/no_fallthrough_rejects_return_inside_function_expression_test.go

@@ -0,0 +1,33 @@
+package linthost
+
+import "testing"
+
+// TestNoFallthroughRejectsReturnInsideFunctionExpression verifies a nested function expression's return does not terminate the case.
+//
+// The `return` belongs to the callback, not to the case: after defining and
+// calling it, control still reaches the case end. Locks the function-boundary
+// rule: expression evaluation is inspected for abrupt edges, but nested
+// function bodies stay invisible.
+//
+// 1. End a case with a function expression containing `return` plus a call.
+// 2. Run the engine with no-fallthrough enabled.
+// 3. Assert exactly one finding at the next case label.
+//
+// @evidence contracts/testing.md#behavioral-verification Exactly one no-fallthrough error reports on target line eight after a function-expression callback.
+// @evidence contracts/testing.md#independent-expectations The authored return exits the callback instead of the switch case, making its next label reachable under the supported policy.
+// @evidence contracts/testing.md#distinguishing-cases Arrow and declaration rejection twins retain both neighboring function forms.
+// @evidence contracts/testing.md#execution-ownership TestNoFallthroughRejectsReturnInsideFunctionExpression is selected in the shared Go unit population and invokes assertNoFallthroughReportsAtLines and the owning AST Engine. Every original source/options/expected line/message and in-source counterpart remains owned by this declaration; no CLI child, installed consumer, native artifact build or real product host runs.
+func TestNoFallthroughRejectsReturnInsideFunctionExpression(t *testing.T) {
+  assertNoFallthroughReportsAtLines(t, `declare const foo: number;
+switch (foo) {
+  case 0:
+    const f = function (): void {
+      return;
+    };
+    f();
+  case 1:
+    console.log(1);
+    break;
+}
+`, "", 8)
+}

package/linthost/no_fallthrough_rejects_unrelated_comment_in_sole_empty_block_test.go

@@ -0,0 +1,29 @@
+package linthost
+
+import "testing"
+
+// TestNoFallthroughRejectsUnrelatedCommentInSoleEmptyBlock verifies a non-marker comment in an empty sole block does not suppress.
+//
+// Upstream invalid case `case 0: { /* comment */ } default: b();`: the empty
+// block completes normally so the case falls through, and the in-block
+// comment does not match the marker pattern. Negative twin of the
+// empty-block marker acceptance, one property away (the comment text).
+//
+// 1. Make the case body a sole empty block containing an unrelated comment.
+// 2. Run the engine with no-fallthrough enabled.
+// 3. Assert exactly one finding at the next case label.
+//
+// @evidence contracts/testing.md#behavioral-verification Exactly one no-fallthrough error reports on target line four for an unrelated sole-block comment.
+// @evidence contracts/testing.md#independent-expectations An eligible comment position alone is insufficient; the independently authored wording does not match the default marker.
+// @evidence contracts/testing.md#distinguishing-cases AcceptsMarkerInSoleEmptyBlock changes only comment text and stays clean.
+// @evidence contracts/testing.md#execution-ownership TestNoFallthroughRejectsUnrelatedCommentInSoleEmptyBlock is selected in the shared Go unit population and invokes assertNoFallthroughReportsAtLines and the owning AST Engine. Every original source/options/expected line/message and in-source counterpart remains owned by this declaration; no CLI child, installed consumer, native artifact build or real product host runs.
+func TestNoFallthroughRejectsUnrelatedCommentInSoleEmptyBlock(t *testing.T) {
+  assertNoFallthroughReportsAtLines(t, `declare const foo: number;
+switch (foo) {
+  case 0: { /* comment */ }
+  case 1:
+    console.log(1);
+    break;
+}
+`, "", 4)
+}

package/linthost/no_fallthrough_rejects_unrelated_trailing_comment_test.go

@@ -0,0 +1,30 @@
+package linthost
+
+import "testing"
+
+// TestNoFallthroughRejectsUnrelatedTrailingComment verifies no-fallthrough still reports when the trailing comment is not a marker.
+//
+// Negative twin of the marked-fallthrough acceptance: a comment sits in the
+// eligible trailing position but does not match the marker pattern, so the
+// transition must report. Locks against "any comment suppresses" over-matching.
+//
+// 1. Build a fallthrough whose trailing comment reads `// keep going`.
+// 2. Run the engine with no-fallthrough enabled.
+// 3. Assert exactly one finding at the next case label.
+//
+// @evidence contracts/testing.md#behavioral-verification Exactly one no-fallthrough error reports on target line six for keep-going wording.
+// @evidence contracts/testing.md#independent-expectations The authored trailing comment occupies the eligible position but fails the marker pattern, distinguishing content from comment presence.
+// @evidence contracts/testing.md#distinguishing-cases AcceptsMarkedFallthroughVariants owns the accepted spelling/case variants.
+// @evidence contracts/testing.md#execution-ownership TestNoFallthroughRejectsUnrelatedTrailingComment is selected in the shared Go unit population and invokes assertNoFallthroughReportsAtLines and the owning AST Engine. Every original source/options/expected line/message and in-source counterpart remains owned by this declaration; no CLI child, installed consumer, native artifact build or real product host runs.
+func TestNoFallthroughRejectsUnrelatedTrailingComment(t *testing.T) {
+  assertNoFallthroughReportsAtLines(t, `declare const foo: number;
+switch (foo) {
+  case 0:
+    console.log(0);
+    // keep going
+  case 1:
+    console.log(1);
+    break;
+}
+`, "", 6)
+}

package/linthost/no_fallthrough_reports_case_message_after_leading_default_test.go

@@ -0,0 +1,37 @@
+package linthost
+
+import "testing"
+
+// TestNoFallthroughReportsCaseMessageAfterLeadingDefault verifies a leading default clause can fall through into a case.
+//
+// Clause order is positional, not semantic: a `default:` that is not last
+// participates in transitions like any case, and the reported clause (a
+// case) picks the 'case' message. Locks both nonterminal default handling and
+// message selection from the target clause.
+//
+// 1. Open the switch with a populated default clause followed by a case.
+// 2. Run the engine with no-fallthrough enabled.
+// 3. Assert one finding at the case with the 'case' message.
+//
+// @evidence contracts/testing.md#behavioral-verification One no-fallthrough error at original line five carries exactly the case-target message.
+// @evidence contracts/testing.md#independent-expectations The authored leading default can fall into a later case; the reported target kind independently selects case rather than predecessor default wording.
+// @evidence contracts/testing.md#distinguishing-cases ReportsDefaultMessageForDefaultClause reverses the target kind and verifies default wording.
+// @evidence contracts/testing.md#execution-ownership TestNoFallthroughReportsCaseMessageAfterLeadingDefault is selected in the shared Go unit population and invokes lintNoFallthrough through the owning AST Engine. Every original source/options/expected line/message and in-source counterpart remains owned by this declaration; no CLI child, installed consumer, native artifact build or real product host runs.
+func TestNoFallthroughReportsCaseMessageAfterLeadingDefault(t *testing.T) {
+  file, findings := lintNoFallthrough(t, `declare const foo: number;
+switch (foo) {
+  default:
+    console.log(0);
+  case 1:
+    console.log(1);
+    break;
+}
+`, "")
+  actual := normalizeRuleFindings(file, findings)
+  if len(actual) != 1 || actual[0].Rule != "no-fallthrough" || actual[0].Severity != SeverityError || actual[0].Line != 5 {
+    t.Fatalf("expected one finding at line 5, got %+v", actual)
+  }
+  if findings[0].Message != "Expected a 'break' statement before 'case'." {
+    t.Fatalf("unexpected message: %q", findings[0].Message)
+  }
+}