@holmes-lab/holmes-kit 0.5.0 → 0.7.0

package/dist/holmes/cpg/foundation/cfg.js

@@ -12,6 +12,14 @@ exports.FUNCTION_TYPES = new Set([
     'function_definition', 'lambda',
     // @implements A-SPEC-519.1 — Go: methods and function literals (closures/goroutine bodies).
     'method_declaration', 'func_literal',
+    // @implements A-SPEC-520.1 — Java: constructors, lambdas and initializer blocks.
+    'constructor_declaration', 'lambda_expression', 'static_initializer',
+    'instance_initializer', 'compact_constructor_declaration',
+    // @implements A-SPEC-521.1 — C#: local functions, anonymous methods, operators, accessors.
+    'local_function_statement', 'anonymous_method_expression', 'destructor_declaration',
+    'operator_declaration', 'conversion_operator_declaration', 'accessor_declaration',
+    // @implements A-SPEC-522.1 — Rust: named functions and closures.
+    'function_item', 'closure_expression',
 ]);
 const TS_SIMPLE = new Set([
     'expression_statement', 'lexical_declaration', 'variable_declaration', 'debugger_statement',
@@ -69,8 +77,102 @@ const GO_RULES = {
     ]),
     block: 'block',
 };
+// @implements A-SPEC-520.1 — Java, classified from the census over gson+junit4 (8,376
+// functions, 20 statement types). Java rides the TS chassis: if/while/for/do/labeled/break/
+// continue/return/throw and the try-clause names are the SAME probed shapes. What is Java's own:
+// one switch node carrying two styles, a try body spelled `block`, try-with-resources, and
+// synchronized as a body wrapper.
+const JAVA_SIMPLE = new Set([
+    'expression_statement', 'local_variable_declaration', 'class_declaration',
+    'record_declaration', 'assert_statement', 'empty_statement',
+]);
+const JAVA_RULES = {
+    simple: JAVA_SIMPLE,
+    handled: new Set([
+        ...JAVA_SIMPLE,
+        'block', 'if_statement', 'while_statement', 'do_statement', 'for_statement',
+        'enhanced_for_statement', 'switch_expression', 'try_statement',
+        'try_with_resources_statement', 'synchronized_statement', 'labeled_statement',
+        'break_statement', 'continue_statement', 'return_statement', 'throw_statement',
+        'yield_statement',
+    ]),
+    block: 'block',
+};
+// @implements A-SPEC-521.1 — C#, classified from the census over newtonsoft+restsharp (13,642
+// functions, 27 statement types). Same face as Java, opposite semantics in three places: switch
+// fallthrough is ILLEGAL (sections isolate), `yield` is the iterator protocol (return passes
+// through, break exits), and the preprocessor puts ALTERNATIVES in statement position. `goto`
+// refuses (one corpus occurrence). Files where conditional compilation crosses syntax refuse at
+// L1 (51 of 1,149 — the honest limit, recorded).
+const CSHARP_SIMPLE = new Set([
+    'expression_statement', 'local_declaration_statement', 'local_function_statement',
+    'empty_statement', 'preproc_region', 'preproc_endregion', 'preproc_pragma',
+]);
+const CSHARP_RULES = {
+    simple: CSHARP_SIMPLE,
+    handled: new Set([
+        ...CSHARP_SIMPLE,
+        'block', 'if_statement', 'while_statement', 'do_statement', 'for_statement',
+        'foreach_statement', 'switch_statement', 'try_statement', 'using_statement',
+        'lock_statement', 'checked_statement', 'preproc_if',
+        'break_statement', 'continue_statement', 'return_statement', 'throw_statement',
+        'yield_statement',
+    ]),
+    block: 'block',
+};
+// @implements A-SPEC-522.1 — Rust, where control flow is an EXPRESSION. The simple set
+// enumerates the value expressions and declarations the corpus census actually put in statement
+// or trailing position (36 kinds over ripgrep+serde); anything new refuses, keeping fail-closed
+// meaningful. Control expressions are lowered as control wherever they stand as a statement or a
+// trailing value — flattening them would produce the zero-violation HOLLOW graph this slice's
+// corpus gate (branch edges > 0) exists to catch.
+const RUST_SIMPLE = new Set([
+    'let_declaration', 'call_expression', 'macro_invocation', 'identifier', 'self',
+    'scoped_identifier', 'field_expression', 'reference_expression', 'binary_expression',
+    'unary_expression', 'assignment_expression', 'compound_assignment_expr', 'struct_expression',
+    'tuple_expression', 'array_expression', 'index_expression', 'await_expression',
+    'type_cast_expression', 'range_expression', 'closure_expression', 'parenthesized_expression',
+    'integer_literal', 'float_literal', 'string_literal', 'raw_string_literal', 'char_literal',
+    'boolean_literal', 'unit_expression', 'try_expression', 'method_call_expression',
+    'use_declaration', 'struct_item', 'enum_item', 'impl_item', 'function_item', 'const_item',
+    'static_item', 'type_item', 'mod_item', 'trait_item', 'macro_definition', 'attribute_item',
+    'inner_attribute_item', 'empty_statement', 'foreign_mod_item', 'extern_crate_declaration',
+    // expression_statement lands here when its inner is NOT a control expression (the unwrap
+    // check runs first), so a plain `g();` is one point.
+    'expression_statement',
+]);
+const RUST_RULES = {
+    simple: RUST_SIMPLE,
+    handled: new Set([
+        ...RUST_SIMPLE,
+        'block', 'expression_statement', 'if_expression', 'match_expression', 'for_expression',
+        'while_expression', 'loop_expression', 'return_expression', 'break_expression',
+        'continue_expression',
+    ]),
+    block: 'block',
+};
+// @implements A-SPEC-523.1 — C++, classified from three corpora. Its first fact is the PARSER:
+// 25-34% of template/macro-heavy real files refuse at L1 (measured on nlohmann/fmt/leveldb) —
+// the matrix's ast basis discloses this. What parses rides the TS chassis (else_clause wrapper,
+// C fallthrough switch, same try-clause names). Labels and goto refuse (zero corpus occurrences).
+const CPP_SIMPLE = new Set([
+    'expression_statement', 'declaration', 'alias_declaration', 'static_assert_declaration',
+    'enum_specifier', 'using_declaration', 'type_definition', 'struct_specifier',
+    'preproc_call', 'preproc_def', 'preproc_function_def', 'preproc_include',
+]);
+const CPP_RULES = {
+    simple: CPP_SIMPLE,
+    handled: new Set([
+        ...CPP_SIMPLE,
+        'compound_statement', 'if_statement', 'while_statement', 'do_statement', 'for_statement',
+        'for_range_loop', 'switch_statement', 'try_statement', 'throw_statement',
+        'break_statement', 'continue_statement', 'return_statement', 'preproc_if', 'preproc_ifdef',
+    ]),
+    block: 'compound_statement',
+};
 const LANG_RULES = {
-    typescript: TS_RULES, tsx: TS_RULES, python: PY_RULES, go: GO_RULES,
+    typescript: TS_RULES, tsx: TS_RULES, python: PY_RULES, go: GO_RULES, java: JAVA_RULES,
+    csharp: CSHARP_RULES, rust: RUST_RULES, cpp: CPP_RULES,
 };
 // @implements A-SPEC-510.6
 /**
@@ -115,6 +217,7 @@ function cfgOf(ast, fn, source) {
     const rules = LANG_RULES[ast.lang];
     const isPython = ast.lang === 'python';
     const isGo = ast.lang === 'go';
+    const isRust = ast.lang === 'rust';
     const kids = childrenIndex(ast);
     // Points: one per lowered statement (block ids after coalescing). 0=ENTRY, 1=EXIT.
     const stmtsOf = [[], []];
@@ -155,7 +258,9 @@ function cfgOf(ast, fn, source) {
             }
             return { entry, exits };
         };
-        const stmtChildren = (i) => kids.of(i).filter((k) => ast.nodes[k].named && ast.nodes[k].type !== 'comment');
+        const stmtChildren = (i) => 
+        // `comment` (TS/PY/Go) and Java's line_comment/block_comment are all named nodes.
+        kids.of(i).filter((k) => ast.nodes[k].named && !ast.nodes[k].type.includes('comment'));
         const wireException = (first, targetProvider) => {
             // Conservative: every point created inside [first, now) can throw into the handler.
             const target = targetProvider();
@@ -168,14 +273,54 @@ function cfgOf(ast, fn, source) {
                 throw new Unsupported(t);
             const label = ctx.pendingLabel;
             ctx.pendingLabel = null;
+            // @implements A-SPEC-522.1 — Rust control lives in expressions. A statement whose sole
+            // named child is a control expression lowers as that control (flattening it makes the
+            // hollow graph); a `?` anywhere in a point's subtree adds the implicit early-return edge;
+            // a let-else is a branch whose false arm is the (compiler-enforced) diverging else block.
+            const RUST_CONTROL = new Set(['if_expression', 'match_expression', 'for_expression', 'while_expression', 'loop_expression', 'return_expression', 'break_expression', 'continue_expression']);
+            if (isRust && t === 'expression_statement') {
+                const inner = stmtChildren(i);
+                if (inner.length === 1 && RUST_CONTROL.has(ast.nodes[inner[0]].type))
+                    return lowerStmt(inner[0], ctx);
+            }
+            const rustQuestion = (p, root) => {
+                if (!isRust)
+                    return;
+                const stack = [root];
+                while (stack.length) {
+                    const n = stack.pop();
+                    if (n !== root && exports.FUNCTION_TYPES.has(ast.nodes[n].type))
+                        continue; // closures own their `?`
+                    if (ast.nodes[n].type === 'try_expression') {
+                        link(p, ctx.catchT.at(-1) ?? EXIT, 'throw');
+                        return;
+                    }
+                    for (const c of kids.of(n))
+                        stack.push(c);
+                }
+            };
+            if (isRust && t === 'let_declaration') {
+                const elseBlock = kids.of(i).some((k) => !ast.nodes[k].named && source !== undefined
+                    && source.slice(ast.nodes[k].start, ast.nodes[k].end) === 'else')
+                    ? kids.of(i).filter((k) => ast.nodes[k].type === 'block').at(-1) : undefined;
+                if (elseBlock !== undefined) {
+                    const p = newPoint(i);
+                    rustQuestion(p, i);
+                    const ef = lowerStmt(elseBlock, ctx);
+                    link(p, ef.entry, 'false');
+                    return { entry: p, exits: [{ from: p, kind: 'true' }, ...ef.exits] };
+                }
+            }
             if (rules.simple.has(t)) {
                 const p = newPoint(i);
+                rustQuestion(p, i);
                 return { entry: p, exits: [{ from: p, kind: 'seq' }] };
             }
             switch (t) {
                 case 'statement_block':
                 case 'block':
                 case 'statement_list':
+                case 'compound_statement':
                     // Go's block carries one extra statement_list layer (probed shape) — both are containers.
                     return lowerSeq(stmtChildren(i), ctx);
                 case 'labeled_statement': {
@@ -209,9 +354,29 @@ function cfgOf(ast, fn, source) {
                                 : stmtChildren(clause).find((k) => ast.nodes[k].type === 'block');
                         }
                     }
+                    else if (ast.lang === 'java' || ast.lang === 'csharp') {
+                        // @implements A-SPEC-520.1 / A-SPEC-521.1 — Java and C# have NO else_clause
+                        // wrapper: named[2] IS the
+                        // alternative (a block, or the next if_statement of an else-if chain). Unwrapping it
+                        // like TS lowered an else-if's CONDITION as a statement — the corpus caught it.
+                        alt = named[2];
+                    }
                     else {
                         alt = named[2] !== undefined ? stmtChildren(named[2])[0] : undefined;
                     }
+                    if (cons === undefined || !rules.handled.has(ast.nodes[cons].type)) {
+                        // `if (c()) ;` — an empty then-arm: both edges leave the header directly.
+                        const exits0 = [{ from: p, kind: 'true' }];
+                        if (alt !== undefined && rules.handled.has(ast.nodes[alt].type)) {
+                            const af0 = lowerStmt(alt, ctx);
+                            link(p, af0.entry, 'false');
+                            exits0.push(...af0.exits);
+                        }
+                        else {
+                            exits0.push({ from: p, kind: 'false' });
+                        }
+                        return { entry: p, exits: exits0 };
+                    }
                     const cf = lowerStmt(cons, ctx);
                     link(p, cf.entry, 'true');
                     const exits = [...cf.exits];
@@ -240,6 +405,17 @@ function cfgOf(ast, fn, source) {
                     const bodyIdx = (isPython || isGo)
                         ? kids.of(i).filter((k) => ast.nodes[k].type === 'block').at(0)
                         : stmtChildren(i).at(-1);
+                    // Found by the Java corpus, latent for TS too: `for (; ; ) ;` has NO named children —
+                    // empty clauses and an empty-statement body. The loop is a bare spin: header with a
+                    // self loop-back and only the (over-approximate) exhaustion exit.
+                    if (bodyIdx === undefined || !rules.handled.has(ast.nodes[bodyIdx].type)) {
+                        // Latent for TS, found by the Java corpus: an EMPTY body (`while (c()) ;`,
+                        // `for (; ; ) ;`) leaves no statement child, so `.at(-1)` lands on the condition
+                        // itself. The loop is a bare spin: header with a self loop-back.
+                        const header = newPoint(i);
+                        link(header, header, 'loop-back');
+                        return { entry: header, exits: [{ from: header, kind: 'false' }] };
+                    }
                     // @implements A-SPEC-519.1 — a bare Go `for {}` (no named non-block child) is INFINITE:
                     // no exhaustion edge. `for { select {…} }` is the daemon idiom, and a phantom false edge
                     // would hang spurious control dependence on everything after the loop. A for_clause with
@@ -273,6 +449,10 @@ function cfgOf(ast, fn, source) {
                 case 'do_statement': {
                     const header = newPoint(i); // condition point (the `do` node)
                     const bodyIdx = stmtChildren(i)[0];
+                    if (bodyIdx === undefined || !rules.handled.has(ast.nodes[bodyIdx].type)) {
+                        link(header, header, 'loop-back');
+                        return { entry: header, exits: [{ from: header, kind: 'false' }] };
+                    }
                     const myBreak = { label, target: -1 };
                     ctx.breakT.push({ label, owner: myBreak }, { label: null, owner: myBreak });
                     ctx.contT.push({ label, target: header }, { label: null, target: header });
@@ -368,6 +548,238 @@ function cfgOf(ast, fn, source) {
                         exits.push({ from: b.point, kind: 'break' });
                     return { entry: p, exits };
                 }
+                // @implements A-SPEC-520.1 — Java's enhanced for: the header owns the binding; body
+                // loops back; exhaustion exits false — same skeleton as Go's range.
+                case 'enhanced_for_statement':
+                case 'foreach_statement':
+                case 'for_range_loop': {
+                    const header = newPoint(i);
+                    const bodyIdx = kids.of(i).find((k) => ast.nodes[k].type === rules.block)
+                        ?? stmtChildren(i).at(-1);
+                    const myBreak = { label, target: -1 };
+                    ctx.breakT.push({ label, owner: myBreak }, { label: null, owner: myBreak });
+                    ctx.contT.push({ label, target: header }, { label: null, target: header });
+                    const bf = lowerStmt(bodyIdx, ctx);
+                    ctx.breakT.splice(-2);
+                    ctx.contT.splice(-2);
+                    link(header, bf.entry, 'true');
+                    for (const e of bf.exits)
+                        link(e.from, header, 'loop-back');
+                    const exits = [{ from: header, kind: 'false' }];
+                    for (const b of claimBreaks(myBreak))
+                        exits.push({ from: b.point, kind: 'break' });
+                    return { entry: header, exits };
+                }
+                // @implements A-SPEC-520.1 — synchronized: a body wrapper for control flow (the lock is
+                // a use the DDG reads off the header point); lock semantics are declared out of scope.
+                case 'synchronized_statement':
+                case 'lock_statement':
+                case 'checked_statement': {
+                    const p = newPoint(i);
+                    const body = kids.of(i).find((k) => ast.nodes[k].type === 'block');
+                    if (body === undefined)
+                        throw new Unsupported(t + ' without a block');
+                    const bf = lowerStmt(body, ctx);
+                    link(p, bf.entry, 'seq');
+                    return { entry: p, exits: bf.exits };
+                }
+                // @implements A-SPEC-521.1 — the preprocessor puts ALTERNATIVES in statement position.
+                // Sequencing the arms would fabricate flow no build configuration ever runs; each arm is
+                // a branch and both rejoin after #endif (a may-analysis over every configuration).
+                case 'preproc_if':
+                case 'preproc_ifdef': {
+                    const p = newPoint(i);
+                    const named = stmtChildren(i);
+                    const elseArm = named.find((k) => ['preproc_else', 'preproc_elif'].includes(ast.nodes[k].type));
+                    const ifStmts = named.filter((k) => rules.handled.has(ast.nodes[k].type));
+                    const exits = [];
+                    const f1 = lowerSeq(ifStmts, ctx);
+                    link(p, f1.entry, 'true');
+                    exits.push(...f1.exits);
+                    if (elseArm !== undefined) {
+                        if (ast.nodes[elseArm].type === 'preproc_elif')
+                            throw new Unsupported('preproc_elif');
+                        const elseStmts = stmtChildren(elseArm).filter((k) => rules.handled.has(ast.nodes[k].type));
+                        const f2 = lowerSeq(elseStmts, ctx);
+                        link(p, f2.entry, 'false');
+                        exits.push(...f2.exits);
+                    }
+                    else {
+                        exits.push({ from: p, kind: 'false' });
+                    }
+                    return { entry: p, exits };
+                }
+                // @implements A-SPEC-521.1 — using: a wrapper whose header owns the resource defs
+                // (variable_declarator does the DDG work); the implicit Dispose is covered by the
+                // enclosing try wiring, same posture as Java's try-with-resources.
+                case 'using_statement': {
+                    const p = newPoint(i);
+                    const body = kids.of(i).find((k) => ast.nodes[k].type === 'block')
+                        ?? stmtChildren(i).filter((k) => rules.handled.has(ast.nodes[k].type)).at(-1);
+                    if (body === undefined)
+                        return { entry: p, exits: [{ from: p, kind: 'seq' }] };
+                    const bf = lowerStmt(body, ctx);
+                    link(p, bf.entry, 'seq');
+                    return { entry: p, exits: bf.exits };
+                }
+                // @implements A-SPEC-520.1 — ONE node, TWO styles. Old-style groups fall through into
+                // each other (TS switch semantics); arrow rules never touch (Go case semantics). A
+                // `yield` leaves the switch like a break-with-value. Statement position only — an
+                // expression-position switch stays inside its statement's point, like a ternary.
+                case 'switch_expression': {
+                    const p = newPoint(i);
+                    const myBreak = { label, target: -1 };
+                    ctx.breakT.push({ label, owner: myBreak }, { label: null, owner: myBreak });
+                    ctx.yieldT.push(myBreak);
+                    const swBlock = kids.of(i).find((k) => ast.nodes[k].type === 'switch_block');
+                    const members = swBlock === undefined ? [] : kids.of(swBlock).filter((k) => ['switch_block_statement_group', 'switch_rule'].includes(ast.nodes[k].type));
+                    let sawDefault = false;
+                    let prevFall = [];
+                    const exits = [];
+                    for (const m of members) {
+                        const labelNode = kids.of(m).find((k) => ast.nodes[k].type === 'switch_label');
+                        if (labelNode !== undefined && source !== undefined
+                            && source.slice(ast.nodes[labelNode].start, ast.nodes[labelNode].end).trim().startsWith('default'))
+                            sawDefault = true;
+                        const stmts = stmtChildren(m).filter((k) => ast.nodes[k].type !== 'switch_label');
+                        const cf = lowerSeq(stmts, ctx);
+                        link(p, cf.entry, 'case');
+                        if (ast.nodes[m].type === 'switch_block_statement_group') {
+                            for (const e of prevFall)
+                                link(e.from, cf.entry, 'seq'); // implicit fallthrough
+                            prevFall = cf.exits;
+                        }
+                        else {
+                            exits.push(...cf.exits); // arrow rule: isolated
+                        }
+                    }
+                    exits.push(...prevFall);
+                    if (!sawDefault)
+                        exits.push({ from: p, kind: 'default' });
+                    ctx.breakT.splice(-2);
+                    ctx.yieldT.pop();
+                    for (const b of claimBreaks(myBreak))
+                        exits.push({ from: b.point, kind: 'break' });
+                    return { entry: p, exits };
+                }
+                case 'yield_statement': {
+                    const p = newPoint(i);
+                    // @implements A-SPEC-521.1 — the SAME node name, two protocols. Java: a value-carrying
+                    // switch escape. C#: the iterator protocol — `yield return v` (has a named child)
+                    // CONTINUES executing; `yield break` (bare) leaves the function.
+                    if (ast.lang === 'csharp') {
+                        if (stmtChildren(i).length > 0)
+                            return { entry: p, exits: [{ from: p, kind: 'seq' }] };
+                        link(p, EXIT, 'return');
+                        return { entry: p, exits: [] };
+                    }
+                    const owner = ctx.yieldT.at(-1);
+                    if (owner === undefined)
+                        throw new Unsupported('yield outside switch');
+                    pendingBreaks.push({ point: p, owner });
+                    return { entry: p, exits: [] };
+                }
+                // @implements A-SPEC-522.1 — Rust's if EXPRESSION: [cond, block, else_clause?[block|if]].
+                case 'if_expression': {
+                    const p = newPoint(i);
+                    rustQuestion(p, i === undefined ? i : kids.of(i)[0] ?? i);
+                    const consR = kids.of(i).find((k) => ast.nodes[k].type === 'block');
+                    const elseClause = kids.of(i).find((k) => ast.nodes[k].type === 'else_clause');
+                    const altR = elseClause === undefined ? undefined
+                        : kids.of(elseClause).find((k) => ['block', 'if_expression'].includes(ast.nodes[k].type));
+                    const cf = lowerStmt(consR, ctx);
+                    link(p, cf.entry, 'true');
+                    const exits = [...cf.exits];
+                    if (altR !== undefined) {
+                        const af = lowerStmt(altR, ctx);
+                        link(p, af.entry, 'false');
+                        exits.push(...af.exits);
+                    }
+                    else {
+                        exits.push({ from: p, kind: 'false' });
+                    }
+                    return { entry: p, exits };
+                }
+                // @implements A-SPEC-522.1 — match: arms isolated, EXHAUSTIVE (rustc enforces it, so a
+                // "no arm matched" escape would be flow no execution takes — the opposite of Python's
+                // match, deliberately). Arm values may be blocks or bare expressions.
+                case 'match_expression': {
+                    const p = newPoint(i);
+                    const mb = kids.of(i).find((k) => ast.nodes[k].type === 'match_block');
+                    const exits = [];
+                    for (const arm of mb === undefined ? [] : kids.of(mb)) {
+                        if (ast.nodes[arm].type !== 'match_arm')
+                            continue;
+                        const val = kids.of(arm).filter((k) => ast.nodes[k].named && ast.nodes[k].type !== 'match_pattern').at(-1);
+                        if (val === undefined)
+                            continue;
+                        const vf = rules.handled.has(ast.nodes[val].type)
+                            ? lowerStmt(val, ctx)
+                            : (() => { const vp = newPoint(val); rustQuestion(vp, val); return { entry: vp, exits: [{ from: vp, kind: 'seq' }] }; })();
+                        link(p, vf.entry, 'case');
+                        exits.push(...vf.exits);
+                    }
+                    return { entry: p, exits };
+                }
+                // @implements A-SPEC-522.1 — for/while/loop expressions ride the loop skeleton; a bare
+                // `loop` is INFINITE (no exhaustion edge — Go's bare-for call, same reasoning).
+                case 'for_expression':
+                case 'while_expression':
+                case 'loop_expression': {
+                    const header = newPoint(i);
+                    rustQuestion(header, i);
+                    const bodyR = kids.of(i).find((k) => ast.nodes[k].type === 'block');
+                    const myBreak = { label, target: -1 };
+                    const loopLabel = (() => {
+                        const ln = kids.of(i).find((k) => ast.nodes[k].type === 'label');
+                        return ln !== undefined && source !== undefined
+                            ? source.slice(ast.nodes[ln].start, ast.nodes[ln].end) : label;
+                    })();
+                    const owner = { label: loopLabel, target: -1 };
+                    ctx.breakT.push({ label: loopLabel, owner }, { label: null, owner });
+                    ctx.contT.push({ label: loopLabel, target: header }, { label: null, target: header });
+                    const bf = lowerStmt(bodyR, ctx);
+                    ctx.breakT.splice(-2);
+                    ctx.contT.splice(-2);
+                    link(header, bf.entry, 'true');
+                    for (const e of bf.exits)
+                        link(e.from, header, 'loop-back');
+                    const exits = [];
+                    if (t !== 'loop_expression')
+                        exits.push({ from: header, kind: 'false' });
+                    for (const b of claimBreaks(owner))
+                        exits.push({ from: b.point, kind: 'break' });
+                    void myBreak;
+                    return { entry: header, exits };
+                }
+                case 'return_expression': {
+                    const p = newPoint(i);
+                    rustQuestion(p, i);
+                    link(p, EXIT, 'return');
+                    return { entry: p, exits: [] };
+                }
+                case 'break_expression': {
+                    const p = newPoint(i);
+                    const ln = kids.of(i).find((k) => ast.nodes[k].type === 'label');
+                    const lbl = ln !== undefined && source !== undefined
+                        ? source.slice(ast.nodes[ln].start, ast.nodes[ln].end) : null;
+                    const bentry = nearestBreak(ctx.breakT, lbl);
+                    if (!bentry)
+                        throw new Unsupported('break outside breakable');
+                    pendingBreaks.push({ point: p, owner: bentry.owner });
+                    return { entry: p, exits: [] };
+                }
+                case 'continue_expression': {
+                    const p = newPoint(i);
+                    const ln = kids.of(i).find((k) => ast.nodes[k].type === 'label');
+                    const lbl = ln !== undefined && source !== undefined
+                        ? source.slice(ast.nodes[ln].start, ast.nodes[ln].end) : null;
+                    const centry = nearestCont(ctx.contT, lbl);
+                    if (!centry || centry.target < 0)
+                        throw new Unsupported('continue outside loop');
+                    link(p, centry.target, 'continue');
+                    return { entry: p, exits: [] };
+                }
                 // @implements A-SPEC-519.1 — select: each communication case is a branch off the header;
                 // WITHOUT a default the statement BLOCKS until some case fires, so there is no "no arm
                 // matched" escape (the opposite of Python's match).
@@ -420,6 +832,67 @@ function cfgOf(ast, fn, source) {
                     return { entry: p, exits: [] };
                 }
                 case 'switch_statement': {
+                    // @implements A-SPEC-521.1 — C# shares the node NAME with TS and inverts the
+                    // semantics: implicit fallthrough is a compile error, so sections are ISOLATED.
+                    // (The suite caught the first attempt — a duplicate case label silently shadowed the
+                    // TS lowering and broke its fallthrough pin.)
+                    if (ast.lang === 'csharp') {
+                        const p = newPoint(i);
+                        const myBreak = { label, target: -1 };
+                        ctx.breakT.push({ label, owner: myBreak }, { label: null, owner: myBreak });
+                        const swBody = kids.of(i).find((k) => ast.nodes[k].type === 'switch_body');
+                        let sawDefault = false;
+                        const exits = [];
+                        for (const sec of swBody === undefined ? [] : kids.of(swBody)) {
+                            if (ast.nodes[sec].type !== 'switch_section')
+                                continue;
+                            const children = stmtChildren(sec);
+                            const stmts = children.filter((k) => rules.handled.has(ast.nodes[k].type));
+                            const hasPattern = children.some((k) => ast.nodes[k].type.includes('pattern'));
+                            if (!hasPattern)
+                                sawDefault = true; // a default section carries no pattern
+                            const cf = lowerSeq(stmts, ctx);
+                            link(p, cf.entry, hasPattern ? 'case' : 'default');
+                            exits.push(...cf.exits); // isolated: nothing flows to a sibling
+                        }
+                        if (!sawDefault)
+                            exits.push({ from: p, kind: 'default' });
+                        ctx.breakT.splice(-2);
+                        for (const b of claimBreaks(myBreak))
+                            exits.push({ from: b.point, kind: 'break' });
+                        return { entry: p, exits };
+                    }
+                    // @implements A-SPEC-523.1 — C++: flat case_statement children inside a
+                    // compound_statement, with C's implicit fallthrough (a value-less case is default).
+                    if (ast.lang === 'cpp') {
+                        const p = newPoint(i);
+                        const myBreak = { label, target: -1 };
+                        ctx.breakT.push({ label, owner: myBreak }, { label: null, owner: myBreak });
+                        const swBody = kids.of(i).find((k) => ast.nodes[k].type === 'compound_statement');
+                        let sawDefault = false;
+                        let prevFall = [];
+                        const exits = [];
+                        for (const c of swBody === undefined ? [] : kids.of(swBody)) {
+                            if (ast.nodes[c].type !== 'case_statement')
+                                continue;
+                            const children = stmtChildren(c);
+                            const stmts = children.filter((k) => rules.handled.has(ast.nodes[k].type));
+                            if (stmts.length === children.length)
+                                sawDefault = true; // no label value → default
+                            const cf = lowerSeq(stmts, ctx);
+                            link(p, cf.entry, stmts.length === children.length ? 'default' : 'case');
+                            for (const e of prevFall)
+                                link(e.from, cf.entry, 'seq'); // C fallthrough
+                            prevFall = cf.exits;
+                        }
+                        exits.push(...prevFall);
+                        if (!sawDefault)
+                            exits.push({ from: p, kind: 'default' });
+                        ctx.breakT.splice(-2);
+                        for (const b of claimBreaks(myBreak))
+                            exits.push({ from: b.point, kind: 'break' });
+                        return { entry: p, exits };
+                    }
                     const p = newPoint(i);
                     const body = stmtChildren(i).at(-1); // switch_body
                     const myBreak = { label, target: -1 };
@@ -478,13 +951,17 @@ function cfgOf(ast, fn, source) {
                     link(p, ctx.catchT.at(-1) ?? EXIT, 'throw');
                     return { entry: p, exits: [] };
                 }
+                // @implements A-SPEC-520.1 — try-with-resources joins the try case: same clause wiring,
+                // plus a point for the resource_specification so its defs (`var r = open()`) have a home.
+                case 'try_with_resources_statement':
                 case 'try_statement': {
                     const named = stmtChildren(i);
                     // @implements A-SPEC-510.7 — Python spells the same shape with `block` / `except_clause`
                     // / `finally_clause`, PLUS an `else_clause` that runs ONLY when no exception was raised.
+                    // @implements A-SPEC-520.1 — Java spells the try body `block`; TS `statement_block`.
                     const body = isPython
                         ? kids.of(i).find((k) => ast.nodes[k].type === 'block')
-                        : named.find((k) => ast.nodes[k].type === 'statement_block');
+                        : named.find((k) => ['statement_block', 'block', 'compound_statement'].includes(ast.nodes[k].type));
                     const handler = isPython
                         ? kids.of(i).find((k) => ast.nodes[k].type === 'except_clause')
                         : named.find((k) => ast.nodes[k].type === 'catch_clause');
@@ -538,6 +1015,12 @@ function cfgOf(ast, fn, source) {
                     else {
                         exits.push(...after);
                     }
+                    const resSpec = kids.of(i).find((k) => ast.nodes[k].type === 'resource_specification');
+                    if (resSpec !== undefined) {
+                        const rp = newPoint(resSpec);
+                        link(rp, bf.entry, 'seq');
+                        return { entry: rp, exits };
+                    }
                     return { entry: bf.entry, exits };
                 }
                 default:
@@ -569,7 +1052,7 @@ function cfgOf(ast, fn, source) {
             }
             return undefined;
         };
-        const ctx = { breakT: [], contT: [], catchT: [], pendingLabel: null };
+        const ctx = { breakT: [], contT: [], catchT: [], yieldT: [], pendingLabel: null };
         const bodyNode = ast.nodes[fn.bodyIndex];
         const flow = bodyNode.type === rules.block
             ? lowerSeq(stmtChildren(fn.bodyIndex), ctx)