sdlc-agent-4-enterprise-server 1.0.0

package/src/engine/analyzers/security/cfg/BasicBlock.ts

@@ -0,0 +1,130 @@
+/**
+ * KSA-164: Basic Block — Fundamental unit of a control flow graph.
+ */
+
+import type { SyntaxNode } from '../../../parsers/types.js';
+import type { BlockType, Statement, VariableDef, VariableUse } from '../types.js';
+
+export class BasicBlock {
+  readonly id: number;
+  readonly type: BlockType;
+  readonly statements: Statement[] = [];
+  startLine: number = 0;
+  endLine: number = 0;
+
+  constructor(id: number, type: BlockType) {
+    this.id = id;
+    this.type = type;
+  }
+
+  addStatement(node: SyntaxNode): void {
+    const stmt: Statement = {
+      node,
+      line: node.startPosition.row + 1,
+      type: node.type,
+      text: node.text.slice(0, 120),
+    };
+    this.statements.push(stmt);
+    if (this.statements.length === 1) this.startLine = stmt.line;
+    this.endLine = stmt.line;
+  }
+
+  /** Extract variable definitions from this block's statements. */
+  getDefinitions(): VariableDef[] {
+    const defs: VariableDef[] = [];
+    for (const stmt of this.statements) {
+      const extracted = extractDefinitions(stmt.node, this.id);
+      defs.push(...extracted);
+    }
+    return defs;
+  }
+
+  /** Extract variable uses from this block's statements. */
+  getUses(): VariableUse[] {
+    const uses: VariableUse[] = [];
+    for (const stmt of this.statements) {
+      const extracted = extractUses(stmt.node, this.id);
+      uses.push(...extracted);
+    }
+    return uses;
+  }
+
+  get isEmpty(): boolean {
+    return this.statements.length === 0;
+  }
+}
+
+/** Extract variable definitions from an AST node. */
+function extractDefinitions(node: SyntaxNode, blockId: number): VariableDef[] {
+  const defs: VariableDef[] = [];
+  const type = node.type;
+
+  // Variable declarations: let x = ..., const y = ..., var z = ...
+  if (type === 'lexical_declaration' || type === 'variable_declaration') {
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const declarator = node.namedChild(i);
+      if (declarator && declarator.type === 'variable_declarator') {
+        const nameNode = declarator.childForFieldName('name');
+        if (nameNode) {
+          defs.push({ name: nameNode.text, line: nameNode.startPosition.row + 1, blockId, node: nameNode });
+        }
+      }
+    }
+  }
+
+  // Assignment expressions: x = ...
+  if (type === 'assignment_expression' || type === 'augmented_assignment_expression') {
+    const left = node.childForFieldName('left');
+    if (left && left.type === 'identifier') {
+      defs.push({ name: left.text, line: left.startPosition.row + 1, blockId, node: left });
+    }
+  }
+
+  // Expression statement wrapping assignment
+  if (type === 'expression_statement') {
+    const expr = node.namedChild(0);
+    if (expr) {
+      defs.push(...extractDefinitions(expr, blockId));
+    }
+  }
+
+  // Python: assignment
+  if (type === 'assignment') {
+    const left = node.childForFieldName('left');
+    if (left && left.type === 'identifier') {
+      defs.push({ name: left.text, line: left.startPosition.row + 1, blockId, node: left });
+    }
+  }
+
+  // For loop variable
+  if (type === 'for_statement' || type === 'for_in_statement') {
+    const init = node.childForFieldName('initializer') ?? node.childForFieldName('left');
+    if (init && init.type === 'identifier') {
+      defs.push({ name: init.text, line: init.startPosition.row + 1, blockId, node: init });
+    }
+  }
+
+  return defs;
+}
+
+/** Extract variable uses from an AST node (identifiers in read position). */
+function extractUses(node: SyntaxNode, blockId: number): VariableUse[] {
+  const uses: VariableUse[] = [];
+  collectIdentifiers(node, uses, blockId, new Set());
+  return uses;
+}
+
+function collectIdentifiers(node: SyntaxNode, uses: VariableUse[], blockId: number, seen: Set<string>): void {
+  if (node.type === 'identifier') {
+    const key = `${node.text}:${node.startPosition.row}`;
+    if (!seen.has(key)) {
+      seen.add(key);
+      uses.push({ name: node.text, line: node.startPosition.row + 1, blockId, node });
+    }
+    return;
+  }
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child) collectIdentifiers(child, uses, blockId, seen);
+  }
+}

