gofront 0.0.9 → 1.0.1

package/src/{parser.js → parser/declarations.js}

@@ -1,159 +1,6 @@
-// Recursive-descent parser.  Produces an AST from a GoFront token stream.
-//
-// Split into sub-modules under parser/:
-//   types.js        — type expression parsing (slice, map, struct, interface, etc.)
-//   statements.js   — block, control flow, simple statements
-//   expressions.js  — operator precedence, unary, postfix, primary, literals
-//
-// Node kinds used throughout the compiler:
-//   Program, PackageDecl, ImportDecl
-//   FuncDecl, MethodDecl, VarDecl, ConstDecl, TypeDecl
-//   StructType, InterfaceType, SliceType, MapType, FuncType, PointerType
-//   Block, IfStmt, ForStmt, RangeStmt, ReturnStmt, BranchStmt
-//   AssignStmt, DefineStmt, IncDecStmt, ExprStmt
-//   SwitchStmt, CaseClause
-//   Ident, BasicLit, UnaryExpr, BinaryExpr
-//   CallExpr, SelectorExpr, IndexExpr, SliceExpr
-//   CompositeLit, KeyValueExpr, FuncLit, AwaitExpr
-
-import { T } from "./lexer.js";
-import { expressionParserMethods } from "./parser/expressions.js";
-import { statementParserMethods } from "./parser/statements.js";
-import { typeParserMethods } from "./parser/types.js";
-
-export class ParseError extends Error {
-	constructor(msg, token, filename, sourceCode) {
-		const loc = filename
-			? `${filename}:${token.line}:${token.col}`
-			: `${token.line}:${token.col}`;
-		let lineContext = "";
-		if (token.line && sourceCode) {
-			const lines = sourceCode.split("\n");
-			const lineStr = lines[token.line - 1];
-			if (lineStr !== undefined) {
-				lineContext = `\n  ${token.line} | ${lineStr}`;
-			}
-		}
-		super(
-			`Parse error at ${loc}: ${msg} (got ${token.type} "${token.value}")${lineContext}`,
-		);
-		this.token = token;
-	}
-}
-
-export class Parser {
-	constructor(tokens, filename = null, source = null) {
-		this.tokens = tokens;
-		this.pos = 0;
-		this.filename = filename;
-		this.source = source;
-	}
-
-	// ── Primitives ───────────────────────────────────────────────
-
-	peek() {
-		return this.tokens[this.pos];
-	}
-	peek2() {
-		return this.tokens[this.pos + 1];
-	}
-
-	advance() {
-		const t = this.tokens[this.pos];
-		if (t.type !== T.EOF) this.pos++;
-		return t;
-	}
-
-	check(type) {
-		return this.peek().type === type;
-	}
-	check2(type) {
-		return this.peek2().type === type;
-	}
-
-	match(...types) {
-		for (const type of types) {
-			if (this.check(type)) {
-				this.advance();
-				return true;
-			}
-		}
-		return false;
-	}
-
-	expect(type) {
-		if (!this.check(type))
-			throw new ParseError(`expected '${type}'`, this.peek());
-		return this.advance();
-	}
-
-	semi() {
-		if (this.check(T.SEMICOLON)) this.advance();
-	}
-
-	err(msg) {
-		throw new ParseError(msg, this.peek(), this.filename, this.source);
-	}
-
-	// ── Entry point ──────────────────────────────────────────────
-
-	parse() {
-		const pkg = this.parsePackage();
-		const imports = [];
-		while (this.check(T.IMPORT)) imports.push(this.parseImport());
-		const decls = [];
-		while (!this.check(T.EOF)) {
-			const result = this.parseTopDecl();
-			if (Array.isArray(result)) decls.push(...result);
-			else decls.push(result);
-		}
-		return {
-			kind: "Program",
-			pkg,
-			imports,
-			decls,
-			_filename: this.filename,
-			_source: this.source,
-		};
-	}
-
-	parsePackage() {
-		this.expect(T.PACKAGE);
-		const name = this.expect(T.IDENT).value;
-		this.semi();
-		return { kind: "PackageDecl", name };
-	}
-
-	parseImport() {
-		this.expect(T.IMPORT);
-		const imports = [];
-		const parseOne = () => {
-			const _line = this.peek().line;
-			let alias = null;
-			if (this.check(T.IDENT)) {
-				alias = this.advance().value;
-			} else if (this.check(T.DOT)) {
-				alias = ".";
-				this.advance();
-			}
-			const path = this.expect(T.STRING).value;
-			return { path, alias, _line };
-		};
-		if (this.match(T.LPAREN)) {
-			while (!this.check(T.RPAREN) && !this.check(T.EOF)) {
-				imports.push(parseOne());
-				this.semi();
-			}
-			this.expect(T.RPAREN);
-		} else {
-			imports.push(parseOne());
-		}
-		this.semi();
-		return { kind: "ImportDecl", imports };
-	}
-
-	// ── Top-level declarations ───────────────────────────────────
+import { T } from "../tokens.js";
 
+export const declarationParseMethods = {
 	parseTopDecl() {
 		const t = this.peek();
 		switch (t.type) {
@@ -170,7 +17,7 @@ export class Parser {
 			default:
 				this.err("Expected top-level declaration");
 		}
-	}
+	},
 
 	parseFuncOrMethod() {
 		const _line = this.peek().line;
@@ -219,14 +66,14 @@ export class Parser {
 			body,
 			_line,
 		};
-	}
+	},
 
 	parseAsyncFuncOrMethod() {
 		this.expect(T.ASYNC);
 		const decl = this.parseFuncOrMethod();
 		decl.async = true;
 		return decl;
-	}
+	},
 
 	// Returns true if tok is a receiver-list terminator (i.e. not a type name)
 	isReceiverTerminator(tok) {
@@ -237,7 +84,7 @@ export class Parser {
 				tok.type === T.SEMICOLON ||
 				tok.type === T.EOF)
 		);
