@kernlang/core 3.5.9-canary.220.1.c398cd95 → 4.0.0

package/dist/native-eligibility-ast.js

@@ -21,8 +21,67 @@
  *  instead of a generic "ineligible". */
 import ts from 'typescript';
 import { supportedCompoundAssignmentOperator } from './assignment-operators.js';
+import { classifyClosureBlock } from './closure-eligibility.js';
 import { emitTypeAnnotation } from './codegen/emitters.js';
+import { deterministicRows, loadEligibilityTaxonomy } from './eligibility-taxonomy.js';
+import { instanceofRhsRejectReasonForName } from './instanceof-rhs.js';
 import { parseExpression } from './parser-expression.js';
+let taxonomyIndexCache = null;
+function taxonomyIndex() {
+    if (taxonomyIndexCache !== null)
+        return taxonomyIndexCache;
+    const exact = new Set();
+    const prefixes = [];
+    for (const row of deterministicRows(loadEligibilityTaxonomy())) {
+        if (row.verdict !== 'ineligible' || row.reason === undefined)
+            continue;
+        if (row.construct.endsWith('-')) {
+            prefixes.push(row.reason);
+        }
+        else {
+            exact.add(row.reason);
+        }
+    }
+    taxonomyIndexCache = { exactReasonCodes: exact, reasonFamilyPrefixes: prefixes };
+    return taxonomyIndexCache;
+}
+/** Coherence-violation collector. `reject()` records (fail-safe, never throws)
+ *  any reason string with no deterministic taxonomy row — exact or family — so
+ *  the coherence-gate tests can assert the live classifier never emits an
+ *  un-taxonomied reason. Production never reads this; tests do, via the getter
+ *  and the reset below. A Set, not an array: violations are reason CODES, so
+ *  duplicates add nothing and growth is bounded by the (finite) code space
+ *  even if an un-taxonomied reason ships and fires on a hot path (agon
+ *  review, codex 0.96). */
+const coherenceViolationsInternal = new Set();
+/** A snapshot of the recorded coherence violations (reasons emitted with no
+ *  taxonomy row). Empty in a coherent build. */
+export function coherenceViolations() {
+    return [...coherenceViolationsInternal];
+}
+/** Test-only: clear the recorded coherence violations between runs. */
+export function resetCoherenceViolations() {
+    coherenceViolationsInternal.clear();
+}
+/** Fail-safe taxonomy AUTHORITY gate for an emitted ineligible reason.
+ *
+ *  Pure indirection: ALWAYS returns `reason` UNCHANGED, never throws, never
+ *  alters classifier behavior. Its ONLY side effect is recording a coherence
+ *  violation when `reason` has no deterministic taxonomy row (exact match or a
+ *  matching dynamic-family prefix). The classifier wraps every ineligible
+ *  reason in `reject(...)`; the recorded violations are surfaced only to the
+ *  coherence-gate tests. */
+function reject(reason) {
+    const index = taxonomyIndex();
+    if (index.exactReasonCodes.has(reason))
+        return reason;
+    for (const prefix of index.reasonFamilyPrefixes) {
+        if (reason.startsWith(prefix))
+            return reason;
+    }
+    coherenceViolationsInternal.add(reason);
+    return reason;
+}
 /** True when `exprText` parses cleanly under KERN's parser-expression.
  *
  *  Multi-line input is accepted: the parser itself is whitespace-insensitive,
@@ -174,9 +233,9 @@ export function isValidKernTypeAnnotation(typeText) {
  */
 function classifyParseFailureBoundary(bodyText) {
     if (/\{\{\s*[A-Za-z_$][\w$.-]*\s*\}\}/.test(bodyText))
-        return 'template-placeholder';
+        return reject('template-placeholder');
     if (isObjectFragmentBody(bodyText))
-        return 'foreign-by-design';
+        return reject('foreign-by-design');
     return null;
 }
 function isObjectFragmentBody(bodyText) {
@@ -512,21 +571,132 @@ function isSimpleTrailingStmt(node) {
     }
     return false;
 }