package/src/engine/analyzers/security/cfg/CFGBuilder.ts

@@ -0,0 +1,266 @@
+/**
+ * KSA-164: CFG Builder — Constructs control flow graphs from AST function nodes.
+ * Handles if/else, loops, try/catch, switch, and early returns.
+ */
+
+import type { SyntaxNode } from '../../../parsers/types.js';
+import { BasicBlock } from './BasicBlock.js';
+import { ControlFlowGraph } from './ControlFlowGraph.js';
+
+export class CFGBuilder {
+  private blockCounter = 0;
+  private cfg!: ControlFlowGraph;
+
+  /** Build CFG from a function AST node. */
+  build(functionNode: SyntaxNode, language: string): ControlFlowGraph {
+    this.blockCounter = 0;
+
+    const entry = this.newBlock('entry');
+    this.cfg = new ControlFlowGraph(entry);
+
+    const exit = this.newBlock('exit');
+    this.cfg.addBlock(exit);
+
+    const body = this.getFunctionBody(functionNode, language);
+    if (!body) {
+      this.cfg.addEdge(entry, exit, 'sequential');
+      return this.cfg;
+    }
+
+    const lastBlock = this.processStatements(body, entry, exit);
+    if (lastBlock && lastBlock !== exit) {
+      this.cfg.addEdge(lastBlock, exit, 'sequential');
+    }
+
+    return this.cfg;
+  }
+
+  private getFunctionBody(node: SyntaxNode, language: string): SyntaxNode | null {
+    const body = node.childForFieldName('body');
+    if (body) return body;
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const child = node.namedChild(i);
+      if (child && (child.type === 'statement_block' || child.type === 'block')) {
+        return child;
+      }
+    }
+    return null;
+  }
+
+  private processStatements(blockNode: SyntaxNode, currentBlock: BasicBlock, exitBlock: BasicBlock): BasicBlock | null {
+    let active: BasicBlock | null = currentBlock;
+    for (let i = 0; i < blockNode.namedChildCount; i++) {
+      const stmt = blockNode.namedChild(i);
+      if (!stmt || !active) break;
+      active = this.processStatement(stmt, active, exitBlock);
+    }
+    return active;
+  }
+
+  private processStatement(stmt: SyntaxNode, currentBlock: BasicBlock, exitBlock: BasicBlock): BasicBlock | null {
+    switch (stmt.type) {
+      case 'if_statement':
+        return this.handleIf(stmt, currentBlock, exitBlock);
+      case 'while_statement':
+      case 'do_statement':
+        return this.handleWhile(stmt, currentBlock, exitBlock);
+      case 'for_statement':
+      case 'for_in_statement':
+        return this.handleFor(stmt, currentBlock, exitBlock);
+      case 'try_statement':
+        return this.handleTryCatch(stmt, currentBlock, exitBlock);
+      case 'switch_statement':
+        return this.handleSwitch(stmt, currentBlock, exitBlock);
+      case 'return_statement':
+        currentBlock.addStatement(stmt);
+        this.cfg.addEdge(currentBlock, exitBlock, 'return');
+        return null;
+      case 'throw_statement':
+        currentBlock.addStatement(stmt);
+        this.cfg.addEdge(currentBlock, exitBlock, 'exception');
+        return null;
+      case 'break_statement':
+      case 'continue_statement':
+        currentBlock.addStatement(stmt);
+        return null;
+      default:
+        currentBlock.addStatement(stmt);
+        return currentBlock;
+    }
+  }
+
+  private handleIf(node: SyntaxNode, currentBlock: BasicBlock, exitBlock: BasicBlock): BasicBlock | null {
+    const condNode = node.childForFieldName('condition');
+    if (condNode) currentBlock.addStatement(condNode);
+
+    const mergeBlock = this.newBlock('normal');
+    this.cfg.addBlock(mergeBlock);
+
+    const consequence = node.childForFieldName('consequence');
+    const thenBlock = this.newBlock('normal');
+    this.cfg.addBlock(thenBlock);
+    this.cfg.addEdge(currentBlock, thenBlock, 'branch-true');
+
+    let thenEnd: BasicBlock | null = thenBlock;
+    if (consequence) {
+      thenEnd = this.processBlockOrStatement(consequence, thenBlock, exitBlock);
+    }
+    if (thenEnd) this.cfg.addEdge(thenEnd, mergeBlock, 'sequential');
+
+    const alternative = node.childForFieldName('alternative');
+    if (alternative) {
+      const elseBlock = this.newBlock('normal');
+      this.cfg.addBlock(elseBlock);
+      this.cfg.addEdge(currentBlock, elseBlock, 'branch-false');
+
+      const elseBody = alternative.type === 'else_clause' ? alternative.namedChild(0) : alternative;
+      let elseEnd: BasicBlock | null = elseBlock;
+      if (elseBody) {
+        if (elseBody.type === 'if_statement') {
+          elseEnd = this.handleIf(elseBody, elseBlock, exitBlock);
+        } else {
+          elseEnd = this.processBlockOrStatement(elseBody, elseBlock, exitBlock);
+        }
+      }
+      if (elseEnd) this.cfg.addEdge(elseEnd, mergeBlock, 'sequential');
+    } else {
+      this.cfg.addEdge(currentBlock, mergeBlock, 'branch-false');
+    }
+
+    return mergeBlock;
+  }
+
+  private handleWhile(node: SyntaxNode, currentBlock: BasicBlock, exitBlock: BasicBlock): BasicBlock | null {
+    const headerBlock = this.newBlock('loop-header');
+    this.cfg.addBlock(headerBlock);
+    this.cfg.addEdge(currentBlock, headerBlock, 'sequential');
+
+    const condNode = node.childForFieldName('condition');
+    if (condNode) headerBlock.addStatement(condNode);
+
+    const postLoop = this.newBlock('normal');
+    this.cfg.addBlock(postLoop);
+
+    const body = node.childForFieldName('body');
+    const bodyBlock = this.newBlock('normal');
+    this.cfg.addBlock(bodyBlock);
+    this.cfg.addEdge(headerBlock, bodyBlock, 'branch-true');
+    this.cfg.addEdge(headerBlock, postLoop, 'loop-exit');
+
+    let bodyEnd: BasicBlock | null = bodyBlock;
+    if (body) bodyEnd = this.processBlockOrStatement(body, bodyBlock, exitBlock);
+    if (bodyEnd) this.cfg.addEdge(bodyEnd, headerBlock, 'loop-back');
+
+    return postLoop;
+  }
+
+  private handleFor(node: SyntaxNode, currentBlock: BasicBlock, exitBlock: BasicBlock): BasicBlock | null {
+    const init = node.childForFieldName('initializer');
+    if (init) currentBlock.addStatement(init);
+
+    const headerBlock = this.newBlock('loop-header');
+    this.cfg.addBlock(headerBlock);
+    this.cfg.addEdge(currentBlock, headerBlock, 'sequential');
+
+    const condNode = node.childForFieldName('condition');
+    if (condNode) headerBlock.addStatement(condNode);
+
+    const postLoop = this.newBlock('normal');
+    this.cfg.addBlock(postLoop);
+
+    const body = node.childForFieldName('body');
+    const bodyBlock = this.newBlock('normal');
+    this.cfg.addBlock(bodyBlock);
+    this.cfg.addEdge(headerBlock, bodyBlock, 'branch-true');
+    this.cfg.addEdge(headerBlock, postLoop, 'loop-exit');
+
+    let bodyEnd: BasicBlock | null = bodyBlock;
+    if (body) bodyEnd = this.processBlockOrStatement(body, bodyBlock, exitBlock);
+
+    const increment = node.childForFieldName('increment');
+    if (increment && bodyEnd) bodyEnd.addStatement(increment);
+    if (bodyEnd) this.cfg.addEdge(bodyEnd, headerBlock, 'loop-back');
+
+    return postLoop;
+  }
+
+  private handleTryCatch(node: SyntaxNode, currentBlock: BasicBlock, exitBlock: BasicBlock): BasicBlock | null {
+    const mergeBlock = this.newBlock('normal');
+    this.cfg.addBlock(mergeBlock);
+
+    const tryBody = node.childForFieldName('body');
+    const tryBlock = this.newBlock('normal');
+    this.cfg.addBlock(tryBlock);
+    this.cfg.addEdge(currentBlock, tryBlock, 'sequential');
+
+    let tryEnd: BasicBlock | null = tryBlock;
+    if (tryBody) tryEnd = this.processBlockOrStatement(tryBody, tryBlock, exitBlock);
+    if (tryEnd) this.cfg.addEdge(tryEnd, mergeBlock, 'sequential');
+
+    const handler = node.childForFieldName('handler');
+    if (handler) {
+      const catchBlock = this.newBlock('catch');
+      this.cfg.addBlock(catchBlock);
+      this.cfg.addEdge(tryBlock, catchBlock, 'exception');
+
+      const catchBody = handler.childForFieldName('body');
+      let catchEnd: BasicBlock | null = catchBlock;
+      if (catchBody) catchEnd = this.processBlockOrStatement(catchBody, catchBlock, exitBlock);
+      if (catchEnd) this.cfg.addEdge(catchEnd, mergeBlock, 'sequential');
+    }
+
+    const finalizer = node.childForFieldName('finalizer');
+    if (finalizer) {
+      const finallyBlock = this.newBlock('normal');
+      this.cfg.addBlock(finallyBlock);
+      this.cfg.addEdge(mergeBlock, finallyBlock, 'sequential');
+      const finallyBody = finalizer.namedChild(0);
+      if (finallyBody) this.processBlockOrStatement(finallyBody, finallyBlock, exitBlock);
+      return finallyBlock;
+    }
+
+    return mergeBlock;
+  }
+
+  private handleSwitch(node: SyntaxNode, currentBlock: BasicBlock, exitBlock: BasicBlock): BasicBlock | null {
+    const value = node.childForFieldName('value');
+    if (value) currentBlock.addStatement(value);
+
+    const mergeBlock = this.newBlock('normal');
+    this.cfg.addBlock(mergeBlock);
+
+    const body = node.childForFieldName('body');
+    if (!body) return mergeBlock;
+
+    for (let i = 0; i < body.namedChildCount; i++) {
+      const caseNode = body.namedChild(i);
+      if (!caseNode) continue;
+
+      const caseBlock = this.newBlock('normal');
+      this.cfg.addBlock(caseBlock);
+      this.cfg.addEdge(currentBlock, caseBlock, 'branch-true');
+
+      let caseEnd: BasicBlock | null = caseBlock;
+      for (let j = 0; j < caseNode.namedChildCount; j++) {
+        const stmt = caseNode.namedChild(j);
+        if (!stmt || !caseEnd) break;
+        if (stmt.type === 'switch_case' || stmt.type === 'switch_default') continue;
+        caseEnd = this.processStatement(stmt, caseEnd, exitBlock);
+      }
+      if (caseEnd) this.cfg.addEdge(caseEnd, mergeBlock, 'sequential');
+    }
+
+    return mergeBlock;
+  }
+
+  private processBlockOrStatement(node: SyntaxNode, currentBlock: BasicBlock, exitBlock: BasicBlock): BasicBlock | null {
+    if (node.type === 'statement_block' || node.type === 'block') {
+      return this.processStatements(node, currentBlock, exitBlock);
+    }
+    return this.processStatement(node, currentBlock, exitBlock);
+  }
+
+  private newBlock(type: BasicBlock['type']): BasicBlock {
+    return new BasicBlock(this.blockCounter++, type);
+  }
+}

