gofront 0.0.8 → 1.0.0

package/src/templ-parser.js

@@ -0,0 +1,235 @@
+// Templ parser: extends the Go Parser to handle TemplDecl nodes.
+//
+// A .templ file is tokenised by TemplLexer into a mixed stream of standard Go
+// tokens (T.*) and HTML/templ tokens (TT.*). This parser handles TT.TEMPL_KW
+// in parseTopDecl; everything else is delegated to the base Parser.
+//
+// Produced AST additions:
+//   TemplDecl   { kind, name, params, body: TemplNode[] }
+//   TemplElement { kind, tag, attrs, children }
+//   TemplText   { kind, value }
+//   TemplExpr   { kind, tokens }          ← raw Go token array
+//   TemplComponent { kind, tokens }       ← raw Go token array for call
+//   TemplChildren  { kind }
+//   TemplIf     { kind, condTokens, then: TemplNode[], else_: TemplNode[] | null }
+//   TemplFor    { kind, stmtTokens, body: TemplNode[] }
+//   TemplSwitch { kind, exprTokens, cases: TemplCase[] }
+//   TemplCase   { kind, caseTokens: tokens | null (null = default), body: TemplNode[] }
+
+import { Parser } from "./parser/index.js";
+import { TT } from "./templ-lexer.js";
+import { T } from "./tokens.js";
+
+const VOID_ELEMENTS = new Set([
+	"area",
+	"base",
+	"br",
+	"col",
+	"embed",
+	"hr",
+	"img",
+	"input",
+	"link",
+	"meta",
+	"param",
+	"source",
+	"track",
+	"wbr",
+]);
+
+export class TemplParser extends Parser {
+	// ── Top-level declaration override ───────────────────────────
+
+	parseTopDecl() {
+		if (this.check(TT.TEMPL_KW)) return this.parseTemplDecl();
+		return super.parseTopDecl();
+	}
+
+	// ── TemplDecl ─────────────────────────────────────────────────
+
+	parseTemplDecl() {
+		const _line = this.peek().line;
+		this.advance(); // consume TEMPL_KW
+
+		const name = this.expect(T.IDENT).value;
+
+		// Parse parameter list (standard Go params: LPAREN...RPAREN)
+		const params = this.parseParamList();
+
+		// Optional semicolon between ) and {
+		this.semi();
+
+		// Consume the opening { of the HTML body
+		this.expect(T.LBRACE);
+
+		// Parse the HTML body; parseHtmlChildren consumes the closing RBRACE
+		const body = this.parseHtmlChildren();
+
+		this.semi();
+
+		return { kind: "TemplDecl", name, params, body, _line };
+	}
+
+	// ── HTML node parsing ─────────────────────────────────────────
+
+	// Parse zero or more HTML nodes until RBRACE (end of body) or EOF.
+	// Consumes the RBRACE.
+	parseHtmlChildren() {
+		const nodes = [];
+		while (!this.check(T.RBRACE) && !this.check(T.EOF)) {
+			if (this.check(TT.TEMPL_ELSE)) break; // handled by caller (parseTemplIf)
+			const node = this.parseHtmlNode();
+			if (node) nodes.push(node);
+		}
+		if (this.check(T.RBRACE)) this.advance(); // consume }
+		return nodes;
+	}
+
+	// Parse a single HTML node from the current token.
+	parseHtmlNode() {
+		const t = this.peek();
+		switch (t.type) {
+			case TT.HTML_OPEN:
+				return this.parseHtmlElement();
+			case TT.HTML_SELF: {
+				this.advance();
+				return {
+					kind: "TemplElement",
+					tag: t.value.tag,
+					attrs: t.value.attrs,
+					children: [],
+				};
+			}
+			case TT.HTML_TEXT:
+				this.advance();
+				return { kind: "TemplText", value: t.value };
+			case TT.TEMPL_EXPR:
+				this.advance();
+				return { kind: "TemplExpr", tokens: t.value };
+			case TT.TEMPL_COMP:
+				this.advance();
+				return { kind: "TemplComponent", tokens: t.value };
+			case TT.TEMPL_CHILDREN:
+				this.advance();
+				return { kind: "TemplChildren" };
+			case TT.TEMPL_IF: {
+				this.advance();
+				return this.parseTemplIf(t);
+			}
+			case TT.TEMPL_FOR: {
+				this.advance();
+				return this.parseTemplFor(t);
+			}
+			case TT.TEMPL_SWITCH: {
+				this.advance();
+				return this.parseTemplSwitch(t);
+			}
+			default:
+				// Unknown token inside HTML body — skip it to avoid infinite loops
+				this.advance();
+				return null;
+		}
+	}
+
+	// Parse children of an element until the matching close tag.
+	parseHtmlElement() {
+		const openTok = this.advance(); // HTML_OPEN
+		const { tag, attrs } = openTok.value;
+
+		// Void elements have no children and no close tag even without />
+		if (VOID_ELEMENTS.has(tag)) {
+			return { kind: "TemplElement", tag, attrs, children: [] };
+		}
+
+		const children = [];
+		while (!this.check(T.EOF) && !this.check(T.RBRACE)) {
+			if (this.check(TT.HTML_CLOSE)) break;
+			// Also break on a close tag for a different ancestor (shouldn't happen in
+			// well-formed HTML, but prevents infinite loops on malformed input)
+			if (this.check(TT.TEMPL_ELSE)) break;
+			const node = this.parseHtmlNode();
+			if (node) children.push(node);
+		}
+		if (this.check(TT.HTML_CLOSE)) {
+			const closeTag = this.peek().value;
+			if (closeTag !== tag) {
+				throw new Error(
+					`${this.filename ?? "<templ>"}:${this.peek().line}: unclosed tag <${tag}>, got </${closeTag}>`,
+				);
+			}
+			this.advance(); // consume HTML_CLOSE
+		} else if (!VOID_ELEMENTS.has(tag)) {
+			// Non-void element with no close tag — parse error
+			throw new Error(
+				`${this.filename ?? "<templ>"}:${openTok.line}: unclosed tag <${tag}>`,
+			);
+		}
+		return { kind: "TemplElement", tag, attrs, children };
+	}
+
+	// Parse a TemplIf node. `tok` is the TEMPL_IF token (already advanced).
+	parseTemplIf(tok) {
+		const condTokens = tok.value; // array of Go tokens
+		const then = this.parseHtmlChildren(); // reads body until RBRACE
+		let else_ = null;
+		if (this.check(TT.TEMPL_ELSE)) {
+			this.advance(); // consume TEMPL_ELSE
+			if (this.check(TT.TEMPL_IF)) {
+				const t2 = this.advance();
+				else_ = [this.parseTemplIf(t2)]; // else if → wrap in array
+			} else {
+				else_ = this.parseHtmlChildren(); // else body until RBRACE
+			}
+		}
+		return { kind: "TemplIf", condTokens, then, else_ };
+	}
+
+	// Parse a TemplFor node. `tok` is the TEMPL_FOR token (already advanced).
+	parseTemplFor(tok) {
+		const stmtTokens = tok.value;
+		const body = this.parseHtmlChildren();
+		return { kind: "TemplFor", stmtTokens, body };
+	}
+
+	// Parse a TemplSwitch node. `tok` is the TEMPL_SWITCH token (already advanced).
+	parseTemplSwitch(tok) {
+		const exprTokens = tok.value;
+		const cases = [];
+		while (
+			!this.check(TT.TEMPL_END) &&
+			!this.check(T.RBRACE) &&
+			!this.check(T.EOF)
+		) {
+			if (this.check(TT.TEMPL_CASE)) {
+				const caseTok = this.advance();
+				const body = this.parseTemplCaseBody();
+				cases.push({ kind: "TemplCase", caseTokens: caseTok.value, body });
+			} else if (this.check(TT.TEMPL_DEFAULT)) {
+				this.advance();
+				const body = this.parseTemplCaseBody();
+				cases.push({ kind: "TemplCase", caseTokens: null, body });
+			} else {
+				this.advance(); // skip unexpected
+			}
+		}
+		if (this.check(TT.TEMPL_END)) this.advance(); // consume closing }
+		return { kind: "TemplSwitch", exprTokens, cases };
+	}
+
+	// Parse HTML nodes for a switch case body — stops at CASE/DEFAULT/END/RBRACE.
+	parseTemplCaseBody() {
+		const nodes = [];
+		while (
+			!this.check(TT.TEMPL_CASE) &&
+			!this.check(TT.TEMPL_DEFAULT) &&
+			!this.check(TT.TEMPL_END) &&
+			!this.check(T.RBRACE) &&
+			!this.check(T.EOF)
+		) {
+			if (this.check(TT.TEMPL_ELSE)) break;
+			const node = this.parseHtmlNode();
+			if (node) nodes.push(node);
+		}
+		return nodes;
+	}
+}

