al-sem 0.0.1

package/src/index/intraprocedural-ops.ts

@@ -0,0 +1,253 @@
+import type {
+	LoopNode,
+	LoopType,
+	OperationSite,
+	RecordOpType,
+	RecordOperation,
+} from "../model/entities.ts";
+import { type LoopId, type RoutineId, encodeLoopId, encodeOperationId } from "../model/ids.ts";
+import { nodeToSourceRange } from "../parser/ast.ts";
+import type { Node as SyntaxNode } from "../parser/native/wrapper.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.
+ * Confirmed against al-perf/src/source/indexer.ts RECORD_OP_CASE_MAP (same grammar).
+ */
+const RECORD_OP_MAP: Record<string, RecordOpType> = {
+	findset: "FindSet",
+	findfirst: "FindFirst",
+	findlast: "FindLast",
+	find: "Find",
+	get: "Get",
+	calcfields: "CalcFields",
+	calcsums: "CalcSums",
+	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 `Validate` so the summary engine's parameter-effects computation
+ * (summary-engine.ts: \`if (op.op === "Validate") for (arg of op.fieldArguments)\`)
+ * actually receives the field-name arguments — without this entry, fieldArguments
+ * was always undefined for Validate ops and the writesFields tracking was silently
+ * empty.
+ *
+ * Includes `Get`, `FindFirst`, `FindLast` 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. `Find` and `FindSet` are also included for completeness,
+ * even though D4 does not currently use them as lookup ops to deduplicate.
+ */
+const FIELD_ARGS_OPS = new Set([
+	"SetRange",
+	"SetFilter",
+	"SetLoadFields",
+	"AddLoadFields",
+	"SetCurrentKey",
+	"Validate",
+	"Get",
+	"Find",
+	"FindFirst",
+	"FindLast",
+	"FindSet",
+]);
+
+export interface ExtractOpsResult {
+	loops: LoopNode[];
+	operationSites: OperationSite[];
+	recordOperations: RecordOperation[];
+	/**
+	 * Next free operation index after this extractor's assignments. The routine indexer
+	 * threads this into `extractRefs` as `startOpIndex` so call-site operation IDs do not
+	 * collide with record-op IDs in the same routine.
+	 */
+	nextOpIndex: number;
+}
+
+/**
+ * Inspect a `call_expression` for member-call shape and check whether its method maps
+ * to a record op. Lazy by design: decode only what's needed at each step.
+ *
+ * CONFIRMED grammar (V2, same as al-perf/src/source/indexer.ts):
+ *   - Call node type: `call_expression`
+ *   - Callee field name: `"function"` (may be a `member_expression`)
+ *   - Member object field: `"object"`
+ *   - Member property field: `"member"`
+ *   - Argument list: named child with type `"argument_list"`
+ *
+ * Returns null if not a member-call OR the method isn't a record op. Returning a
+ * decoded `receiver` and (when relevant) `args` deferred so non-record member calls —
+ * the overwhelming majority — pay nothing past the method-name lookup.
+ */
+function parseRecordMemberCall(
+	node: SyntaxNode,
+): { receiver: string; opType: RecordOpType; args: string[] } | null {
+	const funcNode = node.childForFieldName("function") ?? node.namedChildren[0];
+	if (!funcNode) return null;
+	if (funcNode.type !== "member_expression") return null;
+
+	const propNode = funcNode.childForFieldName("member") ?? funcNode.namedChildren[1];
+	if (!propNode) return null;
+
+	// Decode the method name first — cheap (just the property identifier). Most member
+	// calls aren't record ops; bail before paying for receiver decode or arg traversal.
+	const opType = RECORD_OP_MAP[propNode.text.toLowerCase()];
+	if (opType === undefined) return null;
+
+	const objNode = funcNode.childForFieldName("object") ?? funcNode.namedChildren[0];
+	const receiver = objNode ? objNode.text : "";
+
+	// Argument decode is only meaningful for the field-arg ops; everything else gets [].
+	let args: string[] = [];
+	if (FIELD_ARGS_OPS.has(opType)) {
+		const argListNode = node.namedChildren.find((c) => c !== null && c.type === "argument_list");
+		if (argListNode) {
+			args = [];
+			for (const arg of argListNode.namedChildren) {
+				if (arg !== null) args.push(arg.text);
+			}
+		}
+	}
+
+	return { receiver, opType, args };
+}
+
+/**
+ * Detect whether a `call_expression` node is a bare `Commit()` call.
+ *
+ * CONFIRMED grammar: the `function` child is an `identifier` node whose text is "Commit"
+ * (case-insensitive). Not a `member_expression`. Cheap shape check first; only decode
+ * `.text` when the function child is an identifier.
+ */
+function isBareCommitCall(node: SyntaxNode): boolean {
+	const funcNode = node.childForFieldName("function") ?? node.namedChildren[0];
+	if (!funcNode) return false;
+	if (funcNode.type !== "identifier") return false; // gates the text decode below
+	return funcNode.text.toLowerCase() === "commit";
+}
+
+/**
+ * Extract loops, operation sites, and record operations from a routine body node.
+ * `bodyNode` is typically the routine's `code_block`.
+ *
+ * Single DFS with maintained ancestor `loopStack`. The previous implementation did two
+ * full traversals (one to find/register loops, another to find ops and call
+ * `loopAncestorsOf` per call site — which walked `.parent` chains via FFI). This version
+ * cuts the FFI/allocation cost in half on routine bodies. Document-order preorder is
+ * preserved by recursing into named children left-to-right.
+ */
+export function extractOpsAndLoops(
+	bodyNode: SyntaxNode,
+	routineId: RoutineId,
+	sourceUnitId: string,
+): ExtractOpsResult {
+	const loops: LoopNode[] = [];
+	const operationSites: OperationSite[] = [];
+	const recordOperations: RecordOperation[] = [];
+	let opIndex = 0;
+	const loopStack: LoopId[] = [];
+
+	function visit(node: SyntaxNode): void {
+		const nodeType = node.type;
+		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;
+		}
+
+		// Only call_expression nodes can be record-op member calls or bare Commit().
+		if (nodeType === "call_expression") {
+			const memberCall = parseRecordMemberCall(node);
+			if (memberCall !== null) {
+				const anchor = {
+					sourceUnitId,
+					range: nodeToSourceRange(node),
+					enclosingRoutineId: routineId,
+					syntaxKind: nodeType,
+				};
+				const opId = encodeOperationId(routineId, opIndex++);
+				// snapshot the ambient ancestor loop stack — naturally outermost-first
+				const snapshotLoopStack = loopStack.slice();
+				recordOperations.push({
+					id: opId,
+					routineId,
+					op: memberCall.opType,
+					recordVariableName: memberCall.receiver,
+					tempState: { kind: "unknown" },
+					fieldArguments: FIELD_ARGS_OPS.has(memberCall.opType) ? memberCall.args : undefined,
+					loopStack: snapshotLoopStack,
+					sourceAnchor: anchor,
+				});
+				operationSites.push({
+					id: opId,
+					routineId,
+					kind: memberCall.opType === "LockTable" ? "lock" : "record-op",
+					sourceAnchor: anchor,
+					loopStack: snapshotLoopStack,
+				});
+			} else if (isBareCommitCall(node)) {
+				const opId = encodeOperationId(routineId, opIndex++);
+				operationSites.push({
+					id: opId,
+					routineId,
+					kind: "commit",
+					sourceAnchor: {
+						sourceUnitId,
+						range: nodeToSourceRange(node),
+						enclosingRoutineId: routineId,
+						syntaxKind: nodeType,
+					},
+					loopStack: loopStack.slice(),
+				});
+			}
+		}
+
+		for (const child of node.namedChildren) {
+			if (child) visit(child);
+		}
+
+		if (pushedLoop) loopStack.pop();
+	}
+
+	visit(bodyNode);
+
+	return { loops, operationSites, recordOperations, nextOpIndex: opIndex };
+}

package/src/index/intraprocedural-refs.ts

@@ -0,0 +1,188 @@
+import type { ParameterSymbol, RecordVariable, TempState } from "../model/entities.ts";
+import { type RoutineId, encodeRecordVariableId } from "../model/ids.ts";
+import { stripQuotes } from "../parser/ast.ts";
+import type { Node as SyntaxNode } from "../parser/native/wrapper.ts";
+
+/**
+ * Extract record variables from the parameter list and var_section of a routine node.
+ *
+ * CONFIRMED grammar (V2):
+ *   - Parameters: `parameter_list` → `parameter` children.
+ *     Each parameter has: optional `var_keyword`, `identifier` (name), `type_specification`
+ *   - Variables: `var_section` → `variable_declaration` children.
+ *     Each has: `identifier` (name), `type_specification` → `record_type`
+ *   - `record_type` children: `quoted_identifier` | `identifier` (table name),
+ *     optionally `temporary_keyword`
+ */
+/**
+ * Public re-export so the routine indexer can run record-variable + parameter extraction
+ * up front (before the merged body walk needs `recordVarNames`).
+ *
+ * Two-phase signature so the canonical routine signature can be hashed from
+ * structured `parameters` BEFORE the routineId is encoded. `extractParameters`
+ * needs no routineId; `extractRecordVariables` takes the final routineId so
+ * `RecordVariable.id` values are correct on first construction.
+ */
+export function extractRecordVariablesAndParameters(
+	procNode: SyntaxNode,
+	routineId: RoutineId,
+): { recordVariables: RecordVariable[]; parameters: ParameterSymbol[] } {
+	const parameters = extractParameters(procNode);
+	const recordVariables = extractRecordVariables(procNode, routineId, parameters);
+	return { recordVariables, parameters };
+}
+
+/**
+ * Extract `ParameterSymbol[]` from a procedure/trigger node's `parameter_list`.
+ * No routineId required — parameters carry only structural data, not ids.
+ */
+export function extractParameters(procNode: SyntaxNode): ParameterSymbol[] {
+	const parameters: ParameterSymbol[] = [];
+	const paramList = procNode.namedChildren.find((c) => c !== null && c.type === "parameter_list");
+	if (!paramList) return parameters;
+	let pIndex = 0;
+	for (const param of paramList.namedChildren) {
+		if (!param || param.type !== "parameter") continue;
+		const isVar = param.namedChildren.some((c) => c !== null && c.type === "var_keyword");
+		const nameNode = param.namedChildren.find((c) => c !== null && c.type === "identifier");
+		const typeSpecNode = param.namedChildren.find(
+			(c) => c !== null && c.type === "type_specification",
+		);
+		if (!nameNode) {
+			pIndex++;
+			continue;
+		}
+		const name = nameNode.text;
+		const typeText = typeSpecNode?.text ?? "";
+		const recordTypeNode = typeSpecNode?.namedChildren.find(
+			(c) => c !== null && c.type === "record_type",
+		);
+		const isRecord = recordTypeNode !== undefined;
+		let tableName: string | undefined;
+		if (isRecord && recordTypeNode) {
+			const quotedId = recordTypeNode.namedChildren.find(
+				(c) => c !== null && c.type === "quoted_identifier",
+			);
+			if (quotedId) tableName = stripQuotes(quotedId.text);
+			else {
+				const id = recordTypeNode.namedChildren.find((c) => c !== null && c.type === "identifier");
+				if (id) tableName = id.text;
+			}
+		}
+		parameters.push({
+			index: pIndex++,
+			name,
+			typeText,
+			isVar,
+			isRecord,
+			tableName,
+		});
+	}
+	return parameters;
+}
+
+function extractRecordVariables(
+	procNode: SyntaxNode,
+	routineId: RoutineId,
+	parameters: ParameterSymbol[],
+): RecordVariable[] {
+	const recordVariables: RecordVariable[] = [];
+
+	// --- Record-typed parameters ---
+	// Walk the `parameter_list` again to recover the `record_type` node — needed for
+	// the `temporary_keyword` check below. The structural `parameters` array tells us
+	// which positional slot maps to which name; the node walk supplies the temporary
+	// flag the structural extractor doesn't carry.
+	const paramList = procNode.namedChildren.find((c) => c !== null && c.type === "parameter_list");
+	if (paramList) {
+		let pIndex = -1;
+		for (const param of paramList.namedChildren) {
+			if (!param || param.type !== "parameter") continue;
+			pIndex++;
+			const meta = parameters[pIndex];
+			if (meta === undefined || !meta.isRecord) continue;
+
+			const typeSpecNode = param.namedChildren.find(
+				(c) => c !== null && c.type === "type_specification",
+			);
+			const recordTypeNode = typeSpecNode?.namedChildren.find(
+				(c) => c !== null && c.type === "record_type",
+			);
+			if (!recordTypeNode) continue;
+
+			// Inspect the parameter's record type for the `temporary` keyword.
+			// AL enforces at compile time that a `temporary` parameter can only
+			// be bound to a temporary record at the callsite — so a parameter
+			// carrying the keyword is known-temp regardless of var-ness. Without
+			// this, D40 false-positives on every temp-record forwarding chain
+			// (e.g. `Sort(TempBusinessEntity)` where both sides declare
+			// `temporary` on the parameter).
+			const isTemporaryParam = recordTypeNode.namedChildren.some(
+				(c) => c !== null && c.type === "temporary_keyword",
+			);
+			// Without the keyword:
+			//   By-var: temp-ness depends on what caller passes in.
+			//   By-value: local copy — known non-temp.
+			const tempState: TempState = isTemporaryParam
+				? { kind: "known", value: true }
+				: meta.isVar
+					? { kind: "parameter-dependent", parameterIndex: meta.index }
+					: { kind: "known", value: false };
+			recordVariables.push({
+				id: encodeRecordVariableId(routineId, meta.name),
+				name: meta.name,
+				tableName: meta.tableName,
+				tempState,
+				isParameter: true,
+				parameterIndex: meta.index,
+			});
+		}
+	}
+
+	// --- Local variable declarations ---
+	const varSection = procNode.namedChildren.find((c) => c !== null && c.type === "var_section");
+	if (varSection) {
+		for (const varDecl of varSection.namedChildren) {
+			if (!varDecl || varDecl.type !== "variable_declaration") continue;
+
+			const nameNode = varDecl.namedChildren.find((c) => c !== null && c.type === "identifier");
+			const typeSpecNode = varDecl.namedChildren.find(
+				(c) => c !== null && c.type === "type_specification",
+			);
+			if (!nameNode || !typeSpecNode) continue;
+
+			const recordTypeNode = typeSpecNode.namedChildren.find(
+				(c) => c !== null && c.type === "record_type",
+			);
+			if (!recordTypeNode) continue; // not a Record variable
+
+			const name = nameNode.text;
+
+			// Resolve table name
+			let tableName: string | undefined;
+			const quotedId = recordTypeNode.namedChildren.find(
+				(c) => c !== null && c.type === "quoted_identifier",
+			);
+			if (quotedId) {
+				tableName = stripQuotes(quotedId.text);
+			} else {
+				const id = recordTypeNode.namedChildren.find((c) => c !== null && c.type === "identifier");
+				if (id) tableName = id.text;
+			}
+
+			const isTemporary = recordTypeNode.namedChildren.some(
+				(c) => c !== null && c.type === "temporary_keyword",
+			);
+
+			recordVariables.push({
+				id: encodeRecordVariableId(routineId, name),
+				name,
+				tableName,
+				tempState: { kind: "known", value: isTemporary },
+				isParameter: false,
+			});
+		}
+	}
+
+	return recordVariables;
+}