package/src/engine/analyzers/security/cfg/CFGEdge.ts

@@ -0,0 +1,24 @@
+/**
+ * KSA-164: CFG Edge — Represents control flow between basic blocks.
+ */
+
+import type { EdgeType } from '../types.js';
+import type { BasicBlock } from './BasicBlock.js';
+
+export class CFGEdge {
+  readonly from: BasicBlock;
+  readonly to: BasicBlock;
+  readonly type: EdgeType;
+  readonly label?: string;
+
+  constructor(from: BasicBlock, to: BasicBlock, type: EdgeType, label?: string) {
+    this.from = from;
+    this.to = to;
+    this.type = type;
+    this.label = label;
+  }
+
+  toString(): string {
+    return `B${this.from.id} -[${this.type}]-> B${this.to.id}`;
+  }
+}

package/src/engine/analyzers/security/cfg/ControlFlowGraph.ts

@@ -0,0 +1,102 @@
+/**
+ * KSA-164: Control Flow Graph — Container for basic blocks and edges.
+ */
+
+import { BasicBlock } from './BasicBlock.js';
+import { CFGEdge } from './CFGEdge.js';
+import type { EdgeType } from '../types.js';
+
+export class ControlFlowGraph {
+  readonly entry: BasicBlock;
+  readonly exits: BasicBlock[] = [];
+  readonly blocks: BasicBlock[] = [];
+  readonly edges: CFGEdge[] = [];
+  private adjacency: Map<number, CFGEdge[]> = new Map();
+  private reverseAdj: Map<number, CFGEdge[]> = new Map();
+
+  constructor(entry: BasicBlock) {
+    this.entry = entry;
+    this.addBlock(entry);
+  }
+
+  addBlock(block: BasicBlock): void {
+    this.blocks.push(block);
+    this.adjacency.set(block.id, []);
+    this.reverseAdj.set(block.id, []);
+    if (block.type === 'exit') this.exits.push(block);
+  }
+
+  addEdge(from: BasicBlock, to: BasicBlock, type: EdgeType, label?: string): CFGEdge {
+    const edge = new CFGEdge(from, to, type, label);
+    this.edges.push(edge);
+    this.adjacency.get(from.id)!.push(edge);
+    this.reverseAdj.get(to.id)!.push(edge);
+    return edge;
+  }
+
+  getSuccessors(block: BasicBlock): BasicBlock[] {
+    return (this.adjacency.get(block.id) ?? []).map(e => e.to);
+  }
+
+  getPredecessors(block: BasicBlock): BasicBlock[] {
+    return (this.reverseAdj.get(block.id) ?? []).map(e => e.from);
+  }
+
+  getOutEdges(block: BasicBlock): CFGEdge[] {
+    return this.adjacency.get(block.id) ?? [];
+  }
+
+  getInEdges(block: BasicBlock): CFGEdge[] {
+    return this.reverseAdj.get(block.id) ?? [];
+  }
+
+  /** Topological sort using DFS (for acyclic portions). */
+  topologicalOrder(): BasicBlock[] {
+    const visited = new Set<number>();
+    const result: BasicBlock[] = [];
+
+    const dfs = (block: BasicBlock) => {
+      if (visited.has(block.id)) return;
+      visited.add(block.id);
+      for (const succ of this.getSuccessors(block)) {
+        dfs(succ);
+      }
+      result.unshift(block);
+    };
+
+    dfs(this.entry);
+    return result;
+  }
+
+  /** Reverse post-order traversal (optimal for dataflow iteration). */
+  reversePostOrder(): BasicBlock[] {
+    const visited = new Set<number>();
+    const postOrder: BasicBlock[] = [];
+
+    const dfs = (block: BasicBlock) => {
+      if (visited.has(block.id)) return;
+      visited.add(block.id);
+      for (const succ of this.getSuccessors(block)) {
+        dfs(succ);
+      }
+      postOrder.push(block);
+    };
+
+    dfs(this.entry);
+    return postOrder.reverse();
+  }
+
+  /** Get block by ID. */
+  getBlock(id: number): BasicBlock | undefined {
+    return this.blocks.find(b => b.id === id);
+  }
+
+  /** Summary for debugging. */
+  toString(): string {
+    const lines = [`CFG: ${this.blocks.length} blocks, ${this.edges.length} edges`];
+    for (const edge of this.edges) {
+      lines.push(`  ${edge.toString()}`);
+    }
+    return lines.join('\n');
+  }
+}

