gofront 1.6.1 → 1.8.0

package/src/parser/struct-tag.js

@@ -0,0 +1,144 @@
+// src/parser/struct-tag.js
+// Parse Go struct field tags matching Go's reflect.StructTag specification.
+
+function unquoteTagValue(s) {
+	if (s.length < 2 || s[0] !== '"' || s[s.length - 1] !== '"') return s;
+	const inner = s.slice(1, -1);
+	let res = "";
+	for (let i = 0; i < inner.length; i++) {
+		if (inner[i] === "\\" && i + 1 < inner.length) {
+			i++;
+			const esc = inner[i];
+			switch (esc) {
+				case "n":
+					res += "\n";
+					break;
+				case "t":
+					res += "\t";
+					break;
+				case "r":
+					res += "\r";
+					break;
+				case '"':
+					res += '"';
+					break;
+				case "\\":
+					res += "\\";
+					break;
+				case "a":
+					res += "\x07";
+					break;
+				case "b":
+					res += "\b";
+					break;
+				case "f":
+					res += "\f";
+					break;
+				case "v":
+					res += "\v";
+					break;
+				case "0":
+					res += "\0";
+					break;
+				default:
+					res += `\\${esc}`;
+					break;
+			}
+		} else {
+			res += inner[i];
+		}
+	}
+	return res;
+}
+
+/**
+ * Parses a raw struct tag string into a Map of key -> unquoted string value,
+ * adhering to Go reflect.StructTag convention.
+ *
+ * @param {string | null | undefined} tag
+ * @returns {Map<string, string>}
+ */
+export function parseStructTag(tag) {
+	const map = new Map();
+	if (!tag || typeof tag !== "string") return map;
+
+	let str = tag;
+	while (str.length > 0) {
+		// Skip leading spaces
+		let i = 0;
+		while (i < str.length && str.charCodeAt(i) === 32) i++;
+		str = str.slice(i);
+		if (str.length === 0) break;
+
+		// Scan to colon: key must not contain space, quote, colon, or control characters
+		i = 0;
+		while (
+			i < str.length &&
+			str.charCodeAt(i) > 32 &&
+			str[i] !== ":" &&
+			str[i] !== '"' &&
+			str.charCodeAt(i) !== 127
+		) {
+			i++;
+		}
+		if (
+			i === 0 ||
+			i + 1 >= str.length ||
+			str[i] !== ":" ||
+			str[i + 1] !== '"'
+		) {
+			break;
+		}
+		const key = str.slice(0, i);
+		str = str.slice(i + 1); // skip colon, now points to opening '"'
+
+		// Scan quoted string to find closing '"'
+		i = 1;
+		while (i < str.length && str[i] !== '"') {
+			if (str[i] === "\\") i++; // skip escaped char
+			i++;
+		}
+		if (i >= str.length) break;
+
+		const qval = str.slice(0, i + 1);
+		str = str.slice(i + 1);
+
+		if (!map.has(key)) {
+			map.set(key, unquoteTagValue(qval));
+		}
+	}
+	return map;
+}
+
+/**
+ * Parses the "json" key from a struct tag string or parsed Map according to encoding/json rules.
+ *
+ * @param {string | Map<string, string> | null | undefined} tag
+ * @returns {{ name: string | null, omitempty: boolean, ignored: boolean, options: string[] }}
+ */
+export function parseJsonTag(tag) {
+	if (!tag) {
+		return { name: null, omitempty: false, ignored: false, options: [] };
+	}
+	const map = typeof tag === "string" ? parseStructTag(tag) : tag;
+	if (!map.has("json")) {
+		return { name: null, omitempty: false, ignored: false, options: [] };
+	}
+	const raw = map.get("json");
+	const parts = raw.split(",");
+	const rawName = parts[0];
+	const options = parts.slice(1);
+	const omitempty = options.includes("omitempty");
+
+	if (rawName === "-" && parts.length === 1) {
+		return { name: "-", omitempty: false, ignored: true, options };
+	}
+
+	const name = rawName === "" ? null : rawName;
+	return {
+		name,
+		omitempty,
+		ignored: false,
+		options,
+	};
+}

package/src/{templ-parser.js → parser/templ.js}

@@ -15,10 +15,27 @@
 //   TemplFor    { kind, stmtTokens, body: TemplNode[] }
 //   TemplSwitch { kind, exprTokens, cases: TemplCase[] }
 //   TemplCase   { kind, caseTokens: tokens | null (null = default), body: TemplNode[] }
