gofront 1.6.0 → 1.7.0

package/src/templ-lexer.js

@@ -118,17 +118,15 @@ export class TemplLexer {
 				continue;
 			}
 
-			// Detect `templ` keyword at identifier boundaries
+			// Detect `templ` or `css` keyword at identifier boundaries
 			if (this._matchKeyword("templ")) {
 				this.tokens.push(new Token(TT.TEMPL_KW, "templ", this.line, this.col));
-				this._lexTemplDecl();
+				this._lexBlockDecl("templ");
 				continue;
 			}
-
-			// Detect `css` keyword at identifier boundaries
 			if (this._matchKeyword("css")) {
 				this.tokens.push(new Token(TT.CSS_KW, "css", this.line, this.col));
-				this._lexCssDecl();
+				this._lexBlockDecl("css");
 				continue;
 			}
 
@@ -201,24 +199,25 @@ export class TemplLexer {
 		for (const t of this._goTokens(chunk)) this.tokens.push(t);
 	}
 
-	// ── Templ declaration lexing ─────────────────────────────────
+	// ── Templ / CSS declaration lexing ───────────────────────────
 
-	// Called right after consuming `templ` keyword.
-	// Lexes: Name(params) { <HTML body> }
-	_lexTemplDecl() {
+	// Called right after consuming `templ` or `css` keyword.
+	// Lexes: Name(params) { <body> }
+	_lexBlockDecl(kw) {
 		this.skipWhitespace();
 
-		// Name
-		const nameStart = this.pos;
-		while (!this.eof() && /\w/.test(this.peek())) this.advance();
-		const name = this.src.slice(nameStart, this.pos);
-		if (!name) this.err("expected component name after 'templ'");
+		const name = this._readWord();
+		if (!name) {
+			this.err(
+				`expected ${kw === "templ" ? "component name" : "name"} after '${kw}'`,
+			);
+		}
 		this.tokens.push(new Token(T.IDENT, name, this.line, this.col));
 
 		this.skipWhitespace();
 
 		// Parameter list ( ... ) — lex as Go
-		if (this.peek() !== "(") this.err("expected '(' after templ name");
+		if (this.peek() !== "(") this.err(`expected '(' after ${kw} name`);
 		const paramStart = this.pos;
 		this._skipBalanced("(", ")");
 		const paramSrc = this.src.slice(paramStart, this.pos);
@@ -227,43 +226,12 @@ export class TemplLexer {
 		this.skipWhitespace();
 
 		// Opening { of body
-		if (this.peek() !== "{") this.err("expected '{' after templ params");
+		if (this.peek() !== "{") this.err(`expected '{' after ${kw} params`);
 		this.advance(); // consume {
 		this.tokens.push(new Token(T.LBRACE, "{", this.line, this.col));
 
-		// HTML body
-		this._lexHtmlBody(1);
-	}
-
-	// ── CSS declaration lexing ───────────────────────────────────
-
-	_lexCssDecl() {
-		this.skipWhitespace();
-
-		// Name (identifier)
-		const nameStart = this.pos;
-		while (!this.eof() && /\w/.test(this.peek())) this.advance();
-		const name = this.src.slice(nameStart, this.pos);
-		if (!name) this.err("expected name after 'css'");
-		this.tokens.push(new Token(T.IDENT, name, this.line, this.col));
-
-		this.skipWhitespace();
-
-		// Parameter list (balanced parens)
-		if (this.peek() !== "(") this.err("expected '(' after css name");
-		const paramStart = this.pos;
-		this._skipBalanced("(", ")");
-		const paramSrc = this.src.slice(paramStart, this.pos);
-		for (const t of this._goTokens(paramSrc)) this.tokens.push(t);
-
-		this.skipWhitespace();
-
-		// Opening { of body
-		if (this.peek() !== "{") this.err("expected '{' after css params");
-		this.advance(); // consume {
-		this.tokens.push(new Token(T.LBRACE, "{", this.line, this.col));
-
-		this._lexCssBody();
+		if (kw === "templ") this._lexHtmlBody(1);
+		else this._lexCssBody();
 	}
 
 	_skipCssString(quote) {
@@ -660,7 +628,7 @@ export class TemplLexer {
 	// ── HTML text content ─────────────────────────────────────────
 
 	_lexHtmlText() {
-		let text = "";
+		const start = this.pos;
 		const line = this.line;
 		while (!this.eof()) {
 			const c = this.peek();
@@ -674,9 +642,9 @@ export class TemplLexer {
 				(c === "d" && this._peekKeyword("default"))
 			)
 				break;
-			text += this.advance();
+			this.advance();
 		}
-		const trimmed = text.trim();
+		const trimmed = this.src.slice(start, this.pos).trim();
 		if (trimmed)
 			this.tokens.push(new Token(TT.HTML_TEXT, trimmed, line, this.col));
 	}
@@ -729,17 +697,15 @@ export class TemplLexer {
 	}
 
 	_readHtmlName() {
-		let name = "";
-		while (!this.eof() && /[a-zA-Z0-9_-]/.test(this.peek()))
-			name += this.advance();
-		return name;
+		const start = this.pos;
+		while (!this.eof() && /[a-zA-Z0-9_-]/.test(this.peek())) this.advance();
+		return this.src.slice(start, this.pos);
 	}
 
 	_readHtmlAttrName() {
-		let name = "";
-		while (!this.eof() && /[a-zA-Z0-9_:.-]/.test(this.peek()))
-			name += this.advance();
-		return name;
+		const start = this.pos;
+		while (!this.eof() && /[a-zA-Z0-9_:.-]/.test(this.peek())) this.advance();
+		return this.src.slice(start, this.pos);
 	}
 
 	_readQuotedString() {
@@ -756,9 +722,9 @@ export class TemplLexer {
 	}
 
 	_readWord() {
-		let w = "";
-		while (!this.eof() && /\w/.test(this.peek())) w += this.advance();
-		return w;
+		const start = this.pos;
+		while (!this.eof() && /\w/.test(this.peek())) this.advance();
+		return this.src.slice(start, this.pos);
 	}
 
 	_skipToOpenBrace() {

package/src/templ-parser.js

@@ -48,55 +48,31 @@ export class TemplParser extends Parser {
 
 	// ── CssDecl ───────────────────────────────────────────────────
 
-	parseCssDecl() {
+	_parseDecl(kind, bodyFn) {
 		const _line = this.peek().line;
-		this.advance(); // consume CSS_KW
-
+		this.advance();
 		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 opening {
 		this.expect(T.LBRACE);
-
-		// Consume CSS_BODY
-		const bodyToken = this.expect(TT.CSS_BODY);
-		const cssText = bodyToken.value;
-
-		// Consume closing }
-		this.expect(T.RBRACE);
+		const extra = bodyFn();
 		this.semi();
-
-		return { kind: "CssDecl", name, params, cssText, _line };
+		return { kind, name, params, ...extra, _line };
 	}
 
-	// ── TemplDecl ─────────────────────────────────────────────────
+	parseCssDecl() {
+		return this._parseDecl("CssDecl", () => {
+			const bodyToken = this.expect(TT.CSS_BODY);
+			const cssText = bodyToken.value;
+			this.expect(T.RBRACE);
+			return { cssText };
+		});
+	}
 
 	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 };
+		return this._parseDecl("TemplDecl", () => ({
+			body: this.parseHtmlChildren(),
+		}));
 	}
 
 	// ── HTML node parsing ─────────────────────────────────────────
@@ -229,14 +205,15 @@ export class TemplParser extends Parser {
 			!this.check(T.RBRACE) &&
 			!this.check(T.EOF)
 		) {
-			if (this.check(TT.TEMPL_CASE)) {
+			if (this.check(TT.TEMPL_CASE) || this.check(TT.TEMPL_DEFAULT)) {
+				const isDefault = this.check(TT.TEMPL_DEFAULT);
 				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 });
+				cases.push({
+					kind: "TemplCase",
+					caseTokens: isDefault ? null : caseTok.value,
+					body,
+				});
 			} else {
 				this.advance(); // skip unexpected
 			}

package/src/typechecker/assignability.js

@@ -27,6 +27,16 @@ import {
 	UNTYPED_INT,
 } from "./types.js";
 
+// Unnamed type literal kinds for Go's "identical underlying types" assignability rule.
+const TYPE_LITERAL_KINDS = new Set([
+	"slice",
+	"map",
+	"func",
+	"pointer",
+	"array",
+	"struct",
+]);
+
 /** @typedef {import('./index.js').TypeChecker} TypeChecker */
 
 // Untyped constant assignability: maps source.base → Set of compatible target.name values
@@ -182,24 +192,105 @@ export const assignabilityMethods = {
 	// Tags struct values / struct pointers flowing into an interface so codegen can
 	// tell `T` from `*T` at runtime (both compile to the same class instance).
 	_markIfaceBox(target, source, node) {
-		if (this._skipIfaceMark) return;
-		if (!node || typeof node !== "object" || !target || !source) return;
+		if (
+			this._skipIfaceMark ||
+			!node ||
+			typeof node !== "object" ||
+			!target ||
+			!source
+		)
+			return;
 		if (target.kind === "typeParam") return;
 		const tBase = this.resolveType(
 			target.kind === "named" ? target.underlying : target,
 		);
 		if (!isAny(target) && tBase?.kind !== "interface") return;
-		const structOf = (t) => {
-			const r = this.resolveType(t);
-			const b = r?.kind === "named" ? this.resolveType(r.underlying) : r;
-			return b?.kind === "struct";
-		};
+		const named = this._namedMethodBoxSource(source);
+		if (named) {
+			node._ifaceBox = named.ptr ? "named_ptr" : "named";
+			node._ifaceNamedType = named.type;
+			return;
+		}
 		const sBase = this.resolveType(
 			source.kind === "named" ? source.underlying : source,
 		);
-		if (sBase?.kind === "struct") node._ifaceBox = "value";
-		else if (sBase?.kind === "pointer" && structOf(sBase.base))
-			node._ifaceBox = "ptr";
+		const info = this._classifyIfaceBox(sBase);
+		if (!info) return;
+		node._ifaceBox = info.box;
+		if (info.ptrFields) node._ifacePtrFields = info.ptrFields;
+	},
+
+	// A named non-struct type with methods (or a pointer to one) entering an
+	// interface: the JS backend keeps such values raw and boxes them here so
+	// dynamic method dispatch works.
+	_namedMethodBoxSource(source) {
+		const isPtr = source?.kind === "pointer";
+		const t = isPtr ? source.base : source;
+		if (t?.kind !== "named") return null;
+		const u = this.resolveType(t.underlying);
+		if (!u || u.kind === "struct" || u.kind === "interface") return null;
+		const methods = t.methods ?? t._generic?.methods;
+		if (!methods || methods.size === 0) return null;
+		// Only user-declared types (methods carry _ptrRecv); stdlib named types
+		// such as time.Duration have no box class.
+		if (![...methods.values()].some((m) => Object.hasOwn(m ?? {}, "_ptrRecv")))
+			return null;
+		return { type: t, ptr: isPtr };
+	},
+
+	_getStructPtrFields(st, prefix = "", seen = new Set()) {
+		if (st?.kind !== "struct" || !st?.fields) return [];
+		if (seen.has(st)) return [];
+		const nextSeen = new Set(seen);
+		nextSeen.add(st);
+		const ptrs = [];
+		for (const [fname, ftype] of st.fields.entries()) {
+			const full = prefix ? `${prefix}.${fname}` : fname;
+			const rf = this.resolveType(ftype);
+			const bf = rf?.kind === "named" ? this.resolveType(rf.underlying) : rf;
+			if (isPointer(bf)) {
+				ptrs.push(full);
+			} else if (bf?.kind === "struct") {
+				ptrs.push(...this._getStructPtrFields(bf, full, nextSeen));
+			}
+		}
+		return ptrs;
+	},
+
+	_classifyIfaceBox(sBase) {
+		if (sBase?.kind === "struct") {
+			const pf = this._getStructPtrFields(sBase);
+			return { box: "value", ptrFields: pf.length > 0 ? pf : null };
+		}
+		if (sBase?.kind === "pointer") {
+			const st = this.resolveType(
+				sBase.base?.kind === "named" ? sBase.base.underlying : sBase.base,
+			);
+			if (st?.kind === "struct") {
+				const pf = this._getStructPtrFields(st);
+				return { box: "ptr", ptrFields: pf.length > 0 ? pf : null };
+			}
+			return null;
+		}
+		if (sBase?.kind === "map") {
+			const valType = this.resolveType(sBase.value ?? sBase.val ?? sBase.elem);
+			const keyType = this.resolveType(sBase.key);
+			return {
+				box: isPointer(valType) || isPointer(keyType) ? "ptr_map" : "map",
+			};
+		}
+		if (sBase?.kind === "slice") {
+			const elemType = this.resolveType(sBase.elem);
+			if (isPointer(elemType)) return { box: "ptr_slice" };
+			const elemBase =
+				elemType?.kind === "named"
+					? this.resolveType(elemType.underlying)
+					: elemType;
+			const pf =
+				elemBase?.kind === "struct" ? this._getStructPtrFields(elemBase) : [];
+			return pf.length > 0 ? { box: "slice", ptrFields: pf } : null;
+		}
+		return null;
 	},
 
 	// A js package cannot provide an implementation of a wasm interface: the
@@ -259,9 +350,20 @@ export const assignabilityMethods = {
 			);
 			return;
 		}
+		if (this._identicalUnderlyingLiteral(target, source, tBase, sBase)) return;
 		this.err(`Cannot assign ${typeStr(source)} to ${typeStr(target)}`, node);
 	},
 
+	// Identical underlying types are assignable when one side is an unnamed
+	// type literal (`var n Names = []string{...}`), as in Go.
+	_identicalUnderlyingLiteral(target, source, tBase, sBase) {
+		if ((target.kind === "named") === (source.kind === "named")) return false;
+		const unnamed = target.kind === "named" ? source : target;
+		return (
+			TYPE_LITERAL_KINDS.has(unnamed.kind) && typeStr(tBase) === typeStr(sBase)
+		);
+	},
+
 	_isUntypedAssignable(target, source) {
 		if (isUntyped(target)) return true;
 		// Named types with a basic underlying type (`type Mode string`) accept
@@ -371,12 +473,23 @@ export const assignabilityMethods = {
 		return true;
 	},
 
+	_unpackReturns(rList) {
+		if (
+			rList.length === 1 &&
+			(rList[0]?.kind === "tuple" || rList[0]?.kind === "TupleType") &&
+			rList[0].types
+		) {
+			return rList[0].types;
+		}
+		return rList;
+	},
+
 	_implementsMethod(required, actual) {
 		if (!actual) return false;
 		const rp = required.params ?? [],
 			ap = actual.params ?? [];
-		const rr = required.returns ?? [],
-			ar = actual.returns ?? [];
+		const rr = this._unpackReturns(required.returns ?? []),
+			ar = this._unpackReturns(actual.returns ?? []);
 		if (!this._sigParamsMatch(rp, ap)) return false;
 		if (!!required.variadic !== !!actual.variadic) return false;
 		return this._sigParamsMatch(rr, ar);
@@ -398,7 +511,7 @@ export const assignabilityMethods = {
 		}
 		const methodMap =
 			base?.kind === "struct"
-				? base.methods
+				? base.methods || srcType.methods
 				: srcType.kind === "named"
 					? srcType.methods
 					: null;