gofront 0.0.4 → 0.0.5

package/src/parser/expressions.js

@@ -34,6 +34,8 @@ const TYPE_KEYWORDS = new Set([
 	"byte",
 	"rune",
 	"error",
+	"complex64",
+	"complex128",
 ]);
 
 const BUILTIN_KEYWORDS = new Set([
@@ -48,6 +50,9 @@ const BUILTIN_KEYWORDS = new Set([
 	"println",
 	"panic",
 	"error",
+	"complex",
+	"real",
+	"imag",
 ]);
 
 export const expressionParserMethods = {
@@ -115,22 +120,36 @@ export const expressionParserMethods = {
 					expr = { kind: "SelectorExpr", expr, field };
 				}
 			} else if (t.type === T.LBRACKET) {
-				this.advance();
-				const low = this.check(T.COLON) ? null : this.parseExpr();
-				if (this.match(T.COLON)) {
-					const high =
-						this.check(T.RBRACKET) || this.check(T.COLON)
-							? null
-							: this.parseExpr();
-					let max = null;
-					if (this.match(T.COLON)) {
-						max = this.parseExpr();
-					}
+				// Check if this looks like generic type args: Ident[Type](...)  or Ident[Type]{...}
+				if (expr.kind === "Ident" && this.looksLikeTypeArgList()) {
+					this.advance(); // consume [
+					const typeArgs = [this.parseType()];
+					while (this.match(T.COMMA)) typeArgs.push(this.parseType());
 					this.expect(T.RBRACKET);
-					expr = { kind: "SliceExpr", expr, low, high, max };
+					expr = {
+						kind: "InstantiationExpr",
+						expr,
+						typeArgs,
+						_line: expr._line,
+					};
 				} else {
-					this.expect(T.RBRACKET);
-					expr = { kind: "IndexExpr", expr, index: low };
+					this.advance();
+					const low = this.check(T.COLON) ? null : this.parseExpr();
+					if (this.match(T.COLON)) {
+						const high =
+							this.check(T.RBRACKET) || this.check(T.COLON)
+								? null
+								: this.parseExpr();
+						let max = null;
+						if (this.match(T.COLON)) {
+							max = this.parseExpr();
+						}
+						this.expect(T.RBRACKET);
+						expr = { kind: "SliceExpr", expr, low, high, max };
+					} else {
+						this.expect(T.RBRACKET);
+						expr = { kind: "IndexExpr", expr, index: low };
+					}
 				}
 			} else if (t.type === T.LPAREN) {
 				expr = this.parseCall(expr);
@@ -153,10 +172,87 @@ export const expressionParserMethods = {
 			expr.kind === "Ident" ||
 			expr.kind === "SelectorExpr" ||
 			expr.kind === "TypeExpr" ||
-			expr.kind === "StructType"
+			expr.kind === "StructType" ||
+			expr.kind === "InstantiationExpr"
 		);
 	},
 
+	// Lookahead: does the [ ... ] after an Ident look like generic type args?
+	// Returns true if: only type-like tokens inside brackets, AND followed by a valid continuation
+	looksLikeTypeArgList() {
+		let i = this.pos + 1; // skip [
+		const src = this.tokens;
+		let depth = 1;
+		let hasComma = false;
+		let hasTypeKeyword = false;
+		while (i < src.length && depth > 0) {
+			const tt = src[i].type;
+			if (tt === T.LBRACKET) {
+				depth++;
+				i++;
+				continue;
+			}
+			if (tt === T.RBRACKET) {
+				depth--;
+				if (depth === 0) break;
+				i++;
+				continue;
+			}
+			// Reject literals — it's an index expression
+			if (tt === T.INT || tt === T.FLOAT || tt === T.STRING) return false;
+			// Reject binary operators that wouldn't appear in type args
+			if (
+				tt === T.PLUS ||
+				tt === T.MINUS ||
+				tt === T.PERCENT ||
+				tt === T.SLASH ||
+				tt === T.AND ||
+				tt === T.OR ||
+				tt === T.CARET ||
+				tt === T.NOT ||
+				tt === T.LT ||
+				tt === T.GT ||
+				tt === T.LTE ||
+				tt === T.GTE ||
+				tt === T.EQ ||
+				tt === T.NEQ ||
+				tt === T.LSHIFT ||
+				tt === T.RSHIFT ||
+				tt === T.AND_NOT ||
+				tt === T.COLON ||
+				tt === T.DEFINE ||
+				tt === T.ASSIGN
+			)
+				return false;
+			if (depth === 1) {
+				if (tt === T.COMMA) hasComma = true;
+				if (
+					tt === T.STAR ||
+					tt === T.MAP ||
+					tt === T.FUNC ||
+					tt === T.INTERFACE ||
+					tt === T.STRUCT
+				)
+					hasTypeKeyword = true;
+				// Check if it's a builtin type name
+				if (tt === T.IDENT && TYPE_KEYWORDS.has(src[i].value))
+					hasTypeKeyword = true;
+			}
+			i++;
+		}
+		if (depth !== 0) return false;
+		// Check what follows ]
+		const after = src[i + 1];
+		if (!after) return false;
+		// Call or composite lit — always valid as type args
+		if (after.type === T.LPAREN || after.type === T.LBRACE) return true;
+		// Function value in argument list: Identity[int], 99) — only if clearly a type
+		if (after.type === T.COMMA || after.type === T.RPAREN) {
+			return hasComma || hasTypeKeyword;
+		}
+		return false;
+	},
+
 	parseCall(fn) {
 		this.expect(T.LPAREN);
 		const args = [];
@@ -291,6 +387,10 @@ export const expressionParserMethods = {
 			this.advance();
 			return { kind: "BasicLit", litKind: "STRING", value: t.value };
 		}
+		if (t.type === T.IMAG) {
+			this.advance();
+			return { kind: "ImagLit", value: t.value };
+		}
 		if (t.type === T.TRUE) {
 			this.advance();
 			return { kind: "BasicLit", litKind: "BOOL", value: "true" };

package/src/parser/statements.js

@@ -68,11 +68,11 @@ export const statementParserMethods = {
 			case T.SWITCH:
 				return this.parseSwitch();
 			case T.GO:
-				this.err("goroutines are not supported in GoFront");
-				break;
+				return this.err("goroutines are not supported in GoFront");
 			case T.SELECT:
-				this.err("select statement is not supported in GoFront (no channels)");
-				break;
+				return this.err(
+					"select statement is not supported in GoFront (no channels)",
+				);
 			case T.LBRACE:
 				return this.parseBlock();
 			case T.IDENT:

package/src/parser/types.js

@@ -20,8 +20,7 @@ export const typeParserMethods = {
 				this.advance();
 				return { kind: "PointerType", base: this.parseType() };
 			case T.CHAN:
-				this.err("channels are not supported in GoFront");
-				break;
+				return this.err("channels are not supported in GoFront");
 			case T.IDENT:
 			case "int":
 			case "float64":
@@ -45,9 +44,96 @@ export const typeParserMethods = {
 			this.advance();
 			name += `.${this.expect(T.IDENT).value}`;
 		}
+		// Generic type instantiation: Type[int, string]
+		if (this.check(T.LBRACKET) && this._looksLikeTypeArgListInType()) {
+			this.expect(T.LBRACKET);
+			const typeArgs = [this.parseType()];
+			while (this.match(T.COMMA)) typeArgs.push(this.parseType());
+			this.expect(T.RBRACKET);
+			return { kind: "GenericTypeName", name, typeArgs };
+		}
 		return { kind: "TypeName", name };
 	},
 
+	// Lookahead to distinguish Type[int] (generic) from [n]T (array) in type context.
+	// Scans from [ to matching ] looking for only type-like tokens.
+	_looksLikeTypeArgListInType() {
+		let i = this.pos + 1; // skip [
+		const src = this.tokens;
+		let depth = 1;
+		while (i < src.length && depth > 0) {
+			const tt = src[i].type;
+			if (tt === T.LBRACKET) {
+				depth++;
+				i++;
+				continue;
+			}
+			if (tt === T.RBRACKET) {
+				depth--;
+				if (depth === 0) break;
+				i++;
+				continue;
+			}
+			// Reject literals — it's an index/array expression
+			if (tt === T.INT || tt === T.FLOAT || tt === T.STRING) return false;
+			i++;
+		}
+		return depth === 0;
+	},
+
+	parseTypeParamList() {
+		this.expect(T.LBRACKET);
+		const params = [];
+		do {
+			const name = this.expect(T.IDENT).value;
+			const constraint = this.parseConstraint();
+			params.push({ kind: "TypeParam", name, constraint });
+		} while (this.match(T.COMMA));
+		this.expect(T.RBRACKET);
+		return params;
+	},
+
+	parseConstraint() {
+		// Union constraint: ~int | ~string or int | string
+		if (
+			this.check(T.TILDE) ||
+			(this.check(T.IDENT) && this._looksLikeUnionConstraint())
+		) {
+			return this._parseUnionConstraint();
+		}
+		// Single constraint: any, comparable, or named type
+		return this.parseType();
+	},
+
+	_looksLikeUnionConstraint() {
+		// Check if after the identifier there's a | before the next , or ]
+		let i = this.pos + 1;
+		const src = this.tokens;
+		while (i < src.length) {
+			const tt = src[i].type;
+			if (tt === T.PIPE) return true;
+			if (
+				tt === T.COMMA ||
+				tt === T.RBRACKET ||
+				tt === T.SEMICOLON ||
+				tt === T.EOF
+			)
+				return false;
+			i++;
+		}
+		return false;
+	},
+
+	_parseUnionConstraint() {
+		const terms = [];
+		do {
+			const approx = this.match(T.TILDE);
+			const type = this.parseType();
+			terms.push({ approx, type });
+		} while (this.match(T.PIPE));
+		return { kind: "UnionConstraint", terms };
+	},
+
 	parseSliceOrArrayType() {
 		this.expect(T.LBRACKET);
 		if (this.check(T.RBRACKET)) {
@@ -116,13 +202,30 @@ export const typeParserMethods = {
 		this.expect(T.LBRACE);
 		const methods = [];
 		const embeds = [];
+		let unionConstraint = null;
 		while (!this.check(T.RBRACE) && !this.check(T.EOF)) {
+			// Union constraint element: ~int | ~string
+			if (this.check(T.TILDE)) {
+				unionConstraint = this._parseUnionConstraint();
+				this.semi();
+				continue;
+			}
 			const name = this.expect(T.IDENT).value;
 			if (this.check(T.LPAREN)) {
 				// Method signature: Name(params) returnType
 				const params = this.parseParamList();
 				const returnType = this.parseReturnType();
 				methods.push({ name, params, returnType });
+			} else if (this.check(T.PIPE) || this.check(T.TILDE)) {
+				// Union constraint starting with a type name: int | string
+				// We already consumed the first ident, build the union
+				const terms = [{ approx: false, type: { kind: "TypeName", name } }];
+				while (this.match(T.PIPE)) {
+					const approx = this.match(T.TILDE);
+					const type = this.parseType();
+					terms.push({ approx, type });
+				}
+				unionConstraint = { kind: "UnionConstraint", terms };
 			} else {
 				// Embedded interface: TypeName or pkg.TypeName
 				let typeName = name;
@@ -135,6 +238,8 @@ export const typeParserMethods = {
 			this.semi();
 		}
 		this.expect(T.RBRACE);
-		return { kind: "InterfaceType", methods, embeds };
+		const node = { kind: "InterfaceType", methods, embeds };
+		if (unionConstraint) node.unionConstraint = unionConstraint;
+		return node;
 	},
 };

package/src/parser.js

@@ -195,10 +195,23 @@ export class Parser {
 		}
 		// plain function
 		const name = this.expect(T.IDENT).value;
+		// generic function: func Name[T any, U Stringer](...) ...
+		let typeParams = null;
+		if (this.check(T.LBRACKET) && this._looksLikeTypeParamList()) {
+			typeParams = this.parseTypeParamList();
+		}
 		const { params, returnType } = this.parseSignature();
 		const body = this.parseBlock();
 		this.semi();
-		return { kind: "FuncDecl", name, params, returnType, body, _line };
+		return {
+			kind: "FuncDecl",
+			name,
+			typeParams,
+			params,
+			returnType,
+			body,
+			_line,
+		};
 	}
 
 	parseAsyncFuncOrMethod() {
@@ -219,6 +232,24 @@ export class Parser {
 		);
 	}
 
+	// Lookahead: does the [ ... ] after a func name or type name look like a type param list?
+	// Type param lists contain IDENT followed by a constraint (another IDENT or keyword),
+	// not expressions like integers or operators.
+	_looksLikeTypeParamList() {
+		const i = this.pos + 1; // skip [
+		const src = this.tokens;
+		// First token must be an IDENT (the type param name)
+		if (!src[i] || src[i].type !== T.IDENT) return false;
+		// Second token should be a constraint (IDENT like 'any', 'comparable', another type name)
+		// or TILDE for union constraints
+		const second = src[i + 1];
+		if (!second) return false;
+		if (second.type === T.IDENT) return true; // T any, T Stringer
+		if (second.type === T.TILDE) return true; // T ~int
+		if (second.type === T.INTERFACE) return true; // T interface{...}
+		return false;
+	}
+
 	parseSignature() {
 		const params = this.parseParamList();
 		const returnType = this.parseReturnType();
@@ -234,13 +265,13 @@ export class Parser {
 				if (this.check(T.RPAREN)) break;
 				// Collect names, then type
 				const names = [];
-				if (this.check(T.IDENT) && this.isParamType(this.peek2())) {
+				if (this.check(T.IDENT) && this._isNamedParam()) {
 					// named: a, b int  or  ns ...int
 					names.push(this.advance().value);
 					while (
 						this.match(T.COMMA) &&
 						this.check(T.IDENT) &&
-						this.isParamType(this.peek2())
+						this._isNamedParam()
 					) {
 						names.push(this.advance().value);
 					}
@@ -260,6 +291,23 @@ export class Parser {
 		return params;
 	}
 
+	// Lookahead: determine if current IDENT starts a named param (name type)
+	// vs an unnamed param (just a type). Scans IDENT (COMMA IDENT)* and checks
+	// if a type-start token follows — if so, the IDENTs are names; if ) or ,
+	// follows, the IDENTs are themselves types.
+	_isNamedParam() {
+		let pos = this.pos + 1; // skip current IDENT
+		while (
+			this.tokens[pos]?.type === T.COMMA &&
+			this.tokens[pos + 1]?.type === T.IDENT
+		) {
+			pos += 2;
+		}
+		const next = this.tokens[pos];
+		if (!next) return false;
+		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;
@@ -340,10 +388,15 @@ export class Parser {
 			return decls;
 		}
 		const name = this.expect(T.IDENT).value;
+		// generic type: type Name[T any] struct { ... }
+		let typeParams = null;
+		if (this.check(T.LBRACKET) && this._looksLikeTypeParamList()) {
+			typeParams = this.parseTypeParamList();
+		}
 		const isAlias = this.match(T.ASSIGN);
 		const type = this.parseType();
 		this.semi();
-		return { kind: "TypeDecl", name, type, isAlias };
+		return { kind: "TypeDecl", name, typeParams, type, isAlias };
 	}
 
 	parseVarDecl() {