package/src/tokens.js

@@ -0,0 +1,109 @@
+// Token type table and Token class — pure data leaves used by every layer
+// (lexer, parser, codegen). Putting these in their own module lets parser
+// and codegen depend only on `tokens.js` instead of the full `lexer.js`.
+
+export const T = {
+	// Literals
+	INT: "INT",
+	FLOAT: "FLOAT",
+	STRING: "STRING",
+	IDENT: "IDENT",
+
+	IMAG: "IMAG",
+
+	// Keywords
+	FUNC: "func",
+	VAR: "var",
+	CONST: "const",
+	TYPE: "type",
+	STRUCT: "struct",
+	INTERFACE: "interface",
+	IF: "if",
+	ELSE: "else",
+	FOR: "for",
+	RANGE: "range",
+	RETURN: "return",
+	PACKAGE: "package",
+	IMPORT: "import",
+	TRUE: "true",
+	FALSE: "false",
+	NIL: "nil",
+	BREAK: "break",
+	CONTINUE: "continue",
+	SWITCH: "switch",
+	CASE: "case",
+	DEFAULT: "default",
+	MAP: "map",
+	NEW: "new",
+	DEFER: "defer",
+	ASYNC: "async",
+	AWAIT: "await",
+	GO: "go",
+	CHAN: "chan",
+	SELECT: "select",
+
+	// Operators
+	PLUS: "+",
+	MINUS: "-",
+	STAR: "*",
+	SLASH: "/",
+	PERCENT: "%",
+	EQ: "==",
+	NEQ: "!=",
+	LT: "<",
+	GT: ">",
+	LTE: "<=",
+	GTE: ">=",
+	AND: "&&",
+	OR: "||",
+	NOT: "!",
+	ASSIGN: "=",
+	DEFINE: ":=",
+	PLUS_ASSIGN: "+=",
+	MINUS_ASSIGN: "-=",
+	STAR_ASSIGN: "*=",
+	SLASH_ASSIGN: "/=",
+	PERCENT_ASSIGN: "%=",
+	AMP_ASSIGN: "&=",
+	PIPE_ASSIGN: "|=",
+	CARET_ASSIGN: "^=",
+	LSHIFT_ASSIGN: "<<=",
+	RSHIFT_ASSIGN: ">>=",
+	INC: "++",
+	DEC: "--",
+	AMP: "&",
+	PIPE: "|",
+	CARET: "^",
+	AND_NOT: "&^",
+	TILDE: "~",
+	LSHIFT: "<<",
+	RSHIFT: ">>",
+	ELLIPSIS: "...",
+	FALLTHROUGH: "fallthrough",
+
+	// Delimiters
+	LPAREN: "(",
+	RPAREN: ")",
+	LBRACE: "{",
+	RBRACE: "}",
+	LBRACKET: "[",
+	RBRACKET: "]",
+	COMMA: ",",
+	DOT: ".",
+	COLON: ":",
+	SEMICOLON: ";",
+
+	EOF: "EOF",
+};
+
+export class Token {
+	constructor(type, value, line, col) {
+		this.type = type;
+		this.value = value;
+		this.line = line;
+		this.col = col;
+	}
+	toString() {
+		return `Token(${this.type}, ${JSON.stringify(this.value)}, ${this.line}:${this.col})`;
+	}
+}