package/src/engine/analyzers/security/dataflow/DataFlowAnalyzer.ts

@@ -0,0 +1,78 @@
+/**
+ * KSA-164: Data Flow Analyzer — Computes def-use chains from CFG + reaching definitions.
+ */
+
+import { ControlFlowGraph } from '../cfg/ControlFlowGraph.js';
+import { ReachingDefinitions } from './ReachingDefinitions.js';
+import type { DataFlowResult, DefUseChain, Definition } from '../types.js';
+
+export class DataFlowAnalyzer {
+  private reachingDefs = new ReachingDefinitions();
+
+  /** Analyze data flow for a control flow graph. */
+  analyze(cfg: ControlFlowGraph): DataFlowResult {
+    const reaching = this.reachingDefs.compute(cfg);
+    const allDefs = this.collectAllDefinitions(cfg);
+    const chains = this.buildDefUseChains(cfg, reaching, allDefs);
+
+    return {
+      reachingDefs: reaching,
+      defUseChains: chains,
+      definitions: allDefs,
+    };
+  }
+
+  /** Collect all definitions across all blocks. */
+  private collectAllDefinitions(cfg: ControlFlowGraph): Definition[] {
+    const defs: Definition[] = [];
+    let id = 0;
+    for (const block of cfg.blocks) {
+      for (const varDef of block.getDefinitions()) {
+        defs.push({
+          variable: varDef.name,
+          line: varDef.line,
+          blockId: block.id,
+          id: id++,
+        });
+      }
+    }
+    return defs;
+  }
+
+  /** Build def-use chains: for each definition, find all uses that it reaches. */
+  private buildDefUseChains(
+    cfg: ControlFlowGraph,
+    reaching: Map<number, Set<Definition>>,
+    allDefs: Definition[]
+  ): DefUseChain[] {
+    const chains: DefUseChain[] = [];
+
+    for (const def of allDefs) {
+      const uses: Array<{ line: number; blockId: number }> = [];
+
+      for (const block of cfg.blocks) {
+        const reachingHere = reaching.get(block.id);
+        if (!reachingHere) continue;
+
+        // Check if this definition reaches this block
+        const reaches = Array.from(reachingHere).some(
+          d => d.variable === def.variable && d.line === def.line && d.blockId === def.blockId
+        );
+        if (!reaches) continue;
+
+        // Find uses of this variable in the block
+        for (const use of block.getUses()) {
+          if (use.name === def.variable) {
+            uses.push({ line: use.line, blockId: block.id });
+          }
+        }
+      }
+
+      if (uses.length > 0) {
+        chains.push({ definition: def, uses });
+      }
+    }
+
+    return chains;
+  }
+}

