@hatchingpoint/point 0.0.3 → 0.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hatchingpoint/point",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "private": false,
   "type": "module",
   "description": "Point language compiler and CLI.",

package/src/core/ast.ts

@@ -78,6 +78,13 @@ export interface PointCoreRecordField {
 export type PointCoreStatement =
 	| { kind: "return"; value?: PointCoreExpression; span?: PointSourceSpan }
 	| PointCoreValueDeclaration
+	| {
+			kind: "assignment";
+			name: string;
+			operator: "=" | "+=";
+			value: PointCoreExpression;
+			span?: PointSourceSpan;
+	  }
 	| {
 			kind: "if";
 			condition: PointCoreExpression;

package/src/core/check.ts

@@ -24,6 +24,8 @@ export interface PointCoreDiagnostic {
 }
 
 type DiagnosticMetadata = Partial<Pick<PointCoreDiagnostic, "expected" | "actual" | "repair" | "relatedRefs">>;
+type ScopeEntry = { type: PointCoreTypeExpression; mutable: boolean };
+type Scope = Map<string, ScopeEntry>;
 
 const PRIMITIVE_TYPES = new Set(["Text", "Int", "Float", "Bool", "Void", "List"]);
 
@@ -36,7 +38,7 @@ class CoreChecker {
 	private readonly diagnostics: PointCoreDiagnostic[] = [];
 	private readonly types = new Set(PRIMITIVE_TYPES);
 	private readonly typeDeclarations = new Map<string, PointCoreTypeDeclaration>();
-	private readonly globals = new Map<string, PointCoreTypeExpression>();
+	private readonly globals: Scope = new Map();
 	private readonly functions = new Map<string, PointCoreFunctionDeclaration>();
 
 	constructor(private readonly program: PointCoreProgram) {}
@@ -70,7 +72,7 @@ class CoreChecker {
 		if (this.globals.has(declaration.name)) {
 			this.push("duplicate-value", `Duplicate value ${declaration.name}`, `value.${declaration.name}`, declaration.span);
 		}
-		this.globals.set(declaration.name, declaration.type);
+		this.globals.set(declaration.name, { type: declaration.type, mutable: declaration.mutable });
 	}
 
 	private checkDeclaration(declaration: PointCoreDeclaration) {
@@ -92,7 +94,7 @@ class CoreChecker {
 		const locals = new Map(this.globals);
 		for (const param of declaration.params) {
 			this.checkType(param.type, `fn.${declaration.name}.${param.name}.type`);
-			locals.set(param.name, param.type);
+			locals.set(param.name, { type: param.type, mutable: false });
 		}
 		for (const statement of declaration.body) {
 			this.checkStatement(statement, declaration, locals);
@@ -102,7 +104,7 @@ class CoreChecker {
 	private checkStatement(
 		statement: PointCoreStatement,
 		fn: PointCoreFunctionDeclaration,
-		locals: Map<string, PointCoreTypeExpression>,
+		locals: Scope,
 	) {
 		if (statement.kind === "return") {
 			if (!statement.value) {
@@ -117,7 +119,11 @@ class CoreChecker {
 		if (statement.kind === "value") {
 			this.checkType(statement.type, `fn.${fn.name}.${statement.name}.type`);
 			this.checkExpressionAssignable(statement.value, statement.type, `fn.${fn.name}.${statement.name}.value`, locals);
-			locals.set(statement.name, statement.type);
+			locals.set(statement.name, { type: statement.type, mutable: statement.mutable });
+			return;
+		}
+		if (statement.kind === "assignment") {
+			this.checkAssignment(statement, fn, locals);
 			return;
 		}
 		if (statement.kind === "if") {
@@ -131,11 +137,42 @@ class CoreChecker {
 		this.typeOfExpression(statement.value, locals, `fn.${fn.name}.expression`);
 	}
 
+	private checkAssignment(
+		statement: Extract<PointCoreStatement, { kind: "assignment" }>,
+		fn: PointCoreFunctionDeclaration,
+		locals: Scope,
+	) {
+		const target = locals.get(statement.name);
+		const path = `fn.${fn.name}.${statement.name}.assignment`;
+		if (!target) {
+			this.push("unknown-identifier", `Unknown identifier ${statement.name}`, path, statement.span, {
+				actual: statement.name,
+				repair: `Declare var ${statement.name}: <Type> before assigning to it.`,
+			});
+			this.typeOfExpression(statement.value, locals, `${path}.value`);
+			return;
+		}
+		if (!target.mutable) {
+			this.push("immutable-assignment", `Cannot assign to immutable value ${statement.name}`, path, statement.span, {
+				actual: statement.name,
+				repair: `Declare ${statement.name} with var if it needs to change.`,
+			});
+		}
+		if (statement.operator === "+=" && !isNumeric(String(target.type.name))) {
+			this.push("operator-type-mismatch", "+= requires a numeric target", path, statement.span, {
+				expected: "Int or Float target",
+				actual: formatType(target.type),
+				repair: "Use += only with Int or Float values.",
+			});
+		}
+		this.checkExpressionAssignable(statement.value, target.type, `${path}.value`, locals);
+	}
+
 	private checkExpressionAssignable(
 		expression: PointCoreExpression,
 		expected: PointCoreTypeExpression,
 		path: string,
-		scope: Map<string, PointCoreTypeExpression>,
+		scope: Scope,
 	) {
 		if (expression.kind === "list") {
 			this.checkListAssignable(expression, expected, path, scope);
@@ -159,7 +196,7 @@ class CoreChecker {
 		expression: Extract<PointCoreExpression, { kind: "list" }>,
 		expected: PointCoreTypeExpression,
 		path: string,
-		scope: Map<string, PointCoreTypeExpression>,
+		scope: Scope,
 	) {
 		if (expected.name !== "List" || expected.args.length !== 1) {
 			this.push("type-mismatch", `Expected ${formatType(expected)}, got List`, path, expression.span, {
@@ -178,7 +215,7 @@ class CoreChecker {
 		expression: Extract<PointCoreExpression, { kind: "record" }>,
 		expected: PointCoreTypeExpression,
 		path: string,
-		scope: Map<string, PointCoreTypeExpression>,
+		scope: Scope,
 	) {
 		const declaration = this.typeDeclarations.get(String(expected.name));
 		if (!declaration) {
@@ -216,7 +253,7 @@ class CoreChecker {
 
 	private typeOfExpression(
 		expression: PointCoreExpression,
-		scope: Map<string, PointCoreTypeExpression>,
+		scope: Scope,
 		path: string,
 	): PointCoreTypeExpression | null {
 		if (expression.kind === "literal") {
@@ -236,15 +273,15 @@ class CoreChecker {
 			return null;
 		}
 		if (expression.kind === "identifier") {
-			const type = scope.get(expression.name);
-			if (!type) {
+			const entry = scope.get(expression.name);
+			if (!entry) {
 				this.push("unknown-identifier", `Unknown identifier ${expression.name}`, path, expression.span, {
 					actual: expression.name,
 					repair: `Declare ${expression.name}, pass it as a parameter, or replace it with an in-scope symbol.`,
 				});
 				return null;
 			}
-			return type;
+			return entry.type;
 		}
 		if (expression.kind === "binary") {
 			return this.typeOfBinaryExpression(expression, scope, path);
@@ -278,7 +315,7 @@ class CoreChecker {
 
 	private typeOfListExpression(
 		expression: Extract<PointCoreExpression, { kind: "list" }>,
-		scope: Map<string, PointCoreTypeExpression>,
+		scope: Scope,
 		path: string,
 	): PointCoreTypeExpression | null {
 		if (expression.items.length === 0) {
@@ -298,7 +335,7 @@ class CoreChecker {
 
 	private typeOfPropertyExpression(
 		expression: Extract<PointCoreExpression, { kind: "property" }>,
-		scope: Map<string, PointCoreTypeExpression>,
+		scope: Scope,
 		path: string,
 	): PointCoreTypeExpression | null {
 		const targetType = this.typeOfExpression(expression.target, scope, `${path}.target`);
@@ -326,7 +363,7 @@ class CoreChecker {
 
 	private typeOfBinaryExpression(
 		expression: Extract<PointCoreExpression, { kind: "binary" }>,
-		scope: Map<string, PointCoreTypeExpression>,
+		scope: Scope,
 		path: string,
 	): PointCoreTypeExpression | null {
 		const left = this.typeOfExpression(expression.left, scope, `${path}.left`);

package/src/core/cli.ts

@@ -3,7 +3,7 @@ import { checkPointCore } from "./check.ts";
 import { createPointCoreIndex, createPointCoreRepairPlan, explainPointCoreRef } from "./context.ts";
 import { emitPointCoreTypeScript } from "./emit-typescript.ts";
 import { formatPointCore } from "./format.ts";
-import { parsePointCore } from "./parser.ts";
+import { isSemanticPointSyntax, parsePointCore } from "./parser.ts";
 
 const DEFAULT_INPUT = "examples/math.point";
 const DEFAULT_OUTPUT = "generated/math.ast.json";
@@ -24,12 +24,20 @@ export async function main() {
 	const diagnostics = checkPointCore(program);
 
 	if (command === "fmt") {
+		if (isSemanticPointSyntax(source)) {
+			console.log(`Point core fmt preserved semantic source: ${input}`);
+			return;
+		}
 		await Bun.write(inputPath, formatPointCore(program));
 		console.log(`Point core fmt wrote ${input}`);
 		return;
 	}
 
 	if (command === "fmt-check") {
+		if (isSemanticPointSyntax(source)) {
+			console.log(`Point core fmt check passed: ${input}`);
+			return;
+		}
 		const formatted = formatPointCore(program);
 		if (source !== formatted) {
 			console.error(`Point core fmt check failed: ${input}`);
@@ -111,7 +119,9 @@ async function runProjectCommand(command: string) {
 	if (command === "fmt-all") {
 		await Promise.all(
 			results.map((result) =>
-				Bun.write(resolve(process.cwd(), result.input), formatPointCore(result.program)),
+				isSemanticPointSyntax(result.source)
+					? Promise.resolve()
+					: Bun.write(resolve(process.cwd(), result.input), formatPointCore(result.program)),
 			),
 		);
 		console.log(`Point core fmt wrote ${results.length} files`);
@@ -119,7 +129,9 @@ async function runProjectCommand(command: string) {
 	}
 
 	if (command === "fmt-check-all") {
-		const unformatted = results.filter((result) => result.source !== formatPointCore(result.program));
+		const unformatted = results.filter(
+			(result) => !isSemanticPointSyntax(result.source) && result.source !== formatPointCore(result.program),
+		);
 		if (unformatted.length > 0) {
 			console.error(JSON.stringify({ ok: false, unformatted: unformatted.map((result) => result.input) }, null, 2));
 			process.exit(1);

package/src/core/emit-typescript.ts

@@ -57,6 +57,7 @@ function emitStatement(statement: PointCoreStatement): string[] {
 		return [statement.value ? `return ${emitExpression(statement.value)};` : "return;"];
 	}
 	if (statement.kind === "value") return [emitValue(statement, false)];
+	if (statement.kind === "assignment") return [`${statement.name} ${statement.operator} ${emitExpression(statement.value)};`];
 	if (statement.kind === "if") {
 		const lines = [
 			`if (${emitCondition(statement.condition)}) {`,

package/src/core/format.ts

@@ -51,6 +51,7 @@ function formatStatementLines(statement: PointCoreStatement): string[] {
 		return [statement.value ? `return ${formatExpression(statement.value)}` : "return"];
 	}
 	if (statement.kind === "value") return [formatValue(statement)];
+	if (statement.kind === "assignment") return [`${statement.name} ${statement.operator} ${formatExpression(statement.value)}`];
 	if (statement.kind === "if") return formatIf(statement);
 	return [formatExpression(statement.value)];
 }

package/src/core/lexer.ts

@@ -14,6 +14,7 @@ export type PointCoreTokenType =
 	| "colon"
 	| "dot"
 	| "equals"
+	| "plusEquals"
 	| "equalsEquals"
 	| "bangEquals"
 	| "less"
@@ -128,6 +129,10 @@ class CoreLexer {
 				continue;
 			}
 			if (char === "+") {
+				if (this.peek(1) === "=") {
+					this.push("plusEquals", `${this.advance()}${this.advance()}`);
+					continue;
+				}
 				this.push("plus", this.advance());
 				continue;
 			}

package/src/core/parser.ts

@@ -21,10 +21,241 @@ export class PointCoreParserError extends Error {
 }
 
 export function parsePointCore(source: string): PointCoreProgram {
-	const parser = new CoreParser(lexPointCore(source));
+	const parser = new CoreParser(lexPointCore(lowerSemanticPointSyntax(source)));
 	return parser.parseProgram();
 }
 
+export function isSemanticPointSyntax(source: string): boolean {
+	return source
+		.split(/\r?\n/)
+		.some((line) => /^(record|rule|label)\s+/.test(line.trim()));
+}
+
+function lowerSemanticPointSyntax(source: string): string {
+	if (!isSemanticPointSyntax(source)) return source;
+	const lines = source.split(/\r?\n/);
+	const output: string[] = [];
+	const records = new Map<string, Map<string, string>>();
+	let index = 0;
+
+	while (index < lines.length) {
+		const line = lines[index] ?? "";
+		const trimmed = line.trim();
+		if (!trimmed) {
+			index += 1;
+			continue;
+		}
+		if (trimmed.startsWith("module ")) {
+			output.push(trimmed);
+			index += 1;
+			continue;
+		}
+		if (trimmed.startsWith("record ")) {
+			const lowered = lowerRecord(lines, index, records);
+			output.push(...lowered.lines);
+			index = lowered.next;
+			continue;
+		}
+		if (trimmed.startsWith("rule ")) {
+			const lowered = lowerRule(lines, index, records);
+			output.push(...lowered.lines);
+			index = lowered.next;
+			continue;
+		}
+		if (trimmed.startsWith("label ")) {
+			const lowered = lowerLabel(lines, index, records);
+			output.push(...lowered.lines);
+			index = lowered.next;
+			continue;
+		}
+		output.push(line);
+		index += 1;
+	}
+
+	return `${output.join("\n")}\n`;
+}
+
+function lowerRecord(
+	lines: string[],
+	start: number,
+	records: Map<string, Map<string, string>>,
+): { lines: string[]; next: number } {
+	const name = (lines[start] ?? "").trim().slice("record ".length).trim();
+	const fields = new Map<string, string>();
+	const output = [`type ${name} {`];
+	let index = start + 1;
+	for (; index < lines.length; index += 1) {
+		const trimmed = (lines[index] ?? "").trim();
+		if (!trimmed) continue;
+		if (isSemanticTopLevel(trimmed)) break;
+		const colon = trimmed.indexOf(":");
+		if (colon === -1) throw new Error(`Expected field type in record ${name}: ${trimmed}`);
+		const label = trimmed.slice(0, colon).trim();
+		const fieldName = toIdentifier(label);
+		fields.set(label, fieldName);
+		output.push(`  ${fieldName}: ${trimmed.slice(colon + 1).trim()}`);
+	}
+	output.push("}", "");
+	records.set(name, fields);
+	return { lines: output, next: index };
+}
+
+function lowerRule(
+	lines: string[],
+	start: number,
+	records: Map<string, Map<string, string>>,
+): { lines: string[]; next: number } {
+	const label = (lines[start] ?? "").trim().slice("rule ".length).trim();
+	const body = collectSemanticBody(lines, start + 1);
+	const params: string[] = [];
+	const paramTypes = new Map<string, string>();
+	let outputName = "result";
+	let outputType = "Void";
+	const statements: string[] = [];
+
+	for (const line of body.lines) {
+		if (line.startsWith("input ")) {
+			const param = parseTypedBinding(line.slice("input ".length));
+			params.push(`${param.name}: ${param.type}`);
+			paramTypes.set(param.name, param.type);
+			continue;
+		}
+		if (line.startsWith("output ")) {
+			const output = parseOutputBinding(line.slice("output ".length));
+			outputName = output.name;
+			outputType = output.type;
+			continue;
+		}
+		const startsAt = line.match(/^([A-Za-z_][A-Za-z0-9_]*) starts at (.+)$/);
+		if (startsAt) {
+			statements.push(`var ${startsAt[1]}: ${outputType} = ${lowerExpression(startsAt[2] ?? "", paramTypes, records)}`);
+			continue;
+		}
+		const addWhen = line.match(/^add (.+) when (.+)$/);
+		if (addWhen) {
+			statements.push(`if ${lowerExpression(addWhen[2] ?? "", paramTypes, records)} {`);
+			statements.push(`  ${outputName} += ${lowerExpression(addWhen[1] ?? "", paramTypes, records)}`);
+			statements.push("}");
+			continue;
+		}
+		if (line.startsWith("return ")) {
+			statements.push(`return ${lowerExpression(line.slice("return ".length), paramTypes, records)}`);
+			continue;
+		}
+		throw new Error(`Unknown rule statement: ${line}`);
+	}
+
+	const functionName = `${toIdentifier(label)}${toPascalCase(outputName)}`;
+	return {
+		lines: [`fn ${functionName}(${params.join(", ")}): ${outputType} {`, ...indentRaw(statements), "}", ""],
+		next: body.next,
+	};
+}
+
+function lowerLabel(
+	lines: string[],
+	start: number,
+	records: Map<string, Map<string, string>>,
+): { lines: string[]; next: number } {
+	const label = (lines[start] ?? "").trim().slice("label ".length).trim();
+	const body = collectSemanticBody(lines, start + 1);
+	const params: string[] = [];
+	const paramTypes = new Map<string, string>();
+	let outputType = "Text";
+	const statements: string[] = [];
+
+	for (const line of body.lines) {
+		if (line.startsWith("input ")) {
+			const param = parseTypedBinding(line.slice("input ".length));
+			params.push(`${param.name}: ${param.type}`);
+			paramTypes.set(param.name, param.type);
+			continue;
+		}
+		if (line.startsWith("output ")) {
+			outputType = parseOutputBinding(line.slice("output ".length)).type;
+			continue;
+		}
+		const whenReturn = line.match(/^when (.+) return (.+)$/);
+		if (whenReturn) {
+			statements.push(`if ${lowerExpression(whenReturn[1] ?? "", paramTypes, records)} {`);
+			statements.push(`  return ${lowerExpression(whenReturn[2] ?? "", paramTypes, records)}`);
+			statements.push("}");
+			continue;
+		}
+		if (line.startsWith("otherwise return ")) {
+			statements.push(`return ${lowerExpression(line.slice("otherwise return ".length), paramTypes, records)}`);
+			continue;
+		}
+		throw new Error(`Unknown label statement: ${line}`);
+	}
+
+	return {
+		lines: [`fn ${toIdentifier(label)}Label(${params.join(", ")}): ${outputType} {`, ...indentRaw(statements), "}", ""],
+		next: body.next,
+	};
+}
+
+function collectSemanticBody(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 (isSemanticTopLevel(trimmed)) break;
+		body.push(trimmed);
+	}
+	return { lines: body, next: index };
+}
+
+function isSemanticTopLevel(line: string): boolean {
+	return /^(module|record|rule|label|type|fn|let|var|import)\s+/.test(line);
+}
+
+function parseTypedBinding(source: string): { name: string; type: string } {
+	const colon = source.indexOf(":");
+	if (colon === -1) throw new Error(`Expected typed binding: ${source}`);
+	return { name: source.slice(0, colon).trim(), type: source.slice(colon + 1).trim() };
+}
+
+function parseOutputBinding(source: string): { name: string; type: string } {
+	const colon = source.indexOf(":");
+	if (colon !== -1) return parseTypedBinding(source);
+	return { name: "result", type: source.trim() };
+}
+
+function lowerExpression(
+	source: string,
+	paramTypes: Map<string, string>,
+	records: Map<string, Map<string, string>>,
+): string {
+	let expression = source.trim();
+	for (const [param, type] of paramTypes) {
+		const fields = records.get(type);
+		if (!fields) continue;
+		const labels = [...fields.keys()].sort((a, b) => b.length - a.length);
+		for (const label of labels) {
+			const field = fields.get(label);
+			if (!field) continue;
+			expression = expression.replaceAll(`${param}.${label}`, `${param}.${field}`);
+		}
+	}
+	return expression;
+}
+
+function toIdentifier(label: string): string {
+	const words = label.match(/[A-Za-z0-9]+/g) ?? [];
+	return words.map((word, index) => (index === 0 ? word.toLowerCase() : toPascalCase(word))).join("");
+}
+
+function toPascalCase(label: string): string {
+	const words = label.match(/[A-Za-z0-9]+/g) ?? [];
+	return words.map((word) => `${word.slice(0, 1).toUpperCase()}${word.slice(1)}`).join("");
+}
+
+function indentRaw(lines: string[]): string[] {
+	return lines.map((line) => `  ${line}`);
+}
+
 class CoreParser {
 	private current = 0;
 
@@ -123,10 +354,25 @@ class CoreParser {
 		}
 		if (this.matchKeyword("if")) return this.parseIfStatement();
 		if (this.checkKeyword("let") || this.checkKeyword("var")) return this.parseValueDeclaration();
+		if (this.check("identifier") && (this.checkNext("equals") || this.checkNext("plusEquals"))) return this.parseAssignment();
 		const value = this.parseExpression();
 		return { kind: "expression", value, span: value.span };
 	}
 
+	private parseAssignment(): PointCoreStatement {
+		const name = this.consume("identifier", "Expected assignment target");
+		const operator = this.match("plusEquals") ? "+=" : "=";
+		if (operator === "=") this.consume("equals", "Expected assignment operator");
+		const value = this.parseExpression();
+		return {
+			kind: "assignment",
+			name: name.value,
+			operator,
+			value,
+			span: { start: name.span.start, end: value.span?.end ?? this.previous().span.end },
+		};
+	}
+
 	private parseIfStatement(): PointCoreStatement {
 		const start = this.previous().span.start;
 		const condition = this.parseExpression();
@@ -334,13 +580,17 @@ class CoreParser {
 		return this.peek().type === type;
 	}
 
+	private checkNext(type: PointCoreTokenType) {
+		return this.peek(1).type === type;
+	}
+
 	private advance() {
 		if (!this.check("eof")) this.current += 1;
 		return this.previous();
 	}
 
-	private peek() {
-		return this.tokens[this.current] ?? this.tokens[this.tokens.length - 1]!;
+	private peek(offset = 0) {
+		return this.tokens[this.current + offset] ?? this.tokens[this.tokens.length - 1]!;
 	}
 
 	private previous() {