al-sem 0.0.1

package/src/index/object-indexer.ts

@@ -0,0 +1,279 @@
+import type { Field, Key, ObjectDecl, Table } from "../model/entities.ts";
+import { encodeFieldId, encodeKeyId, encodeObjectId, encodeTableId } from "../model/ids.ts";
+import { isPropertyNamed, nodeToSourceRange, stripQuotes } from "../parser/ast.ts";
+import type { Node as SyntaxNode, Tree } from "../parser/native/wrapper.ts";
+
+/**
+ * Read a property value by name from an object declaration. AL property syntax:
+ *   `Subtype = Install;`
+ * exposed by the grammar as a `property` named-child of the object declaration.
+ * The grammar exposes the property key via `childForFieldName("name")` and the
+ * value via `childForFieldName("value")`. The child nodes are typed `property_name`
+ * and `identifier` respectively — `property_name` is a node TYPE, not a field name.
+ * Returns the raw value text (preserves casing) or undefined.
+ */
+function readObjectProperty(decl: SyntaxNode, propertyName: string): string | undefined {
+	for (let i = 0; i < decl.namedChildCount; i++) {
+		const child = decl.namedChild(i);
+		if (child === null || child.type !== "property") continue;
+		const nameNode = child.childForFieldName("name");
+		if (nameNode === null) continue;
+		if (nameNode.text.toLowerCase() !== propertyName.toLowerCase()) continue;
+		const valueNode = child.childForFieldName("value");
+		if (valueNode !== null) return valueNode.text;
+		return undefined;
+	}
+	return undefined;
+}
+
+/** Maps V2 grammar object declaration node types to display object-type names. */
+const OBJECT_TYPE_MAP: Record<string, string> = {
+	codeunit_declaration: "Codeunit",
+	table_declaration: "Table",
+	tableextension_declaration: "TableExtension",
+	page_declaration: "Page",
+	pageextension_declaration: "PageExtension",
+	report_declaration: "Report",
+	reportextension_declaration: "ReportExtension",
+	query_declaration: "Query",
+	xmlport_declaration: "XMLport",
+	enum_declaration: "Enum",
+	enumextension_declaration: "EnumExtension",
+	interface_declaration: "Interface",
+	controladdin_declaration: "ControlAddIn",
+	permissionset_declaration: "PermissionSet",
+};
+
+export interface IndexObjectInput {
+	tree: Tree;
+	appGuid: string;
+	sourceUnitId: string;
+	/** Unused by the object indexer; present so callers share one input type with the routine indexer, which consumes it. */
+	modelInstanceId: string;
+	sourceHash: string;
+}
+
+export interface IndexObjectResult {
+	object?: ObjectDecl;
+	/** The object declaration node, for the routine indexer to walk further. */
+	objectNode?: SyntaxNode;
+	objectType?: string;
+	/** Present for table and tableextension declarations. */
+	table?: Table;
+}
+
+function findObjectDeclarations(root: SyntaxNode): SyntaxNode[] {
+	const out: SyntaxNode[] = [];
+	for (const child of root.namedChildren) {
+		if (child && child.type in OBJECT_TYPE_MAP) out.push(child);
+	}
+	return out;
+}
+
+function extractObjectNumber(decl: SyntaxNode): number {
+	for (const child of decl.namedChildren) {
+		if (child?.type === "integer") return Number.parseInt(child.text, 10);
+	}
+	// Object types without a number (e.g. interface) yield 0 — acceptable in Phase 1
+	// since such objects carry no tables/fields.
+	return 0;
+}
+
+function extractObjectName(decl: SyntaxNode): string {
+	for (const child of decl.namedChildren) {
+		if (child?.type === "quoted_identifier") return stripQuotes(child.text);
+		if (child?.type === "identifier") return child.text;
+	}
+	return "";
+}
+
+const BLOB_LIKE = new Set(["blob", "media", "mediaset"]);
+
+/**
+ * Classify a field_declaration node's FieldClass and Blob status.
+ * Uses `type_specification` for the data type (confirmed V2 grammar).
+ * Uses generic `property` nodes with isPropertyNamed("FieldClass") for class.
+ */
+function classifyField(fieldNode: SyntaxNode): {
+	dataType: string;
+	fieldClass: Field["fieldClass"];
+	isBlobLike: boolean;
+} {
+	let dataType = "";
+
+	// type_specification is the confirmed V2 node for field data types
+	for (const child of fieldNode.namedChildren) {
+		if (child?.type === "type_specification") {
+			dataType = child.text;
+			break;
+		}
+	}
+
+	let fieldClass: Field["fieldClass"] = "Normal";
+
+	// FieldClass is always a direct `property` child of field_declaration in the V2 grammar.
+	for (const child of fieldNode.namedChildren) {
+		if (!child) continue;
+		if (isPropertyNamed(child, "FieldClass")) {
+			const value = child.childForFieldName("value")?.text ?? "";
+			if (/flowfield/i.test(value)) fieldClass = "FlowField";
+			else if (/flowfilter/i.test(value)) fieldClass = "FlowFilter";
+		}
+	}
+
+	const isBlobLike = BLOB_LIKE.has(dataType.toLowerCase());
+	return { dataType, fieldClass, isBlobLike };
+}
+
+/**
+ * Build a Table (with Fields and Keys) from a table/tableextension declaration node.
+ * Uses V2 grammar node types: `field_declaration` for fields, `key_declaration` for keys,
+ * `field_list` for the list of field names in a key.
+ */
+function indexTable(
+	decl: SyntaxNode,
+	objectId: string,
+	appGuid: string,
+	tableNumber: number,
+	tableName: string,
+): Table {
+	const tableId = encodeTableId(appGuid, tableNumber);
+	const fields: Field[] = [];
+	const keys: Key[] = [];
+
+	// Collect `field_declaration` and `key_declaration` nodes anywhere under the declaration.
+	const fieldNodes: SyntaxNode[] = [];
+	const keyNodes: SyntaxNode[] = [];
+	const stack: SyntaxNode[] = [decl];
+	while (stack.length > 0) {
+		const node = stack.pop();
+		if (!node) continue;
+		if (node.type === "field_declaration") {
+			fieldNodes.push(node);
+			// Don't recurse into nested field declarations
+			continue;
+		}
+		if (node.type === "key_declaration") {
+			keyNodes.push(node);
+			continue;
+		}
+		// Push in reverse so the stack pops in document order
+		for (let i = node.namedChildren.length - 1; i >= 0; i--) {
+			const child = node.namedChildren[i];
+			if (child) stack.push(child);
+		}
+	}
+
+	for (const fieldNode of fieldNodes) {
+		// field_declaration(<number>; <name>; <type>) — number is first integer,
+		// quoted name is quoted_identifier, unquoted name is identifier (after the integer).
+		let fieldNumber = 0;
+		let fieldName = "";
+		let nameFound = false;
+		for (const child of fieldNode.namedChildren) {
+			if (!child) continue;
+			if (fieldNumber === 0 && child.type === "integer") {
+				fieldNumber = Number.parseInt(child.text, 10);
+				continue;
+			}
+			if (!nameFound && fieldNumber !== 0) {
+				if (child.type === "quoted_identifier") {
+					fieldName = stripQuotes(child.text);
+					nameFound = true;
+					continue;
+				}
+				if (child.type === "identifier") {
+					fieldName = child.text;
+					nameFound = true;
+				}
+			}
+		}
+		const { dataType, fieldClass, isBlobLike } = classifyField(fieldNode);
+		fields.push({
+			id: encodeFieldId(tableId, fieldNumber),
+			physicalTableId: tableId,
+			declaringObjectId: objectId,
+			declaringAppId: appGuid,
+			fieldNumber,
+			name: fieldName,
+			fieldClass,
+			dataType,
+			isBlobLike,
+		});
+	}
+
+	const fieldsByName = new Map(fields.map((f) => [f.name.toLowerCase(), f]));
+
+	keyNodes.forEach((keyNode, index) => {
+		// key_declaration: name via childForFieldName("name"),
+		// fields via `field_list` child containing identifier/quoted_identifier nodes.
+		const keyFieldIds: string[] = [];
+		const keyFieldList = keyNode.namedChildren.find((c) => c !== null && c.type === "field_list");
+		if (keyFieldList) {
+			for (const child of keyFieldList.namedChildren) {
+				if (!child) continue;
+				const resolved = fieldsByName.get(stripQuotes(child.text).toLowerCase());
+				// a key field not found in this object is silently skipped — cross-object/tableextension field resolution happens in Phase 2
+				if (resolved) keyFieldIds.push(resolved.id);
+			}
+		}
+		keys.push({
+			id: encodeKeyId(tableId, index),
+			physicalTableId: tableId,
+			declaringObjectId: objectId,
+			fields: keyFieldIds,
+		});
+	});
+
+	return { id: tableId, appGuid, tableNumber, name: tableName, fields, keys };
+}
+
+/** Index all top-level object declarations in a parsed source file. */
+export function indexObjects(input: IndexObjectInput): IndexObjectResult[] {
+	const { tree, appGuid, sourceUnitId, sourceHash } = input;
+	const decls = findObjectDeclarations(tree.rootNode);
+	const results: IndexObjectResult[] = [];
+
+	for (const decl of decls) {
+		const objectType = OBJECT_TYPE_MAP[decl.type] ?? "Unknown";
+		const objectNumber = extractObjectNumber(decl);
+		const name = extractObjectName(decl);
+		const objectId = encodeObjectId(appGuid, objectType, objectNumber);
+
+		let objectSubtype: string | undefined;
+		let pageType: string | undefined;
+		if (objectType === "Codeunit") {
+			objectSubtype = readObjectProperty(decl, "Subtype");
+		}
+		if (objectType === "Page" || objectType === "PageExtension") {
+			pageType = readObjectProperty(decl, "PageType");
+		}
+
+		const object: ObjectDecl = {
+			id: objectId,
+			appGuid,
+			objectType,
+			objectNumber,
+			name,
+			sourceUnitId,
+			sourceHash,
+			sourceAnchor: {
+				sourceUnitId,
+				range: nodeToSourceRange(decl),
+				enclosingRoutineId: "",
+				syntaxKind: decl.type,
+			},
+			objectSubtype,
+			pageType,
+		};
+
+		let table: Table | undefined;
+		if (objectType === "Table" || objectType === "TableExtension") {
+			table = indexTable(decl, objectId, appGuid, objectNumber, name);
+		}
+
+		results.push({ object, objectNode: decl, objectType, table });
+	}
+
+	return results;
+}

