gofront 1.6.0 → 1.7.0

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))
 		);
 	},
@@ -266,6 +267,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 +475,83 @@ 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) && isString(tgtResolved)) return;
+		if (isBool(srcResolved) && isBool(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);
@@ -564,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 (
@@ -575,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;
 	},
 
@@ -629,6 +731,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;
 		}
 
@@ -638,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.
@@ -702,6 +812,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": {
@@ -753,15 +865,44 @@ export const expressionCheckMethods = {
 			);
 	},
 
-	_checkCallArgs(fnType, argTypes, expr) {
+	_checkCallArgs(fnType, argTypes, expr, scope = null) {
 		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);
+		}
+
+		// 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,
+						);
+					}
+				}
+			}
 		}
 	},
 
@@ -859,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")
@@ -866,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++) {
@@ -887,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);

package/src/typechecker/index.js

@@ -57,6 +57,7 @@ export class TypeChecker {
 		this._typeSwitchDepth = 0; // for rejecting fallthrough in type switch
 		this._deferCount = 0; // tracks defer usage in current function body
 		this._imports = []; // tracked imports for unused-import detection
+		this._constExprs = new Map(); // name -> AST initializer expr
 		this._setupGlobals();
 		// Register error as a named type (interface)
 		this.types.set("error", ERROR);
@@ -220,7 +221,11 @@ export class TypeChecker {
 			const type = spec.type
 				? this.resolveTypeNode(spec.type, this.globals)
 				: ANY;
-			for (const name of spec.names) this.globals.defineConst(name, type);
+			for (let i = 0; i < spec.names.length; i++) {
+				const name = spec.names[i];
+				const expr = spec.value?.[i] ?? spec.value?.[0] ?? null;
+				this.globals.defineConst(name, type, expr);
+			}
 		}
 	}
 