-	}
+	},
 
 	// 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),
@@ -255,13 +102,13 @@ export class Parser {
 		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();
 		return { params, returnType };
-	}
+	},
 
 	// Parses (a, b int, c string) style param list
 	parseParamList() {
@@ -296,7 +143,7 @@ export class Parser {
 		}
 		this.expect(T.RPAREN);
 		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
@@ -313,7 +160,7 @@ export class Parser {
 		const next = this.tokens[pos];
 		if (!next) return false;
 		return this.looksLikeType(next) || next.type === T.ELLIPSIS;
-	}
+	},
 
 	looksLikeType(tok) {
 		return (
@@ -325,7 +172,7 @@ export class Parser {
 			tok.type === T.STRUCT ||
 			(tok.type === T.IDENT && tok.value !== "_")
 		);
-	}
+	},
 
 	parseReturnType(inTypeExpr = false) {
 		// No return type
@@ -367,7 +214,7 @@ export class Parser {
 			return typeNode;
 		}
 		return this.parseType();
-	}
+	},
 
 	parseTypeDecl() {
 		this.expect(T.TYPE);
@@ -394,7 +241,7 @@ export class Parser {
 		const type = this.parseType();
 		this.semi();
 		return { kind: "TypeDecl", name, typeParams, type, isAlias };
-	}
+	},
 
 	parseVarDecl() {
 		this.expect(T.VAR);
@@ -410,7 +257,7 @@ export class Parser {
 		}
 		this.semi();
 		return { kind: "VarDecl", decls };
-	}
+	},
 
 	parseVarSpec() {
 		const names = [this.expect(T.IDENT).value];
@@ -426,7 +273,7 @@ export class Parser {
 		}
 		if (this.match(T.ASSIGN)) value = this.parseExprList();
 		return { names, type, value };
-	}
+	},
 
 	parseConstDecl() {
 		this.expect(T.CONST);
@@ -477,7 +324,7 @@ export class Parser {
 		}
 		this.semi();
 		return { kind: "ConstDecl", decls };
-	}
+	},
 
 	// Deep-clone an expression AST, replacing `iota` identifiers with the given integer.
 	_substituteIota(node, val) {
@@ -496,9 +343,5 @@ export class Parser {
 			}
 		}
 		return clone;