package/src/index/routine-indexer.ts

@@ -0,0 +1,282 @@
+import { sha256Hex, sha256HexBytes } from "../hash.ts";
+import type { AttributeInfo } from "../model/attributes.ts";
+import type {
+	ConditionReference,
+	ControlFlowNode,
+	IntraproceduralFeatures,
+	LoopNode,
+	ObjectDecl,
+	ProcedureAccessModifier,
+	Routine,
+	VarAssignment,
+} from "../model/entities.ts";
+import { type CanonicalRoutineKey, type RoutineKind, encodeRoutineId } from "../model/ids.ts";
+import { collectDescendants, nodeToSourceRange, stripQuotes } from "../parser/ast.ts";
+import type { Node as SyntaxNode } from "../parser/native/wrapper.ts";
+import { attributeInfoFromNode } from "./attribute-from-node.ts";
+import { extractBodyFeatures } from "./intraprocedural-body.ts";
+import { extractParameters, extractRecordVariablesAndParameters } from "./intraprocedural-refs.ts";
+import { canonicalRoutineSignature } from "./routine-signature.ts";
+import { extractVariables } from "./variable-indexer.ts";
+
+export interface IndexRoutinesInput {
+	objectNode: SyntaxNode;
+	object: ObjectDecl;
+	sourceUnitId: string;
+	modelInstanceId: string;
+}
+
+/**
+ * Walk a routine's preceding `attribute_item` sibling nodes once, returning the
+ * routine's classification plus raw attribute texts and structured `AttributeInfo[]`
+ * in document order. Single walk; classification reads parsed attribute names rather
+ * than regex-matching the raw `[…]` text.
+ *
+ * Grammar (V2): each attribute (e.g. `[EventSubscriber(...)]`) is an `attribute_item`
+ * node that is a previous sibling of the procedure/trigger node. Walking stops at the
+ * first non-`attribute_item`, so a prior routine's attributes are never picked up.
+ */
+function classifyAndCollectAttributes(
+	node: SyntaxNode,
+	isTrigger: boolean,
+): { kind: RoutineKind; attributes: string[]; attributesParsed: AttributeInfo[] } {
+	const attributes: string[] = [];
+	const attributesParsed: AttributeInfo[] = [];
+	let kind: RoutineKind = isTrigger ? "trigger" : "procedure";
+	let foundEventKind = false;
+	let sibling = node.previousSibling;
+	while (sibling && sibling.type === "attribute_item") {
+		attributes.unshift(sibling.text);
+		const info = attributeInfoFromNode(sibling);
+		if (info !== null) {
+			attributesParsed.unshift(info);
+			// First-match wins for kind, matching the old behavior (closest sibling wins).
+			// We walk closest-first so the same hit wins, but we *record* by unshifting
+			// to keep document order in the arrays.
+			if (!foundEventKind) {
+				const nameLc = info.name.toLowerCase();
+				if (nameLc === "eventsubscriber") {
+					kind = "event-subscriber";
+					foundEventKind = true;
+				} else if (nameLc === "integrationevent" || nameLc === "businessevent") {
+					kind = "event-publisher";
+					foundEventKind = true;
+				}
+			}
+		}
+		sibling = sibling.previousSibling;
+	}
+	return { kind, attributes, attributesParsed };
+}
+
+/**
+ * Read the `modifier` field on a procedure node (`local`/`internal`/`protected`).
+ * The grammar wraps the keyword in a `procedure_modifier` node whose text is the
+ * lowercase keyword. Returns undefined for triggers (no modifier) and for
+ * default-access procedures (AL's `public` default — modifier field absent).
+ */
+function classifyAccessModifier(node: SyntaxNode): ProcedureAccessModifier | undefined {
+	if (node.type !== "procedure") return undefined;
+	const modifier = node.childForFieldName("modifier");
+	if (modifier === null) return undefined;
+	const text = modifier.text.trim().toLowerCase();
+	if (text === "local") return "local";
+	if (text === "internal") return "internal";
+	if (text === "protected") return "protected";
+	return undefined;
+}
+
+/** Find the code_block child of a procedure or trigger node. */
+function findCodeBlock(node: SyntaxNode): SyntaxNode | null {
+	for (const child of node.namedChildren) {
+		if (child?.type === "code_block") return child;
+	}
+	return null;
+}
+
+/**
+ * Read the return-type text of a procedure / trigger declaration. The grammar
+ * exposes return types as a direct `type_specification` child of `procedure`
+ * (parameter types live inside `parameter` nodes, never directly under
+ * `procedure`, so the first direct `type_specification` is unambiguously the
+ * return type). Triggers and void procedures return undefined.
+ */
+function getReturnTypeText(node: SyntaxNode): string | undefined {
+	for (const child of node.namedChildren) {
+		if (child !== null && child.type === "type_specification") return child.text;
+	}
+	return undefined;
+}
+
+/** True if loop `outer`'s source range strictly contains loop `inner`'s range. */
+function loopStrictlyContains(outer: LoopNode, inner: LoopNode): boolean {
+	if (outer.id === inner.id) return false;
+	const o = outer.sourceAnchor.range;
+	const i = inner.sourceAnchor.range;
+	const startsBefore =
+		o.startLine < i.startLine || (o.startLine === i.startLine && o.startColumn <= i.startColumn);
+	const endsAfter =
+		o.endLine > i.endLine || (o.endLine === i.endLine && o.endColumn >= i.endColumn);
+	return startsBefore && endsAfter;
+}
+
+/**
+ * Compute the maximum loop nesting depth from a routine's loop list.
+ * A loop's depth is 1 + the number of OTHER loops strictly containing it; the
+ * routine's nesting depth is the max across all loops (0 when there are no loops).
+ */
+function computeNestingDepth(loops: LoopNode[]): number {
+	let maxDepth = 0;
+	for (const loop of loops) {
+		const enclosing = loops.filter((other) => loopStrictlyContains(other, loop)).length;
+		const depth = 1 + enclosing;
+		if (depth > maxDepth) maxDepth = depth;
+	}
+	return maxDepth;
+}
+
+/** Index every procedure and trigger in an object declaration node. */
+export function indexRoutines(input: IndexRoutinesInput): Routine[] {
+	const { objectNode, object, sourceUnitId, modelInstanceId } = input;
+	const routines: Routine[] = [];
+
+	// Prune at match: AL has no nested procedures, so once we hit a procedure or
+	// trigger_declaration we don't descend into its body. Without this the discovery
+	// scan re-walks every routine body before extractOpsAndLoops walks it again.
+	const routineNodes = collectDescendants(
+		objectNode,
+		(n) => n.type === "procedure" || n.type === "trigger_declaration",
+		true,
+	);
+
+	for (const node of routineNodes) {
+		const isTrigger = node.type === "trigger_declaration";
+		const nameNode = node.childForFieldName("name");
+		const name = nameNode ? stripQuotes(nameNode.text) : "";
+		if (!name) continue;
+
+		const { kind, attributes, attributesParsed } = classifyAndCollectAttributes(node, isTrigger);
+		const accessModifier = classifyAccessModifier(node);
+
+		// Parameters drive the canonical signature hash. Extract them first
+		// (no routineId required) so `normalizedSignatureHash` uses the structured
+		// form (`canonicalRoutineSignature`) — matching the ABI projection's hash
+		// for the same routine declared in a `.app` symbol package.
+		const parameters = extractParameters(node);
+		const returnTypeText = getReturnTypeText(node);
+		const canonical: CanonicalRoutineKey = {
+			appGuid: object.appGuid,
+			objectType: object.objectType,
+			objectNumber: object.objectNumber,
+			routineKind: kind,
+			routineName: name,
+			normalizedSignatureHash: sha256Hex(
+				canonicalRoutineSignature(name, parameters, returnTypeText),
+			),
+		};
+		const routineId = encodeRoutineId(canonical, modelInstanceId);
+
+		// Single body traversal: loops + record-ops + commits + call sites + field accesses
+		// all come from one DFS over the routine body. Record variables and parameters live
+		// on the procedure node (parameter_list, var_section) and are extracted separately —
+		// they need to be known before body walk so field accesses can be filtered to
+		// known record-var receivers.
+		const body = findCodeBlock(node);
+		const { recordVariables } = extractRecordVariablesAndParameters(node, routineId);
+		const recordVarNamesLc = new Set(recordVariables.map((v) => v.name.toLowerCase()));
+		const bodyResult = body
+			? extractBodyFeatures(
+					body,
+					routineId,
+					sourceUnitId,
+					recordVarNamesLc,
+					parameters,
+					recordVariables,
+				)
+			: {
+					loops: [],
+					operationSites: [],
+					recordOperations: [],
+					callSites: [],
+					fieldAccesses: [],
+					unreachableStatements: [],
+					hasBranching: false,
+					statementTree: undefined as ControlFlowNode | undefined,
+					identifierReferences: [] as string[],
+					varAssignments: [] as VarAssignment[],
+					conditionReferences: [] as ConditionReference[],
+				};
+
+		// Propagate per-record-variable temp state onto each RecordOperation. The body
+		// indexer doesn't know the declaring var's tempState (it sees only the receiver
+		// text), so it emits `tempState: {kind: "unknown"}`. We resolve here by matching
+		// op.recordVariableName (case-insensitive) to a declared RecordVariable and
+		// copying its tempState (also resolves the recordVariableId + tableId carry-over).
+		const recordVarByNameLc = new Map(recordVariables.map((rv) => [rv.name.toLowerCase(), rv]));
+		const recordOperations = bodyResult.recordOperations.map((op) => {
+			const rv = recordVarByNameLc.get(op.recordVariableName.toLowerCase());
+			if (rv === undefined) return op;
+			return {
+				...op,
+				recordVariableId: op.recordVariableId ?? rv.id,
+				tempState: rv.tempState,
+				...(rv.tableId !== undefined ? { tableId: op.tableId ?? rv.tableId } : {}),
+			};
+		});
+
+		const variables = extractVariables(node, routineId, sourceUnitId, parameters, recordVariables);
+
+		const features: IntraproceduralFeatures = {
+			loops: bodyResult.loops,
+			operationSites: bodyResult.operationSites,
+			recordOperations,
+			callSites: bodyResult.callSites,
+			fieldAccesses: bodyResult.fieldAccesses,
+			recordVariables,
+			nestingDepth: computeNestingDepth(bodyResult.loops),
+			unreachableStatements: bodyResult.unreachableStatements,
+			hasBranching: bodyResult.hasBranching,
+			statementTree: bodyResult.statementTree,
+			identifierReferences: bodyResult.identifierReferences,
+			variables,
+			varAssignments: bodyResult.varAssignments,
+			conditionReferences: bodyResult.conditionReferences,
+		};
+
+		// `hasError` is a boolean getter property on SyntaxNode (not a method).
+		routines.push({
+			id: routineId,
+			canonical,
+			objectId: object.id,
+			name,
+			kind,
+			parameters,
+			attributes,
+			attributesParsed,
+			...(accessModifier !== undefined ? { accessModifier } : {}),
+			bodyAvailable: body !== null,
+			parseIncomplete: node.hasError,
+			// Hash the raw UTF-8 source bytes directly — equivalent to sha256Hex(node.text)
+			// for valid UTF-8 (which tree-sitter requires) and skips the JS-string allocation
+			// of the routine body. Big at 50k+ routines.
+			sourceHash: sha256HexBytes(node.textBytes),
+			sourceAnchor: {
+				sourceUnitId,
+				range: nodeToSourceRange(node),
+				enclosingRoutineId: routineId,
+				syntaxKind: node.type,
+			},
+			features,
+		});
+	}
+
+	// `collectDescendants` does not guarantee document order — sort by source position
+	// so callers get routines in the order they appear in the file.
+	routines.sort((a, b) => {
+		const ar = a.sourceAnchor.range;
+		const br = b.sourceAnchor.range;
+		return ar.startLine - br.startLine || ar.startColumn - br.startColumn;
+	});
+
+	return routines;
+}

