gofront 0.0.8 → 1.0.0

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;
 	},
@@ -365,9 +382,10 @@ export const expressionParserMethods = {
 	},
 
 	parsePrimary() {
-		const line = this.peek().line;
+		const t = this.peek();
 		const expr = this._parsePrimary();
-		if (!expr._line) expr._line = line;
+		if (!expr._line) expr._line = t.line;
+		if (!expr._col) expr._col = t.col;
 		return expr;
 	},
 

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

@@ -16,10 +16,10 @@
 //   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";
+import { T } from "../tokens.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) {
@@ -107,7 +107,14 @@ export class Parser {
 			if (Array.isArray(result)) decls.push(...result);
 			else decls.push(result);
 		}
-		return { kind: "Program", pkg, imports, decls, _filename: this.filename };
+		return {
+			kind: "Program",
+			pkg,
+			imports,
+			decls,
+			_filename: this.filename,
+			_source: this.source,
+		};
 	}
 
 	parsePackage() {

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() {
@@ -20,67 +33,48 @@ export const statementParserMethods = {
 		const t = this.peek();
 		const stmt = this._parseStmt(t);
 		if (Array.isArray(stmt)) {
-			for (const s of stmt) s._line = t.line;
+			for (const s of stmt) {
+				s._line = t.line;
+				s._col = t.col;
+			}
 			return stmt;
 		}
 		stmt._line = t.line;
+		stmt._col = t.col;
 		return stmt;
 	},
 
 	_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();
+			case T.CONTINUE: {
+				const keyword = this.advance().value;
 				if (this.check(T.IDENT)) {
 					const label = this.advance().value;
 					this.semi();
-					return { kind: "BranchStmt", keyword: "break", label };
+					return { kind: "BranchStmt", keyword, 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" };
+				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:

package/src/parser/types.js

@@ -1,39 +1,41 @@
 // Parser type-expression methods — installed as a mixin on Parser.prototype.
 
-import { T } from "../lexer.js";
+import { T } from "../tokens.js";
+
+// Token types that directly map to parseTypeName().
+const TYPE_NAME_TOKENS = new Set([
+	T.IDENT,
+	"int",
+	"float64",
+	"string",
+	"bool",
+	"any",
+	"byte",
+	"rune",
+	"error",
+]);
+// Method-name dispatch for the simple keyword cases in parseType().
+const PARSE_TYPE_DELEGATE = {
+	[T.LBRACKET]: "parseSliceOrArrayType",
+	[T.MAP]: "parseMapType",
+	[T.FUNC]: "parseFuncType",
+	[T.STRUCT]: "parseStructType",
+	[T.INTERFACE]: "parseInterfaceType",
+};
 
 export const typeParserMethods = {
 	parseType() {
 		const t = this.peek();
-		switch (t.type) {
-			case T.LBRACKET:
-				return this.parseSliceOrArrayType();
-			case T.MAP:
-				return this.parseMapType();
-			case T.FUNC:
-				return this.parseFuncType();
-			case T.STRUCT:
-				return this.parseStructType();
-			case T.INTERFACE:
-				return this.parseInterfaceType();
-			case T.STAR:
-				this.advance();
-				return { kind: "PointerType", base: this.parseType() };
-			case T.CHAN:
-				return this.err("channels are not supported in GoFront");
-			case T.IDENT:
-			case "int":
-			case "float64":
-			case "string":
-			case "bool":
-			case "any":
-			case "byte":
-			case "rune":
-			case "error":
-				return this.parseTypeName();
-			default:
-				this.err(`Expected type, got '${t.value}'`);
+		const delegate = PARSE_TYPE_DELEGATE[t.type];
+		if (delegate) return this[delegate]();
+		if (TYPE_NAME_TOKENS.has(t.type)) return this.parseTypeName();
+		if (t.type === T.STAR) {
+			this.advance();
+			return { kind: "PointerType", base: this.parseType() };
 		}
+		if (t.type === T.CHAN)
+			return this.err("channels are not supported in GoFront");
+		return this.err(`Expected type, got '${t.value}'`);
 	},
 
 	parseTypeName() {