gofront 0.0.1 → 0.0.2

package/src/codegen.js

@@ -210,10 +210,6 @@ export class CodeGen {
 
 	// ── Type declarations ────────────────────────────────────────
 
-	genTypeDecl(decl) {
-		this.genTypeDeclWithMethods(decl, []);
-	}
-
 	genTypeDeclWithMethods(decl, methodDecls) {
 		if (decl.type.kind === "StructType") {
 			this.genStruct(decl.name, decl.type, methodDecls);
@@ -339,22 +335,36 @@ export class CodeGen {
 		this.namedReturnVars = prev;
 	}
 
-	// Emit a function body, wrapping in try/finally for defer if needed.
+	// Emit a function body, wrapping in try/catch/finally for defer if needed.
 	_genBody(body) {
 		if (!this._hasDefer(body)) {
-			this.genBlock(body, true);
+			this.genBlock(body);
 			return;
 		}
 		this.line("const __defers = [];");
+		this.line("let __panic = null;");
 		this.line("try {");
-		this.indented(() => this.genBlock(body, true));
+		this.indented(() => this.genBlock(body));
+		this.line("} catch (__err) {");
+		this.indented(() => this.line("__panic = __err;"));
 		this.line("} finally {");
 		this.indented(() => {
 			this.line(
 				"for (let __i = __defers.length - 1; __i >= 0; __i--) __defers[__i]();",
 			);
+			this.line("if (__panic !== null) throw __panic;");
 		});
 		this.line("}");
+		// If a recover() cleared __panic, execution reaches here.
+		// Return named return vars so deferred mutations are visible to the caller.
+		if (this.namedReturnVars?.length > 0) {
+			const vars = this.namedReturnVars;
+			this.line(
+				vars.length === 1
+					? `return ${vars[0]};`
+					: `return [${vars.join(", ")}];`,
+			);
+		}
 	}
 
 	// Recursively check if a block (or nested blocks) contains any DeferStmt.
@@ -410,7 +420,7 @@ export class CodeGen {
 
 	// ── Statements ───────────────────────────────────────────────
 
-	genBlock(block, _skipBraces = false) {
+	genBlock(block) {
 		for (const stmt of block.stmts) this.genStmt(stmt);
 	}
 
@@ -426,7 +436,7 @@ export class CodeGen {
 				this.genConstDecl(stmt);
 				break;
 			case "TypeDecl":
-				this.genTypeDecl(stmt);
+				this.genTypeDeclWithMethods(stmt, []);
 				break;
 
 			case "DefineStmt": {
@@ -550,12 +560,24 @@ export class CodeGen {
 				this.genSwitch(stmt);
 				break;
 
+			case "TypeSwitchStmt":
+				this.genTypeSwitch(stmt);
+				break;
+
 			case "DeferStmt":
 				this.line(`__defers.push(() => { ${this.genExpr(stmt.call)}; });`);
 				break;
 
+			case "LabeledStmt":
+				this.line(`${stmt.label}:`);
+				this.genStmt(stmt.body);
+				break;
+
 			case "BranchStmt":
-				if (stmt.keyword !== "fallthrough") this.line(`${stmt.keyword};`);
+				if (stmt.keyword !== "fallthrough")
+					this.line(
+						stmt.label ? `${stmt.keyword} ${stmt.label};` : `${stmt.keyword};`,
+					);
 				// fallthrough: omit — JS switch falls through naturally without a break
 				break;
 
@@ -603,6 +625,15 @@ export class CodeGen {
 			return;
 		}
 
+		// for range N { } — no variable, just repeat N times
+		if (stmt.cond?.kind === "RangeExpr") {
+			const iteree = this.genExpr(stmt.cond.expr);
+			this.line(`for (let _$ = 0; _$ < ${iteree}; _$++) {`);
+			this.indented(() => this.genBlock(stmt.body));
+			this.line("}");
+			return;
+		}
+
 		if (!stmt.init && !stmt.post) {
 			if (!stmt.cond) {
 				// infinite loop
@@ -639,6 +670,18 @@ export class CodeGen {
 		const iterType = range.expr._type;
 
 		let iterExpr;
+		if (
+			lhs.length <= 1 &&
+			iterType?.kind === "basic" &&
+			(iterType.name === "int" || iterType.name === "float64")
+		) {
+			// integer range (Go 1.22): for i := range n  → C-style for loop
+			const v = lhs[0] === "_" ? "_$" : lhs[0];
+			this.line(`for (let ${v} = 0; ${v} < ${iteree}; ${v}++) {`);
+			this.indented(() => this.genBlock(stmt.body));
+			this.line("}");
+			return;
+		}
 		if (
 			iterType?.kind === "map" ||
 			(iterType?.kind === "named" && iterType.underlying?.kind === "map")
@@ -697,44 +740,82 @@ export class CodeGen {
 	}
 
 	genSwitch(stmt) {
+		const genBody = () => {
+			const tag = stmt.tag ? this.genExpr(stmt.tag) : "true";
+			this.line(`switch (${tag}) {`);
+			this.indented(() => {
+				for (const c of stmt.cases) {
+					if (c.list) {
+						for (const e of c.list) this.line(`case ${this.genExpr(e)}:`);
+					} else {
+						this.line("default:");
+					}
+					// Wrap each case body in {} so `let` declarations don't bleed
+					// across sibling cases (JS switch shares one block scope).
+					this.line("{");
+					this.indented(() => {
+						for (const s of c.stmts) this.genStmt(s);
+						// Go doesn't fall through by default — add break unless last stmt is return/break
+						const last = c.stmts[c.stmts.length - 1];
+						if (
+							!last ||
+							(last.kind !== "ReturnStmt" && last.kind !== "BranchStmt")
+						) {
+							this.line("break;");
+						}
+					});
+					this.line("}");
+				}
+			});
+			this.line("}");
+		};
+
 		if (stmt.init) {
 			this.line("{");
-			this.indent++;
-			this.genStmt(stmt.init);
+			this.indented(() => {
+				this.genStmt(stmt.init);
+				genBody();
+			});
+			this.line("}");
+		} else {
+			genBody();
 		}
+	}
 
-		const tag = stmt.tag ? this.genExpr(stmt.tag) : "true";
-		this.line(`switch (${tag}) {`);
+	genTypeSwitch(stmt) {
+		this.line("{");
 		this.indented(() => {
+			const val = this.genExpr(stmt.expr);
+			this.line(`const __tsw = ${val};`);
+			if (stmt.assign) this.line(`let ${stmt.assign} = __tsw;`);
+
+			let first = true;
+			let hasDefault = false;
 			for (const c of stmt.cases) {
-				if (c.list) {
-					for (const e of c.list) this.line(`case ${this.genExpr(e)}:`);
-				} else {
-					this.line("default:");
+				if (!c.types) {
+					// default case — emit last
+					hasDefault = c;
+					continue;
 				}
-				// Wrap each case body in {} so `let` declarations don't bleed
-				// across sibling cases (JS switch shares one block scope).
-				this.line("{");
+				const cond = c.types
+					.map((t) => this._typeCheckExpr(t, "__tsw"))
+					.join(" || ");
+				this.line(`${first ? "if" : "else if"} (${cond}) {`);
 				this.indented(() => {
 					for (const s of c.stmts) this.genStmt(s);
-					// Go doesn't fall through by default — add break unless last stmt is return/break
-					const last = c.stmts[c.stmts.length - 1];
-					if (
-						!last ||
-						(last.kind !== "ReturnStmt" && last.kind !== "BranchStmt")
-					) {
-						this.line("break;");
-					}
+				});
+				this.line("}");
+				first = false;
+			}
+			if (hasDefault) {
+				this.line(first ? "{" : "else {");
+				this.indented(() => {
+					for (const s of hasDefault.stmts) this.genStmt(s);
 				});
 				this.line("}");
 			}
 		});
 		this.line("}");
-
-		if (stmt.init) {
-			this.indent--;
-			this.line("}");
-		}
 	}
 
 	// ── Expressions ──────────────────────────────────────────────
@@ -766,7 +847,10 @@ export class CodeGen {
 				) {
 					return `Math.trunc(${l} / ${r})`;
 				}
-				return `${l} ${expr.op} ${r}`;
+				// Go == and != are strict — map to JS === / !==
+				const op =
+					expr.op === "==" ? "===" : expr.op === "!=" ? "!==" : expr.op;
+				return `${l} ${op} ${r}`;
 			}
 
 			case "CallExpr":
@@ -818,7 +902,27 @@ export class CodeGen {
 
 			case "TypeConversion": {
 				const inner = this.genExpr(expr.expr);
-				const target = expr.targetType?.name;
+				const t = expr.targetType;
+
+				// Slice type conversions
+				if (t?.kind === "SliceType") {
+					const elem = t.elem?.name;
+					// []byte(s) → UTF-8 byte array
+					if (elem === "byte" || elem === "uint8") {
+						return `Array.from(new TextEncoder().encode(${inner}))`;
+					}
+					// []rune(s) → Unicode code point array (only when source is a string)
+					if (elem === "rune" || elem === "int32" || elem === "int") {
+						const srcType = expr.expr._type;
+						if (srcType?.kind === "basic" && srcType?.name === "string") {
+							return `Array.from(${inner}, __c => __c.codePointAt(0))`;
+						}
+						return `Array.from(${inner})`;
+					}
+					return `Array.from(${inner})`;
+				}
+
+				const target = t?.name;
 				switch (target) {
 					case "string":
 						return `String(${inner})`;
@@ -893,11 +997,33 @@ export class CodeGen {
 					const arg = this.genExpr(expr.args[0]);
 					return `(() => { throw new Error(${arg}); })()`;
 				}
+				case "recover":
+					return `(typeof __panic !== "undefined" && __panic !== null ? (() => { const __r = __panic.message ?? String(__panic); __panic = null; return __r; })() : null)`;
 				case "error": {
 					// errors are plain strings; nil (null) means no error
 					const arg = this.genExpr(expr.args[0]);
 					return arg;
 				}
+				case "min": {
+					const args = expr.args.map((a) => this.genExpr(a)).join(", ");
+					return `Math.min(${args})`;
+				}
+				case "max": {
+					const args = expr.args.map((a) => this.genExpr(a)).join(", ");
+					return `Math.max(${args})`;
+				}
+				case "clear": {
+					const arg = expr.args[0];
+					const t = arg?._type;
+					const js = this.genExpr(arg);
+					if (
+						t?.kind === "map" ||
+						(t?.kind === "named" && t.underlying?.kind === "map")
+					) {
+						return `((__m) => { for (const __k in __m) delete __m[__k]; })(${js})`;
+					}
+					return `(${js}).length = 0`;
+				}
 			}
 		}
 
@@ -936,14 +1062,20 @@ export class CodeGen {
 			}
 		}
 
-		const fn = this.genExpr(expr.func);
-		const args = expr.args.map((a) => this.genExpr(a)).join(", ");
+		const rawFn = this.genExpr(expr.func);
+		// Wrap function literals in parens so `function(){}()` → `(function(){})()`
+		const fn = expr.func.kind === "FuncLit" ? `(${rawFn})` : rawFn;
+		const args = expr.args
+			.map((a) => (a._spread ? `...${this.genExpr(a)}` : this.genExpr(a)))
+			.join(", ");
 		return `${fn}(${args})`;
 	}
 
 	genAppend(expr) {
 		const slice = this.genExpr(expr.args[0]);
-		const elems = expr.args.slice(1).map((a) => this.genExpr(a));
+		const elems = expr.args
+			.slice(1)
+			.map((a) => (a._spread ? `...${this.genExpr(a)}` : this.genExpr(a)));
 		if (elems.length === 0) return slice;
 		this._usesAppend = true;
 		return `__append(${slice}, ${elems.join(", ")})`;
@@ -973,10 +1105,7 @@ export class CodeGen {
 			}
 			return `new Array(${n}).fill(${zero})`;
 		}
-		if (typeNode.kind === "MapType" || resolvedKind === "map") {
-			return "{}";
-		}
-		// Fallback
+		// map or fallback
 		return "{}";
 	}
 
@@ -1079,6 +1208,17 @@ export class CodeGen {
 	_zeroForBasicName(name) {
 		switch (name) {
 			case "int":
+			case "uint":
+			case "int8":
+			case "int16":
+			case "int32":
+			case "int64":
+			case "uint8":
+			case "uint16":
+			case "uint32":
+			case "uint64":
+			case "uintptr":
+			case "float32":
 			case "float64":
 			case "byte":
 			case "rune":
@@ -1141,6 +1281,17 @@ export class CodeGen {
 		if (typeNode.kind === "TypeName") {
 			switch (typeNode.name) {
 				case "int":
+				case "uint":
+				case "int8":
+				case "int16":
+				case "int32":
+				case "int64":
+				case "uint8":
+				case "uint16":
+				case "uint32":
+				case "uint64":
+				case "uintptr":
+				case "float32":
 				case "float64":
 				case "byte":
 				case "rune":
@@ -1149,6 +1300,10 @@ export class CodeGen {
 					return `typeof ${val} === "string"`;
 				case "bool":
 					return `typeof ${val} === "boolean"`;
+				case "nil":
+					return `${val} === null`;
+				case "error":
+					return `typeof ${val} === "string"`;
 				default:
 					if (this.structNames.has(typeNode.name))
 						return `${val} instanceof ${typeNode.name}`;

package/src/compiler.js

@@ -86,8 +86,9 @@ export function compileFiles(files, options = {}) {
 
 	// js: prefix — local .d.ts files
 	for (const imp of allImports) {
-		for (const path of imp.paths) {
+		for (const { path, alias } of imp.imports) {
 			if (!path.startsWith("js:")) continue;
+			if (alias === "_") continue; // side-effect import — no type definitions
 			const dtsPath = join(fromDir, path.slice(3));
 			try {
 				const { types, values } = parseDts(readFileSync(dtsPath, "utf8"));
@@ -98,8 +99,12 @@ export function compileFiles(files, options = {}) {
 		}
 	}
 
-	// npm packages
-	const resolved = resolveAll(allImports, dummyFromFile, parseDts);
+	// npm packages — exclude side-effect imports (alias "_") from type resolution
+	const allImportsNoSideEffect = allImports.map((imp) => ({
+		...imp,
+		imports: imp.imports.filter(({ alias }) => alias !== "_"),
+	}));
+	const resolved = resolveAll(allImportsNoSideEffect, dummyFromFile, parseDts);
 	for (const [path, info] of resolved) {
 		if (!info) continue;
 		checker.addDefinitions(info.types, info.values);
@@ -109,7 +114,7 @@ export function compileFiles(files, options = {}) {
 	// local GoFront packages (./subdir)
 	const seenLocalPaths = new Set();
 	for (const imp of allImports) {
-		for (const path of imp.paths) {
+		for (const { path, alias } of imp.imports) {
 			if (!isLocalPath(path) || seenLocalPaths.has(path)) continue;
 			seenLocalPaths.add(path);
 
@@ -124,9 +129,11 @@ export function compileFiles(files, options = {}) {
 			// Recursively compile dependency
 			const dep = compileDir(depDir);
 			preambles.push(dep.js);
-			bundledPackages.add(dep.pkgName);
+			if (alias === "_") continue; // side-effect import — bundle code but don't expose namespace
+			const nameUsed = alias ?? dep.pkgName;
+			bundledPackages.add(nameUsed);
 			checker.addPackageNamespace(
-				dep.pkgName,
+				nameUsed,
 				dep.exportedSymbols,
 				dep.exportedTypes,
 			);

package/src/dts-parser.js

@@ -404,13 +404,11 @@ export class DtsParser {
 		if (this.eof() || this.ch() === "}") return;
 
 		// Skip modifiers (export, declare, static, readonly, etc.)
-		let _exported = false;
 		while (true) {
 			this.skip();
 			let found = false;
 			for (const mod of SKIP_MODIFIERS) {
 				if (this.matchKw(mod)) {
-					if (mod === "export") _exported = true;
 					found = true;
 					break;
 				}
@@ -604,13 +602,11 @@ export class DtsParser {
 			if (this.eof() || this.ch() === "}") break;
 
 			// Collect modifiers
-			let _isExport = false;
 			while (true) {
 				this.skip();
 				let found = false;
 				for (const mod of SKIP_MODIFIERS) {
 					if (this.matchKw(mod)) {
-						if (mod === "export") _isExport = true;
 						found = true;
 						break;
 					}

package/src/index.js

@@ -148,16 +148,14 @@ function runCompile() {
 		throw new Error(`cannot read '${inputArg}': ${e.message}`);
 	}
 
-	let tokens;
-	tokens = new Lexer(source, basename(inputPath)).tokenize();
+	const tokens = new Lexer(source, basename(inputPath)).tokenize();
 
 	if (dumpTokens) {
 		for (const tok of tokens) console.log(tok.toString());
 		process.exit(0);
 	}
 
-	let ast;
-	ast = new Parser(tokens, basename(inputPath), source).parse();
+	const ast = new Parser(tokens, basename(inputPath), source).parse();
 	ast._source = source;
 
 	if (dumpAst) {
@@ -170,7 +168,7 @@ function runCompile() {
 	const jsImports = new Map();
 
 	for (const imp of ast.imports) {
-		for (const path of imp.paths) {
+		for (const { path } of imp.imports) {
 			if (!path.startsWith("js:")) continue;
 			const dtsPath = join(fromDir, path.slice(3));
 			try {
@@ -193,7 +191,7 @@ function runCompile() {
 	const preambles = [];
 
 	for (const imp of ast.imports) {
-		for (const path of imp.paths) {
+		for (const { path, alias } of imp.imports) {
 			if (!isLocalPath(path)) continue;
 			const depDir = resolveGwDir(path, inputPath);
 			if (!depDir) {
@@ -204,9 +202,10 @@ function runCompile() {
 			}
 			const dep = compileDir(depDir);
 			preambles.push(dep.js);
-			bundledPackages.add(dep.pkgName);
+			const nameUsed = alias ?? dep.pkgName;
+			bundledPackages.add(nameUsed);
 			checker.addPackageNamespace(
-				dep.pkgName,
+				nameUsed,
 				dep.exportedSymbols,
 				dep.exportedTypes,
 			);
@@ -228,15 +227,7 @@ function runCompile() {
 	}
 
 	const output = preambles.length > 0 ? `${preambles.join("\n")}\n${js}` : js;
-	return { js: output, _cg: cg };
-}
-
-function _writeOutput(js) {
-	if (outputFile) {
-		writeFileSync(outputFile, `${js}\n`);
-	} else {
-		console.log(js);
-	}
+	return { js: output };
 }
 
 // ── Minify helper ────────────────────────────────────────────

package/src/lexer.js

@@ -58,6 +58,11 @@ export const T = {
 	STAR_ASSIGN: "*=",
 	SLASH_ASSIGN: "/=",
 	PERCENT_ASSIGN: "%=",
+	AMP_ASSIGN: "&=",
+	PIPE_ASSIGN: "|=",
+	CARET_ASSIGN: "^=",
+	LSHIFT_ASSIGN: "<<=",
+	RSHIFT_ASSIGN: ">>=",
 	INC: "++",
 	DEC: "--",
 	AMP: "&",
@@ -267,7 +272,7 @@ export class Lexer {
 			}
 		}
 		if (this.pos >= this.src.length)
-			throw new LexError("Unterminated string", l, c, this.filename);
+			throw new LexError("Unterminated string", l, c, this.filename, this.src);
 		this.advance(); // closing "
 		return s;
 	}
@@ -281,6 +286,60 @@ export class Lexer {
 		return s;
 	}
 
+	readRuneLiteral() {
+		const l = this.line,
+			c = this.col;
+		this.advance(); // opening '
+		let code;
+		if (this.peek() === "\\") {
+			this.advance();
+			const esc = this.advance();
+			switch (esc) {
+				case "n":
+					code = 10;
+					break;
+				case "t":
+					code = 9;
+					break;
+				case "r":
+					code = 13;
+					break;
+				case "'":
+					code = 39;
+					break;
+				case "\\":
+					code = 92;
+					break;
+				case "0":
+					code = 0;
+					break;
+				default:
+					throw new LexError(
+						`Unknown escape in rune literal: \\${esc}`,
+						l,
+						c,
+						this.filename,
+						this.src,
+					);
+			}
+		} else if (this.peek() !== "'") {
+			code = this.src.codePointAt(this.pos);
+			this.advance();
+		} else {
+			throw new LexError("Empty rune literal", l, c, this.filename, this.src);
+		}
+		if (this.peek() !== "'")
+			throw new LexError(
+				"Rune literal must contain exactly one character",
+				l,
+				c,
+				this.filename,
+				this.src,
+			);
+		this.advance(); // closing '
+		return String(code);
+	}
+
 	readNumber() {
 		let n = "";
 		let isFloat = false;
@@ -347,6 +406,10 @@ export class Lexer {
 				this.push(T.STRING, this.readRawString(), l, c);
 				continue;
 			}
+			if (ch === "'") {
+				this.push(T.INT, this.readRuneLiteral(), l, c);
+				continue;
+			}
 
 			// Numbers
 			if (/[0-9]/.test(ch)) {
@@ -396,25 +459,32 @@ export class Lexer {
 					else this.push(T.NOT, "!", l, c);
 					break;
 				case "<":
-					if (this.match("<")) this.push(T.LSHIFT, "<<", l, c);
-					else if (this.match("=")) this.push(T.LTE, "<=", l, c);
+					if (this.match("<")) {
+						if (this.match("=")) this.push(T.LSHIFT_ASSIGN, "<<=", l, c);
+						else this.push(T.LSHIFT, "<<", l, c);
+					} else if (this.match("=")) this.push(T.LTE, "<=", l, c);
 					else this.push(T.LT, "<", l, c);
 					break;
 				case ">":
-					if (this.match(">")) this.push(T.RSHIFT, ">>", l, c);
-					else if (this.match("=")) this.push(T.GTE, ">=", l, c);
+					if (this.match(">")) {
+						if (this.match("=")) this.push(T.RSHIFT_ASSIGN, ">>=", l, c);
+						else this.push(T.RSHIFT, ">>", l, c);
+					} else if (this.match("=")) this.push(T.GTE, ">=", l, c);
 					else this.push(T.GT, ">", l, c);
 					break;
 				case "&":
 					if (this.match("&")) this.push(T.AND, "&&", l, c);
+					else if (this.match("=")) this.push(T.AMP_ASSIGN, "&=", l, c);
 					else this.push(T.AMP, "&", l, c);
 					break;
 				case "|":
 					if (this.match("|")) this.push(T.OR, "||", l, c);
+					else if (this.match("=")) this.push(T.PIPE_ASSIGN, "|=", l, c);
 					else this.push(T.PIPE, "|", l, c);
 					break;
 				case "^":
-					this.push(T.CARET, "^", l, c);
+					if (this.match("=")) this.push(T.CARET_ASSIGN, "^=", l, c);
+					else this.push(T.CARET, "^", l, c);
 					break;
 				case ":":
 					if (this.match("=")) this.push(T.DEFINE, ":=", l, c);