gofront 0.0.1 → 0.0.2

package/src/parser.js

@@ -129,18 +129,23 @@ export class Parser {
 
 	parseImport() {
 		this.expect(T.IMPORT);
-		const paths = [];
+		const imports = [];
+		const parseOne = () => {
+			const alias = this.check(T.IDENT) ? this.advance().value : null;
+			const path = this.expect(T.STRING).value;
+			return { path, alias };
+		};
 		if (this.match(T.LPAREN)) {
 			while (!this.check(T.RPAREN) && !this.check(T.EOF)) {
-				paths.push(this.expect(T.STRING).value);
+				imports.push(parseOne());
 				this.semi();
 			}
 			this.expect(T.RPAREN);
 		} else {
-			paths.push(this.expect(T.STRING).value);
+			imports.push(parseOne());
 		}
 		this.semi();
-		return { kind: "ImportDecl", paths };
+		return { kind: "ImportDecl", imports };
 	}
 
 	// ── Top-level declarations ───────────────────────────────────
@@ -155,7 +160,7 @@ export class Parser {
 			case T.TYPE:
 				return this.parseTypeDecl();
 			case T.VAR:
-				return this.parseVarDecl(true);
+				return this.parseVarDecl();
 			case T.CONST:
 				return this.parseConstDecl();
 			default:
@@ -292,7 +297,12 @@ export class Parser {
 
 	parseReturnType(inTypeExpr = false) {
 		// No return type
-		if (this.check(T.LBRACE) || this.check(T.SEMICOLON) || this.check(T.EOF))
+		if (
+			this.check(T.LBRACE) ||
+			this.check(T.RBRACE) ||
+			this.check(T.SEMICOLON) ||
+			this.check(T.EOF)
+		)
 			return null;
 		// Inside a type expression (e.g. func type in a tuple), `,` and `)` also end the type
 		if (inTypeExpr && (this.check(T.COMMA) || this.check(T.RPAREN)))
@@ -330,12 +340,13 @@ export class Parser {
 	parseTypeDecl() {
 		this.expect(T.TYPE);
 		const name = this.expect(T.IDENT).value;
+		const isAlias = this.match(T.ASSIGN);
 		const type = this.parseType();
 		this.semi();
-		return { kind: "TypeDecl", name, type };
+		return { kind: "TypeDecl", name, type, isAlias };
 	}
 
-	parseVarDecl(_topLevel = false) {
+	parseVarDecl() {
 		this.expect(T.VAR);
 		const decls = [];
 		if (this.match(T.LPAREN)) {
@@ -466,6 +477,11 @@ export class Parser {
 			this.advance();
 			return { kind: "SliceType", elem: this.parseType() };
 		}
+		if (this.match(T.ELLIPSIS)) {
+			// [...]T — array with inferred length from composite literal
+			this.expect(T.RBRACKET);
+			return { kind: "ArrayType", inferLen: true, elem: this.parseType() };
+		}
 		// fixed array: [n]T — treated as slice for JS purposes
 		const size = this.parseExpr();
 		this.expect(T.RBRACKET);
@@ -508,6 +524,8 @@ export class Parser {
 				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 });
 			this.semi();
 		}
@@ -519,15 +537,27 @@ export class Parser {
 		this.expect(T.INTERFACE);
 		this.expect(T.LBRACE);
 		const methods = [];
+		const embeds = [];
 		while (!this.check(T.RBRACE) && !this.check(T.EOF)) {
 			const name = this.expect(T.IDENT).value;
-			const params = this.parseParamList();
-			const returnType = this.parseReturnType();
-			methods.push({ name, params, returnType });
+			if (this.check(T.LPAREN)) {
+				// Method signature: Name(params) returnType
+				const params = this.parseParamList();
+				const returnType = this.parseReturnType();
+				methods.push({ name, params, returnType });
+			} else {
+				// Embedded interface: TypeName or pkg.TypeName
+				let typeName = name;
+				if (this.check(T.DOT)) {
+					this.advance();
+					typeName += `.${this.expect(T.IDENT).value}`;
+				}
+				embeds.push({ kind: "TypeName", name: typeName });
+			}
 			this.semi();
 		}
 		this.expect(T.RBRACE);
-		return { kind: "InterfaceType", methods };
+		return { kind: "InterfaceType", methods, embeds };
 	}
 
 	// ── Statements ───────────────────────────────────────────────
@@ -564,10 +594,20 @@ export class Parser {
 				return this.parseDefer();
 			case T.BREAK:
 				this.advance();
+				if (this.check(T.IDENT)) {
+					const label = this.advance().value;
+					this.semi();
+					return { kind: "BranchStmt", keyword: "break", label };
+				}
 				this.semi();
 				return { kind: "BranchStmt", keyword: "break" };
 			case T.CONTINUE:
 				this.advance();
+				if (this.check(T.IDENT)) {
+					const label = this.advance().value;
+					this.semi();
+					return { kind: "BranchStmt", keyword: "continue", label };
+				}
 				this.semi();
 				return { kind: "BranchStmt", keyword: "continue" };
 			case T.FALLTHROUGH:
@@ -582,6 +622,14 @@ export class Parser {
 				return this.parseSwitch();
 			case T.LBRACE:
 				return this.parseBlock();
+			case T.IDENT:
+				if (this.check2(T.COLON)) {
+					const label = this.advance().value; // consume IDENT
+					this.advance(); // consume COLON
+					const body = this.parseStmt();
+					return { kind: "LabeledStmt", label, body };
+				}
+				return this.parseSimpleStmt();
 			default:
 				return this.parseSimpleStmt();
 		}
@@ -687,14 +735,27 @@ export class Parser {
 		let init = null;
 		let tag = null;
 		if (!this.check(T.LBRACE)) {
-			const expr = this.parseExpr(0, true);
+			const first = this.parseSimpleStmtRaw(true);
 			if (this.match(T.SEMICOLON)) {
-				init = this.exprToStmt(expr);
-				if (!this.check(T.LBRACE)) tag = this.parseExpr(0, true);
+				init = first;
+				if (!this.check(T.LBRACE))
+					tag = this.stmtToExpr(this.parseSimpleStmtRaw(true));
 			} else {
-				tag = expr;
+				tag = this.stmtToExpr(first);
 			}
 		}
+
+		// Detect type switch: switch x.(type) or switch v := x.(type)
+		if (tag?.kind === "TypeSwitchExpr") {
+			return this._parseTypeSwitchBody(null, tag.expr);
+		}
+		if (tag?.kind === "DefineStmt" && tag.rhs[0]?.kind === "TypeSwitchExpr") {
+			return this._parseTypeSwitchBody(
+				tag.lhs[0]?.name ?? null,
+				tag.rhs[0].expr,
+			);
+		}
+
 		this.expect(T.LBRACE);
 		const cases = [];
 		while (!this.check(T.RBRACE) && !this.check(T.EOF)) {
@@ -702,29 +763,15 @@ export class Parser {
 				this.advance();
 				const list = this.parseExprList();
 				this.expect(T.COLON);
-				const stmts = [];
-				while (
-					!this.check(T.CASE) &&
-					!this.check(T.DEFAULT) &&
-					!this.check(T.RBRACE)
-				) {
-					stmts.push(this.parseStmt());
-					this.semi();
-				}
-				cases.push({ kind: "CaseClause", list, stmts });
+				cases.push({ kind: "CaseClause", list, stmts: this._parseCaseBody() });
 			} else if (this.check(T.DEFAULT)) {
 				this.advance();
 				this.expect(T.COLON);
-				const stmts = [];
-				while (
-					!this.check(T.CASE) &&
-					!this.check(T.DEFAULT) &&
-					!this.check(T.RBRACE)
-				) {
-					stmts.push(this.parseStmt());
-					this.semi();
-				}
-				cases.push({ kind: "CaseClause", list: null, stmts });
+				cases.push({
+					kind: "CaseClause",
+					list: null,
+					stmts: this._parseCaseBody(),
+				});
 			} else {
 				this.err("Expected case or default");
 			}
@@ -733,6 +780,54 @@ export class Parser {
 		return { kind: "SwitchStmt", init, tag, cases };
 	}
 
+	_parseCaseBody() {
+		const stmts = [];
+		while (
+			!this.check(T.CASE) &&
+			!this.check(T.DEFAULT) &&
+			!this.check(T.RBRACE)
+		) {
+			stmts.push(this.parseStmt());
+			this.semi();
+		}
+		return stmts;
+	}
+
+	_parseTypeSwitchBody(assign, expr) {
+		this.expect(T.LBRACE);
+		const cases = [];
+		while (!this.check(T.RBRACE) && !this.check(T.EOF)) {
+			if (this.check(T.CASE)) {
+				this.advance();
+				const types = this._parseTypeSwitchTypeList();
+				this.expect(T.COLON);
+				cases.push({ types, stmts: this._parseCaseBody() });
+			} else if (this.check(T.DEFAULT)) {
+				this.advance();
+				this.expect(T.COLON);
+				cases.push({ types: null, stmts: this._parseCaseBody() });
+			} else {
+				this.err("Expected case or default");
+			}
+		}
+		this.expect(T.RBRACE);
+		return { kind: "TypeSwitchStmt", assign, expr, cases };
+	}
+
+	_parseTypeSwitchTypeList() {
+		const parseOne = () => {
+			// nil is a keyword, not a type name, so handle it explicitly
+			if (this.check(T.NIL)) {
+				this.advance();
+				return { kind: "TypeName", name: "nil" };
+			}
+			return this.parseType();
+		};
+		const types = [parseOne()];
+		while (this.match(T.COMMA)) types.push(parseOne());
+		return types;
+	}
+
 	// Parses a "simple statement": assignment, define, inc/dec, or expression.
 	// Returns a statement node.
 	parseSimpleStmt() {
@@ -770,6 +865,11 @@ export class Parser {
 			T.STAR_ASSIGN,
 			T.SLASH_ASSIGN,
 			T.PERCENT_ASSIGN,
+			T.AMP_ASSIGN,
+			T.PIPE_ASSIGN,
+			T.CARET_ASSIGN,
+			T.LSHIFT_ASSIGN,
+			T.RSHIFT_ASSIGN,
 		];
 		if (assignOps.includes(t.type)) {
 			const op = this.advance().value;
@@ -800,10 +900,6 @@ export class Parser {
 		return stmt;
 	}
 
-	exprToStmt(expr) {
-		return { kind: "ExprStmt", expr };
-	}
-
 	// ── Expressions ──────────────────────────────────────────────
 
 	parseExprList() {
@@ -855,9 +951,16 @@ export class Parser {
 				// type assertion: expr.(Type)
 				if (this.check(T.LPAREN)) {
 					this.advance();
-					const type = this.parseType();
-					this.expect(T.RPAREN);
-					expr = { kind: "TypeAssertExpr", expr, type };
+					// x.(type) — type switch guard expression
+					if (this.check(T.TYPE)) {
+						this.advance();
+						this.expect(T.RPAREN);
+						expr = { kind: "TypeSwitchExpr", expr };
+					} else {
+						const type = this.parseType();
+						this.expect(T.RPAREN);
+						expr = { kind: "TypeAssertExpr", expr, type };
+					}
 				} else {
 					const field = this.advance().value;
 					expr = { kind: "SelectorExpr", expr, field };
@@ -915,11 +1018,25 @@ export class Parser {
 					(t.type === T.MAP || isSliceOrArrayType) &&
 					!this.looksLikeCompositeLitArg()
 				) {
-					args.push({ kind: "TypeExpr", type: this.parseType() });
+					const typeNode = this.parseType();
+					// []byte(s) / []rune(s) used as a call argument — it's a type conversion
+					if (this.check(T.LPAREN)) {
+						this.advance();
+						const convExpr = this.parseExpr();
+						this.expect(T.RPAREN);
+						args.push({
+							kind: "TypeConversion",
+							targetType: typeNode,
+							expr: convExpr,
+						});
+					} else {
+						args.push({ kind: "TypeExpr", type: typeNode });
+					}
 				} else {
-					args.push(this.parseExpr());
+					const arg = this.parseExpr();
+					if (this.match(T.ELLIPSIS)) arg._spread = true;
+					args.push(arg);
 				}
-				this.match(T.ELLIPSIS); // variadic spread, ignore for now
 			} while (this.match(T.COMMA));
 		}
 		this.expect(T.RPAREN);
@@ -1080,9 +1197,17 @@ export class Parser {
 			return { kind: "Ident", name: t.value };
 		}
 
-		// Slice/array/map composite literals: []int{1,2}, map[string]int{"a":1}
+		// Slice/array/map composite literals or type conversions:
+		//   []int{1,2}           → CompositeLit
+		//   []byte(s), []rune(s) → TypeConversion
 		if (t.type === T.LBRACKET || t.type === T.MAP) {
 			const typeExpr = this.parseType();
+			if (this.check(T.LPAREN)) {
+				this.advance();
+				const expr = this.parseExpr();
+				this.expect(T.RPAREN);
+				return { kind: "TypeConversion", targetType: typeExpr, expr };
+			}
 			return this.parseCompositeLit(typeExpr);
 		}
 

package/src/resolver.js

@@ -82,7 +82,7 @@ export function resolveAll(imports, fromFile, parseDts) {
 	const resolved = new Map();
 
 	for (const imp of imports) {
-		for (const path of imp.paths) {
+		for (const { path } of imp.imports) {
 			if (path.startsWith("js:")) continue; // handled separately
 			if (isLocalPath(path)) continue; // local .go packages — handled by compiler
 

package/src/typechecker.js

@@ -34,6 +34,10 @@ export class TypeCheckError extends Error {
 	}
 }
 
+// ── Static operator sets (module-level for reuse) ────────────
+const CMP_OPS = new Set(["==", "!=", "<", ">", "<=", ">="]);
+const LOG_OPS = new Set(["&&", "||"]);
+
 // ── Built-in types ───────────────────────────────────────────
 
 const INT = { kind: "basic", name: "int" };
@@ -54,6 +58,18 @@ const BASIC_TYPES = {
 	byte: INT,
 	rune: INT,
 	error: ERROR,
+	// Sized integer / float aliases — all map to int or float64 at runtime
+	uint: INT,
+	int8: INT,
+	int16: INT,
+	int32: INT,
+	int64: INT,
+	uint8: INT,
+	uint16: INT,
+	uint32: INT,
+	uint64: INT,
+	uintptr: INT,
+	float32: FLOAT64,
 };
 
 function isNumeric(t) {
@@ -188,7 +204,6 @@ export class TypeChecker {
 			"Boolean",
 			"Array",
 			"Object",
-			"JSON",
 			"parseInt",
 			"parseFloat",
 			"isNaN",
@@ -219,6 +234,8 @@ export class TypeChecker {
 			"FileReader",
 			"ArrayBuffer",
 			"Uint8Array",
+			"TextEncoder",
+			"TextDecoder",
 			"WebGLRenderingContext",
 			"WebGL2RenderingContext",
 			"GPUDevice",
@@ -254,9 +271,13 @@ export class TypeChecker {
 		this.globals.define("print", { kind: "builtin", name: "print" });
 		this.globals.define("println", { kind: "builtin", name: "println" });
 		this.globals.define("panic", { kind: "builtin", name: "panic" });
+		this.globals.define("recover", { kind: "builtin", name: "recover" });
 		this.globals.define("new", { kind: "builtin", name: "new" });
 		this.globals.define("copy", { kind: "builtin", name: "copy" });
 		this.globals.define("error", { kind: "builtin", name: "error" });
+		this.globals.define("min", { kind: "builtin", name: "min" });
+		this.globals.define("max", { kind: "builtin", name: "max" });
+		this.globals.define("clear", { kind: "builtin", name: "clear" });
 	}
 
 	addDefinitions(types, values) {
@@ -412,6 +433,12 @@ export class TypeChecker {
 
 	collectType(decl) {
 		const underlying = this.resolveTypeNode(decl.type, this.globals);
+		if (decl.isAlias) {
+			// type A = B — transparent alias, A and B are identical types
+			this.types.set(decl.name, underlying);
+			this.globals.define(decl.name, underlying);
+			return;
+		}
 		const named = { kind: "named", name: decl.name, underlying };
 		if (underlying.kind === "struct") {
 			underlying.name = decl.name;
@@ -685,9 +712,14 @@ export class TypeChecker {
 				const inner = new Scope(scope);
 				if (stmt.init) this.checkStmt(stmt.init, inner, returnType);
 				if (stmt.cond) {
-					const ct = this.checkExpr(stmt.cond, inner);
-					if (!isBool(ct) && !isAny(ct))
-						this.err("For condition must be bool", stmt);
+					// for range N { } — RangeExpr as condition is valid (Go 1.22 int range)
+					if (stmt.cond.kind !== "RangeExpr") {
+						const ct = this.checkExpr(stmt.cond, inner);
+						if (!isBool(ct) && !isAny(ct))
+							this.err("For condition must be bool", stmt);
+					} else {
+						this.checkExpr(stmt.cond.expr, inner);
+					}
 				}
 				if (stmt.post) this.checkStmt(stmt.post, inner, returnType);
 				this._loopDepth++;
@@ -699,7 +731,7 @@ export class TypeChecker {
 			case "SwitchStmt": {
 				const inner = new Scope(scope);
 				if (stmt.init) this.checkStmt(stmt.init, inner, returnType);
-				const _tagType = stmt.tag ? this.checkExpr(stmt.tag, inner) : BOOL;
+				if (stmt.tag) this.checkExpr(stmt.tag, inner);
 				this._switchDepth++;
 				for (const c of stmt.cases) {
 					const caseScope = new Scope(inner);
@@ -710,6 +742,26 @@ export class TypeChecker {
 				break;
 			}
 
+			case "TypeSwitchStmt": {
+				const inner = new Scope(scope);
+				this.checkExpr(stmt.expr, inner);
+				this._switchDepth++;
+				for (const c of stmt.cases) {
+					const caseScope = new Scope(inner);
+					if (stmt.assign) {
+						// Bind the variable to the single case type, or any for multi/default
+						const bindType =
+							c.types?.length === 1
+								? this.resolveTypeNode(c.types[0], inner)
+								: ANY;
+						caseScope.define(stmt.assign, bindType);
+					}
+					for (const s of c.stmts) this.checkStmt(s, caseScope, returnType);
+				}
+				this._switchDepth--;
+				break;
+			}
+
 			case "DeferStmt": {
 				if (stmt.call.kind !== "CallExpr")
 					this.err("defer requires a function call", stmt.call);
@@ -717,8 +769,13 @@ export class TypeChecker {
 				break;
 			}
 
+			case "LabeledStmt":
+				this.checkStmt(stmt.body, scope, returnType);
+				break;
+
 			case "BranchStmt": {
 				const kw = stmt.keyword;
+				if (stmt.label) break; // labeled branch — target checked by JS
 				if (kw === "continue" && this._loopDepth === 0)
 					this.err("continue statement outside for loop", stmt);
 				else if (
@@ -879,13 +936,20 @@ export class TypeChecker {
 
 	checkCall(expr, scope) {
 		const fnType = this.checkExpr(expr.func, scope);
-		const argTypes = expr.args.map((a) => this.checkExpr(a, scope));
 
-		// Built-in handling
+		// Handle built-ins before evaluating args; some (e.g. new) take type names as
+		// arguments, which would otherwise produce false "Undefined" errors.
 		if (fnType.kind === "builtin") {
+			const argTypes = expr.args.map((a, i) => {
+				// new(T) — first arg is a type name, not a value expression
+				if (fnType.name === "new" && i === 0) return ANY;
+				return this.checkExpr(a, scope);
+			});
 			return this.checkBuiltin(fnType.name, expr, argTypes, scope);
 		}
 
+		const argTypes = expr.args.map((a) => this.checkExpr(a, scope));
+
 		if (isAny(fnType)) return ANY;
 
 		if (fnType.kind !== "func") {
@@ -915,6 +979,8 @@ export class TypeChecker {
 				fnType.variadic && i >= fnType.params.length - 1
 					? fnType.params.length - 1
 					: i;
+			// Spread arg (f(slice...)) passes a whole slice into a variadic — skip per-element check
+			if (expr.args[i]?._spread) continue;
 			this.assertAssignable(fnType.params[paramIdx], argTypes[i], expr.args[i]);
 		}
 
@@ -950,8 +1016,15 @@ export class TypeChecker {
 			case "println":
 			case "panic":
 				return VOID;
+			case "recover":
+				return ANY;
 			case "error":
 				return ERROR;
+			case "min":
+			case "max":
+				return argTypes[0] ?? ANY;
+			case "clear":
+				return VOID;
 			default:
 				return ANY;
 		}
@@ -993,7 +1066,7 @@ export class TypeChecker {
 			return t;
 		}
 
-		if (base?.kind === "slice") {
+		if (base?.kind === "slice" || base?.kind === "array") {
 			for (const elem of expr.elems) {
 				if (elem.kind === "CompositeLit" && elem.typeExpr === null) {
 					const et = this.checkCompositeLit(elem, scope, base.elem);
@@ -1058,7 +1131,12 @@ export class TypeChecker {
 			case "ArrayType":
 				return {
 					kind: "array",
-					size: node.size,
+					// inferLen: true means [...]T — size is determined by composite literal
+					size: node.inferLen
+						? null
+						: node.size?.value !== undefined
+							? Number(node.size.value)
+							: node.size,
 					elem: this.resolveTypeNode(node.elem, scope),
 				};
 			case "MapType":
@@ -1116,6 +1194,24 @@ export class TypeChecker {
 						: [VOID];
 					methods.set(m.name, { kind: "func", params, returns });
 				}
+				// Flatten embedded interface methods
+				if (node.embeds) {
+					for (const embed of node.embeds) {
+						const resolved = this.resolveTypeNode(embed, scope);
+						const base =
+							resolved?.kind === "named" ? resolved.underlying : resolved;
+						if (base?.kind === "interface") {
+							for (const [mName, mType] of base.methods) {
+								if (!methods.has(mName)) methods.set(mName, mType);
+							}
+						} else if (!isAny(resolved)) {
+							this.err(
+								`cannot embed non-interface type ${typeStr(resolved)}`,
+								embed,
+							);
+						}
+					}
+				}
 				return { kind: "interface", methods };
 			}
 			case "TupleType": {
@@ -1189,10 +1285,8 @@ export class TypeChecker {
 	}
 
 	binaryResultType(op, lt, rt, node) {
-		const cmp = ["==", "!=", "<", ">", "<=", ">="];
-		const log = ["&&", "||"];
-		if (cmp.includes(op)) return BOOL;
-		if (log.includes(op)) return BOOL;
+		if (CMP_OPS.has(op)) return BOOL;
+		if (LOG_OPS.has(op)) return BOOL;
 		if (isAny(lt) || isAny(rt)) return ANY;
 		if (isNumeric(lt) && isNumeric(rt)) {
 			// float64 is contagious