al-sem 0.0.1

package/src/index/expression-from-node.ts

@@ -0,0 +1,117 @@
+// src/index/expression-from-node.ts
+// Build a structured `ExpressionInfo` from a tree-sitter expression node.
+//
+// Used by the body indexer to populate `CallSite.argumentInfos` and
+// `RecordOperation.fieldArgumentInfos`. Same shape regardless of where the
+// expression appears — detectors that need a literal-vs-non-literal decision
+// (D18) or quoted-vs-unquoted name disambiguation (D4, D22) read the
+// resulting `ExpressionInfo` through the `model/expression.ts` helpers
+// instead of re-parsing the raw text.
+
+import type { ExpressionInfo, ExpressionKind } from "../model/expression.ts";
+import type { Node as SyntaxNode } from "../parser/native/wrapper.ts";
+
+/** Strip surrounding single or double quotes. */
+function stripQuoteChars(text: string): string {
+	if (text.length < 2) return text;
+	const first = text[0];
+	const last = text[text.length - 1];
+	if ((first === '"' && last === '"') || (first === "'" && last === "'")) {
+		return text.slice(1, -1);
+	}
+	return text;
+}
+
+/** Map a tree-sitter node type into the closed `ExpressionKind` enum. */
+function kindOf(nodeType: string): ExpressionKind {
+	switch (nodeType) {
+		case "string_literal":
+		case "integer":
+		case "decimal":
+		case "boolean":
+		case "identifier":
+		case "quoted_identifier":
+		case "qualified_enum_value":
+		case "database_reference":
+		case "unary_expression":
+		case "member_expression":
+		case "call_expression":
+		case "parenthesized_expression":
+			return nodeType;
+		default:
+			return "other";
+	}
+}
+
+/**
+ * For `unary_expression`, return the operand's kind when the operand is a
+ * numeric literal (`integer` / `decimal`). The signed text — `text` field —
+ * acts as the value. Used by D18 to treat `-5` / `+5.5` as loop-invariant
+ * literals just like a bare `5`.
+ */
+function unaryLiteralValue(node: SyntaxNode, text: string): string | undefined {
+	for (const child of node.namedChildren) {
+		if (child === null) continue;
+		if (child.type === "integer" || child.type === "decimal") return text;
+		return undefined;
+	}
+	return undefined;
+}
+
+/** Pull derived `value` / `qualifier` / `member` fields for the kinds that have them. */
+function deriveParts(
+	node: SyntaxNode,
+	kind: ExpressionKind,
+	text: string,
+): { value?: string; qualifier?: string; member?: string } {
+	switch (kind) {
+		case "string_literal":
+		case "quoted_identifier":
+			return { value: stripQuoteChars(text) };
+		case "integer":
+		case "decimal":
+		case "boolean":
+		case "identifier":
+			return { value: text };
+		case "qualified_enum_value": {
+			const qualifier = node.childForFieldName("enum_type")?.text;
+			const memberRaw = node.childForFieldName("value")?.text;
+			const member = memberRaw !== undefined ? stripQuoteChars(memberRaw) : undefined;
+			return {
+				value: member,
+				...(qualifier !== undefined ? { qualifier } : {}),
+				...(member !== undefined ? { member } : {}),
+			};
+		}
+		case "database_reference": {
+			const qualifier = node.childForFieldName("keyword")?.text;
+			const memberRaw = node.childForFieldName("table_name")?.text;
+			const member = memberRaw !== undefined ? stripQuoteChars(memberRaw) : undefined;
+			return {
+				value: member,
+				...(qualifier !== undefined ? { qualifier } : {}),
+				...(member !== undefined ? { member } : {}),
+			};
+		}
+		case "unary_expression": {
+			const value = unaryLiteralValue(node, text);
+			return value !== undefined ? { value } : {};
+		}
+		default:
+			return {};
+	}
+}
+
+/** Build an `ExpressionInfo` from an arbitrary expression node. */
+export function expressionInfoFromNode(node: SyntaxNode): ExpressionInfo {
+	const kind = kindOf(node.type);
+	const text = node.text;
+	const parts = deriveParts(node, kind, text);
+	return {
+		kind,
+		text,
+		...(parts.value !== undefined ? { value: parts.value } : {}),
+		...(parts.qualifier !== undefined ? { qualifier: parts.qualifier } : {}),
+		...(parts.member !== undefined ? { member: parts.member } : {}),
+	};
+}

