gofront 0.0.6 → 0.0.8

package/src/codegen/source-map.js

@@ -16,9 +16,10 @@ function vlqEncode(value) {
 	return result;
 }
 
-export function buildSourceMap(sources, mappings) {
-	// sources:  string[]
-	// mappings: Array<{ genLine: number, srcLine: number, srcFileIdx?: number }>  (0-based)
+export function buildSourceMap(sources, mappings, sourcesContent) {
+	// sources:         string[]
+	// mappings:        Array<{ genLine: number, srcLine: number, srcFileIdx?: number }>  (0-based)
+	// sourcesContent:  string[] | undefined — original file contents, embedded for DevTools
 	// Emits one segment per generated line, column 0 → source line (delta-encoded).
 	const lines = [];
 	let prevSrcLine = 0;
@@ -44,10 +45,12 @@ export function buildSourceMap(sources, mappings) {
 			lines.push(""); // no mapping for this generated line
 		}
 	}
-	return JSON.stringify({
+	const map = {
 		version: 3,
 		sources,
 		names: [],
 		mappings: lines.join(";"),
-	});
+	};
+	if (sourcesContent) map.sourcesContent = sourcesContent;
+	return JSON.stringify(map);
 }

package/src/codegen/statements.js

@@ -7,6 +7,30 @@ export const statementGenMethods = {
 		for (const stmt of block.stmts) this.genStmt(stmt);
 	},
 