+/** Collect the raw text (braces included) of every block-bodied arrow
+ *  (`x => { … }`) inside a statement subtree. TS-AST walk, never string
+ *  scanning — `arrow.body.getText(sf)` yields the exact `{ … }` source. */
+function collectBlockArrowRaws(node, sf) {
+    const raws = [];
+    const visit = (n) => {
+        if (ts.isArrowFunction(n) && ts.isBlock(n.body)) {
+            raws.push(n.body.getText(sf));
+            // Don't descend into the block body: the v1 closure gate already rejects
+            // nested arrows, so a nested block arrow can't be independently eligible.
+            return;
+        }
+        ts.forEachChild(n, visit);
+    };
+    visit(node);
+    return raws;
+}
+/** Eligibility verdict for any block-bodied arrows in a statement (slices
+ *  0+1+2). Returns a reject reason or `null` if the statement's block arrows
+ *  are all gate-passing:
+ *   - any arrow whose `classifyClosureBlock` is non-null → that gate reason
+ *     (the statement is ineligible for the same reason the closure is).
+ *   - otherwise `null` (eligible — funnels through isValidKernExpression for
+ *     the statement's own expression validity, which now parses the arrow).
+ *
+ *  Slice 2 lifted the former `closure-in-loop` reject: a gate-passing block
+ *  arrow inside a loop is now eligible. The Python lowerer pins per-iteration
+ *  captures via default args (`def __kern_closure_N(p, x=x):`) so JS
+ *  by-reference / per-iteration capture semantics are preserved across both
+ *  targets. The classifier therefore no longer consults `ctx.loopDepth`. */
+function classifyBlockArrows(stmt, sf) {
+    const raws = collectBlockArrowRaws(stmt, sf);
+    if (raws.length === 0)
+        return null;
+    for (const raw of raws) {
+        const gateReason = classifyClosureBlock(raw);
+        if (gateReason !== null)
+            return reject(gateReason);
+    }
+    return null;
+}
+/** Scan a statement subtree for an `instanceof` whose RHS KERN cannot lower
+ *  (eligible ≡ lowerable, spec §3). Returns the first reject reason or `null`:
+ *   - RHS is a bare ident in the reject set →
+ *     `instanceof-rhs-wrapper-rejected` (String/Number/Boolean) or
+ *     `instanceof-rhs-unsupported-builtin` (Object/Function/Date/RegExp/
+ *     Promise/Map/Set/Symbol/BigInt).
+ *   - RHS is NOT an identifier (call/literal/binary/etc.) →
+ *     `instanceof-rhs-not-a-type-name`. A member-access RHS (`a.b.C`) is a
+ *     qualified type name and stays accepted (emits as-is, like a user class).
+ *  Accepted host idents (`Array`/`Error`/`TypeError`) and user-class /
+ *  member RHS pass (return `null`); they emit as-is or via the host map.
+ *
+ *  Detection is on the TS AST (`ts.isBinaryExpression` + `InstanceOfKeyword`),
+ *  mirroring the Python emitter's fail-closed reject so the gate and the
+ *  lowerer share one source of truth (`instanceof-rhs.ts`). The whole subtree
+ *  is scanned so a rejected `instanceof` nested in any expression position
+ *  (ternary arm, call arg, arrow body, …) is caught. */
+// TODO(taxonomy-fold): the `instanceof` RHS reject set in instanceof-rhs.ts
+// (INSTANCEOF_RHS_WRAPPER_REJECT / INSTANCEOF_RHS_BUILTIN_REJECT) is the target
+// declarative shape for a future deterministic-row extraction slice — fold those
+// RHS-name → reason mappings into the taxonomy so this dynamic reason source is
+// itself authority-backed, not just family-validated at runtime. Deferred (phase 2
+// scope is the AUTHORITY inversion; instanceof-rhs.ts fold-in is a separate slice).
+function classifyInstanceofRhs(node) {
+    let reason = null;
+    const visit = (n) => {
+        if (reason !== null)
+            return;
+        if (ts.isBinaryExpression(n) && n.operatorToken.kind === ts.SyntaxKind.InstanceOfKeyword) {
+            // Unwrap parens (`x instanceof (Error)`) before classification — the TS
+            // AST preserves them and a parenthesized bare ident is still a type
+            // name (agon review, 3-engine convergence). KERN's expression parser
+            // unwraps parens at parse time, so the emitter side never sees them.
+            let rhs = n.right;
+            while (ts.isParenthesizedExpression(rhs))
+                rhs = rhs.expression;
+            if (ts.isIdentifier(rhs)) {
+                const rhsReason = instanceofRhsRejectReasonForName(rhs.text);
+                reason = rhsReason === null ? null : reject(rhsReason);
+            }
+            else if (!ts.isPropertyAccessExpression(rhs)) {
+                // Member RHS (`a.b.C`) is a qualified type name → accepted (emit
+                // as-is). Anything else (call/literal/parenthesized/binary) is not a
+                // type name and cannot be lowered.
+                reason = reject('instanceof-rhs-not-a-type-name');
+            }
+            if (reason !== null)
+                return;
+        }
+        ts.forEachChild(n, visit);
+    };
+    visit(node);
+    return reason;
+}
 /** Classify a single statement. Returns null if the migrator can emit it,
  *  otherwise a kebab-case reason. Recurses through if/try branches. */
 function classifyStmt(stmt, sf, ctx) {
+    // Eligible ≡ lowerable (spec §3): a statement carrying an `instanceof` with a
+    // RHS the Python emitter fail-closes on is ineligible, with a reason that
+    // names the exact RHS problem. Run before the per-shape checks so the
+    // instanceof reason wins over a generic `*-bad-expr`.
+    const instanceofReason = classifyInstanceofRhs(stmt);
+    if (instanceofReason !== null)
+        return instanceofReason;
+    // Slices 0+1+2 — a statement containing a block-bodied arrow is eligible IFF
+    // every such arrow passes the v1 closure gate. Slice 2 lifted the former
+    // in-loop reject (the Python lowerer now pins per-iteration captures), so the
+    // loop context no longer matters here. The statement's own expression
+    // validity is still checked below via isValidKernExpression — the block arrow
+    // inside it parses now.
+    const closureReason = classifyBlockArrows(stmt, sf);
+    if (closureReason !== null)
+        return closureReason;
     if (ts.isVariableStatement(stmt)) {
         const flags = stmt.declarationList.flags;
         const isConst = (flags & ts.NodeFlags.Const) !== 0;
         const isLet = (flags & ts.NodeFlags.Let) !== 0;
         if (!isConst && !isLet)
-            return 'var-non-const';
+            return reject('var-non-const');
         const decls = stmt.declarationList.declarations;
         if (decls.length !== 1)
-            return 'var-multi-decl';
+            return reject('var-multi-decl');
         const decl = decls[0];
         if (decl.type && !isValidKernTypeAnnotation(decl.type.getText(sf)))
-            return 'var-bad-type';
+            return reject('var-bad-type');
         if (!decl.initializer) {
             // `let x;` migrates to `let name=x kind=let` (the body emitter handles
             // missing `value=` by emitting `let x = undefined;`, matching TS
@@ -534,7 +704,7 @@ function classifyStmt(stmt, sf, ctx) {
             // TS parse error in practice, but defensively reject them anyway since
             // the migrator can only emit identifier-named lets in this branch.
             if (!ts.isIdentifier(decl.name))
-                return 'var-destructure';
+                return reject('var-destructure');
             return null;
         }
         if (!ts.isIdentifier(decl.name))
@@ -552,13 +722,13 @@ function classifyStmt(stmt, sf, ctx) {
             const raw = decl.initializer.getText(sf);
             const body = raw.slice(1, -1);
             if (body.includes('\n'))
-                return 'var-template-multiline';
+                return reject('var-template-multiline');
             if (hasTsOnlyTemplateEscape(body))
-                return 'var-template-escapes';
+                return reject('var-template-escapes');
             return null;
         }
         if (!isValidKernExpression(decl.initializer.getText(sf)))
-            return 'var-bad-expr';
+            return reject('var-bad-expr');
         return null;
     }
     if (ts.isReturnStatement(stmt)) {
@@ -570,41 +740,43 @@ function classifyStmt(stmt, sf, ctx) {
             const raw = stmt.expression.getText(sf);
             const body = raw.slice(1, -1);
             if (body.includes('\n'))
-                return 'return-template-multiline';
+                return reject('return-template-multiline');
             if (hasTsOnlyTemplateEscape(body))
-                return 'return-template-escapes';
+                return reject('return-template-escapes');
             return null;
         }
         if (!isValidKernExpression(stmt.expression.getText(sf)))
-            return 'return-bad-expr';
+            return reject('return-bad-expr');
         return null;
     }
     if (ts.isThrowStatement(stmt)) {
+        // `throw;` is structurally unreachable (always a TS parse error) and has no
+        // taxonomy row — NOT routed through reject() (it would never validate).
         if (!stmt.expression)
             return 'throw-no-expr';
         if (!isValidKernExpression(stmt.expression.getText(sf)))
-            return 'throw-bad-expr';
+            return reject('throw-bad-expr');
         return null;
     }
     if (ts.isBreakStatement(stmt)) {
         if (stmt.label)
-            return 'break-labeled';
-        return ctx.loopDepth > 0 ? null : 'break-outside-loop';
+            return reject('break-labeled');
+        return ctx.loopDepth > 0 ? null : reject('break-outside-loop');
     }
     if (ts.isContinueStatement(stmt)) {
         if (stmt.label)
-            return 'continue-labeled';
-        return ctx.loopDepth > 0 ? null : 'continue-outside-loop';
+            return reject('continue-labeled');
+        return ctx.loopDepth > 0 ? null : reject('continue-outside-loop');
     }
     if (ts.isIfStatement(stmt)) {
         if (!isValidKernExpression(stmt.expression.getText(sf)))
-            return 'if-bad-cond';
+            return reject('if-bad-cond');
         // Body emitters (`emitNativeKernBodyTS` / `emitNativeKernBodyPython`) always
         // wrap `if` bodies in braces / indented blocks. A raw `if (cond) stmt;`
         // would migrate to `if cond=… → { stmt; }` and lose byte-equivalence under
         // `--verify`. Mirror the `for-of-non-block` / `while-non-block` guards.
         if (!ctx.allowNonBlock && !ts.isBlock(stmt.thenStatement))
-            return 'if-non-block-then';
+            return reject('if-non-block-then');
         const thenReason = classifyBranch(stmt.thenStatement, sf, ctx);
         if (thenReason !== null)
             return thenReason;
@@ -615,7 +787,7 @@ function classifyStmt(stmt, sf, ctx) {
             // 88c06dcc on dev). classifyBranch handles the nested IfStatement
             // by re-entering classifyStmt, so the recursion is automatic.
             if (!ctx.allowNonBlock && !ts.isIfStatement(stmt.elseStatement) && !ts.isBlock(stmt.elseStatement)) {
-                return 'if-non-block-else';
+                return reject('if-non-block-else');
             }
             const elseReason = classifyBranch(stmt.elseStatement, sf, ctx);
             if (elseReason !== null)
@@ -629,12 +801,14 @@ function classifyStmt(stmt, sf, ctx) {
         // (body-ts.ts:286-292 / codegen-body-python.ts:316-323), and the schema
         // permits `finally` as a `try` child. The only remaining requirement is
         // the TS-level shape — at least one of `catch`/`finally` must be present.
+        // `try {}` without catch|finally is structurally unreachable (always a TS
+        // parse error) and has no taxonomy row — NOT routed through reject().
         if (!stmt.catchClause && !stmt.finallyBlock)
             return 'try-no-catch';
         if (stmt.catchClause) {
             const cc = stmt.catchClause;
             if (cc.variableDeclaration && !ts.isIdentifier(cc.variableDeclaration.name))
-                return 'try-destruct-catch';
+                return reject('try-destruct-catch');
             const catchReason = classifyBranch(cc.block, sf, ctx);
             if (catchReason !== null)
                 return catchReason;
@@ -659,12 +833,12 @@ function classifyStmt(stmt, sf, ctx) {
             const op = stmt.expression.operatorToken.kind;
             if (op >= ts.SyntaxKind.FirstAssignment && op <= ts.SyntaxKind.LastAssignment) {
                 if (op !== ts.SyntaxKind.EqualsToken && !supportedCompoundAssignmentOperator(op)) {
-                    return 'expr-stmt-assignment';
+                    return reject('expr-stmt-assignment');
                 }
                 if (!isValidKernAssignmentTarget(stmt.expression.left.getText(sf)))
-                    return 'expr-stmt-bad-assign-target';
+                    return reject('expr-stmt-bad-assign-target');
                 if (!isValidKernAssignmentValue(stmt.expression.right.getText(sf)))
-                    return 'expr-stmt-bad-assign-value';
+                    return reject('expr-stmt-bad-assign-value');
                 return null;
             }
         }
@@ -680,7 +854,7 @@ function classifyStmt(stmt, sf, ctx) {
                 // raw-handler authors get a clear reason and the migrator never rewrites
                 // bytes it cannot reproduce.
                 if (!isValidKernAssignmentTarget(stmt.expression.operand.getText(sf))) {
-                    return 'expr-stmt-bad-assign-target';
+                    return reject('expr-stmt-bad-assign-target');
                 }
                 return null;
             }
@@ -688,32 +862,32 @@ function classifyStmt(stmt, sf, ctx) {
         if (ts.isPrefixUnaryExpression(stmt.expression)) {
             const op = stmt.expression.operator;
             if (op === ts.SyntaxKind.PlusPlusToken || op === ts.SyntaxKind.MinusMinusToken)
-                return 'expr-stmt-mutation';
+                return reject('expr-stmt-mutation');
         }
         if (!isValidKernExpression(stmt.expression.getText(sf)))
-            return 'expr-stmt-bad-expr';
+            return reject('expr-stmt-bad-expr');
         return null;
     }
     if (ts.isForOfStatement(stmt)) {
         if (!ts.isVariableDeclarationList(stmt.initializer))
-            return 'for-of-non-decl';
+            return reject('for-of-non-decl');
         if (!(stmt.initializer.flags & ts.NodeFlags.Const))
-            return 'for-of-non-const';
+            return reject('for-of-non-const');
         const decls = stmt.initializer.declarations;
         if (decls.length !== 1)
-            return 'for-of-multi-decl';
+            return reject('for-of-multi-decl');
         const decl = decls[0];
         if (decl.initializer)
-            return 'for-of-init';
+            return reject('for-of-init');
         if (!ts.isIdentifier(decl.name)) {
             const entryBinding = parseForOfEntryBinding(decl.name);
             if (entryBinding === null)
-                return 'for-of-destructure';
+                return reject('for-of-destructure');
             if (stmt.awaitModifier && canonicalObjectEntriesSource(stmt.expression, sf) !== null) {
-                return 'for-of-async-object-entries';
+                return reject('for-of-async-object-entries');
             }
             if (stmt.awaitModifier && entryBinding.kind !== 'pair')
-                return 'for-of-async-entry';
+                return reject('for-of-async-entry');
             // KERN-GAPS: sync pair iteration (`for (const [k, v] of expr)`) lifts to
             // `each pairKey=k pairValue=v in=expr` regardless of whether `expr` is
             // `Object.entries(...)` — Map.entries(), arrays-of-pairs, and generators
@@ -723,64 +897,68 @@ function classifyStmt(stmt, sf, ctx) {
             if (!stmt.awaitModifier &&
                 entryBinding.kind !== 'pair' &&
                 canonicalObjectEntriesSource(stmt.expression, sf) === null) {
-                return 'for-of-sync-pair';
+                return reject('for-of-sync-pair');
             }
             if (decl.type)
-                return 'for-of-destructure-type';
+                return reject('for-of-destructure-type');
         }
         else if (decl.type && !isValidKernTypeAnnotation(decl.type.getText(sf))) {
-            return 'for-of-bad-type';
+            return reject('for-of-bad-type');
         }
         if (!isValidKernExpression(stmt.expression.getText(sf)))
-            return 'for-of-bad-expr';
+            return reject('for-of-bad-expr');
         // Only block-shaped loops are currently migratable. `each` always emits
         // braces, so migrating `for (const x of xs) do(x);` would drift under
         // --verify even though it is semantically close.
         if (!ctx.allowNonBlock && !ts.isBlock(stmt.statement))
-            return 'for-of-non-block';
+            return reject('for-of-non-block');
         if (ts.isBlock(stmt.statement) && stmt.statement.statements.length === 0)
-            return 'for-of-empty-body';
+            return reject('for-of-empty-body');
         return classifyBranch(stmt.statement, sf, { ...ctx, loopDepth: ctx.loopDepth + 1 });
     }
     if (ts.isWhileStatement(stmt)) {
         if (!isValidKernExpression(stmt.expression.getText(sf)))
-            return 'while-bad-cond';
+            return reject('while-bad-cond');
         if (!ctx.allowNonBlock && !ts.isBlock(stmt.statement))
-            return 'while-non-block';
+            return reject('while-non-block');
         if (ts.isBlock(stmt.statement) && stmt.statement.statements.length === 0)
-            return 'while-empty-body';
+            return reject('while-empty-body');
         return classifyBranch(stmt.statement, sf, { ...ctx, loopDepth: ctx.loopDepth + 1 });
     }
     if (ts.isForStatement(stmt) || ts.isForInStatement(stmt))
-        return 'for-stmt';
+        return reject('for-stmt');
     if (ts.isDoStatement(stmt))
-        return 'do-while-stmt';
+        return reject('do-while-stmt');
     if (ts.isSwitchStatement(stmt))
-        return 'switch-stmt';
+        return reject('switch-stmt');
     if (ts.isBlock(stmt))
-        return 'bare-block';
+        return reject('bare-block');
     // Fallback — the TS SyntaxKind name surfaces in diagnostics so users have
     // a starting point when they hit something exotic (label, with, debugger).
-    return `unsupported-stmt-${ts.SyntaxKind[stmt.kind]}`;
+    // Validated against the `unsupported-stmt-` family prefix row.
+    return reject(`unsupported-stmt-${ts.SyntaxKind[stmt.kind]}`);
 }
 function classifyDestructureDecl(decl, sf) {
+    // `var-no-init` is structurally unreachable (an uninitialised destructure
+    // short-circuits to `var-destructure` before this branch is reached) and has
+    // no taxonomy row — NOT routed through reject().
     if (!decl.initializer)
         return 'var-no-init';
     if (!isValidKernExpression(decl.initializer.getText(sf)))
-        return 'var-destructure-bad-expr';
+        return reject('var-destructure-bad-expr');
     const name = decl.name;
     if (ts.isObjectBindingPattern(name)) {
         if (name.elements.length === 0)
-            return 'var-destructure-empty';
+            return reject('var-destructure-empty');
         for (const element of name.elements) {
             if (element.dotDotDotToken)
-                return 'var-destructure-rest';
+                return reject('var-destructure-rest');
             if (element.initializer)
-                return 'var-destructure-default';
+                return reject('var-destructure-default');
             if (!ts.isIdentifier(element.name))
-                return 'var-destructure-nested';
+                return reject('var-destructure-nested');
             if (element.propertyName && !ts.isIdentifier(element.propertyName))
-                return 'var-destructure-computed';
+                return reject('var-destructure-computed');
         }
         return null;
     }
@@ -791,17 +969,17 @@ function classifyDestructureDecl(decl, sf) {
                 continue;
             concreteElements++;
             if (element.dotDotDotToken)
-                return 'var-destructure-rest';
+                return reject('var-destructure-rest');
             if (element.initializer)
-                return 'var-destructure-default';
+                return reject('var-destructure-default');
             if (!ts.isIdentifier(element.name))
-                return 'var-destructure-nested';
+                return reject('var-destructure-nested');
         }
         if (concreteElements === 0)
-            return 'var-destructure-empty';
+            return reject('var-destructure-empty');
         return null;
     }
-    return 'var-destructure';
+    return reject('var-destructure');
 }
 function parseForOfEntryBinding(name) {
     if (!ts.isArrayBindingPattern(name))
@@ -855,18 +1033,19 @@ export function classifyHandlerBodyAst(rawBody, opts) {
     // public type — the migrator reads it the same way.
     const diags = sf.parseDiagnostics;
     if (diags && diags.length > 0) {
+        // `classifyParseFailureBoundary` already routes its reasons through reject().
         const parseBoundary = classifyParseFailureBoundary(rawBody);
         if (parseBoundary !== null)
             return { eligible: false, reason: parseBoundary };
         if (hasComments(rawBody) && !hasOnlyMigratableComments(rawBody)) {
-            return { eligible: false, reason: 'comments-present' };
+            return { eligible: false, reason: reject('comments-present') };
         }
-        return { eligible: false, reason: 'ts-parse-error' };
+        return { eligible: false, reason: reject('ts-parse-error') };
     }
     if (isHostInteropBody(sf))
-        return { eligible: false, reason: 'foreign-by-design' };
+        return { eligible: false, reason: reject('foreign-by-design') };
     if (hasComments(rawBody) && !hasOnlyMigratableComments(rawBody)) {
-        return { eligible: false, reason: 'comments-present' };
+        return { eligible: false, reason: reject('comments-present') };
     }
     for (const stmt of sf.statements) {
         const r = classifyStmt(stmt, sf, { loopDepth: 0, allowNonBlock: opts?.allowNonBlock });