package/src/typechecker/assignability.js

@@ -0,0 +1,258 @@
+// Assignability, binary result types, and interface satisfaction.
+// Installed as a mixin on TypeChecker.prototype.
+
+import {
+	ANY,
+	BOOL,
+	CMP_OPS,
+	COMPLEX128,
+	FLOAT64,
+	INT,
+	isAny,
+	isComplex,
+	isComplexOrNumeric,
+	isNil,
+	isNumeric,
+	isPointer,
+	isString,
+	isUntyped,
+	LOG_OPS,
+	STRING,
+	typeStr,
+	UNTYPED_COMPLEX,
+	UNTYPED_FLOAT,
+	UNTYPED_INT,
+} from "./types.js";
+
+// Untyped constant assignability: maps source.base → Set of compatible target.name values
+const UNTYPED_COMPAT = {
+	int: new Set(["int", "float64", "complex128", "complex64"]),
+	float64: new Set(["float64", "int", "complex128", "complex64"]),
+	string: new Set(["string"]),
+	bool: new Set(["bool"]),
+	complex128: new Set(["complex128", "complex64"]),
+};
+
+export const assignabilityMethods = {
+	// ── Binary result types ───────────────────────────────────────────
+
+	binaryResultType(op, lt, rt, node) {
+		if (lt?.kind === "typeParam" || rt?.kind === "typeParam")
+			return this._binaryResultTypeTypeParam(op, lt, rt);
+		if (CMP_OPS.has(op)) return this._binaryResultTypeCmp(op, lt, rt, node);
+		if (LOG_OPS.has(op)) return BOOL;
+		return this._binaryResultTypeNonComplex(op, lt, rt, node);
+	},
+
+	_binaryResultTypeTypeParam(op, lt, rt) {
+		if (CMP_OPS.has(op) || LOG_OPS.has(op)) return BOOL;
+		return lt?.kind === "typeParam" ? lt : rt;
+	},
+
+	_binaryResultTypeNonComplex(op, lt, rt, node) {
+		if (isAny(lt) || isAny(rt)) return ANY;
+		if (isComplex(lt) || isComplex(rt))
+			return this._binaryResultTypeComplex(op, lt, rt, node);
+		if (isNumeric(lt) && isNumeric(rt))
+			return this._binaryResultTypeNumeric(lt, rt);
+		if (isString(lt) && isString(rt) && op === "+")
+			return this._binaryResultTypeString(lt, rt);
+		if (node)
+			this.err(`Invalid operation: ${typeStr(lt)} ${op} ${typeStr(rt)}`, node);
+		return ANY;
+	},
+
+	_binaryResultTypeString(lt, rt) {
+		if (lt.kind === "untyped" && rt.kind === "untyped") return lt;
+		if (lt.kind === "untyped") return rt;
+		if (rt.kind === "untyped") return lt;
+		return STRING;
+	},
+
+	_binaryResultTypeCmp(op, lt, rt, node) {
+		if (this._checkComplexCmpOp(op, lt, rt, node)) return ANY;
+		this._checkEqualityComparable(op, lt, rt, node);
+		return BOOL;
+	},
+
+	_binaryResultTypeComplex(op, lt, rt, node) {
+		if (!isComplexOrNumeric(lt) || !isComplexOrNumeric(rt)) {
+			this.err(`invalid operation: ${typeStr(lt)} ${op} ${typeStr(rt)}`, node);
+			return ANY;
+		}
+		if (op !== "+" && op !== "-" && op !== "*" && op !== "/") {
+			this.err(`invalid operation: ${typeStr(lt)} ${op} ${typeStr(rt)}`, node);
+			return ANY;
+		}
+		if (lt.kind === "untyped" && rt.kind === "untyped") return UNTYPED_COMPLEX;
+		return COMPLEX128;
+	},
+
+	_binaryResultTypeNumeric(lt, rt) {
+		const lFloat = (lt.kind === "untyped" ? lt.base : lt.name) === "float64";
+		const rFloat = (rt.kind === "untyped" ? rt.base : rt.name) === "float64";
+		const isFloat = lFloat || rFloat;
+		if (lt.kind === "untyped" && rt.kind === "untyped")
+			return isFloat ? UNTYPED_FLOAT : UNTYPED_INT;
+		if (lt.kind === "untyped")
+			return isFloat && rt.name !== "float64" ? FLOAT64 : rt;
+		if (rt.kind === "untyped")
+			return isFloat && lt.name !== "float64" ? FLOAT64 : lt;
+		return isFloat ? FLOAT64 : INT;
+	},
+
+	_checkComplexCmpOp(op, lt, rt, node) {
+		if (isComplex(lt) || isComplex(rt)) {
+			if (op !== "==" && op !== "!=") {
+				this.err(
+					`invalid operation: ${typeStr(lt)} ${op} ${typeStr(rt)}`,
+					node,
+				);
+				return true;
+			}
+		}
+		return false;
+	},
+
+	_isNonComparableKind(t) {
+		const base = t?.kind === "named" ? t.underlying : t;
+		return (
+			base?.kind === "slice" || base?.kind === "map" || base?.kind === "func"
+		);
+	},
+
+	_checkEqualityComparable(op, lt, rt, node) {
+		if (op !== "==" && op !== "!=") return;
+		if (isNil(lt) || isNil(rt)) return;
+		for (const t of [lt, rt]) {
+			if (this._isNonComparableKind(t))
+				this.err(`operator ${op} not defined on ${typeStr(t)}`, node);
+		}
+	},
+
+	// ── Assignability ─────────────────────────────────────────────────
+
+	assertAssignable(target, source, node) {
+		if (!target || !source) return;
+		target = this.resolveType(target);
+		source = this.resolveType(source);
+		if (this._assertAssignableEarlyReturn(target, source)) return;
+		if (isPointer(target) && isPointer(source)) {
+			this.assertAssignable(
+				target.base ?? target.underlying?.base,
+				source.base ?? source.underlying?.base,
+				node,
+			);
+			return;
+		}
+		if (isUntyped(source) && this._isUntypedAssignable(target, source)) return;
+		if (this._isNumericCoercible(target, source)) return;
+		if (this._checkArrayAssignable(target, source, node)) return;
+		if (typeStr(target) !== typeStr(source))
+			this._assertAssignableTypeMismatch(target, source, node);
+	},
+
+	_assertAssignableEarlyReturn(target, source) {
+		return (
+			target?.kind === "typeParam" ||
+			source?.kind === "typeParam" ||
+			isAny(target) ||
+			isAny(source) ||
+			isNil(source)
+		);
+	},
+
+	_assertAssignableTypeMismatch(target, source, node) {
+		let tBase = target.kind === "named" ? target.underlying : target;
+		tBase = this.resolveType(tBase);
+		if (tBase?.kind === "interface") {
+			if (tBase.methods.size === 0) return;
+			if (!this.implements(source, tBase, node))
+				this.err(
+					`${typeStr(source)} does not implement ${typeStr(target)}`,
+					node,
+				);
+			return;
+		}
+		this.err(`Cannot assign ${typeStr(source)} to ${typeStr(target)}`, node);
+	},
+
+	_isUntypedAssignable(target, source) {
+		if (isUntyped(target)) return true;
+		if (target.kind !== "basic") return false;
+		return (
+			(UNTYPED_COMPAT[source.base]?.has(target.name) ?? false) ||
+			(isComplex(target) &&
+				(source.base === "int" || source.base === "float64"))
+		);
+	},
+
+	_isNumericCoercible(target, source) {
+		if (target.kind !== "basic" || source.kind !== "basic") return false;
+		return (
+			(target.name === "float64" && source.name === "int") ||
+			(target.name === "int" && source.name === "float64")
+		);
+	},
+
+	_checkArrayAssignable(target, source, node) {
+		if (target.kind === "array" && source.kind === "array") {
+			if (
+				target.size != null &&
+				source.size != null &&
+				target.size !== source.size
+			)
+				this.err(
+					`Cannot assign ${typeStr(source)} to ${typeStr(target)} (different array lengths)`,
+					node,
+				);
+			else this.assertAssignable(target.elem, source.elem, node);
+			return true;
+		}
+		if (
+			(target.kind === "array" && source.kind === "slice") ||
+			(target.kind === "slice" && source.kind === "array")
+		) {
+			this.err(`Cannot assign ${typeStr(source)} to ${typeStr(target)}`, node);
+			return true;
+		}
+		return false;
+	},
+
+	// ── Interface satisfaction ────────────────────────────────────────
+
+	_sigParamsMatch(reqList, actList) {
+		if (reqList.length !== actList.length) return false;
+		for (let i = 0; i < reqList.length; i++) {
+			if (typeStr(reqList[i]) !== typeStr(actList[i])) return false;
+		}
+		return true;
+	},
+
+	_implementsMethod(required, actual) {
+		if (!actual) return false;
+		const rp = required.params ?? [],
+			ap = actual.params ?? [];
+		const rr = required.returns ?? [],
+			ar = actual.returns ?? [];
+		if (!this._sigParamsMatch(rp, ap)) return false;
+		if (!!required.variadic !== !!actual.variadic) return false;
+		return this._sigParamsMatch(rr, ar);
+	},
+
+	implements(srcType, iface, _node) {
+		let base = srcType.kind === "named" ? srcType.underlying : srcType;
+		base = this.resolveType(base);
+		const methodMap =
+			base?.kind === "struct"
+				? base.methods
+				: srcType.kind === "named"
+					? srcType.methods
+					: null;
+		if (!methodMap) return false;
+		for (const [name, required] of iface.methods) {
+			if (!this._implementsMethod(required, methodMap.get(name))) return false;
+		}
+		return true;
+	},
+};