-	}
-}
-
-Object.assign(Parser.prototype, typeParserMethods);
-Object.assign(Parser.prototype, statementParserMethods);
-Object.assign(Parser.prototype, expressionParserMethods);
+	},
+};

package/src/parser/expressions.js

@@ -1,6 +1,6 @@
 // Parser expression methods — installed as a mixin on Parser.prototype.
 
-import { T } from "../lexer.js";
+import { T } from "../tokens.js";
 
 // Binary operator precedence (higher = binds tighter, matching Go spec)
 const PREC = {
@@ -55,6 +55,45 @@ const BUILTIN_KEYWORDS = new Set([
 	"imag",
 ]);
 
+// Tokens that cannot legally appear inside a type argument list.
+// Each || in an inline condition counts as CC; extracting here keeps looksLikeTypeArgList lean.
+const DISALLOWED_IN_TYPE_ARGS = new Set([
+	T.PLUS,
+	T.MINUS,
+	T.PERCENT,
+	T.SLASH,
+	T.AND,
+	T.OR,
+	T.CARET,
+	T.NOT,
+	T.LT,
+	T.GT,
+	T.LTE,
+	T.GTE,
+	T.EQ,
+	T.NEQ,
+	T.LSHIFT,
+	T.RSHIFT,
+	T.AND_NOT,
+	T.COLON,
+	T.DEFINE,
+	T.ASSIGN,
+]);
+
+function _isDisallowedInTypeArgs(tt) {
+	return DISALLOWED_IN_TYPE_ARGS.has(tt);
+}
+
+function _isTypeIntroducerToken(tt) {
+	return (
+		tt === T.STAR ||
+		tt === T.MAP ||
+		tt === T.FUNC ||
+		tt === T.INTERFACE ||
+		tt === T.STRUCT
+	);
+}
+
 export const expressionParserMethods = {
 	parseExprList() {
 		const exprs = [this.parseExpr()];
@@ -185,6 +224,7 @@ export const expressionParserMethods = {
 		let depth = 1;
 		let hasComma = false;
 		let hasTypeKeyword = false;
+		let hasUpperIdent = false;
 		while (i < src.length && depth > 0) {
 			const tt = src[i].type;
 			if (tt === T.LBRACKET) {
@@ -201,42 +241,19 @@ export const expressionParserMethods = {
 			// 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 (_isDisallowedInTypeArgs(tt)) 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 (_isTypeIntroducerToken(tt)) hasTypeKeyword = true;
 				if (tt === T.IDENT && TYPE_KEYWORDS.has(src[i].value))
 					hasTypeKeyword = true;
+				// User-defined types start with uppercase (GoFront convention)
+				if (
+					tt === T.IDENT &&
+					/^[A-Z]/.test(src[i].value) &&
+					!TYPE_KEYWORDS.has(src[i].value)
+				)
+					hasUpperIdent = true;
 			}
 			i++;
 		}
@@ -248,7 +265,7 @@ export const expressionParserMethods = {
 		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 hasComma || hasTypeKeyword || hasUpperIdent;
 		}
 		return false;
 	},

package/src/parser/index.js

@@ -0,0 +1,161 @@
+// Recursive-descent parser.  Produces an AST from a GoFront token stream.
+//
+// Split into sub-modules under parser/:
+//   declarations.js — top-level declarations (func, method, type, var, const)
+//   types.js        — type expression parsing (slice, map, struct, interface, etc.)
+//   statements.js   — block, control flow, simple statements
+//   expressions.js  — operator precedence, unary, postfix, primary, literals
+//
+// Node kinds used throughout the compiler:
+//   Program, PackageDecl, ImportDecl
+//   FuncDecl, MethodDecl, VarDecl, ConstDecl, TypeDecl
+//   StructType, InterfaceType, SliceType, MapType, FuncType, PointerType
+//   Block, IfStmt, ForStmt, RangeStmt, ReturnStmt, BranchStmt
+//   AssignStmt, DefineStmt, IncDecStmt, ExprStmt
+//   SwitchStmt, CaseClause
+//   Ident, BasicLit, UnaryExpr, BinaryExpr
+//   CallExpr, SelectorExpr, IndexExpr, SliceExpr
+//   CompositeLit, KeyValueExpr, FuncLit, AwaitExpr
+
+import { T } from "../tokens.js";
+import { declarationParseMethods } from "./declarations.js";
+import { expressionParserMethods } from "./expressions.js";
+import { statementParserMethods } from "./statements.js";
+import { typeParserMethods } from "./types.js";
+
+export class ParseError extends Error {
+	constructor(msg, token, filename, sourceCode) {
+		const loc = filename
+			? `${filename}:${token.line}:${token.col}`
+			: `${token.line}:${token.col}`;
+		let lineContext = "";
+		if (token.line && sourceCode) {
+			const lines = sourceCode.split("\n");
+			const lineStr = lines[token.line - 1];
+			if (lineStr !== undefined) {
+				lineContext = `\n  ${token.line} | ${lineStr}`;
+			}
+		}
+		super(
+			`Parse error at ${loc}: ${msg} (got ${token.type} "${token.value}")${lineContext}`,
+		);
+		this.token = token;
+	}
+}
+
+export class Parser {
+	constructor(tokens, filename = null, source = null) {
+		this.tokens = tokens;
+		this.pos = 0;
+		this.filename = filename;
+		this.source = source;
+	}
+
+	// ── Primitives ───────────────────────────────────────────────
+
+	peek() {
+		return this.tokens[this.pos];
+	}
+	peek2() {
+		return this.tokens[this.pos + 1];
+	}
+
+	advance() {
+		const t = this.tokens[this.pos];
+		if (t.type !== T.EOF) this.pos++;
+		return t;
+	}
+
+	check(type) {
+		return this.peek().type === type;
+	}
+	check2(type) {
+		return this.peek2().type === type;
+	}
+
+	match(...types) {
+		for (const type of types) {
+			if (this.check(type)) {
+				this.advance();
+				return true;
+			}
+		}
+		return false;
+	}
+
+	expect(type) {
+		if (!this.check(type))
+			throw new ParseError(`expected '${type}'`, this.peek());
+		return this.advance();
+	}
+
+	semi() {
+		if (this.check(T.SEMICOLON)) this.advance();
+	}
+
+	err(msg) {
+		throw new ParseError(msg, this.peek(), this.filename, this.source);
+	}
+
+	// ── Entry point ──────────────────────────────────────────────
+
+	parse() {
+		const pkg = this.parsePackage();
+		const imports = [];
+		while (this.check(T.IMPORT)) imports.push(this.parseImport());
+		const decls = [];
+		while (!this.check(T.EOF)) {
+			const result = this.parseTopDecl();
+			if (Array.isArray(result)) decls.push(...result);
+			else decls.push(result);
+		}
+		return {
+			kind: "Program",
+			pkg,
+			imports,
+			decls,
+			_filename: this.filename,
+			_source: this.source,
+		};
+	}
+
+	parsePackage() {
+		this.expect(T.PACKAGE);
+		const name = this.expect(T.IDENT).value;
+		this.semi();
+		return { kind: "PackageDecl", name };
+	}
+
+	parseImport() {
+		this.expect(T.IMPORT);
+		const imports = [];
+		const parseOne = () => {
+			const _line = this.peek().line;
+			let alias = null;
+			if (this.check(T.IDENT)) {
+				alias = this.advance().value;
+			} else if (this.check(T.DOT)) {
+				alias = ".";
+				this.advance();
+			}
+			const path = this.expect(T.STRING).value;
+			return { path, alias, _line };
+		};
+		if (this.match(T.LPAREN)) {
+			while (!this.check(T.RPAREN) && !this.check(T.EOF)) {
+				imports.push(parseOne());
+				this.semi();
+			}
+			this.expect(T.RPAREN);
+		} else {
+			imports.push(parseOne());
+		}
+		this.semi();
+		return { kind: "ImportDecl", imports };
+	}
+}
+
+Object.assign(Parser.prototype, typeParserMethods);
+Object.assign(Parser.prototype, statementParserMethods);
+Object.assign(Parser.prototype, expressionParserMethods);
+Object.assign(Parser.prototype, declarationParseMethods);

package/src/parser/statements.js

@@ -1,6 +1,19 @@
 // Parser statement methods — installed as a mixin on Parser.prototype.
 
-import { T } from "../lexer.js";
+import { T } from "../tokens.js";
+
+// Method-name dispatch for pure-delegation cases in _parseStmt.
+const PARSE_STMT_DELEGATE = {
+	[T.VAR]: "parseVarDecl",
+	[T.CONST]: "parseConstDecl",
+	[T.TYPE]: "parseTypeDecl",
+	[T.RETURN]: "parseReturn",
+	[T.DEFER]: "parseDefer",
+	[T.IF]: "parseIf",
+	[T.FOR]: "parseFor",
+	[T.SWITCH]: "parseSwitch",
+	[T.LBRACE]: "parseBlock",
+};
 
 export const statementParserMethods = {
 	parseBlock() {
@@ -32,59 +45,36 @@ export const statementParserMethods = {
 	},
 
 	_parseStmt(t) {
+		const delegate = PARSE_STMT_DELEGATE[t.type];
+		if (delegate) return this[delegate]();
+
 		switch (t.type) {
-			case T.VAR:
-				return this.parseVarDecl();
-			case T.CONST:
-				return this.parseConstDecl();
-			case T.TYPE:
-				return this.parseTypeDecl();
-			case T.RETURN:
-				return this.parseReturn();
-			case T.DEFER:
-				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();
+			case T.CONTINUE: {
+				const keyword = this.advance().value;
 				if (this.check(T.IDENT)) {
 					const label = this.advance().value;
 					this.semi();
-					return { kind: "BranchStmt", keyword: "continue", label };
+					return { kind: "BranchStmt", keyword, label };
 				}
 				this.semi();
-				return { kind: "BranchStmt", keyword: "continue" };
+				return { kind: "BranchStmt", keyword };
+			}
 			case T.FALLTHROUGH:
 				this.advance();
 				this.semi();
 				return { kind: "BranchStmt", keyword: "fallthrough" };
-			case T.IF:
-				return this.parseIf();
-			case T.FOR:
-				return this.parseFor();
-			case T.SWITCH:
-				return this.parseSwitch();
 			case T.GO:
 				return this.err("goroutines are not supported in GoFront");
 			case T.SELECT:
 				return this.err(
 					"select statement is not supported in GoFront (no channels)",
 				);
-			case T.LBRACE:
-				return this.parseBlock();
 			case T.IDENT:
 				if (this.check2(T.COLON)) {
-					const label = this.advance().value; // consume IDENT
+					const label = this.advance().value;
 					this.advance(); // consume COLON
-					const body = this.parseStmt();
-					return { kind: "LabeledStmt", label, body };
+					return { kind: "LabeledStmt", label, body: this.parseStmt() };
 				}
 				return this.parseSimpleStmt();
 			default: