gitnexus 1.6.8-rc.37 → 1.6.8-rc.38

package/dist/core/ingestion/cfg/control-flow-context.d.ts

@@ -62,6 +62,15 @@ export declare class ControlFlowContext {
     resolveBreak(label?: string): JumpResolution | undefined;
     /** Resolve a `continue`: like {@link resolveBreak} but only loop frames match. */
     resolveContinue(label?: string): JumpResolution | undefined;
+    /**
+     * Resolve a Java `yield e` (switch-EXPRESSION arm exit): the nearest enclosing
+     * SWITCH frame's exit, threading the finalizers stacked above it. Unlike a
+     * `break`, a `yield` ALWAYS targets the switch — never an intervening loop — so
+     * it cannot match a loop frame (a `yield` inside a loop inside a switch arm
+     * still exits the whole switch). Returns `undefined` when there is no enclosing
+     * switch (malformed input); the caller falls back to its conservative routing.
+     */
+    resolveYield(): JumpResolution | undefined;
     /** Every active finalizer, innermost first — what a `return` must cross. */
     finalizersForReturn(): readonly FinalizerFrame[];
     /**

package/dist/core/ingestion/cfg/control-flow-context.js

@@ -39,6 +39,17 @@ export class ControlFlowContext {
     resolveContinue(label) {
         return this.resolve((f) => f.kind === 'loop' && (label === undefined || f.labels.includes(label)), (f) => f.continueTo);
     }
+    /**
+     * Resolve a Java `yield e` (switch-EXPRESSION arm exit): the nearest enclosing
+     * SWITCH frame's exit, threading the finalizers stacked above it. Unlike a
+     * `break`, a `yield` ALWAYS targets the switch — never an intervening loop — so
+     * it cannot match a loop frame (a `yield` inside a loop inside a switch arm
+     * still exits the whole switch). Returns `undefined` when there is no enclosing
+     * switch (malformed input); the caller falls back to its conservative routing.
+     */
+    resolveYield() {
+        return this.resolve((f) => f.kind === 'switch');
+    }
     /** Every active finalizer, innermost first — what a `return` must cross. */
     finalizersForReturn() {
         const fins = [];

package/dist/core/ingestion/cfg/visitors/csharp-harvest.d.ts

@@ -61,6 +61,14 @@ export declare class CsharpHarvester extends ScopeTreeHarvester {
     facts(node: SyntaxNode): StatementFacts;
     /** Facts for an expression whose WHOLE evaluation is conditional (case tests). */
     factsConditional(node: SyntaxNode): StatementFacts;
+    /**
+     * Def-ONLY facts for a value-position binding carrier (`var x = k switch {…}`,
+     * #2207): just the declared name(s)' def, attached to the continuation block the
+     * switch arms rejoin. The discriminant + arm-value USES are already harvested
+     * onto the branch's own blocks ({@link facts} on each arm), so this must NOT
+     * re-walk the initializer — only each `variable_declarator`'s name is a def here.
+     */
+    bindingDefFacts(stmt: SyntaxNode): StatementFacts | undefined;
     /** Facts for a `foreach (decl in right)` head: decl binds, right is used. */
     forEachHeadFacts(stmt: SyntaxNode): StatementFacts;
     /** ENTRY-block facts for the function's parameters (defs only). */
@@ -101,7 +109,13 @@ export declare class CsharpHarvester extends ScopeTreeHarvester {
      * identifier; `skipFinalRead` suppresses it when that access is the callee.
      */
     private walkChain;
-    /** The initializer value of a `variable_declarator` — the named child after `name`. */
+    /**
+     * The initializer value of a `variable_declarator` — the named child after
+     * `name`. NOTE: deliberately duplicated in `csharp.ts` (the visitor is a
+     * standalone class with no shared base — repo convention). The two copies must
+     * stay in sync; there is no C#-specific shared module to host it, and the only
+     * module both files share is the generic `utils/ast-helpers` (types only).
+     */
     private declaratorInit;
     /** Whether a unary expression is `++`/`--` (the only writing unary ops). */
     private isIncDec;

package/dist/core/ingestion/cfg/visitors/csharp-harvest.js

@@ -170,6 +170,28 @@ export class CsharpHarvester extends ScopeTreeHarvester {
         this.conditional(() => this.walkValue(node, acc));
         return acc.finish();
     }
+    /**
+     * Def-ONLY facts for a value-position binding carrier (`var x = k switch {…}`,
+     * #2207): just the declared name(s)' def, attached to the continuation block the
+     * switch arms rejoin. The discriminant + arm-value USES are already harvested
+     * onto the branch's own blocks ({@link facts} on each arm), so this must NOT
+     * re-walk the initializer — only each `variable_declarator`'s name is a def here.
+     */
+    bindingDefFacts(stmt) {
+        const acc = new FactAccumulator(stmt.startPosition.row + 1);
+        const decl = stmt.namedChildren.find((c) => c.type === 'variable_declaration');
+        if (decl) {
+            for (let i = 0; i < decl.namedChildCount; i++) {
+                const d = decl.namedChild(i);
+                if (d?.type !== 'variable_declarator')
+                    continue;
+                const name = d.childForFieldName('name');
+                if (name)
+                    this.def(name, acc);
+            }
+        }
+        return acc.defCount() ? acc.finish() : undefined;
+    }
     /** Facts for a `foreach (decl in right)` head: decl binds, right is used. */
     forEachHeadFacts(stmt) {
         const acc = new FactAccumulator(stmt.startPosition.row + 1);
@@ -517,7 +539,13 @@ export class CsharpHarvester extends ScopeTreeHarvester {
             : undefined;
         return { path, rootIdx };
     }
-    /** The initializer value of a `variable_declarator` — the named child after `name`. */
+    /**
+     * The initializer value of a `variable_declarator` — the named child after
+     * `name`. NOTE: deliberately duplicated in `csharp.ts` (the visitor is a
+     * standalone class with no shared base — repo convention). The two copies must
+     * stay in sync; there is no C#-specific shared module to host it, and the only
+     * module both files share is the generic `utils/ast-helpers` (types only).
+     */
     declaratorInit(declarator) {
         const name = declarator.childForFieldName('name');
         for (let i = 0; i < declarator.namedChildCount; i++) {

package/dist/core/ingestion/cfg/visitors/csharp.d.ts

@@ -66,6 +66,12 @@
  *    unresolved label.
  *  - Async/await suspension points are modeled as straight-line (the awaited
  *    continuation is not a separate flow), consistent with the TS visitor.
+ *  - A value-position `switch_expression` (`k switch {…}`) with ≥2 arms IS modeled
+ *    as a `switch-case` dispatch in three carriers (#2207): a single-declarator
+ *    `var x = k switch {…}` (arms rejoin at a binding continuation), `return k
+ *    switch {…}`, and an `=> k switch {…}` expression body (each arm returns).
+ *    A value switch in any OTHER position — an assignment RHS (`x = k switch …`),
+ *    a call argument, or a multi-declarator decl — stays INLINE (one block).
  *  - Def/use harvest scope: see `csharp-harvest.ts` — member/element writes are
  *    not scalar defs; nested-function bodies are opaque in both directions.
  *

package/dist/core/ingestion/cfg/visitors/csharp.js

@@ -92,7 +92,7 @@ class CsharpCfgWalk {
                     dangling = [...scope.exits];
                     break; // the rest of the sequence is consumed by the dispose scope
                 }
-                if (CONTROL_FLOW_TYPES.has(stmt.type)) {
+                if (this.breaksBlock(stmt)) {
                     openSimple = undefined; // close any open straight-line block
                     const res = this.visitStmt(stmt);
                     if (res === null)
@@ -123,9 +123,29 @@ class CsharpCfgWalk {
             return { entry, exits: dangling };
         });
     }
+    /**
+     * Whether a statement breaks the current straight-line block. Adds the
+     * value-position switch carrier to the base {@link CONTROL_FLOW_TYPES} set: a
+     * `local_declaration_statement` whose single initializer is a modelable
+     * `switch_expression` (`var x = k switch {…}`, #2207) breaks so `visitStmt`
+     * models the arms as control flow instead of collapsing the decl to one block.
+     */
+    breaksBlock(stmt) {
+        if (this.isValueSwitchDecl(stmt))
+            return true;
+        return CONTROL_FLOW_TYPES.has(stmt.type);
+    }
     /** Dispatch one statement to its handler. Non-null except for empty blocks. */
     visitStmt(stmt) {
         switch (stmt.type) {
+            case 'local_declaration_statement': {
+                // `var x = k switch { … }` (#2207): the initializer is a value-position
+                // branch — model it as control flow and bind the result on the rejoin.
+                const branch = this.declValueSwitch(stmt);
+                if (branch)
+                    return this.visitBindBranch(stmt, branch);
+                return this.visitSimple(stmt);
+            }
             case 'if_statement':
                 return this.visitIf(stmt);
             case 'while_statement':
@@ -169,6 +189,18 @@ class CsharpCfgWalk {
         return { entry: idx, exits: [idx] };
     }
     visitReturn(stmt) {
+        // `return k switch { … };` (#2207): the returned value is a value-position
+        // branch — model it as control flow, with each arm returning (its value IS
+        // the function result), threading every active finalizer per arm.
+        const branch = stmt.namedChildren.find((c) => c.type !== 'comment');
+        if (branch && this.isModelableValueBranch(branch)) {
+            const res = this.visitBranchExpr(branch);
+            const finalizers = this.cfc.finalizersForReturn();
+            for (const ex of res.exits) {
+                wireJumpThroughFinalizers(this.builder, ex, finalizers, this.builder.exitIndex, 'return');
+            }
+            return { entry: res.entry, exits: [] };
+        }
         const idx = this.builder.newBlock(startLineOf(stmt), endLineOf(stmt), stmt.text, 'normal', this.harvest.facts(stmt));
         // A return crosses EVERY active finally (try/using/lock) before EXIT.
         wireJumpThroughFinalizers(this.builder, idx, this.cfc.finalizersForReturn(), this.builder.exitIndex, 'return');
@@ -446,6 +478,126 @@ class CsharpCfgWalk {
     isStatementLike(node) {
         return node.type.endsWith('_statement') || node.type === 'block';
     }
+    // ── value-position switch expression (#2207) ────────────────────────────────
+    /**
+     * The `switch_expression` initializer of a single-declarator
+     * `local_declaration_statement` (`var x = k switch {…}`) when it is a modelable
+     * value branch, else undefined. A `using` decl and a multi-declarator decl are
+     * excluded (the `using` dispose path / multi-declarator stay inline).
+     */
+    declValueSwitch(stmt) {
+        if (stmt.type !== 'local_declaration_statement')
+            return undefined;
+        if (this.isUsingLocalDecl(stmt))
+            return undefined;
+        const decl = stmt.namedChildren.find((c) => c.type === 'variable_declaration');
+        if (!decl)
+            return undefined;
+        const declarators = decl.namedChildren.filter((c) => c.type === 'variable_declarator');
+        if (declarators.length !== 1)
+            return undefined;
+        const init = this.declaratorInit(declarators[0]);
+        return init && this.isModelableValueBranch(init) ? init : undefined;
+    }
+    isValueSwitchDecl(stmt) {
+        return this.declValueSwitch(stmt) !== undefined;
+    }
+    /**
+     * The initializer of a `variable_declarator` — its named child after `name`.
+     * NOTE: deliberately duplicated in `csharp-harvest.ts` (the harvester is a
+     * standalone class with no shared base — repo convention). The two copies must
+     * stay in sync; there is no C#-specific shared module to host it, and the only
+     * module both files share is the generic `utils/ast-helpers` (types only).
+     */
+    declaratorInit(declarator) {
+        const name = declarator.childForFieldName('name');
+        for (let i = 0; i < declarator.namedChildCount; i++) {
+            const c = declarator.namedChild(i);
+            if (c && c.id !== name?.id)
+                return c;
+        }
+        return undefined;
+    }
+    /**
+     * Whether `node` is a value-position branch worth modeling as control flow
+     * (#2207): a `switch_expression` (`k switch {…}`) with ≥2 arms — a real
+     * dispatch. C# value-position `if` does not exist (the ternary `?:` is excluded,
+     * like elvis in Kotlin).
+     */
+    isModelableValueBranch(node) {
+        if (node.type !== 'switch_expression')
+            return false;
+        return node.namedChildren.filter((c) => c.type === 'switch_expression_arm').length >= 2;
+    }
+    /**
+     * Model a value-position `switch_expression` (`k switch { p => v, … }`) as a CFG
+     * dispatch: a discriminant block, each arm's value expression a block reached by
+     * a `switch-case` edge, all arms rejoining at a single exit. The arm patterns /
+     * `when` guards are harvested as conditional uses on the dispatch (a later arm
+     * test runs only when earlier arms didn't match), mirroring {@link visitSwitch}.
+     */
+    visitSwitchExpr(node) {
+        const arms = node.namedChildren.filter((c) => c.type === 'switch_expression_arm');
+        const discriminant = node.namedChildren.find((c) => c.type !== 'switch_expression_arm') ?? node;
+        const dispatch = this.builder.newBlock(startLineOf(node), endLineOf(discriminant), discriminant.text, 'normal', this.harvest.facts(discriminant));
+        const switchExit = this.builder.newBlock(endLineOf(node), endLineOf(node), '');
+        let hasCatchAll = false;
+        for (const arm of arms) {
+            const pattern = arm.namedChild(0);
+            const guard = arm.namedChildren.find((c) => c.type === 'when_clause');
+            if (pattern)
+                this.builder.attachFacts(dispatch, this.harvest.factsConditional(pattern));
+            if (guard) {
+                const inner = guard.namedChild(0);
+                if (inner)
+                    this.builder.attachFacts(dispatch, this.harvest.factsConditional(inner));
+            }
+            // An unguarded `_`/`var` arm matches everything — the exhaustive default.
+            if (!guard && pattern && (pattern.type === 'discard' || pattern.type === 'var_pattern')) {
+                hasCatchAll = true;
+            }
+            const value = this.armValue(arm);
+            const armBlock = this.builder.newBlock(startLineOf(value ?? arm), endLineOf(value ?? arm), (value ?? arm).text, 'normal', value ? this.harvest.facts(value) : undefined);
+            this.builder.edge(dispatch, armBlock, 'switch-case');
+            this.builder.edge(armBlock, switchExit, 'seq');
+        }
+        // A non-exhaustive switch throws at runtime; conservatively keep EXIT directly
+        // reachable from the dispatch when no catch-all arm covers the no-match path.
+        if (!hasCatchAll)
+            this.builder.edge(dispatch, switchExit, 'switch-case');
+        return { entry: dispatch, exits: [switchExit] };
+    }
+    /** The value expression of a `switch_expression_arm` (the child after `=>`). */
+    armValue(arm) {
+        // pattern [when_clause] => value — the value is the LAST named child.
+        return arm.namedChild(arm.namedChildCount - 1) ?? undefined;
+    }
+    /** Model a value-position branch as control flow (only `switch_expression`). */
+    visitBranchExpr(node) {
+        return this.visitSwitchExpr(node);
+    }
+    /**
+     * An expression-bodied member's value (`=> k switch {…}`, #2207): if it is a
+     * modelable value branch, model its arms as control flow (each arm returns the
+     * function result); otherwise return null so the caller falls back to a single
+     * inline block.
+     */
+    tryVisitValueBranchBody(expr) {
+        return this.isModelableValueBranch(expr) ? this.visitBranchExpr(expr) : null;
+    }
+    /**
+     * `var x = k switch { … }` (#2207): visit the switch as control flow, then
+     * rejoin its arms at a facts-only continuation carrying ONLY the bound name's
+     * def (the discriminant + arm-value uses are already on the switch's blocks).
+     * The arms are now control-dependent on the dispatch, and `x` is defined at the
+     * join — mirrors the Java / Kotlin / Rust value-position binding.
+     */
+    visitBindBranch(stmt, branch) {
+        const res = this.visitBranchExpr(branch);
+        const cont = this.builder.newBlock(startLineOf(stmt), startLineOf(stmt), '', 'normal', this.harvest.bindingDefFacts(stmt));
+        this.builder.connect(res.exits, cont, 'seq');
+        return { entry: res.entry, exits: [cont] };
+    }
     visitTry(stmt) {
         const bodyNode = stmt.childForFieldName('body');
         const catchClauses = [];
@@ -673,6 +825,14 @@ function buildFunctionCfg(fnNode, filePath) {
             // Expression-bodied member / single-expression lambda: one block whose
             // value is returned. For an arrow clause the value is its inner expression.
             const expr = body.type === 'arrow_expression_clause' ? (body.namedChild(0) ?? body) : body;
+            // `=> k switch { … }` (#2207): model the arms as control flow, each arm
+            // returning the function result, instead of one inline block.
+            const branchRes = new CsharpCfgWalk(builder, harvest).tryVisitValueBranchBody(expr);
+            if (branchRes) {
+                builder.edge(builder.entryIndex, branchRes.entry, 'seq');
+                builder.connect(branchRes.exits, builder.exitIndex, 'return');
+                return builder.finish(harvest.bindingTable());
+            }
             const blk = builder.newBlock(startLineOf(expr), endLineOf(expr), expr.text, 'normal', harvest.facts(expr));
             builder.edge(builder.entryIndex, blk, 'seq');
             builder.edge(blk, builder.exitIndex, 'return');

package/dist/core/ingestion/cfg/visitors/dart-harvest.d.ts

@@ -131,6 +131,14 @@ export declare class DartHarvester {
     facts(node: SyntaxNode): StatementFacts;
     /** Facts for an expression whose WHOLE evaluation is conditional (case tests). */
     factsConditional(node: SyntaxNode): StatementFacts;
+    /**
+     * Def-ONLY facts for a value-position binding carrier (`var x = switch (…) {…}`,
+     * #2207): just the declared name(s)' def, attached to the continuation block the
+     * switch arms rejoin. The subject + arm-value USES are already harvested onto
+     * the branch's own blocks, so this must NOT re-walk the value — only each
+     * `initialized_variable_definition`'s `name` (and trailing binders) is a def.
+     */
+    bindingDefFacts(stmt: SyntaxNode): StatementFacts | undefined;
     /**
      * Facts for a `for` head. For-in: the loop var name is a def, the collection a
      * use. C-style: the init/condition/update sub-expressions are walked for

package/dist/core/ingestion/cfg/visitors/dart-harvest.js

@@ -186,6 +186,32 @@ export class DartHarvester {
         this.conditional(() => this.walkValue(node, acc));
         return acc.finish();
     }
+    /**
+     * Def-ONLY facts for a value-position binding carrier (`var x = switch (…) {…}`,
+     * #2207): just the declared name(s)' def, attached to the continuation block the
+     * switch arms rejoin. The subject + arm-value USES are already harvested onto
+     * the branch's own blocks, so this must NOT re-walk the value — only each
+     * `initialized_variable_definition`'s `name` (and trailing binders) is a def.
+     */
+    bindingDefFacts(stmt) {
+        const acc = new FactAccumulator(stmt.startPosition.row + 1);
+        for (const def of stmt.namedChildren) {
+            if (def.type !== 'initialized_variable_definition')
+                continue;
+            const name = def.childForFieldName('name');
+            if (name)
+                this.def(name, acc);
+            for (let i = 0; i < def.namedChildCount; i++) {
+                const c = def.namedChild(i);
+                if (c?.type !== 'initialized_identifier')
+                    continue;
+                const id = c.namedChildren.find((g) => g.type === 'identifier');
+                if (id)
+                    this.def(id, acc);
+            }
+        }
+        return acc.defCount() ? acc.finish() : undefined;
+    }
     /**
      * Facts for a `for` head. For-in: the loop var name is a def, the collection a
      * use. C-style: the init/condition/update sub-expressions are walked for

package/dist/core/ingestion/cfg/visitors/dart.d.ts

@@ -88,10 +88,13 @@
  *  - a closure (`function_expression`) is collected as its OWN function by
  *    `isFunction`, so its body gets a standalone CFG; in the ENCLOSING function it
  *    is an opaque straight-line value (its body is not followed inline).
- *  - `switch_expression` / `if`-as-expression / `?:` / `??` / `?.` used as a VALUE
- *    are left INLINE inside their owning statement's block — their conditional
- *    sub-evaluation is a HARVEST may-def concern (see dart-harvest.ts), not a CFG
- *    split (consistent with the TS `&&`/`??` treatment).
+ *  - a value-position `switch_expression` (Dart 3) with ≥2 arms IS modeled as a
+ *    `switch-case` dispatch in two carriers (#2207): a single-binding `var x =
+ *    switch (v) {…}` (arms rejoin at a binding continuation) and `return switch
+ *    (v) {…}` (each arm returns). A `switch_expression` in any OTHER position — a
+ *    call argument, a multi-binding decl — stays INLINE (its conditional arm
+ *    sub-evaluation is a HARVEST may-def concern, see dart-harvest.ts). `?:` /
+ *    `??` / `?.` micro-branches are excluded by design (like the TS treatment).
  *
  * Known limitations:
  *  - block-scope shadowing in the harvest is flattened to one function table (see

package/dist/core/ingestion/cfg/visitors/dart.js

@@ -115,6 +115,12 @@ class DartCfgWalk {
             return true; // a stray label sibling — queue it
         if (isThrowStatement(stmt) || isRethrowStatement(stmt))
             return true;
+        // `var x = switch (v) { … }` (#2207): a value-position switch breaks so
+        // `visitStmt` models the arms as control flow instead of coalescing.
+        if (stmt.type === 'local_variable_declaration') {
+            const v = this.directValue(stmt);
+            return v !== undefined && this.isModelableValueBranch(v);
+        }
         return CONTROL_FLOW_TYPES.has(stmt.type);
     }
     /**
@@ -141,6 +147,14 @@ class DartCfgWalk {
         if (isRethrowStatement(stmt))
             return this.visitRethrow(stmt);
         switch (stmt.type) {
+            case 'local_variable_declaration': {
+                // `var x = switch (v) { … }` (#2207): the value is a value-position
+                // branch — model it as control flow and bind the result on the rejoin.
+                const value = this.directValue(stmt);
+                if (value && this.isModelableValueBranch(value))
+                    return this.visitBindBranch(stmt, value);
+                return this.visitSimple(stmt);
+            }
             case 'if_statement':
                 return this.visitIf(stmt);
             case 'for_statement':
@@ -180,6 +194,18 @@ class DartCfgWalk {
     // ── jumps (return / throw / rethrow / break / continue / assert) ──────────
     /** `return [expr];` — threads through every active finalizer before EXIT. */
     visitReturn(stmt) {
+        // `return switch (v) { … };` (#2207): the returned value is a value-position
+        // branch — model it as control flow, with each arm returning (its value IS
+        // the function result), threading every active finalizer per arm.
+        const branch = stmt.namedChildren.find((c) => !isComment(c));
+        if (branch && this.isModelableValueBranch(branch)) {
+            const res = this.visitBranchExpr(branch);
+            const finalizers = this.cfc.finalizersForReturn();
+            for (const ex of res.exits) {
+                wireJumpThroughFinalizers(this.builder, ex, finalizers, this.builder.exitIndex, 'return');
+            }
+            return { entry: res.entry, exits: [] };
+        }
         const idx = this.builder.newBlock(startLineOf(stmt), endLineOf(stmt), stmt.text, 'normal', this.harvest.facts(stmt));
         wireJumpThroughFinalizers(this.builder, idx, this.cfc.finalizersForReturn(), this.builder.exitIndex, 'return');
         return { entry: idx, exits: [] };
@@ -366,7 +392,12 @@ class DartCfgWalk {
      */
     visitSwitch(stmt) {
         const labels = this.takeLabels();
-        const value = stmt.childForFieldName('condition');
+        // The `condition` field is a `parenthesized_expression` (verified) — unwrap it
+        // so the dispatch text/discriminant matches the value-position `visitSwitchExpr`
+        // form (`switch x`, not `switch (x)`). The harvest walks into the paren either
+        // way, so the def/use facts are unchanged — only the block text normalizes.
+        const condRaw = stmt.childForFieldName('condition');
+        const value = condRaw ? this.unwrapParen(condRaw) : undefined;
         const dispatch = this.builder.newBlock(startLineOf(stmt), value ? endLineOf(value) : startLineOf(stmt), value ? `switch ${value.text}` : 'switch', 'normal', value ? this.harvest.facts(value) : undefined);
         const switchExit = this.builder.newBlock(endLineOf(stmt), endLineOf(stmt), '');
         const block = stmt.childForFieldName('body');
@@ -469,6 +500,122 @@ class DartCfgWalk {
         const id = cont.namedChildren.find((ch) => ch.type === 'identifier');
         return id?.text || undefined;
     }
+    // ── value-position switch expression (#2207) ────────────────────────────────
+    /**
+     * The direct value of a `local_variable_declaration` with a SINGLE
+     * `initialized_variable_definition` (`var x = <value>`): its `value` field.
+     * Returns undefined for a multi-binding decl (`var a = …, b = …`) — modeling
+     * those arm-by-arm is out of scope, so they coalesce inline.
+     */
+    directValue(stmt) {
+        const defs = stmt.namedChildren.filter((c) => c.type === 'initialized_variable_definition');
+        if (defs.length !== 1)
+            return undefined;
+        return defs[0].childForFieldName('value') ?? undefined;
+    }
+    /**
+     * Whether `node` is a value-position branch worth modeling as control flow
+     * (#2207): a `switch_expression` (Dart 3) with ≥2 arms — a real dispatch. Dart's
+     * value-position `if` does not exist; the ternary `?:` is excluded by design.
+     */
+    isModelableValueBranch(node) {
+        if (node.type !== 'switch_expression')
+            return false;
+        return node.namedChildren.filter((c) => c.type === 'switch_expression_case').length >= 2;
+    }
+    /** Model a value-position branch as control flow (only `switch_expression`). */
+    visitBranchExpr(node) {
+        return this.visitSwitchExpr(node);
+    }
+    /**
+     * Model a value-position `switch (v) { p [when g] => e, _ => e }` (Dart 3) as a
+     * CFG dispatch: a discriminant block, each arm's value a block reached by a
+     * `switch-case` edge, all arms rejoining at one exit (no fallthrough). The arm
+     * PATTERN and any `when` GUARD are harvested as conditional uses on the dispatch
+     * (they evaluate before the body, only when earlier arms missed); a Dart call
+     * value parses as `identifier` + `selector` (multiple children), so the arm-value
+     * facts come from each post-`=>` child. Only an UNGUARDED `_` arm is the
+     * exhaustive catch-all — a guarded `_ when …` is NOT (the no-match path still
+     * needs the conservative edge), mirroring the C# `visitSwitchExpr`.
+     */
+    visitSwitchExpr(node) {
+        const condRaw = node.childForFieldName('condition');
+        const cond = condRaw ? this.unwrapParen(condRaw) : node;
+        const dispatch = this.builder.newBlock(startLineOf(node), endLineOf(cond), `switch ${cond.text}`, 'normal', this.harvest.facts(cond));
+        const switchExit = this.builder.newBlock(endLineOf(node), endLineOf(node), '');
+        const arms = node.namedChildren.filter((c) => c.type === 'switch_expression_case');
+        let hasCatchAll = false;
+        for (const arm of arms) {
+            const { pattern, guards, values } = this.armParts(arm);
+            // The pattern + `when` guard are conditional dispatch tests, NOT arm-value
+            // uses — harvest them onto the dispatch (mirrors casePatterns for switch_statement).
+            if (pattern)
+                this.builder.attachFacts(dispatch, this.harvest.factsConditional(pattern));
+            for (const g of guards)
+                this.builder.attachFacts(dispatch, this.harvest.factsConditional(g));
+            if (pattern && pattern.text === '_' && guards.length === 0)
+                hasCatchAll = true;
+            const first = values[0] ?? arm;
+            const last = values[values.length - 1] ?? arm;
+            const armBlock = this.builder.newBlock(startLineOf(first), endLineOf(last), values.map((c) => c.text).join('') || arm.text, 'normal', undefined);
+            for (const v of values)
+                this.builder.attachFacts(armBlock, this.harvest.facts(v));
+            this.builder.edge(dispatch, armBlock, 'switch-case');
+            this.builder.edge(armBlock, switchExit, 'seq');
+        }
+        // A non-exhaustive Dart switch expression throws at runtime; conservatively
+        // keep EXIT reachable via a no-match edge when no `_` catch-all arm exists.
+        if (!hasCatchAll)
+            this.builder.edge(dispatch, switchExit, 'switch-case');
+        return { entry: dispatch, exits: [switchExit] };
+    }
+    /**
+     * Split a `switch_expression_case` at the `=>` token: the PATTERN (first named
+     * child before `=>`), any `when` GUARD (named children between the pattern and
+     * `=>` — tree-sitter-dart parses the guard as a bare sibling, not a wrapper),
+     * and the VALUE expression (named children after `=>` — a Dart call is split
+     * across `identifier` + `selector`, hence an array).
+     */
+    armParts(arm) {
+        const before = [];
+        const values = [];
+        let seenArrow = false;
+        for (let i = 0; i < arm.childCount; i++) {
+            const c = arm.child(i);
+            if (!c)
+                continue;
+            if (!c.isNamed) {
+                if (c.text === '=>')
+                    seenArrow = true;
+                continue;
+            }
+            if (isComment(c))
+                continue;
+            (seenArrow ? values : before).push(c);
+        }
+        return { pattern: before[0], guards: before.slice(1), values };
+    }
+    /** Strip a `parenthesized_expression` wrapper (a switch/if condition). */
+    unwrapParen(node) {
+        if (node.type === 'parenthesized_expression') {
+            const inner = node.namedChildren.find((c) => !isComment(c));
+            if (inner)
+                return inner;
+        }
+        return node;
+    }
+    /**
+     * `var x = switch (v) { … }` (#2207): visit the switch as control flow, then
+     * rejoin its arms at a facts-only continuation carrying ONLY the declared name's
+     * def (the subject + arm-value uses are already on the switch's blocks). The
+     * arms are now control-dependent on the dispatch — mirrors Java / Kotlin / Rust.
+     */
+    visitBindBranch(stmt, branch) {
+        const res = this.visitBranchExpr(branch);
+        const cont = this.builder.newBlock(startLineOf(stmt), startLineOf(stmt), '', 'normal', this.harvest.bindingDefFacts(stmt));
+        this.builder.connect(res.exits, cont, 'seq');
+        return { entry: res.entry, exits: [cont] };
+    }
     // ── try / on / catch / finally ─────────────────────────────────────────────
     /**
      * `try body:block (on TYPE? catch_clause? block)* finally_clause?`. The handler

package/dist/core/ingestion/cfg/visitors/java-harvest.d.ts

@@ -58,6 +58,14 @@ export declare class JavaHarvester extends ScopeTreeHarvester {
     facts(node: SyntaxNode): StatementFacts;
     /** Facts for an expression whose WHOLE evaluation is conditional (case tests). */
     factsConditional(node: SyntaxNode): StatementFacts;
+    /**
+     * Def-ONLY facts for a value-position binding carrier (`var x = switch (…) {…}`,
+     * #2207): just the declared name(s)' def, attached to the continuation block the
+     * switch arms rejoin. The switch subject + arm-value USES are already harvested
+     * onto the branch's own blocks ({@link facts} on each arm), so this must NOT
+     * re-walk the value — only each `variable_declarator`'s `name` is a def here.
+     */
+    bindingDefFacts(stmt: SyntaxNode): StatementFacts | undefined;
     /** Facts for a `for (T name : value)` head: name binds, value is used. */
     forEachHeadFacts(stmt: SyntaxNode): StatementFacts;
     /** Facts for the resource-close finalizer: each resource is USED on close. */

package/dist/core/ingestion/cfg/visitors/java-harvest.js

@@ -147,6 +147,25 @@ export class JavaHarvester extends ScopeTreeHarvester {
         this.conditional(() => this.walkValue(node, acc));
         return acc.finish();
     }
+    /**
+     * Def-ONLY facts for a value-position binding carrier (`var x = switch (…) {…}`,
+     * #2207): just the declared name(s)' def, attached to the continuation block the
+     * switch arms rejoin. The switch subject + arm-value USES are already harvested
+     * onto the branch's own blocks ({@link facts} on each arm), so this must NOT
+     * re-walk the value — only each `variable_declarator`'s `name` is a def here.
+     */
+    bindingDefFacts(stmt) {
+        const acc = new FactAccumulator(stmt.startPosition.row + 1);
+        for (let i = 0; i < stmt.namedChildCount; i++) {
+            const d = stmt.namedChild(i);
+            if (d?.type !== 'variable_declarator')
+                continue;
+            const name = d.childForFieldName('name');
+            if (name)
+                this.def(name, acc);
+        }
+        return acc.defCount() ? acc.finish() : undefined;
+    }
     /** Facts for a `for (T name : value)` head: name binds, value is used. */
     forEachHeadFacts(stmt) {
         const acc = new FactAccumulator(stmt.startPosition.row + 1);

package/dist/core/ingestion/cfg/visitors/java.d.ts

@@ -74,11 +74,12 @@
  *    TS `visitTry` over-approximation.
  *
  * Known limitations:
- *  - `switch` as an EXPRESSION value (`int r = switch (x) { … };`) is left INLINE
- *    inside its owning statement's block — its arms are not modeled as separate
- *    CFG blocks (the value flows to the assignment). Only a `switch` used as a
- *    STATEMENT (a direct statement child) is modeled as a dispatch construct.
- *    This mirrors the C# `switch_expression`-in-return handling — documented gap.
+ *  - A value-position `switch` with ≥2 arms is modeled as control flow in the two
+ *    highest-value carriers (#2207): a single-declarator `var x = switch (…) {…}`
+ *    (arms rejoin at a binding continuation) and `return switch (…) {…}` (each arm
+ *    returns). A value-position `switch` in any OTHER position — an assignment RHS
+ *    (`x = switch …`), a call argument, or a multi-declarator decl — is still left
+ *    INLINE inside its owning block (the value flows to one coalesced block).
  *  - `yield` (in a switch expression) continues to the next statement (it yields
  *    one value to the enclosing switch and the arm ends); the switch-expression
  *    state machine is not modeled, consistent with the inline-value-switch gap.