al-sem 0.0.1

package/src/index/intraprocedural-body.ts

@@ -0,0 +1,1467 @@
+// src/index/intraprocedural-body.ts
+// Single-DFS body walker: loops + record ops + commits + call sites + field accesses.
+//
+// Previously the routine-indexer drove TWO separate full-body traversals — one in
+// `extractOpsAndLoops` (loops + record-ops + commits) and one in `extractRefs` (call
+// sites + field accesses). Each traversal walked `namedChildren` recursively through
+// FFI; combined, they did 2× the work. On Microsoft Base Application that was a
+// significant chunk of the per-file cost.
+//
+// This module fuses both passes. The walker maintains an ambient `loopStack` (so
+// call sites' `loopStack` is populated directly — no post-pass back-fill), and it
+// handles `call_expression` nodes structurally: only the argument list is recursed
+// into, so the function-callee subtree (`member_expression` or `identifier`) is
+// never re-examined as a stray field access. That structural skip removes the
+// previous `node.parent`/`.id`-based "is this a callee?" check that called FFI on
+// every member-expression descendant.
+
+import type {
+	CallArgumentBinding,
+	CallSite,
+	ConditionReference,
+	ControlFlowNode,
+	FieldAccess,
+	LoopNode,
+	LoopType,
+	OperationSite,
+	ParameterSymbol,
+	RecordOpType,
+	RecordOperation,
+	RecordVariable,
+	UnreachableStatement,
+	VarAssignment,
+} from "../model/entities.ts";
+import type { ExpressionInfo } from "../model/expression.ts";
+import {
+	type LoopId,
+	type RoutineId,
+	encodeCallsiteId,
+	encodeLoopId,
+	encodeOperationId,
+} from "../model/ids.ts";
+import { nodeToSourceRange } from "../parser/ast.ts";
+import type { Node as SyntaxNode } from "../parser/native/wrapper.ts";
+import { calleeFromNode } from "./callee-from-node.ts";
+import { expressionInfoFromNode } from "./expression-from-node.ts";
+
+const LOOP_TYPE_MAP: Record<string, LoopType> = {
+	repeat_statement: "repeat",
+	for_statement: "for",
+	foreach_statement: "foreach",
+	while_statement: "while",
+};
+
+/** Canonical record-op name (lowercase) -> properly-cased RecordOpType. */
+const RECORD_OP_MAP: Record<string, RecordOpType> = {
+	findset: "FindSet",
+	findfirst: "FindFirst",
+	findlast: "FindLast",
+	find: "Find",
+	get: "Get",
+	calcfields: "CalcFields",
+	calcsums: "CalcSums",
+	testfield: "TestField",
+	modify: "Modify",
+	modifyall: "ModifyAll",
+	insert: "Insert",
+	delete: "Delete",
+	deleteall: "DeleteAll",
+	setloadfields: "SetLoadFields",
+	addloadfields: "AddLoadFields",
+	setrange: "SetRange",
+	setfilter: "SetFilter",
+	setcurrentkey: "SetCurrentKey",
+	reset: "Reset",
+	copy: "Copy",
+	transferfields: "TransferFields",
+	validate: "Validate",
+	init: "Init",
+	next: "Next",
+	count: "Count",
+	countapprox: "CountApprox",
+	isempty: "IsEmpty",
+	locktable: "LockTable",
+};
+
+/**
+ * Record ops for which we capture all field arguments.
+ *
+ * Includes `Get`, `Find`, `FindFirst`, `FindLast`, `FindSet` so that D4 (repeated
+ * identical lookup in a loop) can read the first argument (the key expression) and
+ * detect duplicate calls with the same literal key.
+ */
+const FIELD_ARGS_OPS = new Set([
+	"SetRange",
+	"SetFilter",
+	"SetLoadFields",
+	"AddLoadFields",
+	"SetCurrentKey",
+	"Validate",
+	"Get",
+	"Find",
+	"FindFirst",
+	"FindLast",
+	"FindSet",
+	"CalcFields",
+	"CalcSums",
+	"TestField",
+]);
+
+export interface ExtractBodyResult {
+	loops: LoopNode[];
+	operationSites: OperationSite[];
+	recordOperations: RecordOperation[];
+	callSites: CallSite[];
+	fieldAccesses: FieldAccess[];
+	unreachableStatements: UnreachableStatement[];
+	/** True iff the visitor saw any branching node (if/case/case_branch/try). */
+	hasBranching: boolean;
+	/**
+	 * Compact control-flow tree rooted at the routine's code_block. Populated
+	 * alongside the flat feature lists and consumed by the path-aware walker in
+	 * P6.T2. Uses the same op/callsite IDs as the flat lists.
+	 */
+	statementTree: ControlFlowNode;
+	/**
+	 * Set of identifier names referenced as values in the body — lowercased,
+	 * sorted, deduped. Excludes member-of-member-expression (field/method names),
+	 * value-of-qualified-enum (enum members), and bare-type-name in enum-type
+	 * position. Used by D19 (unused parameter) and any detector that needs a
+	 * cheap "is this name referenced anywhere?" query.
+	 */
+	identifierReferences: string[];
+	/**
+	 * Var-assignment stream — every `<lhs> := <rhs>` statement in the body
+	 * where the LHS is an identifier or member_expression. RHS literal is
+	 * captured when the RHS node is a boolean / integer / string_literal.
+	 * Sorted by source position. Phase 3 D43 consumes this.
+	 */
+	varAssignments: VarAssignment[];
+	/**
+	 * Identifiers referenced in a control-predicate position (if-test,
+	 * while-test, repeat-until, case-of subject). Sorted by referenceAnchor.
+	 * Phase 3.1 D43 dispatch-site guard detection consumes this.
+	 */
+	conditionReferences: ConditionReference[];
+}
+
+/**
+ * Build the per-argument structural bindings for a callsite. Caller-side fields
+ * only — callee-side var-ness and bindingResolution upgrades happen later when
+ * the call-resolver matches the callsite against a callee signature.
+ */
+function extractArgumentBindings(
+	argumentNodes: SyntaxNode[],
+	enclosingRoutineParameters: ParameterSymbol[],
+	enclosingRoutineRecordVariables: RecordVariable[],
+	sourceUnitId: string,
+	routineId: RoutineId,
+): CallArgumentBinding[] {
+	const recVarByLcName = new Map(
+		enclosingRoutineRecordVariables.map((rv) => [rv.name.toLowerCase(), rv]),
+	);
+	const paramByLcName = new Map(enclosingRoutineParameters.map((p) => [p.name.toLowerCase(), p]));
+	return argumentNodes.map((argNode, parameterIndex): CallArgumentBinding => {
+		const text = argNode.text.trim();
+		const argumentAnchor: CallArgumentBinding["argumentAnchor"] = {
+			sourceUnitId,
+			range: nodeToSourceRange(argNode),
+			enclosingRoutineId: routineId,
+			syntaxKind: argNode.type,
+		};
+		// Only bare-identifier args can bind to a record/parameter symbol. The grammar
+		// surfaces this directly as `argNode.type === "identifier"` — anything else
+		// (literals, calls, member expressions, quoted identifiers, etc.) is a value
+		// expression that flows by-value and can't carry record-flow semantics.
+		if (argNode.type !== "identifier") {
+			return {
+				parameterIndex,
+				sourceKind: "expression",
+				calleeParameterIsVar: false,
+				argumentAnchor,
+				bindingResolution: "non-record-arg",
+			};
+		}
+		const lcName = text.toLowerCase();
+		const recVar = recVarByLcName.get(lcName);
+		const param = paramByLcName.get(lcName);
+		const sourceKind: CallArgumentBinding["sourceKind"] =
+			param !== undefined
+				? "parameter"
+				: recVar !== undefined
+					? "local"
+					: lcName === "rec" || lcName === "xrec"
+						? "implicit-rec"
+						: "unknown";
+		return {
+			parameterIndex,
+			sourceKind,
+			// Per the field doc on CallArgumentBinding, `sourceVariableName` is set for
+			// named-variable kinds only. An identifier we cannot resolve to any local /
+			// parameter / implicit-Rec gets sourceKind === "unknown" and no name.
+			sourceVariableName: sourceKind === "unknown" ? undefined : lcName,
+			sourceRecordVariableId: recVar?.id,
+			sourceParameterIndex: param?.index,
+			callerSourceParameterIsVar: param?.isVar,
+			// `undefined` here means "not yet resolved" — the Phase 2 call-resolver will
+			// upgrade it. `"unknown"` is reserved for "tried and failed to resolve",
+			// which is a Phase 2+ outcome.
+			sourceTableId: recVar?.tableId,
+			sourceTempState: recVar?.tempState,
+			argumentAnchor,
+			calleeParameterIsVar: false, // upgraded by call-resolver later
+			bindingResolution: recVar !== undefined ? "unresolved-callee" : "non-record-arg",
+		};
+	});
+}
+
+/**
+ * Extract the LHS identifier name from an assignment target node.
+ * - `identifier` → the identifier text directly.
+ * - `member_expression` → the trailing member field (`Rec.Field := ...` → "field").
+ * Returns `undefined` for any other shape.
+ */
+function lhsIdentifierOf(target: SyntaxNode): string | undefined {
+	if (target.type === "identifier") return target.text;
+	if (target.type === "member_expression") {
+		const member =
+			target.childForFieldName("member") ?? target.namedChild(target.namedChildCount - 1);
+		return member?.text;
+	}
+	return undefined;
+}
+
+/**
+ * Extract a lowercased literal string from an RHS value node, or `undefined`
+ * when the node is not a recognized literal.
+ *
+ * Tree-sitter-al literal types (confirmed via probe):
+ *   - `boolean`       → "true" / "false" (lowercased)
+ *   - `integer`       → decimal digits
+ *   - `string_literal` → AL single-quoted string; surrounding `'` are stripped
+ *                        and the bare content is lowercased
+ */
+function literalTextOf(value: SyntaxNode): string | undefined {
+	if (value.type === "boolean") return value.text.toLowerCase();
+	if (value.type === "integer") return value.text;
+	if (value.type === "string_literal") {
+		// AL string literals are single-quoted (e.g. `'foo'`). Strip exactly one
+		// leading and trailing `'` before lowercasing so consumers see the bare
+		// content per `VarAssignment.rhsLiteralValue`'s "lowercased" contract.
+		const raw = value.text;
+		const stripped =
+			raw.length >= 2 && raw.startsWith("'") && raw.endsWith("'") ? raw.slice(1, -1) : raw;
+		return stripped.toLowerCase();
+	}
+	return undefined;
+}
+
+/**
+ * Collect every `<lhs> := <rhs>` assignment in the routine body where the LHS
+ * is an `identifier` or `member_expression`. Results are sorted by source
+ * position for deterministic output.
+ */
+function collectVarAssignments(
+	bodyNode: SyntaxNode,
+	routineId: RoutineId,
+	sourceUnitId: string,
+): VarAssignment[] {
+	const out: VarAssignment[] = [];
+	const stack: SyntaxNode[] = [bodyNode];
+	while (stack.length > 0) {
+		const n = stack.pop();
+		if (!n) continue;
+		if (n.type === "assignment_statement") {
+			// Match the field-accessor pattern in variable-initializer-extractor.ts:
+			// prefer named-field accessors, fall back to positional named children.
+			// This insulates the indexer from minor grammar-field renames.
+			const target =
+				n.childForFieldName("left") ?? n.childForFieldName("target") ?? n.namedChild(0);
+			const value =
+				n.childForFieldName("right") ??
+				n.childForFieldName("value") ??
+				n.namedChild(n.namedChildCount - 1);
+			if (target && value) {
+				const lhsName = lhsIdentifierOf(target);
+				if (lhsName !== undefined) {
+					out.push({
+						lhsName: lhsName.toLowerCase(),
+						rhsLiteralValue: literalTextOf(value),
+						sourceAnchor: {
+							sourceUnitId,
+							range: nodeToSourceRange(n),
+							enclosingRoutineId: routineId,
+							syntaxKind: n.type,
+						},
+					});
+				}
+			}
+		}
+		for (let i = 0; i < n.namedChildCount; i++) {
+			const c = n.namedChild(i);
+			if (c) stack.push(c);
+		}
+	}
+	out.sort((a, b) => {
+		const ar = a.sourceAnchor.range;
+		const br = b.sourceAnchor.range;
+		return ar.startLine - br.startLine || ar.startColumn - br.startColumn;
+	});
+	return out;
+}
+
+/**
+ * Collect every identifier referenced in a control-predicate position in the
+ * routine body: if-test, while-test, repeat-until, case-of subject. Walks
+ * compound expressions recursively so `A and not IsHandled` captures both
+ * identifiers. For member expressions, only the trailing member name is
+ * captured (the receiver is not a predicate operand). Results are sorted by
+ * referenceAnchor position for deterministic output.
+ *
+ * Grammar field names (confirmed by probe):
+ *   if_statement    → childForFieldName("condition")
+ *   while_statement → childForFieldName("condition")
+ *   repeat_statement → childForFieldName("condition")   (the until-expr)
+ *   case_statement  → childForFieldName("expression")   (NOT "subject")
+ */
+function collectConditionReferences(
+	bodyNode: SyntaxNode,
+	routineId: RoutineId,
+	sourceUnitId: string,
+): ConditionReference[] {
+	const out: ConditionReference[] = [];
+
+	function sourceAnchorOf(n: SyntaxNode): ConditionReference["referenceAnchor"] {
+		return {
+			sourceUnitId,
+			range: nodeToSourceRange(n),
+			enclosingRoutineId: routineId,
+			syntaxKind: n.type,
+		};
+	}
+
+	function collectIdentifiersInExpression(
+		expr: SyntaxNode | null,
+		kind: ConditionReference["conditionKind"],
+		stmt: ConditionReference["statementAnchor"],
+	): void {
+		if (!expr) return;
+		if (expr.type === "identifier") {
+			out.push({
+				identifier: expr.text.toLowerCase(),
+				conditionKind: kind,
+				statementAnchor: stmt,
+				referenceAnchor: sourceAnchorOf(expr),
+			});
+			return;
+		}
+		if (expr.type === "member_expression") {
+			const member = expr.childForFieldName("member") ?? expr.namedChild(expr.namedChildCount - 1);
+			if (member?.type === "identifier") {
+				out.push({
+					identifier: member.text.toLowerCase(),
+					conditionKind: kind,
+					statementAnchor: stmt,
+					referenceAnchor: sourceAnchorOf(member),
+				});
+			}
+			return;
+		}
+		for (let i = 0; i < expr.namedChildCount; i++) {
+			collectIdentifiersInExpression(expr.namedChild(i), kind, stmt);
+		}
+	}
+
+	const stack: SyntaxNode[] = [bodyNode];
+	while (stack.length > 0) {
+		const n = stack.pop();
+		if (!n) continue;
+		if (n.type === "if_statement") {
+			const cond = n.childForFieldName("condition");
+			if (cond) {
+				const stmt = sourceAnchorOf(n);
+				collectIdentifiersInExpression(cond, "if", stmt);
+			}
+		} else if (n.type === "while_statement") {
+			const cond = n.childForFieldName("condition");
+			if (cond) {
+				const stmt = sourceAnchorOf(n);
+				collectIdentifiersInExpression(cond, "while", stmt);
+			}
+		} else if (n.type === "repeat_statement") {
+			const cond = n.childForFieldName("condition");
+			if (cond) {
+				const stmt = sourceAnchorOf(n);
+				collectIdentifiersInExpression(cond, "repeat-until", stmt);
+			}
+		} else if (n.type === "case_statement") {
+			// field name is "expression" (confirmed by grammar probe)
+			const subj = n.childForFieldName("expression");
+			if (subj) {
+				const stmt = sourceAnchorOf(n);
+				collectIdentifiersInExpression(subj, "case", stmt);
+			}
+		}
+		// Always recurse into all named children to find nested statements
+		for (let i = 0; i < n.namedChildCount; i++) {
+			const c = n.namedChild(i);
+			if (c) stack.push(c);
+		}
+	}
+
+	out.sort((a, b) => {
+		const ar = a.referenceAnchor.range;
+		const br = b.referenceAnchor.range;
+		return ar.startLine - br.startLine || ar.startColumn - br.startColumn;
+	});
+	return out;
+}
+
+/**
+ * Walk a routine body once, emitting every L1 feature the indexer needs.
+ *
+ * Operation-id ordering matches the previous two-pass implementation: record-ops
+ * and commits get ids 0..N-1 (in body DFS order), call sites get ids N..N+M-1
+ * (also in body DFS order). The two streams are collected during the walk and
+ * assigned final operation ids after — that's why call-site `operationId` is
+ * filled in post-walk.
+ */
+export function extractBodyFeatures(
+	bodyNode: SyntaxNode,
+	routineId: RoutineId,
+	sourceUnitId: string,
+	recordVarNames: Set<string>,
+	enclosingParameters: ParameterSymbol[],
+	enclosingRecordVariables: RecordVariable[],
+): ExtractBodyResult {
+	const loops: LoopNode[] = [];
+	const operationSites: OperationSite[] = [];
+	const recordOperations: RecordOperation[] = [];
+	const callSites: CallSite[] = [];
+	const fieldAccesses: FieldAccess[] = [];
+	const unreachableStatements: UnreachableStatement[] = [];
+	const identifierRefSet = new Set<string>();
+
+	/**
+	 * Walk an arbitrary subtree and add every value-position identifier to
+	 * `identifierRefSet`. Used inside `handleCallExpression` for the callee subtree
+	 * (which the main visitor skips for performance) so the receiver in
+	 * `Other.SetRange(...)` and the callee name in `Helper(x)` are captured.
+	 *
+	 * Same exclusion rules as the identifier hook in `visit()` — skips the
+	 * `member` field of `member_expression`, the `value` field of
+	 * `qualified_enum_value`, and bare type names in `enum_type` position.
+	 */
+	function collectIdentifiersFrom(root: SyntaxNode): void {
+		const stack: { node: SyntaxNode; parent: SyntaxNode | null }[] = [{ node: root, parent: null }];
+		while (stack.length > 0) {
+			const item = stack.pop();
+			if (item === undefined) continue;
+			const { node, parent } = item;
+			if (node.type === "identifier" && parent !== null) {
+				const parentType = parent.type;
+				let isValueRef = true;
+				if (parentType === "member_expression") {
+					const memberField = parent.childForFieldName("member");
+					if (memberField !== null && memberField.startIndex === node.startIndex) {
+						isValueRef = false;
+					}
+				} else if (parentType === "qualified_enum_value") {
+					const valueField = parent.childForFieldName("value");
+					const enumTypeField = parent.childForFieldName("enum_type");
+					if (valueField !== null && valueField.startIndex === node.startIndex) {
+						isValueRef = false;
+					} else if (
+						enumTypeField !== null &&
+						enumTypeField.startIndex === node.startIndex &&
+						enumTypeField.type === "identifier"
+					) {
+						isValueRef = false;
+					}
+				}
+				if (isValueRef) identifierRefSet.add(node.text.toLowerCase());
+			}
+			for (const child of node.namedChildren) {
+				if (child !== null) stack.push({ node: child, parent: node });
+			}
+		}
+	}
+
+	const loopStack: LoopId[] = [];
+	let opIndex = 0;
+	let csIndex = 0;
+	let unreachableIndex = 0;
+	let hasBranching = false;
+
+	// Maps from tree-sitter Node.id (unique per node within a tree) to the op/callsite
+	// ID assigned during the visit pass. Used post-visit to build the statement tree
+	// without a second DFS.
+	//
+	// Keyed by `node.id` rather than `startIndex` because chained-receiver expressions
+	// (e.g. `Helper(C).FindSet()`) produce nested `call_expression` nodes that share
+	// the same `startIndex` — keying by `startIndex` collapses them and silently drops
+	// the inner call. `Node.id` is a per-tree interned identifier that's unique even
+	// for nodes spanning the same source position.
+	const opIdByNodeId = new Map<number, string>();
+	const csIdByNodeId = new Map<number, string>();
+
+	/**
+	 * Classify a statement node as an unconditional exit from the enclosing routine.
+	 * Recognised shapes (case-insensitive):
+	 *  - `exit_statement` (covers `Exit;` and `Exit(value);`)
+	 *  - bare `call_expression` whose callee identifier is `Error` (any arity)
+	 *  - `call_expression` whose callee is a `member_expression` `<receiver>.Quit`
+	 *    where receiver is `CurrReport` (the report-runtime exit)
+	 * Returns `undefined` for non-exit statements.
+	 */
+	function unconditionalExitKind(node: SyntaxNode): UnreachableStatement["exitKind"] | undefined {
+		if (node.type === "exit_statement") return "exit";
+		if (node.type !== "call_expression") return undefined;
+		const funcNode = node.childForFieldName("function") ?? node.namedChildren[0];
+		if (!funcNode) return undefined;
+		if (funcNode.type === "identifier" && funcNode.text.toLowerCase() === "error") {
+			return "error";
+		}
+		if (funcNode.type === "member_expression") {
+			const objNode = funcNode.childForFieldName("object") ?? funcNode.namedChildren[0];
+			const memberNode = funcNode.childForFieldName("member") ?? funcNode.namedChildren[1];
+			if (
+				objNode &&
+				memberNode &&
+				objNode.text.toLowerCase() === "currreport" &&
+				memberNode.text.toLowerCase() === "quit"
+			) {
+				return "currreport-quit";
+			}
+		}
+		return undefined;
+	}
+
+	function handleCallExpression(node: SyntaxNode, nodeType: string): void {
+		const funcNode = node.childForFieldName("function") ?? node.namedChildren[0];
+		if (!funcNode) return;
+
+		// Collect identifier-uses from the callee subtree. The main visitor's
+		// "recurse only into argument_list" optimization (below) intentionally
+		// skips the function-callee subtree to avoid re-emitting its member
+		// expressions as stray field accesses — but D19 still needs to see
+		// receivers (`Other` in `Other.SetRange(...)`) and bare callee names
+		// (`Helper` in `Helper(x)`) as identifier references.
+		collectIdentifiersFrom(funcNode);
+
+		if (funcNode.type === "member_expression") {
+			const memberNode = funcNode.childForFieldName("member") ?? funcNode.namedChildren[1];
+			if (!memberNode) return;
+			const methodLc = memberNode.text.toLowerCase();
+			const opType = RECORD_OP_MAP[methodLc];
+			if (opType !== undefined) {
+				// Record-op site (e.g. SalesLine.SetRange(...)).
+				const objNode = funcNode.childForFieldName("object") ?? funcNode.namedChildren[0];
+				const receiver = objNode ? objNode.text : "";
+				let fieldArguments: string[] | undefined;
+				let fieldArgumentInfos: ExpressionInfo[] | undefined;
+				if (FIELD_ARGS_OPS.has(opType)) {
+					const argListNode = node.namedChildren.find(
+						(c) => c !== null && c.type === "argument_list",
+					);
+					if (argListNode) {
+						const args: string[] = [];
+						const infos: ExpressionInfo[] = [];
+						for (const arg of argListNode.namedChildren) {
+							if (arg !== null) {
+								args.push(arg.text);
+								infos.push(expressionInfoFromNode(arg));
+							}
+						}
+						fieldArguments = args;
+						fieldArgumentInfos = infos;
+					}
+				}
+				const anchor = {
+					sourceUnitId,
+					range: nodeToSourceRange(node),
+					enclosingRoutineId: routineId,
+					syntaxKind: nodeType,
+				};
+				const opId = encodeOperationId(routineId, opIndex++);
+				opIdByNodeId.set(node.id, opId);
+				const snapshotLoopStack = loopStack.slice();
+				recordOperations.push({
+					id: opId,
+					routineId,
+					op: opType,
+					recordVariableName: receiver,
+					tempState: { kind: "unknown" },
+					fieldArguments,
+					...(fieldArgumentInfos !== undefined ? { fieldArgumentInfos } : {}),
+					loopStack: snapshotLoopStack,
+					sourceAnchor: anchor,
+				});
+				operationSites.push({
+					id: opId,
+					routineId,
+					kind: opType === "LockTable" ? "lock" : "record-op",
+					sourceAnchor: anchor,
+					loopStack: snapshotLoopStack,
+				});
+			} else {
+				// Member call that is NOT a record op — emit as a CallSite.
+				const argListNode = node.namedChildren.find(
+					(c) => c !== null && c.type === "argument_list",
+				);
+				const argumentTexts: string[] = [];
+				const argumentInfos: ExpressionInfo[] = [];
+				const argNodes: SyntaxNode[] = [];
+				if (argListNode) {
+					for (const arg of argListNode.namedChildren) {
+						if (arg !== null) {
+							argumentTexts.push(arg.text);
+							argumentInfos.push(expressionInfoFromNode(arg));
+							argNodes.push(arg);
+						}
+					}
+				}
+				const csId = encodeCallsiteId(routineId, csIndex++);
+				csIdByNodeId.set(node.id, csId);
+				callSites.push({
+					id: csId,
+					operationId: "", // filled in post-walk; see assignCallSiteOperationIds below
+					calleeText: funcNode.text,
+					callee: calleeFromNode(node),
+					argumentTexts,
+					argumentInfos,
+					argumentBindings: extractArgumentBindings(
+						argNodes,
+						enclosingParameters,
+						enclosingRecordVariables,
+						sourceUnitId,
+						routineId,
+					),
+					loopStack: loopStack.slice(),
+					sourceAnchor: {
+						sourceUnitId,
+						range: nodeToSourceRange(node),
+						enclosingRoutineId: routineId,
+						syntaxKind: nodeType,
+					},
+				});
+			}
+		} else if (funcNode.type === "identifier") {
+			// Bare call: plain identifier (e.g. EnrichLine, Message, Error, Commit).
+			const methodText = funcNode.text;
+			if (methodText.toLowerCase() === "commit") {
+				const opId = encodeOperationId(routineId, opIndex++);
+				opIdByNodeId.set(node.id, opId);
+				operationSites.push({
+					id: opId,
+					routineId,
+					kind: "commit",
+					sourceAnchor: {
+						sourceUnitId,
+						range: nodeToSourceRange(node),
+						enclosingRoutineId: routineId,
+						syntaxKind: nodeType,
+					},
+					loopStack: loopStack.slice(),
+				});
+			} else {
+				const argListNode = node.namedChildren.find(
+					(c) => c !== null && c.type === "argument_list",
+				);
+				const argumentTexts: string[] = [];
+				const argumentInfos: ExpressionInfo[] = [];
+				const argNodes: SyntaxNode[] = [];
+				if (argListNode) {
+					for (const arg of argListNode.namedChildren) {
+						if (arg !== null) {
+							argumentTexts.push(arg.text);
+							argumentInfos.push(expressionInfoFromNode(arg));
+							argNodes.push(arg);
+						}
+					}
+				}
+				const csId2 = encodeCallsiteId(routineId, csIndex++);
+				csIdByNodeId.set(node.id, csId2);
+				callSites.push({
+					id: csId2,
+					operationId: "",
+					calleeText: methodText,
+					callee: calleeFromNode(node),
+					argumentTexts,
+					argumentInfos,
+					argumentBindings: extractArgumentBindings(
+						argNodes,
+						enclosingParameters,
+						enclosingRecordVariables,
+						sourceUnitId,
+						routineId,
+					),
+					loopStack: loopStack.slice(),
+					sourceAnchor: {
+						sourceUnitId,
+						range: nodeToSourceRange(node),
+						enclosingRoutineId: routineId,
+						syntaxKind: nodeType,
+					},
+				});
+			}
+		}
+
+		// Recurse only into the argument_list children. The function-callee subtree is
+		// already handled above — recursing into it would either re-visit it (no-op) or
+		// risk treating its inner member_expression as a stray field access.
+		const argListNode = node.namedChildren.find((c) => c !== null && c.type === "argument_list");
+		if (argListNode) {
+			for (const child of argListNode.namedChildren) {
+				if (child) visit(child, argListNode);
+			}
+		}
+
+		// Chained-receiver descent (P7.5 review): if the callee is a member_expression
+		// whose object is itself a call (e.g. `Helper(C).FindSet()` — outer is FindSet,
+		// inner Helper lives in the receiver), recursively visit the inner call so it
+		// gets registered as a CallSite. Without this, `harvestExpressionLeaves` can't
+		// surface the receiver call as a sibling leaf because no csId exists for it.
+		if (funcNode.type === "member_expression") {
+			const objNode = funcNode.childForFieldName("object") ?? funcNode.namedChildren[0];
+			if (objNode && objNode.type === "call_expression") {
+				visit(objNode, funcNode);
+			}
+		}
+	}
+
+	/**
+	 * Parents whose direct child IS a statement (no nuance, no condition / body
+	 * disambiguation needed). A member_expression with one of these parents is a
+	 * bare method call written without parens (e.g. `Customer.SetRecFilter;`), not a
+	 * field access — AL has no bare-expression statements that read a field for
+	 * side-effect.
+	 */
+	const PURE_STATEMENT_PARENTS: ReadonlySet<string> = new Set(["code_block"]);
+
+	/**
+	 * Parents that contain expression-position children (condition / variable / start /
+	 * end / iterable / object) and statement-position children (body / then_branch /
+	 * else_branch). The grammar uses positive fields for these — see grammar.js's
+	 * `field('body', ...)` etc.
+	 *
+	 * Map: parentType → set of FIELD NAMES whose child is statement-position. A
+	 * member_expression in any OTHER child position of the same parent is treated as
+	 * expression-position (field access).
+	 *
+	 * `repeat_statement` is special: it has no body field. Its direct children
+	 * `repeat($._statement)` are statement-position; its `condition` field child
+	 * is expression-position. Treated below as "all children except condition are
+	 * statements".
+	 */
+	const STATEMENT_FIELDS_BY_PARENT: ReadonlyMap<string, ReadonlySet<string>> = new Map([
+		["if_statement", new Set(["then_branch", "else_branch"])],
+		["for_statement", new Set(["body"])],
+		["while_statement", new Set(["body"])],
+		["foreach_statement", new Set(["body"])],
+		["with_statement", new Set(["body"])],
+		["case_branch", new Set(["body"])],
+		// repeat_statement handled via "not condition" logic in the visitor itself.
+	]);
+
+	function visit(node: SyntaxNode, parent: SyntaxNode | null): void {
+		const nodeType = node.type;
+		const parentType = parent?.type ?? "";
+
+		// Identifier-reference collection: record every `identifier` node that is in
+		// VALUE position. Skipped:
+		//   - `member` field of `member_expression` — field/method name, not a value
+		//   - `value` field of `qualified_enum_value` — enum option name, not a value
+		//   - direct `enum_type` field of `qualified_enum_value` when the type is a
+		//     bare identifier — that's a type reference, not a variable reference
+		//     (when `enum_type` is a `member_expression`, its inner identifier IS
+		//     a value reference and is visited recursively).
+		// Definition positions (`parameter_list`, `var_section`) are outside the body
+		// code_block we walk, so no extra filter is needed for those.
+		if (nodeType === "identifier" && parent !== null) {
+			let isValueRef = true;
+			if (parentType === "member_expression") {
+				const memberField = parent.childForFieldName("member");
+				if (memberField !== null && memberField.startIndex === node.startIndex) {
+					isValueRef = false;
+				}
+			} else if (parentType === "qualified_enum_value") {
+				const valueField = parent.childForFieldName("value");
+				const enumTypeField = parent.childForFieldName("enum_type");
+				if (valueField !== null && valueField.startIndex === node.startIndex) {
+					isValueRef = false;
+				} else if (
+					enumTypeField !== null &&
+					enumTypeField.startIndex === node.startIndex &&
+					enumTypeField.type === "identifier"
+				) {
+					isValueRef = false;
+				}
+			}
+			if (isValueRef) identifierRefSet.add(node.text.toLowerCase());
+		}
+
+		// Unreachable-after-exit scan: when entering a code_block, walk its statement-position
+		// children pairwise. The first one classified as an unconditional exit, with any
+		// later sibling, marks the rest of the block unreachable. We emit only the FIRST
+		// unreachable sibling (D20 reports per-block, not per-statement) and don't recurse
+		// past the exit — the indexer's normal traversal continues into all children, so
+		// nested code blocks (inside conditionals, loops, etc.) get their own scan.
+		if (nodeType === "code_block") {
+			const stmts = node.namedChildren.filter(
+				(c): c is SyntaxNode =>
+					c !== null && c.type !== "begin_keyword" && c.type !== "end_keyword",
+			);
+			for (let i = 0; i < stmts.length - 1; i++) {
+				const s = stmts[i];
+				if (s === undefined) continue;
+				const exitKind = unconditionalExitKind(s);
+				if (exitKind === undefined) continue;
+				const next = stmts[i + 1];
+				if (next === undefined) break;
+				unreachableStatements.push({
+					id: `${routineId}/u${unreachableIndex++}`,
+					exitKind,
+					exitAnchor: {
+						sourceUnitId,
+						range: nodeToSourceRange(s),
+						enclosingRoutineId: routineId,
+						syntaxKind: s.type,
+					},
+					unreachableAnchor: {
+						sourceUnitId,
+						range: nodeToSourceRange(next),
+						enclosingRoutineId: routineId,
+						syntaxKind: next.type,
+					},
+				});
+				break;
+			}
+		}
+
+		// Branching-control-flow detection. Loops are handled separately by `nestingDepth`;
+		// unconditional early-exit shapes are handled by `unreachableStatements`. This flag
+		// captures everything else that breaks the straight-line assumption — conditional
+		// (`if`/`case`) and exception-handling (`try`) constructs. Used by the Phase 4
+		// control-flow walker (and any future straight-line analysis).
+		if (
+			nodeType === "if_statement" ||
+			nodeType === "case_statement" ||
+			nodeType === "case_branch" ||
+			nodeType === "try_statement"
+		) {
+			hasBranching = true;
+		}
+
+		// Loop detection.
+		const loopType = LOOP_TYPE_MAP[nodeType];
+		let pushedLoop = false;
+		if (loopType !== undefined) {
+			const id = encodeLoopId(routineId, loops.length);
+			loops.push({
+				id,
+				type: loopType,
+				sourceAnchor: {
+					sourceUnitId,
+					range: nodeToSourceRange(node),
+					enclosingRoutineId: routineId,
+					syntaxKind: nodeType,
+				},
+			});
+			loopStack.push(id);
+			pushedLoop = true;
+		}
+
+		if (nodeType === "call_expression") {
+			handleCallExpression(node, nodeType);
+			if (pushedLoop) loopStack.pop();
+			return;
+		}
+
+		if (nodeType === "member_expression") {
+			// Non-callee member_expression (the callee shape exits via handleCallExpression
+			// without recursing back here). Decide between two cases:
+			//   - Statement position (parent is code_block, or a control-flow rule's body
+			//     field): AL has no bare-field-read statements, so `Customer.X;` is a
+			//     parameterless method call. Treat as record-op if X is in the op map,
+			//     otherwise emit as a CallSite so callers/D14 see the dependency.
+			//   - Expression position (parent is assignment_statement, argument_list, or
+			//     a control-flow rule's condition field): treat as a field access on a
+			//     known record var.
+			const objNode = node.childForFieldName("object") ?? node.namedChildren[0];
+			const memberNode = node.childForFieldName("member") ?? node.namedChildren[1];
+			if (objNode && memberNode) {
+				let isStatementPosition = PURE_STATEMENT_PARENTS.has(parentType);
+				if (!isStatementPosition && parent !== null) {
+					const stmtFields = STATEMENT_FIELDS_BY_PARENT.get(parentType);
+					if (stmtFields !== undefined) {
+						// Check whether the member_expression occupies one of the parent's
+						// known statement-position fields.
+						for (const fieldName of stmtFields) {
+							const fieldChild = parent.childForFieldName(fieldName);
+							if (fieldChild !== null && fieldChild.startIndex === node.startIndex) {
+								isStatementPosition = true;
+								break;
+							}
+						}
+					} else if (parentType === "repeat_statement") {
+						// repeat_statement has no body field — every direct child except
+						// the `condition` field is a statement.
+						const conditionChild = parent.childForFieldName("condition");
+						if (conditionChild === null || conditionChild.startIndex !== node.startIndex) {
+							isStatementPosition = true;
+						}
+					}
+				}
+				if (isStatementPosition) {
+					// Parameterless method call written without parens (e.g.
+					// `Customer.SetRecFilter;`). Mirror the `member_expression`-branch
+					// of handleCallExpression, minus argument processing.
+					const methodLc = memberNode.text.toLowerCase();
+					const opType = RECORD_OP_MAP[methodLc];
+					const anchor = {
+						sourceUnitId,
+						range: nodeToSourceRange(node),
+						enclosingRoutineId: routineId,
+						syntaxKind: nodeType,
+					};
+					if (opType !== undefined) {
+						const opId = encodeOperationId(routineId, opIndex++);
+						opIdByNodeId.set(node.id, opId);
+						const snapshotLoopStack = loopStack.slice();
+						recordOperations.push({
+							id: opId,
+							routineId,
+							op: opType,
+							recordVariableName: objNode.text,
+							tempState: { kind: "unknown" },
+							loopStack: snapshotLoopStack,
+							sourceAnchor: anchor,
+						});
+						operationSites.push({
+							id: opId,
+							routineId,
+							kind: opType === "LockTable" ? "lock" : "record-op",
+							sourceAnchor: anchor,
+							loopStack: snapshotLoopStack,
+						});
+					} else {
+						const csId3 = encodeCallsiteId(routineId, csIndex++);
+						csIdByNodeId.set(node.id, csId3);
+						callSites.push({
+							id: csId3,
+							operationId: "",
+							calleeText: node.text,
+							callee: calleeFromNode(node),
+							argumentTexts: [],
+							argumentInfos: [],
+							argumentBindings: [],
+							loopStack: loopStack.slice(),
+							sourceAnchor: anchor,
+						});
+					}
+					if (pushedLoop) loopStack.pop();
+					return;
+				}
+				// Skip `Record.Field::Option` enum-scope references. Tree-sitter-al
+				// wraps these in a `qualified_enum_value` parent; the inner
+				// member_expression is a TYPE-side reference used to resolve the
+				// enum option name at compile time, not a runtime field read. Emitting
+				// it as a fieldAccess causes the path-aware walker (which raises
+				// `requiresLoadedAtEntry` on any field-access against an unloaded
+				// record) to false-positive on loader routines that filter by enum
+				// fields, e.g. `AIField.SetRange(Type, AIField.Type::Header); ... AIField.FindFirst;`.
+				const isEnumScopeRef = parentType === "qualified_enum_value";
+				const recordVariableName = objNode.text;
+				if (!isEnumScopeRef && recordVarNames.has(recordVariableName.toLowerCase())) {
+					// Strip the surrounding double quotes when the field name is a
+					// `quoted_identifier` (`Customer."No."`) so downstream consumers
+					// (D22 lookupField, fingerprinting) compare against the canonical
+					// `Field.name` without re-stripping. Plain `identifier` members
+					// pass through unchanged.
+					const fieldName =
+						memberNode.type === "quoted_identifier" &&
+						memberNode.text.length >= 2 &&
+						memberNode.text.startsWith('"') &&
+						memberNode.text.endsWith('"')
+							? memberNode.text.slice(1, -1)
+							: memberNode.text;
+					fieldAccesses.push({
+						recordVariableName,
+						fieldName,
+						sourceAnchor: {
+							sourceUnitId,
+							range: nodeToSourceRange(node),
+							enclosingRoutineId: routineId,
+							syntaxKind: nodeType,
+						},
+					});
+				}
+			}
+			// Continue into children to find chained accesses (`A.B.C`).
+		}
+
+		for (const child of node.namedChildren) {
+			if (child) visit(child, node);
+		}
+
+		if (pushedLoop) loopStack.pop();
+	}
+
+	visit(bodyNode, null);
+
+	// Assign final operationIds to call sites: their range is opIndex..opIndex+csIndex-1
+	// (call-sites come after every record-op/commit in the routine's id space, matching
+	// the old two-pass behavior).
+	for (let i = 0; i < callSites.length; i++) {
+		const cs = callSites[i];
+		if (cs) cs.operationId = encodeOperationId(routineId, opIndex + i);
+	}
+
+	// Build the compact statement tree. This pass is purely structural — it reads the
+	// op/callsite ID maps populated during `visit`, so all ids are final.
+	const statementTree = buildCFNForBlock(bodyNode);
+
+	return {
+		loops,
+		operationSites,
+		recordOperations,
+		callSites,
+		fieldAccesses,
+		unreachableStatements,
+		hasBranching,
+		statementTree,
+		// Deterministic, sorted order — model dumps stay byte-stable across runs.
+		identifierReferences: [...identifierRefSet].sort(),
+		varAssignments: collectVarAssignments(bodyNode, routineId, sourceUnitId),
+		conditionReferences: collectConditionReferences(bodyNode, routineId, sourceUnitId),
+	};
+
+	/**
+	 * Recursively build a ControlFlowNode for a code_block node. Returns a "block" node
+	 * whose children are the CFNs for each statement in the block (skipping begin/end keywords).
+	 */
+	function buildCFNForBlock(blockNode: SyntaxNode): ControlFlowNode {
+		const children: ControlFlowNode[] = [];
+		for (const child of blockNode.namedChildren) {
+			if (child === null) continue;
+			const t = child.type;
+			if (t === "begin_keyword" || t === "end_keyword") continue;
+			const cfn = buildCFNForStatement(child);
+			if (cfn !== null) children.push(cfn);
+		}
+		return {
+			kind: "block",
+			sourceAnchor: {
+				sourceUnitId,
+				range: nodeToSourceRange(blockNode),
+				enclosingRoutineId: routineId,
+				syntaxKind: blockNode.type,
+			},
+			children,
+		};
+	}
+
+	/**
+	 * Build a ControlFlowNode for a branch/loop body. The AL grammar allows the
+	 * `then_branch` / `else_branch` / loop `body` / case_branch `body` field to be
+	 * EITHER a `code_block` (when begin/end is present) OR the single statement
+	 * itself (when begin/end is omitted, e.g. `if X then Foo();`).
+	 *
+	 * If it's a code_block, delegate to `buildCFNForBlock`. Otherwise, synthesize
+	 * a one-statement block so the walker can treat all branch bodies uniformly.
+	 * The synthetic block's `sourceAnchor` covers the single statement (no enclosing
+	 * code_block exists in the source).
+	 */
+	function buildCFNForBranchBody(node: SyntaxNode): ControlFlowNode {
+		if (node.type === "code_block") return buildCFNForBlock(node);
+		const stmtCFN = buildCFNForStatement(node);
+		const children: ControlFlowNode[] = stmtCFN !== null ? [stmtCFN] : [];
+		return {
+			kind: "block",
+			sourceAnchor: {
+				sourceUnitId,
+				range: nodeToSourceRange(node),
+				enclosingRoutineId: routineId,
+				syntaxKind: node.type,
+			},
+			children,
+		};
+	}
+
+	/**
+	 * Harvest leaves from the receiver (function-side) of a chained call expression.
+	 * For `Helper(C).FindSet()`, the outer `call_expression`'s function field is a
+	 * `member_expression` whose object is another `call_expression` (`Helper(C)`).
+	 * That inner call is registered by the visit pass as a CallSite, but lives in
+	 * the receiver subtree — outside the outer's argument_list. AL evaluates the
+	 * receiver BEFORE the outer call, so the harvested leaf must be a SIBLING of
+	 * the outer leaf in the parent's conditionLeaves, ordered before it.
+	 *
+	 * This helper does nothing if the function-side is not a member_expression with
+	 * a call_expression / member_expression object (the common non-chained shape).
+	 */
+	function harvestReceiverLeaves(callNode: SyntaxNode, out: ControlFlowNode[]): void {
+		const funcNode = callNode.childForFieldName("function") ?? callNode.namedChildren[0];
+		if (!funcNode || funcNode.type !== "member_expression") return;
+		const objNode = funcNode.childForFieldName("object") ?? funcNode.namedChildren[0];
+		if (!objNode) return;
+		if (objNode.type !== "call_expression" && objNode.type !== "member_expression") return;
+		harvestExpressionLeaves(objNode, out);
+	}
+
+	/**
+	 * Harvest expression-position record-op / callsite leaves from an expression
+	 * subtree (P7.5). For each `call_expression` / `member_expression` encountered,
+	 * look up its `node.id` in the op/callsite id maps populated by `visit`. If
+	 * a hit, emit a one-shot leaf, harvest any chained receiver as a sibling leaf
+	 * (see `harvestReceiverLeaves`), and STOP descending into the call's children
+	 * (apart from its argument_list — nested ops inside arguments are captured
+	 * as the outer leaf's own `conditionLeaves`, so the walker runs them BEFORE
+	 * applying the outer leaf's effect).
+	 *
+	 * Used by: if / while / for / foreach / repeat / case condition harvest, and by
+	 * the call_expression leaf's own argument harvest in buildCFNForStatement.
+	 */
+	function harvestExpressionLeaves(exprNode: SyntaxNode | null, out: ControlFlowNode[]): void {
+		if (exprNode === null) return;
+		const type = exprNode.type;
+		if (type === "call_expression" || type === "member_expression") {
+			const anchor: ControlFlowNode["sourceAnchor"] = {
+				sourceUnitId,
+				range: nodeToSourceRange(exprNode),
+				enclosingRoutineId: routineId,
+				syntaxKind: type,
+			};
+			// When the outer node matches an op or callsite, harvest its argument-list
+			// children as inner conditionLeaves (nested under the outer leaf), AND
+			// also descend into the function-side receiver if it's a chained call
+			// (e.g. `Helper(C).FindSet()` — the inner `Helper(C)` callsite must
+			// appear as a SIBLING of the outer leaf in the parent's conditionLeaves,
+			// since AL evaluates the receiver before the outer call).
+			const opId = opIdByNodeId.get(exprNode.id);
+			if (opId !== undefined) {
+				const argList = exprNode.namedChildren.find(
+					(c) => c !== null && c.type === "argument_list",
+				);
+				const innerLeaves: ControlFlowNode[] = [];
+				if (argList) {
+					for (const arg of argList.namedChildren) {
+						if (arg) harvestExpressionLeaves(arg, innerLeaves);
+					}
+				}
+				// Chained-receiver harvest: receiver leaves go into `out` (sibling
+				// position), not into innerLeaves (which is the outer's own arglist).
+				harvestReceiverLeaves(exprNode, out);
+				const leaf: ControlFlowNode = { kind: "op", sourceAnchor: anchor, operationId: opId };
+				if (innerLeaves.length > 0) leaf.conditionLeaves = innerLeaves;
+				out.push(leaf);
+				return;
+			}
+			const csId = csIdByNodeId.get(exprNode.id);
+			if (csId !== undefined) {
+				const argList = exprNode.namedChildren.find(
+					(c) => c !== null && c.type === "argument_list",
+				);
+				const innerLeaves: ControlFlowNode[] = [];
+				if (argList) {
+					for (const arg of argList.namedChildren) {
+						if (arg) harvestExpressionLeaves(arg, innerLeaves);
+					}
+				}
+				const funcNode = exprNode.childForFieldName("function") ?? exprNode.namedChildren[0];
+				// Chained-receiver harvest: same treatment as the op branch above.
+				harvestReceiverLeaves(exprNode, out);
+				const isError = funcNode?.type === "identifier" && funcNode.text.toLowerCase() === "error";
+				const leaf: ControlFlowNode = isError
+					? { kind: "error", sourceAnchor: anchor, callsiteId: csId }
+					: { kind: "call", sourceAnchor: anchor, callsiteId: csId };
+				if (innerLeaves.length > 0) leaf.conditionLeaves = innerLeaves;
+				out.push(leaf);
+				return;
+			}
+			// Not registered as either op or callsite — keep descending so nested
+			// receiver / argument expressions can still surface their ops.
+		}
+		// Recurse into all named children (including argument_list, comparison
+		// operands, etc.). Statement-position children DO NOT appear in expression
+		// subtrees by construction of the grammar (an if-condition can't be a
+		// statement, etc.).
+		for (const child of exprNode.namedChildren) {
+			if (child) harvestExpressionLeaves(child, out);
+		}
+	}
+
+	/**
+	 * Build a ControlFlowNode for a single statement node. Returns null for nodes that
+	 * should be skipped (e.g. keywords, empty statements).
+	 *
+	 * Grammar-verified node types:
+	 *  - if_statement: fields `condition` (expression), `then_branch` (code_block or
+	 *    bare statement), `else_branch` (optional)
+	 *  - case_statement: field `expression` (expression); namedChildren include
+	 *    case_branch / case_else_branch nodes
+	 *  - case_branch: field `body` (code_block); case_else_branch: second namedChild is code_block
+	 *  - for_statement: fields `start`, `end`, `variable`, `body`
+	 *  - foreach_statement: fields `iterable`, `variable`, `body`
+	 *  - while_statement: fields `condition`, `body`
+	 *  - repeat_statement: field `condition` (the until-expr); namedChildren before
+	 *    until_keyword are the body statements
+	 *  - exit_statement: leaf, kind "exit"
+	 *  - call_expression: op leaf (op map hit) or call leaf (callsite); already visited
+	 *  - member_expression in statement position: same as call_expression
+	 *
+	 * P7.5: branching / looping nodes harvest expression-position record-ops /
+	 * callsites from their condition / range / iterable / expression fields into
+	 * `conditionLeaves`. Call / op leaves harvest from their `argument_list`. The
+	 * walker processes `conditionLeaves` at the position dictated by AL semantics
+	 * (pre-body for if / case / while / for / foreach; post-body for repeat;
+	 * pre-effect for call / op).
+	 */
+	function buildCFNForStatement(node: SyntaxNode): ControlFlowNode | null {
+		const type = node.type;
+		const anchor: ControlFlowNode["sourceAnchor"] = {
+			sourceUnitId,
+			range: nodeToSourceRange(node),
+			enclosingRoutineId: routineId,
+			syntaxKind: type,
+		};
+
+		if (type === "if_statement") {
+			// then_branch / else_branch may be EITHER a code_block (begin/end present) OR a
+			// bare statement (begin/end omitted, e.g. `if X then Foo();`). Use
+			// buildCFNForBranchBody to handle both shapes.
+			const thenBranchNode = node.childForFieldName("then_branch");
+			const elseBranchNode = node.childForFieldName("else_branch");
+			const children = thenBranchNode !== null ? [buildCFNForBranchBody(thenBranchNode)] : [];
+			const elseChildren =
+				elseBranchNode !== null ? [buildCFNForBranchBody(elseBranchNode)] : undefined;
+			// P7.5: harvest expression-position record-ops / callsites from the
+			// condition field (e.g. `if Cust.FindSet() then ...`).
+			const conditionLeaves: ControlFlowNode[] = [];
+			harvestExpressionLeaves(node.childForFieldName("condition"), conditionLeaves);
+			const result: ControlFlowNode = {
+				kind: "if",
+				sourceAnchor: anchor,
+				children,
+				...(elseChildren !== undefined ? { elseChildren } : {}),
+			};
+			if (conditionLeaves.length > 0) result.conditionLeaves = conditionLeaves;
+			return result;
+		}
+
+		if (type === "case_statement") {
+			// Children of case_statement are case_branch and case_else_branch nodes.
+			const branchCFNs: ControlFlowNode[] = [];
+			for (const child of node.namedChildren) {
+				if (child === null) continue;
+				if (child.type === "case_branch" || child.type === "case_else_branch") {
+					const cfn = buildCFNForCaseBranch(child);
+					if (cfn !== null) branchCFNs.push(cfn);
+				}
+			}
+			// P7.5: harvest from the case-value expression (e.g. `case Rec.Find('-') of`).
+			const conditionLeaves: ControlFlowNode[] = [];
+			harvestExpressionLeaves(node.childForFieldName("expression"), conditionLeaves);
+			const result: ControlFlowNode = {
+				kind: "case",
+				sourceAnchor: anchor,
+				children: branchCFNs,
+			};
+			if (conditionLeaves.length > 0) result.conditionLeaves = conditionLeaves;
+			return result;
+		}
+
+		if (type === "for_statement" || type === "foreach_statement" || type === "while_statement") {
+			const kind: ControlFlowNode["kind"] =
+				type === "for_statement" ? "for" : type === "foreach_statement" ? "foreach" : "while";
+			// Loop `body` field may be either a code_block or a bare statement (no begin/end).
+			const bodyNode = node.childForFieldName("body");
+			const children = bodyNode !== null ? [buildCFNForBranchBody(bodyNode)] : [];
+			// P7.5: harvest expression-position ops from the loop's controlling expressions:
+			//   - while: `condition` (evaluated before each iteration)
+			//   - for:   `start` + `end` (`start` evaluated once at loop entry; `end` per
+			//            iteration in strict AL semantics, but the walker's fixed-point
+			//            naturally re-applies these each iteration, which is sound)
+			//   - foreach: `iterable` (evaluated once at loop entry — the iterator is
+			//            stepped each iteration, but the iterable's own evaluation is once;
+			//            still sound to apply per-iteration via the fixed-point)
+			const conditionLeaves: ControlFlowNode[] = [];
+			if (type === "while_statement") {
+				harvestExpressionLeaves(node.childForFieldName("condition"), conditionLeaves);
+			} else if (type === "for_statement") {
+				harvestExpressionLeaves(node.childForFieldName("start"), conditionLeaves);
+				harvestExpressionLeaves(node.childForFieldName("end"), conditionLeaves);
+			} else {
+				// foreach_statement
+				harvestExpressionLeaves(node.childForFieldName("iterable"), conditionLeaves);
+			}
+			const result: ControlFlowNode = { kind, sourceAnchor: anchor, children };
+			if (conditionLeaves.length > 0) result.conditionLeaves = conditionLeaves;
+			return result;
+		}
+
+		if (type === "repeat_statement") {
+			// repeat_statement has no body field: body children are all namedChildren before
+			// the until_keyword (which is followed by the condition expression).
+			const bodyChildren: ControlFlowNode[] = [];
+			for (const child of node.namedChildren) {
+				if (child === null) continue;
+				if (child.type === "until_keyword" || child.type === "repeat_keyword") continue;
+				// Once we hit the condition (which follows until_keyword in the source), stop.
+				// The condition field is the comparison/expression after "until". We detect this
+				// by checking if we're at the condition field.
+				if (node.childForFieldName("condition")?.startIndex === child.startIndex) break;
+				const cfn = buildCFNForStatement(child);
+				if (cfn !== null) bodyChildren.push(cfn);
+			}
+			// P7.5: harvest from the until-condition (e.g. `until Cust.Next() = 0`). The
+			// walker processes these AFTER body each iteration (post-condition semantics).
+			const conditionLeaves: ControlFlowNode[] = [];
+			harvestExpressionLeaves(node.childForFieldName("condition"), conditionLeaves);
+			const result: ControlFlowNode = {
+				kind: "repeat",
+				sourceAnchor: anchor,
+				children: bodyChildren,
+			};
+			if (conditionLeaves.length > 0) result.conditionLeaves = conditionLeaves;
+			return result;
+		}
+
+		if (type === "try_statement") {
+			// The AL grammar (tree-sitter-al / src/node-types.json) does not currently
+			// define a `try_statement` node — AL's TryFunction is a [TryFunction] attribute
+			// on a procedure declaration, and `asserterror_statement` is the closest
+			// statement-level cousin. The branching-flag code in `visit` checks for
+			// `try_statement` defensively in case the grammar adds it later; mirror that
+			// here by emitting a "try" wrapper with no children rather than guessing the
+			// field structure.
+			// TODO P6.T2: if the AL grammar ever adds a real try_statement node, verify
+			// its named fields with a grammar probe before populating `children`.
+			return { kind: "try", sourceAnchor: anchor, children: [] };
+		}
+
+		if (type === "exit_statement") {
+			return { kind: "exit", sourceAnchor: anchor };
+		}
+
+		// call_expression: check if we recorded an op or callsite at this node's id.
+		if (type === "call_expression" || type === "member_expression") {
+			// P7.5: harvest argument-position ops/calls (e.g. `Helper(Cust.FindSet())`)
+			// AND chained-receiver ops/calls (e.g. `Helper(C).FindSet()`). The walker
+			// processes both BEFORE applying the outer leaf's own effect. They live
+			// in the outer leaf's `conditionLeaves` because there's no parent slot
+			// at statement position (cf. expression-position harvest, where the
+			// receiver leaf goes into the parent's conditionLeaves as a sibling).
+			const argList = node.namedChildren.find((c) => c !== null && c.type === "argument_list");
+			const preLeaves: ControlFlowNode[] = [];
+			// Receiver first (evaluates first in AL), then arglist.
+			harvestReceiverLeaves(node, preLeaves);
+			if (argList) {
+				for (const arg of argList.namedChildren) {
+					if (arg) harvestExpressionLeaves(arg, preLeaves);
+				}
+			}
+			const opId = opIdByNodeId.get(node.id);
+			if (opId !== undefined) {
+				const leaf: ControlFlowNode = { kind: "op", sourceAnchor: anchor, operationId: opId };
+				if (preLeaves.length > 0) leaf.conditionLeaves = preLeaves;
+				return leaf;
+			}
+			const csId = csIdByNodeId.get(node.id);
+			if (csId !== undefined) {
+				// Determine if this is an error-kind call (bare Error(...)).
+				const funcNode = node.childForFieldName("function") ?? node.namedChildren[0];
+				const isError = funcNode?.type === "identifier" && funcNode.text.toLowerCase() === "error";
+				const leaf: ControlFlowNode = isError
+					? { kind: "error", sourceAnchor: anchor, callsiteId: csId }
+					: { kind: "call", sourceAnchor: anchor, callsiteId: csId };
+				if (preLeaves.length > 0) leaf.conditionLeaves = preLeaves;
+				return leaf;
+			}
+			// Unrecognised expression-position call (no op/callsite registered). Still
+			// emit any nested argument-position / receiver leaves we found so they
+			// aren't lost.
+			if (preLeaves.length > 0) {
+				return { kind: "other", sourceAnchor: anchor, conditionLeaves: preLeaves };
+			}
+			return { kind: "other", sourceAnchor: anchor };
+		}
+
+		// Compound statements that contain a body (e.g. with_statement, asserterror_statement).
+		// Recurse to expose any ops/calls inside. The `body` field may be a code_block
+		// OR a bare statement — use buildCFNForBranchBody to handle both.
+		if (type === "with_statement" || type === "asserterror_statement") {
+			const bodyNode = node.childForFieldName("body");
+			if (bodyNode !== null) {
+				const children = [buildCFNForBranchBody(bodyNode)];
+				return { kind: "other", sourceAnchor: anchor, children };
+			}
+			return { kind: "other", sourceAnchor: anchor };
+		}
+
+		// Everything else (assignment, message, continue, break, empty, preproc, …):
+		// treat as opaque straight-line "other". These don't affect control flow and
+		// contain no ops/callsites at top-level (sub-expressions with calls are captured
+		// separately by the visit pass, but we don't expose them in the tree for now).
+		if (
+			type === "begin_keyword" ||
+			type === "end_keyword" ||
+			type === "if_keyword" ||
+			type === "then_keyword" ||
+			type === "else_keyword" ||
+			type === "case_keyword" ||
+			type === "of_keyword" ||
+			type === "repeat_keyword" ||
+			type === "until_keyword" ||
+			type === "while_keyword" ||
+			type === "for_keyword" ||
+			type === "do_keyword" ||
+			type === "foreach_keyword" ||
+			type === "in_keyword" ||
+			type === "empty_statement"
+		) {
+			return null;
+		}
+
+		return { kind: "other", sourceAnchor: anchor };
+	}
+
+	/**
+	 * Build a ControlFlowNode for a case_branch or case_else_branch node.
+	 * - case_branch: field `body` — may be a code_block OR a bare statement (no begin/end).
+	 * - case_else_branch: no named body field. The body is the first non-keyword namedChild
+	 *   (typically `else_keyword`, then either a `code_block` or a bare statement).
+	 */
+	function buildCFNForCaseBranch(node: SyntaxNode): ControlFlowNode | null {
+		const anchor: ControlFlowNode["sourceAnchor"] = {
+			sourceUnitId,
+			range: nodeToSourceRange(node),
+			enclosingRoutineId: routineId,
+			syntaxKind: node.type,
+		};
+		let bodyNode: SyntaxNode | null = null;
+		if (node.type === "case_branch") {
+			bodyNode = node.childForFieldName("body");
+		} else {
+			// case_else_branch: prefer a code_block child, but if absent (single-statement
+			// body, no begin/end), fall back to the first non-keyword namedChild as the body.
+			for (const child of node.namedChildren) {
+				if (child?.type === "code_block") {
+					bodyNode = child;
+					break;
+				}
+			}
+			if (bodyNode === null) {
+				for (const child of node.namedChildren) {
+					if (child === null) continue;
+					if (child.type === "else_keyword") continue;
+					bodyNode = child;
+					break;
+				}
+			}
+		}
+		const children = bodyNode !== null ? [buildCFNForBranchBody(bodyNode)] : [];
+		return { kind: "case-branch", sourceAnchor: anchor, children };
+	}
+}