+	// Shared helper for comma-ok map index in both DefineStmt and AssignStmt.
+	// isDefine=true  → emit `let v = m[k]; let ok = k in m;`
+	// isDefine=false → emit `v = k in m ? m[k] : zero; ok = k in m;`
+	_genCommaOkMapIndex(stmt, rhsNode, isDefine) {
+		const mapExpr = this.genExpr(rhsNode.expr);
+		const keyExpr = this.genExpr(rhsNode.index);
+		const [vName, okName] = stmt.lhs.map((e) => e.name ?? this.genExpr(e));
+		const decl = isDefine ? "let " : "";
+		if (vName !== "_") {
+			if (isDefine) {
+				this.line(`let ${vName} = ${mapExpr}[${keyExpr}];`);
+			} else {
+				const zero = rhsNode._mapValueType
+					? this.zeroValueForType(rhsNode._mapValueType)
+					: "undefined";
+				this.line(
+					`${vName} = (${keyExpr}) in ${mapExpr} ? ${mapExpr}[${keyExpr}] : ${zero};`,
+				);
+			}
+		}
+		if (okName !== "_")
+			this.line(`${decl}${okName} = (${keyExpr}) in ${mapExpr};`);
+	},
+
 	genStmt(stmt) {
 		// Record source mapping for the first line this statement produces
 		const srcLine = stmt._line ?? null;
@@ -31,15 +55,7 @@ export const statementGenMethods = {
 					rhsNode?.kind === "IndexExpr" &&
 					rhsNode.expr?._type?.kind === "map"
 				) {
-					const mapExpr = this.genExpr(rhsNode.expr);
-					const keyExpr = this.genExpr(rhsNode.index);
-					const [vName, okName] = stmt.lhs.map(
-						(e) => e.name ?? this.genExpr(e),
-					);
-					if (vName !== "_")
-						this.line(`let ${vName} = ${mapExpr}[${keyExpr}];`);
-					if (okName !== "_")
-						this.line(`let ${okName} = (${keyExpr}) in ${mapExpr};`);
+					this._genCommaOkMapIndex(stmt, rhsNode, true);
 					break;
 				}
 				const rhs = stmt.rhs.map((e) => this.genExpr(e));
@@ -117,22 +133,7 @@ export const statementGenMethods = {
 				}
 				// comma-ok map index: v, ok = m["key"]
 				if (stmt._commaOkMap) {
-					const rhsNode = stmt.rhs[0];
-					const mapExpr = this.genExpr(rhsNode.expr);
-					const keyExpr = this.genExpr(rhsNode.index);
-					const [vName, okName] = stmt.lhs.map(
-						(e) => e.name ?? this.genExpr(e),
-					);
-					if (vName !== "_") {
-						const zero = rhsNode._mapValueType
-							? this.zeroValueForType(rhsNode._mapValueType)
-							: "undefined";
-						this.line(
-							`${vName} = (${keyExpr}) in ${mapExpr} ? ${mapExpr}[${keyExpr}] : ${zero};`,
-						);
-					}
-					if (okName !== "_")
-						this.line(`${okName} = (${keyExpr}) in ${mapExpr};`);
+					this._genCommaOkMapIndex(stmt, stmt.rhs[0], false);
 					break;
 				}
 				// comma-ok type assertion: v, ok = x.(T)
@@ -383,8 +384,11 @@ export const statementGenMethods = {
 		const init = stmt.init;
 		const range = init.rhs[0];
 		const lhs = init.lhs.map((e) => e.name ?? this.genExpr(e));
-		const iteree = this.genExpr(range.expr);
 		const iterType = range.expr._type;
+		const wrapField = this._namedWrapperField(iterType, range.expr);
+		const iteree = wrapField
+			? `${this.genExpr(range.expr)}.${wrapField}`
+			: this.genExpr(range.expr);
 
 		let iterExpr;
 		if (

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
@@ -51,6 +52,9 @@ export class CodeGen {
 		this._usesCdiv = false;
 		this._usesError = false;
 		this._usesErrorIs = false;
+		this._usesPathClean = false;
+		this._usesTimeFmt = false;
+		this._usesTimeParse = false;
 		// Iterator (range-over-func) context
 		this._inIteratorBody = false;
 		this._iterDepth = 0;
@@ -92,7 +96,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 +106,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;
@@ -213,6 +229,47 @@ export class CodeGen {
 			helpers.push(
 				'var __errorIs = __errorIs || function(err, target) { while (err !== null && err !== undefined) { if (err === target) return true; if (typeof err === "object" && typeof target === "object" && err._msg !== undefined && target._msg !== undefined && err._msg === target._msg) return true; err = err?._cause ?? null; } return false; };',
 			);
+		if (this._usesPathClean)
+			helpers.push(
+				'var __pathClean = __pathClean || function(p) { if (!p) return "."; const abs = p.startsWith("/"); const parts = p.split("/").reduce((acc, s) => { if (s === "" || s === ".") return acc; if (s === "..") { if (acc.length && acc[acc.length-1] !== "..") acc.pop(); else if (!abs) acc.push(".."); } else acc.push(s); return acc; }, []); return (abs ? "/" : "") + (parts.join("/") || "."); };',
+			);
+		if (this._usesTimeFmt)
+			helpers.push(
+				[
+					"var __timeFmt = __timeFmt || function(d, layout) {",
+					'const pad = (n, w=2) => String(n).padStart(w, "0");',
+					'const DAYS=["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"];',
+					'const MONTHS=["January","February","March","April","May","June","July","August","September","October","November","December"];',
+					"return layout.replace(/2006|06|Monday|Mon|January|Jan|01|1|02|2|15|PM|3|04|4|05|5|Z07:00|\\.000|\\.999/g, t => {",
+					"switch(t){",
+					'case "2006": return d.getFullYear();',
+					'case "06": return String(d.getFullYear()).slice(-2);',
+					'case "Monday": return DAYS[d.getDay()];',
+					'case "Mon": return DAYS[d.getDay()].slice(0,3);',
+					'case "January": return MONTHS[d.getMonth()];',
+					'case "Jan": return MONTHS[d.getMonth()].slice(0,3);',
+					'case "01": return pad(d.getMonth()+1);',
+					'case "1": return String(d.getMonth()+1);',
+					'case "02": return pad(d.getDate());',
+					'case "2": return String(d.getDate());',
+					'case "15": return pad(d.getHours());',
+					'case "PM": return d.getHours()<12?"AM":"PM";',
+					'case "3": return String(d.getHours()%12||12);',
+					'case "04": return pad(d.getMinutes());',
+					'case "4": return String(d.getMinutes());',
+					'case "05": return pad(d.getSeconds());',
+					'case "5": return String(d.getSeconds());',
+					'case "Z07:00": { const o=-d.getTimezoneOffset(); return o===0?"Z":(o>0?"+":"-")+pad(Math.floor(Math.abs(o)/60))+":"+pad(Math.abs(o)%60); }',
+					'case ".000": return "."+pad(d.getMilliseconds(),3);',
+					'case ".999": return d.getMilliseconds()>0?"."+String(d.getMilliseconds()).replace(/0+$/,""):"";',
+					"default: return t;}});",
+					"};",
+				].join(""),
+			);
+		if (this._usesTimeParse)
+			helpers.push(
+				'var __timeParse = __timeParse || function(layout, value) { try { const d = new Date(value); if (isNaN(d.getTime())) throw 0; return [{_d:d}, null]; } catch { return [{_d:new Date(0)}, "parsing time: cannot parse"]; } };',
+			);
 
 		if (helpers.length > 0) this.out.unshift(...helpers, "");
 
@@ -235,9 +292,10 @@ export class CodeGen {
 
 	// Returns a source map JSON string for the last generate() call.
 	// sources: string[] of source filenames (relative to the output file).
-	getSourceMap(sources) {
+	// sourcesContent: string[] of original file contents (embedded for DevTools breakpoints).
+	getSourceMap(sources, sourcesContent) {
 		const srcArray = Array.isArray(sources) ? sources : [sources];
-		return buildSourceMap(srcArray, this._srcMappings);
+		return buildSourceMap(srcArray, this._srcMappings, sourcesContent);
 	}
 
 	// ── Type declarations ────────────────────────────────────────
@@ -248,13 +306,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 +403,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) {
@@ -471,7 +579,10 @@ export class CodeGen {
 				}
 			} else {
 				const zero = spec.type ? this.zeroValueForTypeNode(spec.type) : "null";
-				for (const name of spec.names) this.line(`let ${name} = ${zero};`);
+				for (const name of spec.names) {
+					const val = this._boxedVars.has(name) ? `{ value: ${zero} }` : zero;
+					this.line(`let ${name} = ${val};`);
+				}
 			}
 		}
 	}

package/src/compiler.js

@@ -170,7 +170,8 @@ export function compileFiles(files, options = {}) {
 	if (options.sourceMap) {
 		const outputDir = options.outputDir ?? fromDir;
 		const sourceFiles = files.map((f) => relative(outputDir, f));
-		const map = codegen.getSourceMap(sourceFiles);
+		const sourcesContent = files.map((f) => readFileSync(f, "utf8"));
+		const map = codegen.getSourceMap(sourceFiles, sourcesContent);
 		const b64 = Buffer.from(map).toString("base64");
 		js += `\n//# sourceMappingURL=data:application/json;base64,${b64}`;
 	}

package/src/dev-server.js

@@ -10,6 +10,7 @@ const MIME = {
 	".js": "application/javascript; charset=utf-8",
 	".css": "text/css; charset=utf-8",
 	".json": "application/json; charset=utf-8",
+	".go": "text/plain; charset=utf-8",
 	".svg": "image/svg+xml",
 	".png": "image/png",
 	".jpg": "image/jpeg",

package/src/index.js

@@ -232,7 +232,7 @@ function runCompile() {
 	if (sourceMap) {
 		const outputDir = outputFile ? dirname(resolve(outputFile)) : resolve(".");
 		const srcPath = relative(outputDir, inputPath);
-		const map = cg.getSourceMap(srcPath);
+		const map = cg.getSourceMap(srcPath, [source]);
 		const b64 = Buffer.from(map).toString("base64");
 		js += `\n//# sourceMappingURL=data:application/json;base64,${b64}`;
 	}

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/resolver.js

@@ -25,11 +25,39 @@ function findNodeModules(startDir) {
 	}
 }
 
+// Built-in stdlib package paths that are always available as globals — no resolution needed.
+const BUILTIN_PACKAGES = new Set([
+	"fmt",
+	"strings",
+	"bytes",
+	"strconv",
+	"sort",
+	"math",
+	"math/rand",
+	"errors",
+	"time",
+	"unicode",
+	"unicode/utf8",
+	"os",
+	"slices",
+	"html",
+	"io",
+	"gom",
+	"maps",
+	"regexp",
+	"path",
+	"path/filepath",
+]);
+
 // Returns true for local relative paths (start with ./ or ../)
 export function isLocalPath(importPath) {
 	return importPath.startsWith("./") || importPath.startsWith("../");
 }
 
+export function isBuiltinPackage(importPath) {
+	return BUILTIN_PACKAGES.has(importPath);
+}
+
 // Resolve a local relative import path to an absolute directory of .go files.
 // Returns the absolute dir path, or null if it doesn't contain any .go files.
 export function resolveGwDir(importPath, fromFile) {
@@ -85,6 +113,7 @@ export function resolveAll(imports, fromFile, parseDts) {
 		for (const { path } of imp.imports) {
 			if (path.startsWith("js:")) continue; // handled separately
 			if (isLocalPath(path)) continue; // local .go packages — handled by compiler
+			if (isBuiltinPackage(path)) continue; // built-in stdlib namespaces — always available
 
 			if (resolved.has(path)) continue;
 

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);