package/src/index/indexer.ts

@@ -0,0 +1,102 @@
+import { sha256Hex } from "../hash.ts";
+import type { App } from "../model/entities.ts";
+import type { Diagnostic } from "../model/finding.ts";
+import type { ModelIdentity } from "../model/identity.ts";
+import type { SemanticIndex } from "../model/model.ts";
+import { NativeParserUnavailableError, parseALSource } from "../parser/parser-init.ts";
+import type { SourceUnit } from "../providers/types.ts";
+import { indexObjects } from "./object-indexer.ts";
+import { indexRoutines } from "./routine-indexer.ts";
+
+export interface BuildIndexResult {
+	index: SemanticIndex;
+	diagnostics: Diagnostic[];
+}
+
+/**
+ * Parse and index every source unit into a SemanticIndex. Parse/index failures degrade
+ * gracefully: the offending unit is skipped with a diagnostic; other units still index.
+ */
+export async function buildSemanticIndex(
+	units: SourceUnit[],
+	identity: ModelIdentity,
+	modelInstanceId: string,
+): Promise<BuildIndexResult> {
+	const diagnostics: Diagnostic[] = [];
+	const index: SemanticIndex = {
+		identity,
+		apps: identity.apps.map(
+			(a): App => ({
+				appGuid: a.appGuid,
+				publisher: a.publisher,
+				name: a.name,
+				version: a.version,
+			}),
+		),
+		objects: [],
+		routines: [],
+		tables: [],
+	};
+
+	let parserDownGuard = false;
+	for (const unit of units) {
+		if (parserDownGuard) break;
+		if (unit.kind !== "source" || unit.content === undefined) continue;
+		let tree: Awaited<ReturnType<typeof parseALSource>> | undefined;
+		try {
+			tree = await parseALSource(unit.content);
+			const sourceHash = sha256Hex(unit.content);
+			const objResults = indexObjects({
+				tree,
+				appGuid: unit.appGuid,
+				sourceUnitId: unit.id,
+				modelInstanceId,
+				sourceHash,
+			});
+			if (objResults.length === 0) {
+				diagnostics.push({
+					severity: "info",
+					stage: "index",
+					message: `No object declaration found in ${unit.relativePath}`,
+					sourceRef: unit.id,
+				});
+				continue;
+			}
+			for (const objResult of objResults) {
+				if (!objResult.object || !objResult.objectNode) continue;
+				objResult.object.analysisRole = unit.analysisRole ?? "primary";
+				index.objects.push(objResult.object);
+				if (objResult.table) index.tables.push(objResult.table);
+				const routines = indexRoutines({
+					objectNode: objResult.objectNode,
+					object: objResult.object,
+					sourceUnitId: unit.id,
+					modelInstanceId,
+				});
+				for (const r of routines) r.analysisRole = unit.analysisRole ?? "primary";
+				index.routines.push(...routines);
+			}
+		} catch (err) {
+			if (err instanceof NativeParserUnavailableError) {
+				diagnostics.push({
+					severity: "error",
+					stage: "parse",
+					message: `[PARSER001] native parser unavailable: ${err.message}`,
+				});
+				parserDownGuard = true;
+				continue;
+			}
+			diagnostics.push({
+				severity: "warning",
+				stage: "index",
+				message: `Failed to index ${unit.relativePath}: ${(err as Error).message}`,
+				sourceRef: unit.id,
+			});
+		} finally {
+			// Free WASM-backed tree-sitter `Tree` — JS GC alone doesn't reclaim it.
+			tree?.delete();
+		}
+	}
+
+	return { index, diagnostics };
+}