@hatchingpoint/point 0.0.3 → 0.0.6

package/src/semantic/ast.ts

@@ -0,0 +1,230 @@
+import type { PointSourceSpan } from "../core/ast.ts";
+
+export interface PointSemanticProgram {
+	kind: "semanticProgram";
+	module?: string;
+	uses: PointSemanticUseDeclaration[];
+	declarations: PointSemanticDeclaration[];
+	span?: PointSourceSpan;
+}
+
+export interface PointSemanticUseDeclaration {
+	kind: "use";
+	moduleName: string;
+	from?: string;
+	span?: PointSourceSpan;
+}
+
+export type PointSemanticDeclaration =
+	| PointSemanticRecordDeclaration
+	| PointSemanticCalculationDeclaration
+	| PointSemanticRuleDeclaration
+	| PointSemanticLabelDeclaration
+	| PointSemanticExternalDeclaration
+	| PointSemanticActionDeclaration
+	| PointSemanticPolicyDeclaration
+	| PointSemanticViewDeclaration
+	| PointSemanticRouteDeclaration
+	| PointSemanticWorkflowDeclaration
+	| PointSemanticCommandDeclaration;
+
+export interface PointSemanticRecordDeclaration {
+	kind: "record";
+	name: string;
+	fields: PointSemanticField[];
+	span?: PointSourceSpan;
+}
+
+export interface PointSemanticField {
+	label: string;
+	type: PointSemanticTypeExpression;
+	span?: PointSourceSpan;
+}
+
+export interface PointSemanticBinding {
+	label: string;
+	type: PointSemanticTypeExpression;
+	span?: PointSourceSpan;
+}
+
+export interface PointSemanticOutputBinding {
+	name: string;
+	type: PointSemanticTypeExpression;
+	span?: PointSourceSpan;
+}
+
+export interface PointSemanticCalculationDeclaration {
+	kind: "calculation";
+	name: string;
+	inputs: PointSemanticBinding[];
+	output: PointSemanticOutputBinding;
+	body: PointSemanticCalculationStatement[];
+	span?: PointSourceSpan;
+}
+
+export interface PointSemanticRuleDeclaration {
+	kind: "rule";
+	name: string;
+	inputs: PointSemanticBinding[];
+	output: PointSemanticOutputBinding;
+	body: PointSemanticRuleStatement[];
+	span?: PointSourceSpan;
+}
+
+export interface PointSemanticLabelDeclaration {
+	kind: "label";
+	name: string;
+	inputs: PointSemanticBinding[];
+	output: PointSemanticOutputBinding;
+	body: PointSemanticLabelStatement[];
+	span?: PointSourceSpan;
+}
+
+export interface PointSemanticExternalDeclaration {
+	kind: "external";
+	name: string;
+	functions: PointSemanticExternalFunction[];
+	span?: PointSourceSpan;
+}
+
+export interface PointSemanticExternalFunction {
+	label: string;
+	params: PointSemanticBinding[];
+	returnType: PointSemanticTypeExpression;
+	from: string;
+	importAs?: string;
+	span?: PointSourceSpan;
+}
+
+export interface PointSemanticActionDeclaration {
+	kind: "action";
+	name: string;
+	inputs: PointSemanticBinding[];
+	output: PointSemanticOutputBinding;
+	touches: string[];
+	body: PointSemanticActionStatement[];
+	span?: PointSourceSpan;
+}
+
+export interface PointSemanticPolicyDeclaration {
+	kind: "policy";
+	name: string;
+	inputs: PointSemanticBinding[];
+	body: PointSemanticPolicyStatement[];
+	span?: PointSourceSpan;
+}
+
+export interface PointSemanticViewDeclaration {
+	kind: "view";
+	name: string;
+	inputs: PointSemanticBinding[];
+	output: PointSemanticOutputBinding;
+	body: PointSemanticViewStatement[];
+	span?: PointSourceSpan;
+}
+
+export interface PointSemanticRouteDeclaration {
+	kind: "route";
+	name: string;
+	method: string;
+	path: string;
+	inputs: PointSemanticBinding[];
+	output: PointSemanticOutputBinding;
+	body: PointSemanticRouteStatement[];
+	span?: PointSourceSpan;
+}
+
+export interface PointSemanticWorkflowDeclaration {
+	kind: "workflow";
+	name: string;
+	inputs: PointSemanticBinding[];
+	output: PointSemanticOutputBinding;
+	body: PointSemanticWorkflowStatement[];
+	span?: PointSourceSpan;
+}
+
+export interface PointSemanticCommandDeclaration {
+	kind: "command";
+	name: string;
+	inputs: PointSemanticBinding[];
+	output: PointSemanticOutputBinding;
+	body: PointSemanticCommandStatement[];
+	span?: PointSourceSpan;
+}
+
+export type PointSemanticCalculationStatement =
+	| { kind: "assignIs"; name: string; value: PointSemanticExpression; span?: PointSourceSpan }
+	| { kind: "startsAt"; name: string; value: PointSemanticExpression; span?: PointSourceSpan }
+	| { kind: "startsAs"; name: string; value: PointSemanticExpression; span?: PointSourceSpan }
+	| { kind: "forEach"; item: string; iterable: PointSemanticExpression; body: PointSemanticMutationStatement[]; span?: PointSourceSpan }
+	| PointSemanticMutationStatement
+	| { kind: "return"; value: PointSemanticExpression; span?: PointSourceSpan };
+
+export type PointSemanticRuleStatement =
+	| { kind: "startsAt"; name: string; value: PointSemanticExpression; span?: PointSourceSpan }
+	| { kind: "addWhen"; amount: PointSemanticExpression; condition: PointSemanticExpression; span?: PointSourceSpan }
+	| { kind: "forEach"; item: string; iterable: PointSemanticExpression; body: PointSemanticMutationStatement[]; span?: PointSourceSpan }
+	| PointSemanticMutationStatement
+	| { kind: "return"; value: PointSemanticExpression; span?: PointSourceSpan };
+
+export type PointSemanticLabelStatement =
+	| { kind: "whenReturn"; condition: PointSemanticExpression; value: PointSemanticExpression; span?: PointSourceSpan }
+	| { kind: "otherwiseReturn"; value: PointSemanticExpression; span?: PointSourceSpan };
+
+export type PointSemanticActionStatement =
+	| { kind: "return"; value: PointSemanticExpression; span?: PointSourceSpan }
+	| { kind: "expression"; value: PointSemanticExpression; span?: PointSourceSpan };
+
+export type PointSemanticPolicyStatement =
+	| { kind: "allow"; condition: PointSemanticExpression; span?: PointSourceSpan }
+	| { kind: "deny"; condition: PointSemanticExpression; span?: PointSourceSpan }
+	| { kind: "require"; condition: PointSemanticExpression; span?: PointSourceSpan };
+
+export type PointSemanticViewStatement =
+	| { kind: "render"; value: PointSemanticExpression; span?: PointSourceSpan }
+	| { kind: "whenRender"; condition: PointSemanticExpression; value: PointSemanticExpression; span?: PointSourceSpan };
+
+export type PointSemanticRouteStatement = { kind: "return"; value: PointSemanticExpression; span?: PointSourceSpan };
+
+export type PointSemanticWorkflowStatement =
+	| { kind: "step"; name: string; value: PointSemanticExpression; span?: PointSourceSpan }
+	| { kind: "return"; value: PointSemanticExpression; span?: PointSourceSpan };
+
+export type PointSemanticCommandStatement = { kind: "return"; value: PointSemanticExpression; span?: PointSourceSpan };
+
+export type PointSemanticMutationStatement =
+	| { kind: "addTo"; amount: PointSemanticExpression; target: string; span?: PointSourceSpan }
+	| { kind: "subtractFrom"; amount: PointSemanticExpression; target: string; span?: PointSourceSpan }
+	| { kind: "setTo"; target: string; value: PointSemanticExpression; span?: PointSourceSpan };
+
+export interface PointSemanticTypeExpression {
+	kind: "typeRef";
+	name: string;
+	args: PointSemanticTypeExpression[];
+	span?: PointSourceSpan;
+}
+
+export type PointSemanticExpression =
+	| { kind: "literal"; value: string | number | boolean | null; span?: PointSourceSpan }
+	| { kind: "name"; label: string; span?: PointSourceSpan }
+	| { kind: "property"; target: PointSemanticExpression; label: string; span?: PointSourceSpan }
+	| { kind: "list"; items: PointSemanticExpression[]; span?: PointSourceSpan }
+	| { kind: "record"; fields: PointSemanticRecordLiteralField[]; span?: PointSourceSpan }
+	| { kind: "call"; callee: string; args: PointSemanticExpression[]; span?: PointSourceSpan }
+	| { kind: "await"; value: PointSemanticExpression; span?: PointSourceSpan }
+	| { kind: "error"; message: string; span?: PointSourceSpan }
+	| {
+			kind: "binary";
+			operator: PointSemanticBinaryOperator;
+			left: PointSemanticExpression;
+			right: PointSemanticExpression;
+			span?: PointSourceSpan;
+	  };
+
+export interface PointSemanticRecordLiteralField {
+	label: string;
+	value: PointSemanticExpression;
+	span?: PointSourceSpan;
+}
+
+export type PointSemanticBinaryOperator = "+" | "-" | "*" | "/" | "==" | "!=" | "<" | "<=" | ">" | ">=" | "and" | "or";