+//
+// Go expressions embedded in templ (`{ expr }`, attribute values, `if`
+// conditions, `switch` and `case` expressions, `@Comp(...)` calls) and `for`
+// headers are also parsed here, so the code generator never runs the parser.
+// The results sit on the node as non-enumerable properties (the generic AST
+// walkers in rename/lowering visit enumerable keys only, and these ASTs have
+// no type information):
+//   expr       Expression AST, or null when there are no tokens to parse
+//   exprError  The ParseError a malformed expression raised. The parser keeps
+//              it instead of throwing, so the error still surfaces when the
+//              code generator reads the node (after type-checking), as before
+//   raw        TemplComponent only: `@templ.Raw(arg)`; `expr` is then `arg`
+//   forStmt    TemplFor only: the parsed ForStmt, or null when the header does
+//              not parse as a Go `for` clause
+//   forError   TemplFor only: the ParseError the header raised (kept, like
+//              exprError, for the code generator to throw)
+//   attr.expr / attr.exprError on `expr` and `cond-bool` attributes
 
-import { Parser } from "./parser/index.js";
-import { TT } from "./templ-lexer.js";
-import { T } from "./tokens.js";
+import { TT } from "../lexer/templ-lexer.js";
+import { T, Token } from "../lexer/tokens.js";
+import { Parser } from "./index.js";
 
 const VOID_ELEMENTS = new Set([
 	"area",
@@ -37,6 +54,90 @@ const VOID_ELEMENTS = new Set([
 	"wbr",
 ]);
 
+function attach(node, props) {
+	for (const [name, value] of Object.entries(props)) {
+		Object.defineProperty(node, name, {
+			value,
+			enumerable: false,
+			writable: true,
+			configurable: true,
+		});
+	}
+	return node;
+}
+
+// Parses `tokens` as one Go expression, ending at a synthetic EOF token.
+function parseExprTokens(tokens, allowEmpty = true) {
+	if (allowEmpty && (!tokens || tokens.length === 0)) return { expr: null };
+	try {
+		const eofTok = new Token(T.EOF, "", 1, 1);
+		return { expr: new Parser([...tokens, eofTok]).parseExpr() };
+	} catch (exprError) {
+		return { expr: null, exprError };
+	}
+}
+
+// Parses an `if` condition; the lexer may leave the `if` keyword in front.
+function parseCondTokens(tokens) {
+	if (!tokens || tokens.length === 0) return { expr: null };
+	return parseExprTokens(
+		tokens[0]?.type === T.IF ? tokens.slice(1) : tokens,
+		false,
+	);
+}
+
+function isTemplRaw(toks) {
+	return (
+		toks.length >= 4 &&
+		toks[0]?.value === "templ" &&
+		toks[1]?.type === T.DOT &&
+		toks[2]?.value === "Raw" &&
+		toks[3]?.type === T.LPAREN
+	);
+}
+
+// Strips the trailing semicolons the Go lexer inserts at a newline.
+function trimSemicolons(tokens) {
+	let end = tokens.length;
+	while (end > 0 && tokens[end - 1].type === T.SEMICOLON) end--;
+	return tokens.slice(0, end);
+}
+
+// Parses a `for` header (the `for` keyword plus the clause, no body) as a
+// ForStmt, with a fake empty body `{ }` so the parser can complete it. A header
+// that is not a valid Go `for` clause gives `forStmt: null` plus its error.
+function parseForHeader(tokens) {
+	const eofTok = new Token(T.EOF, "", 1, 1);
+	const lbrace = new Token(T.LBRACE, "{", 1, 1);
+	const rbrace = new Token(T.RBRACE, "}", 1, 1);
+	const semi = new Token(T.SEMICOLON, ";", 1, 1);
+	const withFor =
+		tokens[0]?.type === T.FOR
+			? [...tokens, lbrace, rbrace, semi, eofTok]
+			: [
+					new Token(T.FOR, "for", 1, 1),
+					...tokens,
+					lbrace,
+					rbrace,
+					semi,
+					eofTok,
+				];
+	try {
+		return { forStmt: new Parser(withFor).parseFor() };
+	} catch (forError) {
+		return { forStmt: null, forError };
+	}
+}
+
+// Parses the `expr` and `cond-bool` attribute expressions of an element.
+function parseAttrExprs(attrs) {
+	for (const attr of attrs) {
+		if (attr.kind === "expr" || attr.kind === "cond-bool")
+			attach(attr, parseExprTokens(attr.tokens));
+	}
+	return attrs;
+}
+
 export class TemplParser extends Parser {
 	// ── Top-level declaration override ───────────────────────────
 
@@ -101,7 +202,7 @@ export class TemplParser extends Parser {
 				return {
 					kind: "TemplElement",
 					tag: t.value.tag,
-					attrs: t.value.attrs,
+					attrs: parseAttrExprs(t.value.attrs),
 					children: [],
 				};
 			}
@@ -110,10 +211,13 @@ export class TemplParser extends Parser {
 				return { kind: "TemplText", value: t.value };
 			case TT.TEMPL_EXPR:
 				this.advance();
-				return { kind: "TemplExpr", tokens: t.value };
+				return attach(
+					{ kind: "TemplExpr", tokens: t.value },
+					parseExprTokens(t.value),
+				);
 			case TT.TEMPL_COMP:
 				this.advance();
-				return { kind: "TemplComponent", tokens: t.value };
+				return this.templComponent(t.value);
 			case TT.TEMPL_CHILDREN:
 				this.advance();
 				return { kind: "TemplChildren" };
@@ -136,10 +240,18 @@ export class TemplParser extends Parser {
 		}
 	}
 
+	// `@templ.Raw(arg)` parses `arg`; any other component parses the whole call.
+	templComponent(tokens) {
+		const raw = isTemplRaw(tokens);
+		const parsed = parseExprTokens(raw ? tokens.slice(4, -1) : tokens);
+		return attach({ kind: "TemplComponent", tokens }, { raw, ...parsed });
+	}
+
 	// Parse children of an element until the matching close tag.
 	parseHtmlElement() {
 		const openTok = this.advance(); // HTML_OPEN
-		const { tag, attrs } = openTok.value;
+		const { tag } = openTok.value;
+		const attrs = parseAttrExprs(openTok.value.attrs);
 
 		// Void elements have no children and no close tag even without />
 		if (VOID_ELEMENTS.has(tag)) {
@@ -186,14 +298,20 @@ export class TemplParser extends Parser {
 				else_ = this.parseHtmlChildren(); // else body until RBRACE
 			}
 		}
-		return { kind: "TemplIf", condTokens, then, else_ };
+		return attach(
+			{ kind: "TemplIf", condTokens, then, else_ },
+			parseCondTokens(condTokens),
+		);
 	}
 
 	// 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 };
+		return attach(
+			{ kind: "TemplFor", stmtTokens, body },
+			parseForHeader(trimSemicolons(stmtTokens)),
+		);
 	}
 
 	// Parse a TemplSwitch node. `tok` is the TEMPL_SWITCH token (already advanced).
@@ -209,17 +327,22 @@ export class TemplParser extends Parser {
 				const isDefault = this.check(TT.TEMPL_DEFAULT);
 				const caseTok = this.advance();
 				const body = this.parseTemplCaseBody();
-				cases.push({
-					kind: "TemplCase",
-					caseTokens: isDefault ? null : caseTok.value,
-					body,
-				});
+				const caseTokens = isDefault ? null : caseTok.value;
+				cases.push(
+					attach(
+						{ kind: "TemplCase", caseTokens, body },
+						isDefault ? { expr: null } : parseExprTokens(caseTokens),
+					),
+				);
 			} else {
 				this.advance(); // skip unexpected
 			}
 		}
 		if (this.check(TT.TEMPL_END)) this.advance(); // consume closing }
-		return { kind: "TemplSwitch", exprTokens, cases };
+		return attach(
+			{ kind: "TemplSwitch", exprTokens, cases },
+			parseExprTokens(exprTokens),
+		);
 	}
 
 	// Parse HTML nodes for a switch case body — stops at CASE/DEFAULT/END/RBRACE.

