gofront 0.0.6 → 0.0.7

package/src/codegen.js

@@ -35,6 +35,7 @@ export class CodeGen {
 		this.out = [];
 		this.indent = 0;
 		this.structNames = new Set();
+		this.namedWrapperNames = new Set();
 		this.jsImports = jsImports;
 		this.bundledPackages = bundledPackages;
 		this.namedReturnVars = null; // names of current function's named return vars
@@ -92,7 +93,7 @@ export class CodeGen {
 			}
 		}
 
-		// Build a map: structName → [MethodDecl, ...]
+		// Build a map: typeName → [MethodDecl, ...]
 		const methods = new Map();
 		for (const d of program.decls) {
 			if (d.kind === "MethodDecl") {
@@ -102,6 +103,18 @@ export class CodeGen {
 			}
 		}
 
+		// Collect named non-struct types that have methods (emitted as wrapper classes)
+		for (const d of program.decls) {
+			if (
+				d.kind === "TypeDecl" &&
+				d.type.kind !== "StructType" &&
+				d.type.kind !== "InterfaceType" &&
+				(methods.get(d.name) ?? []).length > 0
+			) {
+				this.namedWrapperNames.add(d.name);
+			}
+		}
+
 		// Emit ESM import statements for npm packages
 		for (const [importPath, names] of this.jsImports) {
 			if (names.length === 0) continue;
@@ -248,13 +261,41 @@ export class CodeGen {
 		} else if (decl.type.kind === "InterfaceType") {
 			// Interfaces are compile-time only — no JS output needed.
 			this.line(`// interface ${decl.name} (compile-time only)`);
+		} else if (methodDecls.length > 0) {
+			// Named non-struct type with methods — emit an ES6 wrapper class.
+			this.genNamedTypeClass(decl.name, methodDecls);
 		} else {
-			// Type alias — no JS equivalent needed unless it's used as a constructor.
-			// e.g. type MyInt int → just a comment
 			this.line(`// type ${decl.name} = ${this.typeComment(decl.type)}`);
 		}
 	}
 
+	genNamedTypeClass(name, methodDecls) {
+		const namedType = this.checker?.types.get(name);
+		const underlying = namedType?.underlying;
+		let field, ctorDefault;
+		if (underlying?.kind === "func") {
+			field = "_fn";
+			ctorDefault = "null";
+		} else if (underlying?.kind === "map") {
+			field = "_map";
+			ctorDefault = "{}";
+		} else {
+			field = "_items";
+			ctorDefault = "[]";
+		}
+		this.line(`class ${name} {`);
+		this.indented(() => {
+			this.line(
+				`constructor(${field} = ${ctorDefault}) { this.${field} = ${field}; }`,
+			);
+			for (const m of methodDecls) {
+				this.blank();
+				this.genMethod(m, field);
+			}
+		});
+		this.line("}");
+	}
+
 	genStruct(name, structTypeAst, methodDecls) {
 		const fields = [];
 		if (this.checker) {
@@ -317,23 +358,45 @@ export class CodeGen {
 		this.line("}");
 	}
 
-	genMethod(decl) {
+	genMethod(decl, recvField = null) {
 		const params = decl.params.map((p) => p.name).join(", ");
 		const asyncPrefix = decl.async ? "async " : "";
 		this.line(`${asyncPrefix}${decl.name}(${params}) {`);
 		const prevBoxed = this._boxedVars;
 		this._boxedVars = new Set();
 		this._scanAddressTaken(decl.body);
+		const prevUnwrapped = this._unwrappedRecv;
 		this.indented(() => {
 			if (decl.recvName && decl.recvName !== "_") {
-				this.line(`const ${decl.recvName} = this;`);
+				if (recvField) {
+					this.line(`const ${decl.recvName} = this.${recvField};`);
+					this._unwrappedRecv = decl.recvName;
+				} else {
+					this.line(`const ${decl.recvName} = this;`);
+				}
 			}
 			this._withNamedReturns(decl, () => this._genBody(decl.body));
 		});
+		this._unwrappedRecv = prevUnwrapped;
 		this._boxedVars = prevBoxed;
 		this.line("}");
 	}
 
+	// Returns the wrapper field name ("_fn", "_items", "_map") if `type` is a named
+	// non-struct type emitted as a wrapper class, or null otherwise.
+	// Pass `expr` so we can skip unwrapping when the expression is the method receiver
+	// (which was already unwrapped to `this.<field>` at the top of the method body).
+	_namedWrapperField(type, expr = null) {
+		if (type?.kind !== "named") return null;
+		if (!this.namedWrapperNames.has(type.name)) return null;
+		if (expr?.kind === "Ident" && expr.name === this._unwrappedRecv)
+			return null;
+		const u = type.underlying;
+		if (u?.kind === "func") return "_fn";
+		if (u?.kind === "map") return "_map";
+		return "_items";
+	}
+
 	// ── Function declarations ────────────────────────────────────
 
 	genFuncDecl(decl, nameOverride) {

package/src/parser.js

@@ -308,16 +308,6 @@ export class Parser {
 		return this.looksLikeType(next) || next.type === T.ELLIPSIS;
 	}
 
-	// Heuristic: peek2 is a param-name separator if it's a comma, rparen, or a type token
-	isParamType(tok) {
-		if (!tok) return false;
-		// T.RPAREN is intentionally excluded: when peek2 is ")", the current IDENT
-		// is the type of an unnamed param (e.g. func(int)), not a param name.
-		return (
-			tok.type === T.COMMA || tok.type === T.ELLIPSIS || this.looksLikeType(tok)
-		);
-	}
-
 	looksLikeType(tok) {
 		return (
 			tok.type === T.LBRACKET ||

package/src/typechecker/expressions.js

@@ -111,8 +111,16 @@ export const expressionCheckMethods = {
 				if (expr.expr._isTypeRef) {
 					let base = baseType.kind === "named" ? baseType.underlying : baseType;
 					base = this.resolveType(base);
+					let methodType = null;
 					if (base?.kind === "struct" && base.methods?.has(expr.field)) {
-						const methodType = base.methods.get(expr.field);
+						methodType = base.methods.get(expr.field);
+					} else if (
+						baseType.kind === "named" &&
+						baseType.methods?.has(expr.field)
+					) {
+						methodType = baseType.methods.get(expr.field);
+					}
+					if (methodType) {
 						// Return a func type with the receiver prepended to params
 						expr._isMethodExpr = true;
 						expr._methodExprRecv = baseType;
@@ -129,7 +137,10 @@ export const expressionCheckMethods = {
 				if (ft?.kind === "func") {
 					let base = baseType.kind === "named" ? baseType.underlying : baseType;
 					base = this.resolveType(base);
-					if (base?.kind === "struct" && base.methods?.has(expr.field)) {
+					if (
+						(base?.kind === "struct" && base.methods?.has(expr.field)) ||
+						(baseType.kind === "named" && baseType.methods?.has(expr.field))
+					) {
 						expr._isMethodValue = true;
 					}
 				}
@@ -140,9 +151,14 @@ export const expressionCheckMethods = {
 				const bt = this.checkExpr(expr.expr, scope);
 				this.checkExpr(expr.index, scope);
 				if (isAny(bt)) return ANY;
-				if (bt.kind === "slice" || bt.kind === "array") {
+				// Named types (e.g. type Nums []int) are indexable via their underlying
+				const btu =
+					bt.kind === "named"
+						? (this.resolveType(bt.underlying) ?? bt.underlying)
+						: bt;
+				if (btu.kind === "slice" || btu.kind === "array") {
 					// Compile-time bounds checking for arrays
-					if (bt.kind === "array" && bt.size != null) {
+					if (btu.kind === "array" && btu.size != null) {
 						const idx = this._constIntValue(expr.index);
 						if (idx !== null) {
 							if (idx < 0) {
@@ -150,7 +166,7 @@ export const expressionCheckMethods = {
 									`invalid array index ${idx} (index must not be negative)`,
 									expr,
 								);
-							} else if (idx >= bt.size) {
+							} else if (idx >= btu.size) {
 								this.err(
 									`invalid array index ${idx} (out of bounds for ${typeStr(bt)})`,
 									expr,
@@ -158,11 +174,11 @@ export const expressionCheckMethods = {
 							}
 						}
 					}
-					return bt.elem;
+					return btu.elem;
 				}
-				if (bt.kind === "map") {
-					expr._mapValueType = bt.value; // for codegen zero-value fallback
-					return bt.value;
+				if (btu.kind === "map") {
+					expr._mapValueType = btu.value; // for codegen zero-value fallback
+					return btu.value;
 				}
 				if (isString(bt)) return INT; // byte
 				return this.err(`Cannot index type ${typeStr(bt)}`, expr);
@@ -410,6 +426,19 @@ export const expressionCheckMethods = {
 
 		if (isAny(fnType)) return ANY;
 
+		// Named type used as a constructor/conversion: Greeter(fn), NodeFunc(fn)
+		// The callee is a type name, not a callable variable.
+		if (fnType.kind === "named" && expr.func._isTypeRef) {
+			expr._isTypeConversion = true;
+			expr._conversionTargetType = fnType;
+			return fnType;
+		}
+
+		// Named func types (e.g. type Handler func(int) int) are callable via variable
+		if (fnType.kind === "named" && fnType.underlying?.kind === "func") {
+			fnType = fnType.underlying;
+		}
+
 		// Generic function inference
 		if (fnType.kind === "generic") {
 			const typeArgs = this.inferTypeArgs(fnType, argTypes);