gofront 1.6.1 → 1.7.0

package/src/dts-parser.js

@@ -203,9 +203,48 @@ export class DtsParser {
 
 	// ── Type parsing ─────────────────────────────────────────────
 
+	_parseTupleElement() {
+		this.skip();
+		if (this.startsWith("...")) this.pos += 3;
+
+		const savedPos = this.pos;
+		const ident = this.readIdent();
+		if (ident) {
+			this.skip();
+			if (this.ch() === "?") {
+				this.pos++;
+				this.skip();
+			}
+			if (this.ch() === ":") {
+				this.pos++;
+				return this.parseType(false);
+			}
+		}
+		this.pos = savedPos;
+		return this.parseType(false);
+	}
+
+	_parseTupleType(inReturn) {
+		this.consume("[");
+		const elements = [];
+		while (!this.eof() && this.peek() !== "]") {
+			this.skip();
+			if (this.ch() === "]") break;
+			elements.push(this._parseTupleElement());
+			this.skip();
+			if (this.ch() !== ",") break;
+			this.pos++;
+		}
+		this.consume("]");
+		if (inReturn) {
+			return { kind: "tuple", types: elements };
+		}
+		return { kind: "slice", elem: ANY };
+	}
+
 	// Parse a TypeScript type expression and return a GoFront type.
 	// Always returns something; falls back to ANY for complex types.
-	parseType() {
+	parseType(inReturn = false) {
 		this.skip();
 
 		// Skip modifiers
@@ -226,13 +265,16 @@ export class DtsParser {
 		this.skip();
 		if (this.ch() === "|" || this.ch() === "&") this.pos++;
 
-		let base = this._parseBaseType();
+		let base = this._parseBaseType(inReturn);
 
 		this.skip();
 		// Array suffix: T[] or T[][]
 		while (this.startsWith("[]")) {
 			this.pos += 2;
-			base = { kind: "slice", elem: base };
+			base = {
+				kind: "slice",
+				elem: base.kind === "tuple" ? { kind: "slice", elem: ANY } : base,
+			};
 			this.skip();
 		}
 
@@ -285,14 +327,11 @@ export class DtsParser {
 		return { kind: "basic", name: "any", alias: name };
 	}
 
-	_parseBaseType() {
+	_parseBaseType(inReturn = false) {
 		this.skip();
 		const c = this.ch();
 		if (c === "[") {
-			this.pos++;
-			this.skipTypeExpr("]");
-			this.consume("]");
-			return ANY;
+			return this._parseTupleType(inReturn);
 		}
 		if (c === "{") {
 			this.skipBlock();
@@ -399,15 +438,24 @@ export class DtsParser {
 		let ret = VOID;
 		if (this.ch() === ":") {
 			this.pos++;
-			ret = this.parseType();
+			ret = this.parseType(true);
 		}
 		this.consume(";");
+		const isVariadic = params.some((p) => p.variadic);
 		return {
 			name,
 			val: {
 				kind: "func",
-				params: params.map((p) => p.type),
-				returns: [ret],
+				params: params.map((p) =>
+					p.variadic && p.type?.kind === "slice" ? p.type.elem : p.type,
+				),
+				returns:
+					ret.kind === "tuple"
+						? ret.types.length > 0
+							? ret.types
+							: [VOID]
+						: [ret],
+				...(isVariadic ? { variadic: true } : {}),
 			},
 		};
 	}
@@ -545,13 +593,22 @@ export class DtsParser {
 			let ret = VOID;
 			if (this.ch() === ":") {
 				this.pos++;
-				ret = this.parseType();
+				ret = this.parseType(true);
 			}
 			this.consume(";");
+			const isVariadic = params.some((p) => p.variadic);
 			out[name] = {
 				kind: "func",
-				params: params.map((p) => p.type),
-				returns: [ret],
+				params: params.map((p) =>
+					p.variadic && p.type?.kind === "slice" ? p.type.elem : p.type,
+				),
+				returns:
+					ret.kind === "tuple"
+						? ret.types.length > 0
+							? ret.types
+							: [VOID]
+						: [ret],
+				...(isVariadic ? { variadic: true } : {}),
 			};
 		} else if (this.ch() === ":") {
 			this.pos++;

package/src/lower/boxing.js

@@ -6,12 +6,7 @@ import { forEachChild } from "./walk.js";
 export function isReferenceType(t) {
 	if (!t) return false;
 	const base = t.kind === "named" ? t.underlying : t;
-	return (
-		base?.kind === "struct" ||
-		base?.kind === "slice" ||
-		base?.kind === "map" ||
-		base?.kind === "func"
-	);
+	return base?.kind === "struct" || base?.kind === "func";
 }
 
 // Scan AST node for _addressTaken idents on scalars and populate a Set of boxed variable names.

package/src/lower/embedding.js

@@ -9,7 +9,8 @@ export function computeEmbeddedStubs(name, methodDecls, checker) {
 	const declared = new Set(methodDecls.map((m) => m.name));
 	const stubs = [];
 
-	for (const embed of resolvedType._embeds) {
+	for (const rawEmbed of resolvedType._embeds) {
+		const embed = rawEmbed.kind === "pointer" ? rawEmbed.base : rawEmbed;
 		const embedName = embed.kind === "named" ? embed.name : null;
 		if (!embedName) continue;
 		const embedBase = embed.kind === "named" ? embed.underlying : embed;

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/parser/types.js

@@ -175,23 +175,80 @@ 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: { kind: "TypeName", name: typeName },
+				};
+				let tag = null;
+				if (this.check(T.STRING)) {
+					tag = this.advance().value;
+				}
+				fields.push({
+					names: [],
+					type,
+					embedded: true,
+					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}`;
+				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;
 			}
+
+			// 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);

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
@@ -195,6 +205,12 @@ export const assignabilityMethods = {
 			target.kind === "named" ? target.underlying : target,
 		);
 		if (!isAny(target) && tBase?.kind !== "interface") return;
+		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,
 		);
@@ -204,6 +220,24 @@ export const assignabilityMethods = {
 		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 [];
@@ -316,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

package/src/typechecker/expressions.js

@@ -228,6 +228,7 @@ export const expressionCheckMethods = {
 	_isStructOrNamedMethod(baseType, base, field) {
 		return (
 			(base?.kind === "struct" && base.methods?.has(field)) ||
+			(base?.kind === "simd" && base.methods?.has(field)) ||
 			(baseType.kind === "named" && baseType.methods?.has(field))
 		);
 	},
@@ -513,6 +514,8 @@ export const expressionCheckMethods = {
 		}
 		if (typeStr(srcResolved) === typeStr(tgtResolved)) return;
 		if (isNumeric(srcResolved) && isNumeric(tgtResolved)) return;
+		if (isString(srcResolved) && isString(tgtResolved)) return;
+		if (isBool(srcResolved) && isBool(tgtResolved)) return;
 		if (
 			isString(srcResolved) &&
 			tgtResolved?.kind === "slice" &&
@@ -649,7 +652,8 @@ export const expressionCheckMethods = {
 		return expr;
 	},
 
-	_constIntValue(expr) {
+	_constIntValue(expr, scope = null) {
+		if (!expr) return null;
 		if (expr.kind === "BasicLit" && expr.litKind === "INT")
 			return Number(expr.value);
 		if (
@@ -660,6 +664,19 @@ export const expressionCheckMethods = {
 		) {
 			return -Number(expr.operand.value);
 		}
+		if (expr.kind === "UnaryExpr" && expr.op === "+") {
+			return this._constIntValue(expr.operand, scope);
+		}
+		if (expr.kind === "Ident") {
+			const c =
+				scope?.lookupConstExpr?.(expr.name) ??
+				this.globals.lookupConstExpr?.(expr.name) ??
+				this._constExprs?.get(expr.name);
+			if (c) return this._constIntValue(c, scope);
+		}
+		if (expr.kind === "ParenExpr") {
+			return this._constIntValue(expr.expr, scope);
+		}
 		return null;
 	},
 
@@ -731,7 +748,7 @@ export const expressionCheckMethods = {
 			return this.err(`Cannot call non-function type ${typeStr(fnType)}`, expr);
 		}
 
-		this._checkCallArgs(fnType, argTypes, expr);
+		this._checkCallArgs(fnType, argTypes, expr, scope);
 
 		// Pseudo-generic stdlib helpers (maps.Keys, slices.Clone, ...) declare
 		// how their result derives from the first argument.
@@ -848,7 +865,7 @@ export const expressionCheckMethods = {
 			);
 	},
 
-	_checkCallArgs(fnType, argTypes, expr) {
+	_checkCallArgs(fnType, argTypes, expr, scope = null) {
 		this._checkArgCount(fnType, argTypes, expr);
 		const maxLen = fnType.variadic
 			? argTypes.length
@@ -863,6 +880,30 @@ export const expressionCheckMethods = {
 			const node = expr._multiForward ? null : expr.args[i];
 			this.assertAssignable(targetParam, argTypes[i], node);
 		}
+
+		// Validate Lane and WithLane constant integer lane index
+		if (expr.func?.kind === "SelectorExpr") {
+			const recvType = expr.func.expr?._type;
+			const isSimd =
+				recvType?.name === "simd.F32x4" ||
+				recvType?.name === "F32x4" ||
+				recvType?.underlying?.kind === "simd";
+			if (
+				isSimd &&
+				(expr.func.field === "Lane" || expr.func.field === "WithLane")
+			) {
+				const laneArg = expr.args[0];
+				if (laneArg) {
+					const idx = this._constIntValue(laneArg, scope);
+					if (idx === null || idx < 0 || idx > 3) {
+						this.err(
+							"lane index must be a constant integer in range [0, 3]",
+							laneArg,
+						);
+					}
+				}
+			}
+		}
 	},
 
 	checkBuiltin(name, expr, argTypes, scope) {
@@ -959,6 +1000,8 @@ export const expressionCheckMethods = {
 		this._inferArraySize(expr, typeNode, base);
 		if (base?.kind === "struct")
 			return this._checkStructCompositeLit(expr, scope, t, base);
+		if (base?.kind === "simd")
+			return this._checkSimdCompositeLit(expr, scope, t, base);
 		if (this._isSliceOrArray(base))
 			return this._checkSliceArrayCompositeLit(expr, scope, t, base, typeNode);
 		if (base?.kind === "map")
@@ -966,6 +1009,17 @@ export const expressionCheckMethods = {
 		return this._checkUnknownCompositeLit(expr, scope, t);
 	},
 
+	_checkSimdCompositeLit(expr, scope, t, base) {
+		if (expr.elems.length > 4) {
+			this.err("too many values in simd.F32x4 literal", expr);
+		}
+		for (const elem of expr.elems) {
+			const vt = this.checkExpr(elem, scope);
+			this.assertAssignable(base.elem ?? FLOAT32, vt, elem);
+		}
+		return t;
+	},
+
 	_checkStructPositionalElems(expr, scope, t, base) {
 		const fieldNames = [...(base.fields?.keys() ?? [])];
 		for (let i = 0; i < expr.elems.length; i++) {
@@ -987,21 +1041,19 @@ export const expressionCheckMethods = {
 		for (const elem of expr.elems) {
 			if (elem.kind === "KeyValueExpr") {
 				const keyName = elem.key.name;
-				const fieldType = base.fields?.get(keyName);
+				const embed = base._embeds?.find((e) => {
+					const inner = e.kind === "pointer" ? e.base : e;
+					const name =
+						inner.kind === "named" ? inner.name.split(".").pop() : null;
+					return name === keyName;
+				});
+				if (embed) elem._isEmbedInit = true;
+				const fieldType = base.fields?.get(keyName) ?? embed;
 				if (fieldType) {
 					const vt = this.checkExpr(elem.value, scope);
 					this.assertAssignable(fieldType, vt, elem.value);
 				} else {
-					const embed = base._embeds?.find(
-						(e) => (e.kind === "named" ? e.name : null) === keyName,
-					);
-					if (embed) {
-						const vt = this.checkExpr(elem.value, scope);
-						this.assertAssignable(embed, vt, elem.value);
-						elem._isEmbedInit = true;
-					} else {
-						this.err(`Unknown field '${keyName}'`, elem.key);
-					}
+					this.err(`Unknown field '${keyName}'`, elem.key);
 				}
 			} else {
 				this.checkExpr(elem, scope);