@@ -510,7 +515,8 @@ export class TypeChecker {
 			const struct = type.underlying;
 			if (struct?.kind === "struct" && struct._embeds) {
 				for (const embed of struct._embeds) {
-					const base = embed.kind === "named" ? embed.underlying : embed;
+					const inner = embed.kind === "pointer" ? embed.base : embed;
+					const base = inner.kind === "named" ? inner.underlying : inner;
 					if (base?.kind !== "struct" || !base.methods) continue;
 					for (const [mName, mType] of base.methods.entries()) {
 						if (!struct.methods.has(mName)) struct.methods.set(mName, mType);
@@ -899,14 +905,31 @@ export class TypeChecker {
 			let type = spec.type ? this.resolveTypeNode(spec.type, scope) : null;
 			if (spec.value) {
 				const valTypes = spec.value.map((v) => this.checkExpr(v, scope));
-				if (!type) type = defaultType(valTypes[0]) ?? ANY;
+				const isTuple = valTypes.length === 1 && valTypes[0]?.kind === "tuple";
+				const valTypesFlat = isTuple ? valTypes[0].types : valTypes;
+				if (spec.names.length !== valTypesFlat.length) {
+					const vars =
+						spec.names.length === 1
+							? "1 variable"
+							: `${spec.names.length} variables`;
+					const vals = isTuple
+						? `returns ${valTypesFlat.length} values`
+						: valTypesFlat.length === 1
+							? "1 value"
+							: `${valTypesFlat.length} values`;
+					this.err(`assignment mismatch: ${vars} but ${vals}`, spec);
+				}
 				for (let i = 0; i < spec.names.length; i++) {
-					const vt = valTypes[i] ?? ANY;
-					this.assertAssignable(type, vt, spec.value[i]);
+					const vt = valTypesFlat[i] ?? ANY;
+					const varType = type ?? defaultType(vt) ?? ANY;
+					if (type)
+						this.assertAssignable(type, vt, spec.value[i] ?? spec.value[0]);
+					scope.defineLocal(spec.names[i], varType);
 				}
+			} else {
+				if (!type) type = ANY;
+				for (const name of spec.names) scope.defineLocal(name, type);
 			}
-			if (!type) type = ANY;
-			for (const name of spec.names) scope.defineLocal(name, type);
 		}
 		this._sharedAllocOk = savedSharedAlloc;
 	}
@@ -918,7 +941,11 @@ export class TypeChecker {
 			const type = spec.type
 				? this.resolveTypeNode(spec.type, scope)
 				: (valTypes[0] ?? ANY);
-			for (const name of spec.names) scope.defineConst(name, type);
+			for (let i = 0; i < spec.names.length; i++) {
+				const name = spec.names[i];
+				const expr = spec.value?.[i] ?? spec.value?.[0] ?? null;
+				scope.defineConst(name, type, expr);
+			}
 		}
 	}
 

package/src/typechecker/resolve.js

@@ -1,6 +1,7 @@
 // Type resolution methods — resolveTypeNode, resolveType, fieldType, generics.
 // Installed as a mixin on TypeChecker.prototype.
 
+import { parseJsonTag } from "../parser/struct-tag.js";
 import {
 	ANY,
 	BASIC_TYPES,
@@ -97,20 +98,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
@@ -200,10 +210,28 @@ export const resolveMethods = {
 	_resolveStructType(node, scope) {
 		const fields = new Map();
 		const embeds = [];
+		const structFields = [];
 		for (const f of node.fields) {
 			const ft = this.resolveTypeNode(f.type, scope);
+			structFields.push({
+				names: f.names,
+				type: ft,
+				tag: f.tag ?? null,
+				embedded: Boolean(f.embedded),
+				astType: f.type,
+			});
 			if (f.embedded) {
-				const base = ft.kind === "named" ? ft.underlying : ft;
+				const inner = ft.kind === "pointer" ? ft.base : ft;
+				const embedName = (
+					f.astType?.name ??
+					f.type?.name ??
+					f.type?.base?.name ??
+					(inner.kind === "named" ? inner.name : "")
+				)
+					.split(".")
+					.pop();
+				if (embedName) fields.set(embedName, ft);
+				const base = inner.kind === "named" ? inner.underlying : inner;
 				if (base?.kind === "struct") {
 					for (const [k, v] of base.fields.entries()) fields.set(k, v);
 				}
@@ -212,7 +240,13 @@ export const resolveMethods = {
 				for (const n of f.names) fields.set(n, ft);
 			}
 		}
-		return { kind: "struct", fields, methods: new Map(), _embeds: embeds };
+		return {
+			kind: "struct",
+			fields,
+			methods: new Map(),
+			_embeds: embeds,
+			_structFields: structFields,
+		};
 	},
 
 	_resolveInterfaceType(node, scope) {
@@ -291,6 +325,7 @@ export const resolveMethods = {
 			name: generic.declNode.name,
 			typeArgs,
 			underlying: instantiated,
+			methods: instantiated.methods,
 		};
 	},
 
@@ -381,6 +416,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;
 	},
 
@@ -416,6 +459,7 @@ export const resolveMethods = {
 			case "namespace":
 				return this._fieldTypeNamespace(base, field, node);
 			case "shared":
+			case "simd":
 				if (base.methods?.has(field)) return base.methods.get(field);
 				return this.err(`No method '${field}' on ${typeStr(baseType)}`, node);
 			case "slice":
@@ -432,7 +476,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);
 	},
@@ -507,4 +563,127 @@ export const resolveMethods = {
 		}
 		return this.err(`No member '${field}' in namespace ${base.name}`, node);
 	},
+
+	resolveJsonFields(structType) {
+		return resolveJsonFields(structType);
+	},
 };
+
+function isExported(name) {
+	if (!name || typeof name !== "string") return false;
+	const code = name.charCodeAt(0);
+	return code >= 65 && code <= 90;
+}
+
+function _processJsonField(f, depth, path, visited, queue, candidates) {
+	const tagInfo = parseJsonTag(f.tag);
+	if (tagInfo.ignored) return;
+
+	if (f.embedded) {
+		const isPtr = f.type.kind === "pointer" || f.type.kind === "PointerType";
+		const inner = isPtr ? f.type.base : f.type;
+		const embedStruct = inner.kind === "named" ? inner.underlying : inner;
+		const embedName = (
+			f.astType?.name ??
+			f.astType?.base?.name ??
+			inner.name ??
+			""
+		)
+			.split(".")
+			.pop();
+
+		if (tagInfo.name !== null) {
+			if (isExported(embedName)) {
+				candidates.push({
+					jsonKey: tagInfo.name,
+					goName: embedName,
+					type: f.type,
+					omitempty: tagInfo.omitempty,
+					depth,
+					tagged: true,
+					isEmbedded: true,
+					path: [...path, { name: embedName, isPtr, typeName: embedName }],
+				});
+			}
+		} else if (embedStruct?.kind === "struct") {
+			if (!visited.has(embedStruct)) {
+				const nextVisited = new Set(visited);
+				nextVisited.add(embedStruct);
+				queue.push({
+					struct: embedStruct,
+					depth: depth + 1,
+					path: [...path, { name: embedName, isPtr, typeName: embedName }],
+					visited: nextVisited,
+				});
+			}
+		}
+		return;
+	}
+
+	for (const name of f.names) {
+		if (!isExported(name)) continue;
+		candidates.push({
+			jsonKey: tagInfo.name !== null ? tagInfo.name : name,
+			goName: name,
+			type: f.type,
+			omitempty: tagInfo.omitempty,
+			quoted: tagInfo.options.includes("string"),
+			depth,
+			tagged: tagInfo.name !== null,
+			path: [...path, { name, isPtr: false }],
+		});
+	}
+}
+
+function _resolveCandidateCollisions(candidates) {
+	const byKey = new Map();
+	for (const cand of candidates) {
+		if (!byKey.has(cand.jsonKey)) byKey.set(cand.jsonKey, []);
+		byKey.get(cand.jsonKey).push(cand);
+	}
+
+	const winningFields = [];
+	for (const [, group] of byKey.entries()) {
+		let minDepth = Infinity;
+		for (const c of group) {
+			if (c.depth < minDepth) minDepth = c.depth;
+		}
+
+		const atMin = group.filter((c) => c.depth === minDepth);
+		if (atMin.length === 1) {
+			winningFields.push(atMin[0]);
+		} else {
+			const tagged = atMin.filter((c) => c.tagged);
+			if (tagged.length === 1) winningFields.push(tagged[0]);
+		}
+	}
+
+	winningFields.sort((a, b) => candidates.indexOf(a) - candidates.indexOf(b));
+	return winningFields;
+}
+
+export function resolveJsonFields(structType) {
+	if (!structType) return [];
+	const underlying =
+		structType.kind === "named" ? structType.underlying : structType;
+	if (underlying?.kind !== "struct") return [];
+	if (underlying._jsonFields) return underlying._jsonFields;
+
+	const queue = [
+		{ struct: underlying, depth: 0, path: [], visited: new Set([underlying]) },
+	];
+	const candidates = [];
+
+	while (queue.length > 0) {
+		const { struct: curr, depth, path, visited } = queue.shift();
+		if (curr?.kind !== "struct") continue;
+
+		for (const f of curr._structFields || []) {
+			_processJsonField(f, depth, path, visited, queue, candidates);
+		}
+	}
+
+	const winning = _resolveCandidateCollisions(candidates);
+	underlying._jsonFields = winning;
+	return winning;
+}