al-sem 0.0.1

package/src/engine/combined-graph.ts

@@ -0,0 +1,357 @@
+import type { ObjectRunKind } from "../model/callee.ts";
+import type { ValueSource } from "../model/capability.ts";
+import type { CallSite } from "../model/entities.ts";
+import type { GraphEdge } from "../model/graph-edge.ts";
+import type { DispatchKind, ResolutionQuality } from "../model/graph.ts";
+import type { CallsiteId, EventId, ObjectId, OperationId, RoutineId } from "../model/ids.ts";
+import type { SemanticModel } from "../model/model.ts";
+import type { Uncertainty } from "../model/summary.ts";
+import { compareStrings } from "./uncertainty-util.ts";
+
+/** The origin kind of a combined-graph edge. */
+export type CombinedEdgeKind =
+	| "direct"
+	| "method"
+	| "codeunit-run"
+	| "report-run"
+	| "page-run"
+	| "interface"
+	| "implicit-trigger"
+	| "event-dispatch"
+	| "dynamic";
+
+/** A resolved routine -> routine edge in the combined graph. */
+export interface CombinedEdge {
+	from: RoutineId;
+	to: RoutineId;
+	kind: CombinedEdgeKind;
+	callsiteId?: CallsiteId; // present for call-derived edges
+	operationId?: OperationId; // present for call-derived edges
+	eventId?: EventId; // present for event-dispatch edges
+	subscriberAppId?: string; // present for event-dispatch edges
+	resolution: ResolutionQuality;
+}
+
+/** An uncertainty attached to a routine because one of its call sites had no resolved target. */
+export interface UncertaintyEdge {
+	from: RoutineId;
+	uncertainty: Uncertainty;
+}
+
+/** The combined call + event + implicit-trigger graph the summary engine and path-walker traverse. */
+export interface CombinedGraph {
+	nodes: RoutineId[]; // sorted
+	edgesByFrom: Map<RoutineId, CombinedEdge[]>; // each list sorted
+	uncertaintyEdges: UncertaintyEdge[]; // sorted
+}
+
+/** The object-run dispatch kinds that map to typed GraphEdge object-run variants. */
+const OBJECT_RUN_KINDS: ReadonlySet<DispatchKind> = new Set<DispatchKind>([
+	"codeunit-run",
+	"page-run",
+	"report-run",
+]);
+
+/** Map a call-graph dispatchKind to the GraphEdge objectType field. */
+function dispatchKindToObjectType(
+	dispatchKind: DispatchKind,
+): "Codeunit" | "Page" | "Report" | undefined {
+	if (dispatchKind === "codeunit-run") return "Codeunit";
+	if (dispatchKind === "page-run") return "Page";
+	if (dispatchKind === "report-run") return "Report";
+	return undefined;
+}
+
+/** Build a ValueSource for an object-run callsite's target id. */
+function objectRunTargetIdSource(callSite: CallSite): ValueSource {
+	if (callSite.callee.kind !== "object-run") return { kind: "unknown" };
+	const c = callSite.callee;
+	if (c.targetRef === undefined) {
+		// Dynamic — no static info about which object
+		return { kind: "expression" };
+	}
+	if (c.targetIsName) {
+		// Named object — treat as an enum reference (objectKind::"name")
+		return { kind: "enum", enumName: c.objectKind, member: c.targetRef };
+	}
+	// Numeric object id — literal
+	return { kind: "literal", value: c.targetRef };
+}
+
+/**
+ * Derive the target ObjectId for an object-run callee when the targetRef is
+ * statically known but the routine entry wasn't resolved (opaque dep). Returns
+ * undefined when the target is fully dynamic.
+ */
+function objectRunTargetObject(
+	callSite: CallSite,
+	objectsByTypeNumber: Map<string, ObjectId>,
+	objectsByTypeName: Map<string, ObjectId>,
+): ObjectId | undefined {
+	if (callSite.callee.kind !== "object-run") return undefined;
+	const c = callSite.callee;
+	if (c.targetRef === undefined) return undefined;
+	if (c.targetIsName) {
+		return objectsByTypeName.get(`${c.targetType.toLowerCase()}/${c.targetRef.toLowerCase()}`);
+	}
+	return objectsByTypeNumber.get(`${c.targetType.toLowerCase()}/${c.targetRef}`);
+}
+
+// CallGraph dispatchKinds that become resolved routine->routine edges (when `to` is set).
+const EDGE_KINDS: ReadonlySet<DispatchKind> = new Set<DispatchKind>([
+	"direct",
+	"method",
+	"codeunit-run",
+	"report-run",
+	"page-run",
+	"interface",
+	"implicit-trigger",
+	"dynamic",
+]);
+
+function edgeSortKey(e: CombinedEdge): string {
+	return `${e.kind}|${e.callsiteId ?? e.operationId ?? e.eventId ?? ""}|${e.to}`;
+}
+
+function uncertaintySortKey(ue: UncertaintyEdge): string {
+	const u = ue.uncertainty;
+	const ref = "callsiteId" in u ? u.callsiteId : "operationId" in u ? u.operationId : u.routineId;
+	return `${ue.from}|${u.kind}|${ref}`;
+}
+
+/**
+ * Build the typed `GraphEdge[]` for the Phase 0b-β typed edge layer.
+ *
+ * Kinds emitted here:
+ *   direct-call           — resolved bare/direct procedure→procedure call
+ *   object-run-resolved   — Codeunit/Page/Report.Run with a resolved entry routine
+ *   object-run-unresolved — Codeunit/Page/Report.Run with dynamic or opaque target,
+ *                           or a `dynamic` dispatchKind (variable-typed Run)
+ *   event-dispatch        — composed publisher→subscriber edge (Task 20)
+ *
+ * Implicit-trigger and dependency-export edges are deferred to Tasks 21+.
+ */
+function buildTypedEdges(model: SemanticModel): GraphEdge[] {
+	// --- look-up maps built from the model ---
+	// callsite id → CallSite (for sourceAnchor + callee details)
+	const callSiteById = new Map<CallsiteId, CallSite>();
+	for (const routine of model.routines) {
+		for (const cs of routine.features.callSites) {
+			callSiteById.set(cs.id, cs);
+		}
+	}
+	// routine id → Routine (for sourceAnchor on publisher/subscriber)
+	const routineById = new Map<RoutineId, (typeof model.routines)[number]>();
+	for (const routine of model.routines) {
+		routineById.set(routine.id, routine);
+	}
+	// routine id → objectId (for resolved object-run target)
+	const objectIdByRoutineId = new Map<RoutineId, ObjectId>();
+	for (const routine of model.routines) {
+		objectIdByRoutineId.set(routine.id, routine.objectId);
+	}
+	// object type+number / type+name → objectId (for unresolved object-run target)
+	const objectsByTypeNumber = new Map<string, ObjectId>();
+	const objectsByTypeName = new Map<string, ObjectId>();
+	for (const obj of model.objects) {
+		objectsByTypeNumber.set(`${obj.objectType.toLowerCase()}/${obj.objectNumber}`, obj.id);
+		objectsByTypeName.set(`${obj.objectType.toLowerCase()}/${obj.name.toLowerCase()}`, obj.id);
+	}
+
+	const typedEdges: GraphEdge[] = [];
+
+	for (const ce of model.callGraph) {
+		if (ce.dispatchKind === "event-dispatch" || ce.dispatchKind === "implicit-trigger") continue;
+
+		const callSite = callSiteById.get(ce.callsiteId);
+		if (callSite === undefined) continue; // opaque (dependency-only) callsite — skip
+
+		const sourceAnchor = callSite.sourceAnchor;
+
+		if (ce.to !== undefined) {
+			// Resolved edges
+			if (ce.dispatchKind === "direct" || ce.dispatchKind === "method") {
+				typedEdges.push({
+					kind: "direct-call",
+					callsiteId: ce.callsiteId,
+					from: ce.from,
+					to: ce.to,
+					sourceAnchor,
+				});
+			} else if (OBJECT_RUN_KINDS.has(ce.dispatchKind)) {
+				const objectType = dispatchKindToObjectType(ce.dispatchKind);
+				if (objectType === undefined) continue;
+				// Resolved: target routine is known; derive its object id
+				const targetObject = objectIdByRoutineId.get(ce.to);
+				if (targetObject === undefined) continue; // should not happen in a sound model
+				typedEdges.push({
+					kind: "object-run-resolved",
+					callsiteId: ce.callsiteId,
+					from: ce.from,
+					to: ce.to,
+					targetObject,
+					objectType,
+					sourceAnchor,
+				});
+			}
+			// interface / unresolved with a `to` — skip (should be rare; not a typed kind yet)
+		} else {
+			// Unresolved edges
+			if (OBJECT_RUN_KINDS.has(ce.dispatchKind)) {
+				// Static target exists but the entry routine isn't in the index (opaque dep)
+				const objectType = dispatchKindToObjectType(ce.dispatchKind);
+				if (objectType === undefined) continue;
+				const targetIdSource = objectRunTargetIdSource(callSite);
+				const targetObject = objectRunTargetObject(
+					callSite,
+					objectsByTypeNumber,
+					objectsByTypeName,
+				);
+				typedEdges.push({
+					kind: "object-run-unresolved",
+					callsiteId: ce.callsiteId,
+					from: ce.from,
+					...(targetObject !== undefined ? { targetObject } : {}),
+					targetIdSource,
+					objectType,
+					sourceAnchor,
+				});
+			} else if (ce.dispatchKind === "dynamic") {
+				// Dynamic dispatch — we don't know objectType without checking the callee
+				if (callSite.callee.kind === "object-run") {
+					const objectType = callSite.callee.objectKind as "Codeunit" | "Page" | "Report";
+					const targetIdSource = objectRunTargetIdSource(callSite);
+					typedEdges.push({
+						kind: "object-run-unresolved",
+						callsiteId: ce.callsiteId,
+						from: ce.from,
+						targetIdSource,
+						objectType,
+						sourceAnchor,
+					});
+				}
+				// dynamic member call (method dispatch) — not an object-run; skip
+			}
+			// interface / unresolved bare call — skip (not yet a typed kind)
+		}
+	}
+
+	// --- event-dispatch edges (Task 20): bipartite publisher → subscriber composition ---
+	const subsByEventTyped = new Map<EventId, typeof model.eventGraph.edges>();
+	for (const ee of model.eventGraph.edges) {
+		const list = subsByEventTyped.get(ee.eventId);
+		if (list) list.push(ee);
+		else subsByEventTyped.set(ee.eventId, [ee]);
+	}
+	for (const sym of model.eventGraph.events) {
+		if (sym.publisherRoutineId === undefined) continue;
+		const publisherRoutine = routineById.get(sym.publisherRoutineId);
+		if (publisherRoutine === undefined) continue;
+		for (const ee of subsByEventTyped.get(sym.id) ?? []) {
+			const subscriberRoutine = routineById.get(ee.subscriberRoutineId);
+			if (subscriberRoutine === undefined) continue;
+			typedEdges.push({
+				kind: "event-dispatch",
+				from: sym.publisherRoutineId,
+				to: ee.subscriberRoutineId,
+				eventId: sym.id,
+				publishAnchor: publisherRoutine.sourceAnchor,
+				subscriberAnchor: subscriberRoutine.sourceAnchor,
+			});
+		}
+	}
+
+	return typedEdges;
+}
+
+/**
+ * Build the combined graph + populate `model.typedEdges` as a side effect.
+ *
+ * Idempotent on already-populated models — `analyzeWorkspace` calls this
+ * before returning the model, so downstream consumers receive a populated
+ * `model.typedEdges`. Re-calling produces an identical result; the call is
+ * safe but wasteful. Don't re-invoke from CLI runners or detectors.
+ *
+ * Resolved CallEdges (and event-dispatch hops derived from the event graph)
+ * become CombinedEdges; to-less CallEdges become UncertaintyEdges. The
+ * `event-dispatch` dispatchKind on CallEdges is intentionally skipped here —
+ * event hops are generated once from `model.eventGraph` to avoid double counting.
+ */
+export function buildCombinedGraph(model: SemanticModel): CombinedGraph {
+	const edges: CombinedEdge[] = [];
+	const uncertaintyEdges: UncertaintyEdge[] = [];
+
+	// --- call-derived edges + uncertainty records ---
+	for (const ce of model.callGraph) {
+		if (ce.dispatchKind === "event-dispatch") continue; // event hops come from the event graph
+		if (ce.to !== undefined) {
+			if (EDGE_KINDS.has(ce.dispatchKind)) {
+				edges.push({
+					from: ce.from,
+					to: ce.to,
+					kind: ce.dispatchKind as CombinedEdgeKind,
+					callsiteId: ce.callsiteId,
+					operationId: ce.operationId,
+					resolution: ce.resolution,
+				});
+			}
+			continue;
+		}
+		// to-less edge -> typed uncertainty on the `from` routine
+		if (ce.dispatchKind === "interface") {
+			uncertaintyEdges.push({
+				from: ce.from,
+				uncertainty: { kind: "interface-dispatch", callsiteId: ce.callsiteId },
+			});
+		} else if (ce.dispatchKind === "dynamic") {
+			uncertaintyEdges.push({
+				from: ce.from,
+				uncertainty: { kind: "dynamic-dispatch", operationId: ce.operationId },
+			});
+		} else {
+			uncertaintyEdges.push({
+				from: ce.from,
+				uncertainty: { kind: "unresolved-call", callsiteId: ce.callsiteId },
+			});
+		}
+	}
+
+	// --- event-dispatch edges: publisher routine -> subscriber routine ---
+	const subsByEvent = new Map<EventId, typeof model.eventGraph.edges>();
+	for (const ee of model.eventGraph.edges) {
+		const list = subsByEvent.get(ee.eventId);
+		if (list) list.push(ee);
+		else subsByEvent.set(ee.eventId, [ee]);
+	}
+	for (const sym of model.eventGraph.events) {
+		if (sym.publisherRoutineId === undefined) continue;
+		for (const ee of subsByEvent.get(sym.id) ?? []) {
+			edges.push({
+				from: sym.publisherRoutineId,
+				to: ee.subscriberRoutineId,
+				kind: "event-dispatch",
+				eventId: sym.id,
+				subscriberAppId: ee.subscriberAppId,
+				resolution: ee.resolution,
+			});
+		}
+	}
+
+	// --- assemble: sorted nodes, sorted edge lists, sorted uncertainty edges ---
+	const nodes = model.routines.map((r) => r.id).sort();
+	const edgesByFrom = new Map<RoutineId, CombinedEdge[]>();
+	for (const e of edges) {
+		const list = edgesByFrom.get(e.from);
+		if (list) list.push(e);
+		else edgesByFrom.set(e.from, [e]);
+	}
+	for (const list of edgesByFrom.values()) {
+		list.sort((a, b) => compareStrings(edgeSortKey(a), edgeSortKey(b)));
+	}
+	uncertaintyEdges.sort((a, b) => compareStrings(uncertaintySortKey(a), uncertaintySortKey(b)));
+
+	// --- typed GraphEdge[] (Phase 0b-β Task 19) — attached to the model in-place ---
+	model.typedEdges = buildTypedEdges(model);
+
+	return { nodes, edgesByFrom, uncertaintyEdges };
+}