package/src/semantic/callables.ts

@@ -0,0 +1,51 @@
+const CALLABLE_KEYWORDS = [
+	"calculation",
+	"rule",
+	"label",
+	"action",
+	"view",
+	"route",
+	"workflow",
+	"command",
+] as const;
+
+export function collectSemanticCallables(source: string): string[] {
+	const callables = new Set<string>();
+	const lines = source.split(/\r?\n/);
+	let index = 0;
+	while (index < lines.length) {
+		const trimmed = (lines[index] ?? "").trim();
+		if (trimmed.startsWith("external ")) {
+			const body = collectBody(lines, index + 1);
+			for (const line of body.lines) {
+				const match = line.match(/^(.+)\(/);
+				if (match) callables.add(match[1]?.trim() ?? "");
+			}
+			index = body.next;
+			continue;
+		}
+		for (const keyword of CALLABLE_KEYWORDS) {
+			if (trimmed.startsWith(`${keyword} `)) {
+				callables.add(trimmed.slice(keyword.length + 1).trim());
+			}
+		}
+		index += 1;
+	}
+	return [...callables];
+}
+
+function collectBody(lines: string[], start: number): { lines: string[]; next: number } {
+	const body: string[] = [];
+	let index = start;
+	for (; index < lines.length; index += 1) {
+		const trimmed = (lines[index] ?? "").trim();
+		if (!trimmed) continue;
+		if (isTopLevel(trimmed)) break;
+		body.push(trimmed);
+	}
+	return { lines: body, next: index };
+}
+
+function isTopLevel(line: string): boolean {
+	return /^(module|use|record|calculation|rule|label|external|action|policy|view|route|workflow|command)\s+/.test(line);
+}

package/src/semantic/context.ts

@@ -0,0 +1,347 @@
+import type { PointCoreProgram, PointSourceSpan } from "../core/ast.ts";
+import type { PointCoreDiagnostic } from "../core/check.ts";
+import { mapDiagnosticsToSemanticRefs } from "../core/context.ts";
+import type {
+	PointSemanticBinding,
+	PointSemanticDeclaration,
+	PointSemanticExpression,
+	PointSemanticOutputBinding,
+	PointSemanticProgram,
+	PointSemanticTypeExpression,
+} from "./ast.ts";
+
+function formatSemanticType(type: PointSemanticTypeExpression): string {
+	if (type.args.length === 0) return type.name;
+	return `${type.name}<${type.args.map(formatSemanticType).join(", ")}>`;
+}
+
+export type PointSemanticSymbolKind =
+	| "module"
+	| "use"
+	| "record"
+	| "field"
+	| "calculation"
+	| "rule"
+	| "label"
+	| "external"
+	| "action"
+	| "policy"
+	| "view"
+	| "route"
+	| "workflow"
+	| "command"
+	| "param";
+
+export interface PointSemanticSymbol {
+	ref: string;
+	path: string;
+	kind: PointSemanticSymbolKind;
+	name: string;
+	module: string;
+	type?: string;
+	from?: string;
+	effects?: string[];
+	span: PointSourceSpan | null;
+}
+
+export interface PointSemanticIndex {
+	schemaVersion: "point.semantic.index.v1";
+	module: string;
+	refs: PointSemanticSymbol[];
+}
+
+export interface PointSemanticExplanation {
+	schemaVersion: "point.semantic.explain.v1";
+	ref: string;
+	found: boolean;
+	symbol?: PointSemanticSymbol;
+	relatedRefs: string[];
+	summary: string;
+}
+
+export function createSemanticIndex(program: PointSemanticProgram): PointSemanticIndex {
+	const moduleName = program.module ?? "anonymous";
+	const refs: PointSemanticSymbol[] = [
+		{
+			ref: semanticRefFor(moduleName, "module"),
+			path: "module",
+			kind: "module",
+			name: moduleName,
+			module: moduleName,
+			span: program.span ?? null,
+		},
+		...program.uses.map((use) => ({
+			ref: semanticRefFor(moduleName, `use.${use.moduleName}`),
+			path: `use.${use.moduleName}`,
+			kind: "use" as const,
+			name: use.moduleName,
+			module: moduleName,
+			from: use.from,
+			span: use.span ?? null,
+		})),
+	];
+	for (const declaration of program.declarations) {
+		refs.push(...symbolsForDeclaration(moduleName, declaration));
+	}
+	return { schemaVersion: "point.semantic.index.v1", module: moduleName, refs };
+}
+
+export function explainSemanticRef(program: PointSemanticProgram, ref: string): PointSemanticExplanation {
+	const index = createSemanticIndex(program);
+	const symbol = index.refs.find((candidate) => candidate.ref === ref);
+	if (!symbol) {
+		return {
+			schemaVersion: "point.semantic.explain.v1",
+			ref,
+			found: false,
+			relatedRefs: [],
+			summary: `No Point symbol found for ${ref}.`,
+		};
+	}
+	const relatedRefs = relatedRefsFor(symbol, index);
+	return {
+		schemaVersion: "point.semantic.explain.v1",
+		ref,
+		found: true,
+		symbol,
+		relatedRefs,
+		summary: summaryFor(symbol),
+	};
+}
+
+export function mapPublicDiagnostics(program: PointCoreProgram, diagnostics: PointCoreDiagnostic[]): PointCoreDiagnostic[] {
+	const mapped = mapDiagnosticsToSemanticRefs(program, diagnostics);
+	if (!program.semanticSource) return mapped;
+	return mapped.map((diagnostic) => ({
+		...diagnostic,
+		span: diagnostic.span ?? semanticSpanForDiagnosticPath(program.semanticSource!, program, diagnostic.path),
+	}));
+}
+
+function symbolsForDeclaration(moduleName: string, declaration: PointSemanticDeclaration): PointSemanticSymbol[] {
+	if (declaration.kind === "record") {
+		const recordPath = `record.${declaration.name}`;
+		return [
+			{
+				ref: semanticRefFor(moduleName, recordPath),
+				path: recordPath,
+				kind: "record",
+				name: declaration.name,
+				module: moduleName,
+				span: declaration.span ?? null,
+			},
+			...declaration.fields.map((field) => ({
+				ref: semanticRefFor(moduleName, `${recordPath}.field.${field.label}`),
+				path: `${recordPath}.field.${field.label}`,
+				kind: "field" as const,
+				name: field.label,
+				module: moduleName,
+				type: formatSemanticType(field.type),
+				span: field.span ?? null,
+			})),
+		];
+	}
+	if (declaration.kind === "external") {
+		return declaration.functions.flatMap((fn) => {
+			const path = `external.${fn.label}`;
+			return [
+				{
+					ref: semanticRefFor(moduleName, path),
+					path,
+					kind: "external" as const,
+					name: fn.label,
+					module: moduleName,
+					type: formatSemanticType(fn.returnType),
+					from: fn.from,
+					span: fn.span ?? null,
+				},
+				...bindingSymbols(moduleName, path, fn.params),
+			];
+		});
+	}
+	const callable = callableDeclaration(declaration);
+	if (!callable) return [];
+	const path = `${callable.kind}.${callable.name}`;
+	return [
+		{
+			ref: semanticRefFor(moduleName, path),
+			path,
+			kind: callable.kind,
+			name: callable.name,
+			module: moduleName,
+			type: formatSemanticType(callable.output.type),
+			effects: callable.effects,
+			span: callable.declaration.span ?? null,
+		},
+		...bindingSymbols(moduleName, path, callable.inputs),
+		{
+			ref: semanticRefFor(moduleName, `${path}.output.${callable.output.name}`),
+			path: `${path}.output.${callable.output.name}`,
+			kind: "param",
+			name: callable.output.name,
+			module: moduleName,
+			type: formatSemanticType(callable.output.type),
+			span: callable.output.span ?? null,
+		},
+	];
+}
+
+function callableDeclaration(declaration: PointSemanticDeclaration):
+	| {
+			kind: Exclude<PointSemanticSymbolKind, "module" | "use" | "record" | "field" | "external" | "param">;
+			name: string;
+			inputs: PointSemanticBinding[];
+			output: PointSemanticOutputBinding;
+			effects?: string[];
+			declaration: PointSemanticDeclaration;
+	  }
+	| null {
+	if (declaration.kind === "calculation" || declaration.kind === "rule" || declaration.kind === "label") {
+		return { kind: declaration.kind, name: declaration.name, inputs: declaration.inputs, output: declaration.output, declaration };
+	}
+	if (declaration.kind === "action") {
+		return {
+			kind: "action",
+			name: declaration.name,
+			inputs: declaration.inputs,
+			output: declaration.output,
+			effects: declaration.touches,
+			declaration,
+		};
+	}
+	if (declaration.kind === "policy") {
+		return { kind: "policy", name: declaration.name, inputs: declaration.inputs, output: { name: "allowed", type: boolType() }, declaration };
+	}
+	if (declaration.kind === "view" || declaration.kind === "route" || declaration.kind === "workflow" || declaration.kind === "command") {
+		return { kind: declaration.kind, name: declaration.name, inputs: declaration.inputs, output: declaration.output, declaration };
+	}
+	return null;
+}
+
+function bindingSymbols(moduleName: string, ownerPath: string, bindings: PointSemanticBinding[]): PointSemanticSymbol[] {
+	return bindings.map((binding) => ({
+		ref: semanticRefFor(moduleName, `${ownerPath}.input.${binding.label}`),
+		path: `${ownerPath}.input.${binding.label}`,
+		kind: "param" as const,
+		name: binding.label,
+		module: moduleName,
+		type: formatSemanticType(binding.type),
+		span: binding.span ?? null,
+	}));
+}
+
+function semanticSpanForDiagnosticPath(
+	semantic: PointSemanticProgram,
+	program: PointCoreProgram,
+	path: string,
+): PointSourceSpan | null {
+	const fnMatch = path.match(/^fn\.([^.]+)(?:\.(.+))?$/);
+	if (fnMatch) {
+		const fnName = fnMatch[1] ?? "";
+		const suffix = fnMatch[2] ?? "";
+		const coreFn = program.declarations.find((declaration) => declaration.kind === "function" && declaration.name === fnName);
+		if (!coreFn || coreFn.kind !== "function" || !coreFn.semantic) return coreFn?.span ?? null;
+		const semanticDecl = semantic.declarations.find(
+			(declaration) => declaration.kind === coreFn.semantic!.kind && "name" in declaration && declaration.name === coreFn.semantic!.name,
+		);
+		if (!semanticDecl) return coreFn.span ?? null;
+		if (suffix.startsWith("if.condition") || suffix.endsWith(".condition")) {
+			return findConditionSpan(semanticDecl) ?? coreFn.span ?? null;
+		}
+		if (suffix === "return" || suffix.endsWith(".return")) {
+			return findReturnSpan(semanticDecl) ?? coreFn.span ?? null;
+		}
+		return ("span" in semanticDecl ? semanticDecl.span : null) ?? coreFn.span ?? null;
+	}
+	const typeMatch = path.match(/^type\.([^.]+)(?:\.(.+))?$/);
+	if (typeMatch) {
+		const typeName = typeMatch[1] ?? "";
+		const fieldName = typeMatch[2];
+		const coreType = program.declarations.find((declaration) => declaration.kind === "type" && declaration.name === typeName);
+		if (fieldName && coreType?.kind === "type") {
+			const field = coreType.fields.find((candidate) => candidate.name === fieldName);
+			return field?.span ?? coreType.span ?? null;
+		}
+		return coreType?.kind === "type" ? coreType.span ?? null : null;
+	}
+	return null;
+}
+
+function findConditionSpan(declaration: PointSemanticDeclaration): PointSourceSpan | null {
+	if (declaration.kind === "label") {
+		for (const statement of declaration.body) {
+			if (statement.kind === "whenReturn") return expressionSpan(statement.condition) ?? statement.span ?? null;
+		}
+	}
+	if (declaration.kind === "view") {
+		for (const statement of declaration.body) {
+			if (statement.kind === "whenRender") return expressionSpan(statement.condition) ?? statement.span ?? null;
+		}
+	}
+	if (declaration.kind === "rule") {
+		for (const statement of declaration.body) {
+			if (statement.kind === "addWhen") return expressionSpan(statement.condition) ?? statement.span ?? null;
+		}
+	}
+	if (declaration.kind === "policy") {
+		for (const statement of declaration.body) {
+			if (statement.kind === "allow" || statement.kind === "deny" || statement.kind === "require") {
+				return expressionSpan(statement.condition) ?? statement.span ?? null;
+			}
+		}
+	}
+	return null;
+}
+
+function findReturnSpan(declaration: PointSemanticDeclaration): PointSourceSpan | null {
+	if ("body" in declaration && Array.isArray(declaration.body)) {
+		for (const statement of declaration.body) {
+			if (statement.kind === "return") return expressionSpan(statement.value) ?? statement.span ?? null;
+			if (statement.kind === "otherwiseReturn") return expressionSpan(statement.value) ?? statement.span ?? null;
+			if (statement.kind === "render") return expressionSpan(statement.value) ?? statement.span ?? null;
+		}
+	}
+	return null;
+}
+
+function expressionSpan(expression: PointSemanticExpression): PointSourceSpan | null {
+	return expression.span ?? null;
+}
+
+function relatedRefsFor(symbol: PointSemanticSymbol, index: PointSemanticIndex): string[] {
+	if (symbol.kind === "field") {
+		const ownerPath = symbol.path.split(".").slice(0, 2).join(".");
+		return index.refs.filter((candidate) => candidate.path.startsWith(`${ownerPath}.`) && candidate.ref !== symbol.ref).map((candidate) => candidate.ref);
+	}
+	if (symbol.kind === "record" || symbol.kind === "calculation" || symbol.kind === "rule" || symbol.kind === "label" || symbol.kind === "action" || symbol.kind === "policy" || symbol.kind === "view" || symbol.kind === "route" || symbol.kind === "workflow" || symbol.kind === "command" || symbol.kind === "external") {
+		return index.refs.filter((candidate) => candidate.path.startsWith(`${symbol.path}.`)).map((candidate) => candidate.ref);
+	}
+	return [];
+}
+
+function summaryFor(symbol: PointSemanticSymbol): string {
+	if (symbol.kind === "module") return `Module ${symbol.name}.`;
+	if (symbol.kind === "use") return `Use ${symbol.name}${symbol.from ? ` from ${symbol.from}` : ""}.`;
+	if (symbol.kind === "record") return `Semantic record ${symbol.name}.`;
+	if (symbol.kind === "field") return `Field ${symbol.name}: ${symbol.type}.`;
+	if (symbol.kind === "param") return `Parameter ${symbol.name}: ${symbol.type}.`;
+	if (symbol.kind === "external") return `External function ${symbol.name} from ${symbol.from} returns ${symbol.type}.`;
+	if (symbol.kind === "calculation") return `Semantic calculation ${symbol.name} returns ${symbol.type}.`;
+	if (symbol.kind === "rule") return `Semantic rule ${symbol.name} returns ${symbol.type}.`;
+	if (symbol.kind === "label") return `Semantic label ${symbol.name} returns ${symbol.type}.`;
+	if (symbol.kind === "action") return `Semantic action ${symbol.name} returns ${symbol.type}; effects: ${(symbol.effects ?? []).join(", ") || "none"}.`;
+	if (symbol.kind === "policy") return `Semantic policy ${symbol.name} returns ${symbol.type}.`;
+	if (symbol.kind === "view") return `Semantic view ${symbol.name} returns ${symbol.type}.`;
+	if (symbol.kind === "route") return `Semantic route ${symbol.name} returns ${symbol.type}.`;
+	if (symbol.kind === "workflow") return `Semantic workflow ${symbol.name} returns ${symbol.type}.`;
+	if (symbol.kind === "command") return `Semantic command ${symbol.name} returns ${symbol.type}.`;
+	return `Point symbol ${symbol.name}.`;
+}
+
+function semanticRefFor(moduleName: string, path: string): string {
+	return `point://semantic/${moduleName}/${path}`;
+}
+
+function boolType(): PointSemanticTypeExpression {
+	return { kind: "typeRef", name: "Bool", args: [] };
+}