package/src/engine/analyzers/security/dataflow/ReachingDefinitions.ts

@@ -0,0 +1,91 @@
+/**
+ * KSA-164: Reaching Definitions — Iterative dataflow algorithm.
+ * Computes which definitions reach each basic block.
+ */
+
+import { BasicBlock } from '../cfg/BasicBlock.js';
+import { ControlFlowGraph } from '../cfg/ControlFlowGraph.js';
+import type { Definition } from '../types.js';
+
+export class ReachingDefinitions {
+  private defCounter = 0;
+
+  /** Compute reaching definitions for all blocks in the CFG. */
+  compute(cfg: ControlFlowGraph): Map<number, Set<Definition>> {
+    const IN = new Map<number, Set<Definition>>();
+    const OUT = new Map<number, Set<Definition>>();
+
+    // Initialize
+    for (const block of cfg.blocks) {
+      IN.set(block.id, new Set());
+      OUT.set(block.id, this.gen(block));
+    }
+
+    // Iterate until fixed point
+    let changed = true;
+    let iterations = 0;
+    const MAX_ITERATIONS = 100;
+
+    while (changed && iterations < MAX_ITERATIONS) {
+      changed = false;
+      iterations++;
+
+      for (const block of cfg.reversePostOrder()) {
+        // IN[B] = union of OUT[P] for all predecessors P
+        const newIN = new Set<Definition>();
+        for (const pred of cfg.getPredecessors(block)) {
+          const predOut = OUT.get(pred.id);
+          if (predOut) {
+            for (const def of predOut) newIN.add(def);
+          }
+        }
+        IN.set(block.id, newIN);
+
+        // OUT[B] = GEN[B] union (IN[B] - KILL[B])
+        const genSet = this.gen(block);
+        const newOUT = new Set<Definition>(genSet);
+        for (const def of newIN) {
+          if (!this.kills(block, def)) {
+            newOUT.add(def);
+          }
+        }
+
+        const oldOUT = OUT.get(block.id)!;
+        if (!this.setsEqual(oldOUT, newOUT)) {
+          OUT.set(block.id, newOUT);
+          changed = true;
+        }
+      }
+    }
+
+    return IN;
+  }
+
+  /** GEN set: definitions created in this block. */
+  private gen(block: BasicBlock): Set<Definition> {
+    const defs = new Set<Definition>();
+    for (const varDef of block.getDefinitions()) {
+      defs.add({
+        variable: varDef.name,
+        line: varDef.line,
+        blockId: block.id,
+        id: this.defCounter++,
+      });
+    }
+    return defs;
+  }
+
+  /** Check if a block kills a definition (redefines the same variable). */
+  private kills(block: BasicBlock, def: Definition): boolean {
+    const blockDefs = block.getDefinitions();
+    return blockDefs.some(d => d.name === def.variable && d.blockId === block.id);
+  }
+
+  private setsEqual(a: Set<Definition>, b: Set<Definition>): boolean {
+    if (a.size !== b.size) return false;
+    for (const item of a) {
+      if (!b.has(item)) return false;
+    }
+    return true;
+  }
+}