package/src/parser/types.js

@@ -1,6 +1,6 @@
 // Parser type-expression methods — installed as a mixin on Parser.prototype.
 
-import { T } from "../tokens.js";
+import { T } from "../lexer/tokens.js";
 
 // Token types that directly map to parseTypeName().
 const TYPE_NAME_TOKENS = new Set([
@@ -76,8 +76,10 @@ export const typeParserMethods = {
 				i++;
 				continue;
 			}
-			// Reject literals — it's an index/array expression
-			if (tt === T.INT || tt === T.FLOAT || tt === T.STRING) return false;
+			// Reject literals — it's an index/array expression. A literal nested
+			// deeper is an array length inside a type argument: Stack[[2]int].
+			if (depth === 1 && (tt === T.INT || tt === T.FLOAT || tt === T.STRING))
+				return false;
 			i++;
 		}
 		return depth === 0;
@@ -86,11 +88,17 @@ export const typeParserMethods = {
 	parseTypeParamList() {
 		this.expect(T.LBRACKET);
 		const params = [];
-		do {
-			const name = this.expect(T.IDENT).value;
+		while (!this.check(T.RBRACKET) && !this.check(T.EOF)) {
+			const names = [this.expect(T.IDENT).value];
+			while (this.match(T.COMMA)) {
+				names.push(this.expect(T.IDENT).value);
+			}
 			const constraint = this.parseConstraint();
-			params.push({ kind: "TypeParam", name, constraint });
-		} while (this.match(T.COMMA));
+			for (const name of names) {
+				params.push({ kind: "TypeParam", name, constraint });
+			}
+			if (!this.match(T.COMMA)) break;
+		}
 		this.expect(T.RBRACKET);
 		return params;
 	},
@@ -175,29 +183,138 @@ export const typeParserMethods = {
 		this.expect(T.LBRACE);
 		const fields = [];
 		while (!this.check(T.RBRACE) && !this.check(T.EOF)) {
+			// Embedded pointer field: *Base or *pkg.Base
+			if (this.check(T.STAR)) {
+				this.advance();
+				let typeName = this.expect(T.IDENT).value;
+				if (this.check(T.DOT)) {
+					this.advance();
+					typeName += `.${this.expect(T.IDENT).value}`;
+				}
+				const type = {
+					kind: "PointerType",
+					base: this._embeddedTypeName(typeName, true),
+				};
+				let tag = null;
+				if (this.check(T.STRING)) {
+					tag = this.advance().value;
+				}
+				fields.push({
+					names: [],
+					type,
+					embedded: true,
+					embeddedName: type.base.name,
+					tag,
+				});
+				this.semi();
+				continue;
+			}
+
 			const names = this.parseIdentList();
-			// Check if this is an embedded field (just a type name)
-			// e.g., type T struct { Base }
-			if (this.check(T.SEMICOLON) || this.check(T.RBRACE)) {
-				const typeName = names[0]; // assuming no comma list for embedded
+			// Check if this is a qualified embedded field: pkg.Base
+			if (names.length === 1 && this.check(T.DOT)) {
+				this.advance();
+				const typeName = `${names[0]}.${this.expect(T.IDENT).value}`;
+				const embeddedType = this._embeddedTypeName(typeName, true);
+				let tag = null;
+				if (this.check(T.STRING)) {
+					tag = this.advance().value;
+				}
+				fields.push({
+					names: [],
+					type: embeddedType,
+					embedded: true,
+					embeddedName: typeName,
+					tag,
+				});
+				this.semi();
+				continue;
+			}
+
+			// Embedded generic instance: Inner[T] (not an array field `a [N]T`)
+			if (
+				names.length === 1 &&
+				this.check(T.LBRACKET) &&
+				this._bracketEndsEmbeddedField()
+			) {
+				const embeddedType = this._embeddedTypeName(names[0], true);
+				let tag = null;
+				if (this.check(T.STRING)) {
+					tag = this.advance().value;
+				}
+				fields.push({
+					names: [],
+					type: embeddedType,
+					embedded: true,
+					embeddedName: names[0],
+					tag,
+				});
+				this.semi();
+				continue;
+			}
+
+			// Embedded field (just a type name, e.g. Base), optionally tagged
+			if (
+				names.length === 1 &&
+				(this.check(T.SEMICOLON) ||
+					this.check(T.RBRACE) ||
+					this.check(T.STRING))
+			) {
+				const typeName = names[0];
+				let tag = null;
+				if (this.check(T.STRING)) {
+					tag = this.advance().value;
+				}
 				fields.push({
 					names: [],
 					type: { kind: "TypeName", name: typeName },
 					embedded: true,
+					tag,
 				});
 				this.semi();
 				continue;
 			}
+
 			const type = this.parseType();
 			// Consume optional struct tag (backtick string), e.g. `json:"name"`
-			if (this.check(T.STRING)) this.advance();
-			fields.push({ names, type });
+			let tag = null;
+			if (this.check(T.STRING)) {
+				tag = this.advance().value;
+			}
+			fields.push({ names, type, tag });
 			this.semi();
 		}
 		this.expect(T.RBRACE);
 		return { kind: "StructType", fields };
 	},
 
+	// True when the `[...]` at the cursor is followed by the end of a field
+	// (`Inner[T]` embedded), rather than an element type (`a [N]T`).
+	_bracketEndsEmbeddedField() {
+		let depth = 0;
+		for (let i = this.pos; i < this.tokens.length; i++) {
+			const tt = this.tokens[i].type;
+			if (tt === T.LBRACKET) depth++;
+			else if (tt === T.RBRACKET && --depth === 0) {
+				const next = this.tokens[i + 1]?.type;
+				return next === T.SEMICOLON || next === T.RBRACE || next === T.STRING;
+			}
+		}
+		return false;
+	},
+
+	// Embedded field type: `name`, or `name[Args]` when type arguments follow.
+	_embeddedTypeName(name, allowArgs) {
+		if (allowArgs && this.check(T.LBRACKET)) {
+			this.expect(T.LBRACKET);
+			const typeArgs = [this.parseType()];
+			while (this.match(T.COMMA)) typeArgs.push(this.parseType());
+			this.expect(T.RBRACKET);
+			return { kind: "GenericTypeName", name, typeArgs };
+		}
+		return { kind: "TypeName", name };
+	},
+
 	parseInterfaceType() {
 		this.expect(T.INTERFACE);
 		this.expect(T.LBRACE);

package/src/resolver.js

@@ -12,6 +12,7 @@
 
 import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
 
 // Walk up from startDir looking for a node_modules directory
 function findNodeModules(startDir) {
@@ -25,6 +26,7 @@ function findNodeModules(startDir) {
 	}
 }
 
+import { EXCLUDED_STDLIB_PACKAGES } from "./typechecker/stdlib/excluded.js";
 import { STDLIB_PACKAGES } from "./typechecker/types.js";
 
 // Returns true for local relative paths (start with ./ or ../)
@@ -36,6 +38,23 @@ export function isBuiltinPackage(importPath) {
 	return STDLIB_PACKAGES.has(importPath);
 }
 
+// Go-source stdlib: `stdlib/<import path>/*.go`, written in GoFront Go
+// and compiled into the caller's target.  A directory for a path that is also
+// in STDLIB_PACKAGES is an overlay: its declarations extend that namespace.
+const STDLIB_SOURCE_ROOT = fileURLToPath(
+	new URL("../stdlib/", import.meta.url),
+);
+const STDLIB_PATH_RE = /^[a-z0-9]+(\/[a-z0-9]+)*$/;
+
+// Returns the source directory for a Go-source stdlib import path, or null.
+// `root` replaces stdlib/ (tests use a temporary tree).
+export function resolveStdlibSource(importPath, root = null) {
+	if (!STDLIB_PATH_RE.test(importPath)) return null;
+	const dir = join(root ?? STDLIB_SOURCE_ROOT, importPath);
+	if (!existsSync(dir)) return null;
+	return readdirSync(dir).some((f) => f.endsWith(".go")) ? dir : null;
+}
+
 // Resolve a local relative import path to an absolute directory of .go files.
 // Returns the absolute dir path, or null if it doesn't contain any .go files.
 export function resolveGwDir(importPath, fromFile) {
@@ -86,14 +105,16 @@ function resolveImport(importPath, fromFile) {
 
 // Given an AST's import list, resolve all imports.
 // Returns Map<importPath, { dtsPath, importPath, types, values }>
-export function resolveAll(imports, fromFile, parseDts) {
+export function resolveAll(imports, fromFile, parseDts, stdlibRoot = null) {
 	const resolved = new Map();
 
 	for (const imp of imports) {
 		for (const { path } of imp.imports) {
 			if (path.startsWith("js:")) continue; // handled separately
 			if (isLocalPath(path)) continue; // local .go packages — handled by compiler
+			if (EXCLUDED_STDLIB_PACKAGES.has(path)) continue; // the checker reports it
 			if (isBuiltinPackage(path)) continue; // built-in stdlib namespaces — always available
+			if (resolveStdlibSource(path, stdlibRoot)) continue; // Go-source stdlib — handled by compiler
 
 			if (resolved.has(path)) continue;