package/src/index/routine-signature.ts

@@ -0,0 +1,46 @@
+// src/index/routine-signature.ts
+// Canonical routine signature, used as the input to `sha256Hex` for
+// `CanonicalRoutineKey.normalizedSignatureHash` on both sides:
+//   - native AL source (`routine-indexer.ts`)
+//   - .app dependency symbols (`dependency-projection.ts`)
+//
+// Pre-PR-4 the two paths produced *different* hashes for the same routine:
+// native shred raw param-list text (whitespace-stripped, including names),
+// ABI hashed type-only with return type. Same routine in primary source vs
+// the same routine as a dep symbol therefore minted different `RoutineId`s —
+// a latent inconsistency masked only because the two sides never co-resolve.
+//
+// AL overload resolution disambiguates routines by parameter *types*, not
+// names, and return type is part of the signature. The canonical form below
+// matches that: per-parameter `[var ]<type>`, joined with `;`, plus the
+// return type, plus the lowercased routine name. Case-insensitive throughout
+// (AL identifiers are case-insensitive).
+
+import type { ParameterSymbol } from "../model/entities.ts";
+
+/**
+ * Build the deterministic text form hashed into `normalizedSignatureHash`.
+ * Stable across runs and across native/ABI sources for the same routine.
+ *
+ * Format:
+ *   `<name-lc>(<param-spec>;<param-spec>;…):<return-lc>`
+ * where `<param-spec>` is `var <type-lc>` or `<type-lc>`.
+ *
+ * Trims surrounding whitespace from each `typeText` (a defensive normalization
+ * — tree-sitter typeSpec node text is already token-tight) but does NOT touch
+ * inner whitespace, because that may be meaningful inside `quoted_identifier`
+ * table names (`Record "Sales Line"` vs `Record "SalesLine"` are different
+ * tables). The parameter separator is the literal `;`, so per-parameter
+ * boundaries do not need text normalization.
+ */
+export function canonicalRoutineSignature(
+	name: string,
+	parameters: readonly ParameterSymbol[],
+	returnTypeText: string | undefined,
+): string {
+	const params = parameters
+		.map((p) => `${p.isVar ? "var " : ""}${p.typeText.trim().toLowerCase()}`)
+		.join(";");
+	const ret = (returnTypeText ?? "").trim().toLowerCase();
+	return `${name.toLowerCase()}(${params}):${ret}`;
+}