gofront 0.0.3 → 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

@@ -172,7 +172,7 @@ export class Parser {
 		if (this.check(T.LPAREN)) {
 			this.expect(T.LPAREN);
 			const recvName =
-				this.check(T.IDENT) && !this.isTypeName(this.peek2())
+				this.check(T.IDENT) && !this.isReceiverTerminator(this.peek2())
 					? this.advance().value
 					: "_";
 			this.match(T.STAR); // pointer receiver: (c *Counter) — strip *, treat same as value receiver
@@ -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() {
@@ -208,8 +221,8 @@ export class Parser {
 		return decl;
 	}
 
-	// Returns true if tok looks like a type name token (for receiver parsing)
-	isTypeName(tok) {
+	// Returns true if tok is a receiver-list terminator (i.e. not a type name)
+	isReceiverTerminator(tok) {
 		return (
 			tok &&
 			(tok.type === T.RPAREN ||
@@ -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() {
@@ -383,31 +436,34 @@ export class Parser {
 		const decls = [];
 		if (this.match(T.LPAREN)) {
 			let iotaVal = 0;
+			let prevRawExprs = null; // raw AST (with iota Idents) from the previous spec
+			let prevType = null;
 			while (!this.check(T.RPAREN) && !this.check(T.EOF)) {
 				const names = [this.expect(T.IDENT).value];
 				while (this.match(T.COMMA)) names.push(this.expect(T.IDENT).value);
 				let type = null;
-				let value;
+				let rawExprs; // before iota substitution
 				if (this.check(T.ASSIGN)) {
 					this.advance();
-					value = this.parseExprList();
+					rawExprs = this.parseExprList();
+					prevRawExprs = rawExprs;
+					prevType = null;
 				} else if (!this.check(T.SEMICOLON) && !this.check(T.RPAREN)) {
 					// optional type annotation before =
 					type = this.parseType();
+					prevType = type;
 					this.expect(T.ASSIGN);
-					value = this.parseExprList();
+					rawExprs = this.parseExprList();
+					prevRawExprs = rawExprs;
 				} else {
-					// implicit iota
-					value = [
+					// Omitted expression — repeat previous expression with updated iota
+					rawExprs = prevRawExprs ?? [
 						{ kind: "BasicLit", litKind: "INT", value: String(iotaVal) },
 					];
+					type = prevType ?? null;
 				}
-				// Replace iota identifier with current counter value
-				value = value.map((v) =>
-					v.kind === "Ident" && v.name === "iota"
-						? { kind: "BasicLit", litKind: "INT", value: String(iotaVal) }
-						: v,
-				);
+				// Substitute iota deeply in a cloned expression AST
+				const value = rawExprs.map((v) => this._substituteIota(v, iotaVal));
 				decls.push({ names, type, value });
 				iotaVal++;
 				this.semi();
@@ -425,6 +481,25 @@ export class Parser {
 		this.semi();
 		return { kind: "ConstDecl", decls };
 	}
+
+	// Deep-clone an expression AST, replacing `iota` identifiers with the given integer.
+	_substituteIota(node, val) {
+		if (!node || typeof node !== "object") return node;
+		if (node.kind === "Ident" && node.name === "iota") {
+			return { kind: "BasicLit", litKind: "INT", value: String(val) };
+		}
+		// Shallow-clone the node, then recursively substitute in all child properties
+		const clone = { ...node };
+		for (const key of Object.keys(clone)) {
+			const v = clone[key];
+			if (Array.isArray(v)) {
+				clone[key] = v.map((item) => this._substituteIota(item, val));
+			} else if (v && typeof v === "object" && v.kind) {
+				clone[key] = this._substituteIota(v, val);
+			}
+		}
+		return clone;
+	}
 }
 
 Object.assign(Parser.prototype, typeParserMethods);