gofront 1.6.0 → 1.6.1

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

@@ -182,24 +182,81 @@ 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 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;
+	},
+
+	_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
@@ -371,12 +428,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 +466,7 @@ export const assignabilityMethods = {
 		}
 		const methodMap =
 			base?.kind === "struct"
-				? base.methods
+				? base.methods || srcType.methods
 				: srcType.kind === "named"
 					? srcType.methods
 					: null;

package/src/typechecker/expressions.js

@@ -266,6 +266,16 @@ export const expressionCheckMethods = {
 			if (this._isStructOrNamedMethod(baseType, base, expr.field))
 				expr._isMethodValue = true;
 		}
+		if (
+			baseType?.kind === "namespace" &&
+			this.types.has(`${baseType.name}.${expr.field}`) &&
+			!(
+				baseType.name === "binary" &&
+				(expr.field === "LittleEndian" || expr.field === "BigEndian")
+			)
+		) {
+			expr._isTypeRef = true;
+		}
 		return ft;
 	},
 
@@ -464,6 +474,81 @@ export const expressionCheckMethods = {
 		return targetType;
 	},
 
+	_checkConversionValidity(srcType, targetType, expr) {
+		if (!srcType || !targetType || isAny(srcType) || isAny(targetType)) return;
+		const srcResolved = srcType.kind === "named" ? srcType.underlying : srcType;
+		const tgtResolved =
+			targetType.kind === "named" ? targetType.underlying : targetType;
+
+		if (isNumeric(targetType) && isComplex(srcType)) {
+			this.err(
+				`cannot convert ${typeStr(srcType)} to ${typeStr(targetType)} (use real() or imag())`,
+				expr,
+			);
+			return;
+		}
+		if (isComplex(targetType) && !isComplexOrNumeric(srcType)) {
+			this.err(
+				`cannot convert ${typeStr(srcType)} to ${typeStr(targetType)}`,
+				expr,
+			);
+			return;
+		}
+		if (this._isMutualArraySlice(tgtResolved, srcResolved)) {
+			this._checkElemTypeCompatible(
+				tgtResolved.elem,
+				srcResolved.elem,
+				srcType,
+				targetType,
+				expr,
+			);
+			return;
+		}
+		if (this._isInvalidArrayConv(tgtResolved, srcResolved, srcType)) {
+			this.err(
+				`cannot convert ${typeStr(srcType)} to ${typeStr(targetType)}`,
+				expr,
+			);
+			return;
+		}
+		if (typeStr(srcResolved) === typeStr(tgtResolved)) return;
+		if (isNumeric(srcResolved) && isNumeric(tgtResolved)) return;
+		if (
+			isString(srcResolved) &&
+			tgtResolved?.kind === "slice" &&
+			(tgtResolved.elem?.name === "byte" ||
+				tgtResolved.elem?.name === "rune" ||
+				tgtResolved.elem?.name === "uint8" ||
+				tgtResolved.elem?.name === "int32")
+		)
+			return;
+		if (
+			isString(tgtResolved) &&
+			(isNumeric(srcResolved) ||
+				(srcResolved?.kind === "slice" &&
+					(srcResolved.elem?.name === "byte" ||
+						srcResolved.elem?.name === "rune" ||
+						srcResolved.elem?.name === "uint8" ||
+						srcResolved.elem?.name === "int32")))
+		)
+			return;
+		if (srcResolved?.kind === "pointer" && tgtResolved?.kind === "pointer") {
+			const sBase =
+				srcResolved.base?.kind === "named"
+					? srcResolved.base.underlying
+					: srcResolved.base;
+			const tBase =
+				tgtResolved.base?.kind === "named"
+					? tgtResolved.base.underlying
+					: tgtResolved.base;
+			if (typeStr(sBase) === typeStr(tBase)) return;
+		}
+		this.err(
+			`cannot convert ${typeStr(srcType)} to ${typeStr(targetType)}`,
+			expr,
+		);
+	},
+
 	_checkTypeAssertExpr(expr, scope) {
 		const srcType = this.checkExpr(expr.expr, scope);
 		const targetType = this.resolveTypeNode(expr.type, scope);
@@ -629,6 +714,14 @@ export const expressionCheckMethods = {
 		if (fnType.kind === "named" && expr.func._isTypeRef) {
 			expr._isTypeConversion = true;
 			expr._conversionTargetType = fnType;
+			if (expr.args.length !== 1) {
+				return this.err(
+					`cannot convert ${expr.args.length} arguments to type ${typeStr(fnType)}`,
+					expr,
+				);
+			}
+			const argType = argTypes[0];
+			this._checkConversionValidity(argType, fnType, expr);
 			return fnType;
 		}
 
@@ -702,6 +795,8 @@ export const expressionCheckMethods = {
 		switch (mode) {
 			case "arg0":
 				return under ? arg : null;
+			case "elemOfArg0":
+				return under?.elem ?? null;
 			case "keysOfArg0":
 				return under?.key ? { kind: "slice", elem: under.key } : null;
 			case "valuesOfArg0": {
@@ -755,13 +850,18 @@ export const expressionCheckMethods = {
 
 	_checkCallArgs(fnType, argTypes, expr) {
 		this._checkArgCount(fnType, argTypes, expr);
-		for (let i = 0; i < fnType.params.length && i < argTypes.length; i++) {
+		const maxLen = fnType.variadic
+			? argTypes.length
+			: Math.min(fnType.params.length, argTypes.length);
+		for (let i = 0; i < maxLen; i++) {
 			const paramIdx =
 				fnType.variadic && i >= fnType.params.length - 1
 					? fnType.params.length - 1
 					: i;
 			if (expr.args[i]?._spread) continue;
-			this.assertAssignable(fnType.params[paramIdx], argTypes[i], expr.args[i]);
+			const targetParam = fnType.params[paramIdx];
+			const node = expr._multiForward ? null : expr.args[i];
+			this.assertAssignable(targetParam, argTypes[i], node);
 		}
 	},
 

package/src/typechecker/resolve.js

@@ -97,20 +97,29 @@ export const resolveMethods = {
 				}
 				return this.err(`Unknown type '${node.name}'`, node);
 			}
-			case "GenericTypeName": {
-				const base = this.types.get(node.name);
-				if (!base) return this.err(`Unknown type '${node.name}'`, node);
+			case "GenericTypeName":
+			case "InstantiationExpr":
+			case "IndexExpr": {
+				const name =
+					node.name ?? (node.expr?.kind === "Ident" ? node.expr.name : null);
+				const typeArgs = node.typeArgs ?? (node.index ? [node.index] : []);
+				const base = name
+					? this.types.get(name)
+					: node.expr
+						? this.resolveTypeNode(node.expr, scope)
+						: null;
+				if (!base) return this.err(`Unknown type '${name ?? "?"}'`, node);
 				if (base.kind === "named" && base._generic) {
 					const res = this.instantiateGenericType(
 						base._generic,
-						node.typeArgs,
+						typeArgs,
 						scope,
 					);
 					node._typeArgs = res.typeArgs;
 					node._genericType = base;
 					return res;
 				}
-				return this.err(`Type '${node.name}' is not generic`, node);
+				return this.err(`Type '${name ?? "?"}' is not generic`, node);
 			}
 			case "TypeParam": {
 				const constraint = node.constraint
@@ -291,6 +300,7 @@ export const resolveMethods = {
 			name: generic.declNode.name,
 			typeArgs,
 			underlying: instantiated,
+			methods: instantiated.methods,
 		};
 	},
 
@@ -381,6 +391,14 @@ export const resolveMethods = {
 			const found = this.types.get(t.alias);
 			if (found) return found;
 		}
+		if (
+			t.kind === "named" &&
+			(!t.typeArgs || t.typeArgs.length === 0) &&
+			(!t.underlying || !t.methods)
+		) {
+			const found = this.types.get(t.name);
+			if (found) return found;
+		}
 		return t;
 	},
 
@@ -432,7 +450,19 @@ export const resolveMethods = {
 	},
 
 	_fieldTypeStruct(base, baseType, field, node) {
-		if (base.fields?.has(field)) return base.fields.get(field);
+		if (base.fields?.has(field)) {
+			if (
+				field.startsWith("_") &&
+				(baseType?.name?.startsWith("strings.") ||
+					baseType?.name?.startsWith("bytes."))
+			) {
+				return this.err(
+					`Cannot refer to unexported field '${field}' on ${typeStr(baseType)}`,
+					node,
+				);
+			}
+			return base.fields.get(field);
+		}
 		if (base.methods?.has(field)) return base.methods.get(field);
 		return this.err(`No field '${field}' on ${typeStr(baseType)}`, node);
 	},