gofront 0.0.9 → 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;
 	},

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) {

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:

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() {

package/src/templ-parser.js

@@ -16,9 +16,9 @@
 //   TemplSwitch { kind, exprTokens, cases: TemplCase[] }
 //   TemplCase   { kind, caseTokens: tokens | null (null = default), body: TemplNode[] }
 
-import { T } from "./lexer.js";
-import { Parser } from "./parser.js";
+import { Parser } from "./parser/index.js";
 import { TT } from "./templ-lexer.js";
+import { T } from "./tokens.js";
 
 const VOID_ELEMENTS = new Set([
 	"area",

package/src/tokens.js

@@ -0,0 +1,109 @@
+// Token type table and Token class — pure data leaves used by every layer
+// (lexer, parser, codegen). Putting these in their own module lets parser
+// and codegen depend only on `tokens.js` instead of the full `lexer.js`.
+
+export const T = {
+	// Literals
+	INT: "INT",
+	FLOAT: "FLOAT",
+	STRING: "STRING",
+	IDENT: "IDENT",
+
+	IMAG: "IMAG",
+
+	// Keywords
+	FUNC: "func",
+	VAR: "var",
+	CONST: "const",
+	TYPE: "type",
+	STRUCT: "struct",
+	INTERFACE: "interface",
+	IF: "if",
+	ELSE: "else",
+	FOR: "for",
+	RANGE: "range",
+	RETURN: "return",
+	PACKAGE: "package",
+	IMPORT: "import",
+	TRUE: "true",
+	FALSE: "false",
+	NIL: "nil",
+	BREAK: "break",
+	CONTINUE: "continue",
+	SWITCH: "switch",
+	CASE: "case",
+	DEFAULT: "default",
+	MAP: "map",
+	NEW: "new",
+	DEFER: "defer",
+	ASYNC: "async",
+	AWAIT: "await",
+	GO: "go",
+	CHAN: "chan",
+	SELECT: "select",
+
+	// Operators
+	PLUS: "+",
+	MINUS: "-",
+	STAR: "*",
+	SLASH: "/",
+	PERCENT: "%",
+	EQ: "==",
+	NEQ: "!=",
+	LT: "<",
+	GT: ">",
+	LTE: "<=",
+	GTE: ">=",
+	AND: "&&",
+	OR: "||",
+	NOT: "!",
+	ASSIGN: "=",
+	DEFINE: ":=",
+	PLUS_ASSIGN: "+=",
+	MINUS_ASSIGN: "-=",
+	STAR_ASSIGN: "*=",
+	SLASH_ASSIGN: "/=",
+	PERCENT_ASSIGN: "%=",
+	AMP_ASSIGN: "&=",
+	PIPE_ASSIGN: "|=",
+	CARET_ASSIGN: "^=",
+	LSHIFT_ASSIGN: "<<=",
+	RSHIFT_ASSIGN: ">>=",
+	INC: "++",
+	DEC: "--",
+	AMP: "&",
+	PIPE: "|",
+	CARET: "^",
+	AND_NOT: "&^",
+	TILDE: "~",
+	LSHIFT: "<<",
+	RSHIFT: ">>",
+	ELLIPSIS: "...",
+	FALLTHROUGH: "fallthrough",
+
+	// Delimiters
+	LPAREN: "(",
+	RPAREN: ")",
+	LBRACE: "{",
+	RBRACE: "}",
+	LBRACKET: "[",
+	RBRACKET: "]",
+	COMMA: ",",
+	DOT: ".",
+	COLON: ":",
+	SEMICOLON: ";",
+
+	EOF: "EOF",
+};
+
+export class Token {
+	constructor(type, value, line, col) {
+		this.type = type;
+		this.value = value;
+		this.line = line;
+		this.col = col;
+	}
+	toString() {
+		return `Token(${this.type}, ${JSON.stringify(this.value)}, ${this.line}:${this.col})`;
+	}
+}

package/src/typechecker/assignability.js

@@ -0,0 +1,258 @@
+// Assignability, binary result types, and interface satisfaction.
+// Installed as a mixin on TypeChecker.prototype.
+
+import {
+	ANY,
+	BOOL,
+	CMP_OPS,
+	COMPLEX128,
+	FLOAT64,
+	INT,
+	isAny,
+	isComplex,
+	isComplexOrNumeric,
+	isNil,
+	isNumeric,
+	isPointer,
+	isString,
+	isUntyped,
+	LOG_OPS,
+	STRING,
+	typeStr,
+	UNTYPED_COMPLEX,
+	UNTYPED_FLOAT,
+	UNTYPED_INT,
+} from "./types.js";
+
+// Untyped constant assignability: maps source.base → Set of compatible target.name values
+const UNTYPED_COMPAT = {
+	int: new Set(["int", "float64", "complex128", "complex64"]),
+	float64: new Set(["float64", "int", "complex128", "complex64"]),
+	string: new Set(["string"]),
+	bool: new Set(["bool"]),
+	complex128: new Set(["complex128", "complex64"]),
+};
+
+export const assignabilityMethods = {
+	// ── Binary result types ───────────────────────────────────────────
+
+	binaryResultType(op, lt, rt, node) {
+		if (lt?.kind === "typeParam" || rt?.kind === "typeParam")
+			return this._binaryResultTypeTypeParam(op, lt, rt);
+		if (CMP_OPS.has(op)) return this._binaryResultTypeCmp(op, lt, rt, node);
+		if (LOG_OPS.has(op)) return BOOL;
+		return this._binaryResultTypeNonComplex(op, lt, rt, node);
+	},
+
+	_binaryResultTypeTypeParam(op, lt, rt) {
+		if (CMP_OPS.has(op) || LOG_OPS.has(op)) return BOOL;
+		return lt?.kind === "typeParam" ? lt : rt;
+	},
+
+	_binaryResultTypeNonComplex(op, lt, rt, node) {
+		if (isAny(lt) || isAny(rt)) return ANY;
+		if (isComplex(lt) || isComplex(rt))
+			return this._binaryResultTypeComplex(op, lt, rt, node);
+		if (isNumeric(lt) && isNumeric(rt))
+			return this._binaryResultTypeNumeric(lt, rt);
+		if (isString(lt) && isString(rt) && op === "+")
+			return this._binaryResultTypeString(lt, rt);
+		if (node)
+			this.err(`Invalid operation: ${typeStr(lt)} ${op} ${typeStr(rt)}`, node);
+		return ANY;
+	},
+
+	_binaryResultTypeString(lt, rt) {
+		if (lt.kind === "untyped" && rt.kind === "untyped") return lt;
+		if (lt.kind === "untyped") return rt;
+		if (rt.kind === "untyped") return lt;
+		return STRING;
+	},
+
+	_binaryResultTypeCmp(op, lt, rt, node) {
+		if (this._checkComplexCmpOp(op, lt, rt, node)) return ANY;
+		this._checkEqualityComparable(op, lt, rt, node);
+		return BOOL;
+	},
+
+	_binaryResultTypeComplex(op, lt, rt, node) {
+		if (!isComplexOrNumeric(lt) || !isComplexOrNumeric(rt)) {
+			this.err(`invalid operation: ${typeStr(lt)} ${op} ${typeStr(rt)}`, node);
+			return ANY;
+		}
+		if (op !== "+" && op !== "-" && op !== "*" && op !== "/") {
+			this.err(`invalid operation: ${typeStr(lt)} ${op} ${typeStr(rt)}`, node);
+			return ANY;
+		}
+		if (lt.kind === "untyped" && rt.kind === "untyped") return UNTYPED_COMPLEX;
+		return COMPLEX128;
+	},
+
+	_binaryResultTypeNumeric(lt, rt) {
+		const lFloat = (lt.kind === "untyped" ? lt.base : lt.name) === "float64";
+		const rFloat = (rt.kind === "untyped" ? rt.base : rt.name) === "float64";
+		const isFloat = lFloat || rFloat;
+		if (lt.kind === "untyped" && rt.kind === "untyped")
+			return isFloat ? UNTYPED_FLOAT : UNTYPED_INT;
+		if (lt.kind === "untyped")
+			return isFloat && rt.name !== "float64" ? FLOAT64 : rt;
+		if (rt.kind === "untyped")
+			return isFloat && lt.name !== "float64" ? FLOAT64 : lt;
+		return isFloat ? FLOAT64 : INT;
+	},
+
+	_checkComplexCmpOp(op, lt, rt, node) {
+		if (isComplex(lt) || isComplex(rt)) {
+			if (op !== "==" && op !== "!=") {
+				this.err(
+					`invalid operation: ${typeStr(lt)} ${op} ${typeStr(rt)}`,
+					node,
+				);
+				return true;
+			}
+		}
+		return false;
+	},
+
+	_isNonComparableKind(t) {
+		const base = t?.kind === "named" ? t.underlying : t;
+		return (
+			base?.kind === "slice" || base?.kind === "map" || base?.kind === "func"
+		);
+	},
+
+	_checkEqualityComparable(op, lt, rt, node) {
+		if (op !== "==" && op !== "!=") return;
+		if (isNil(lt) || isNil(rt)) return;
+		for (const t of [lt, rt]) {
+			if (this._isNonComparableKind(t))
+				this.err(`operator ${op} not defined on ${typeStr(t)}`, node);
+		}
+	},
+
+	// ── Assignability ─────────────────────────────────────────────────
+
+	assertAssignable(target, source, node) {
+		if (!target || !source) return;
+		target = this.resolveType(target);
+		source = this.resolveType(source);
+		if (this._assertAssignableEarlyReturn(target, source)) return;
+		if (isPointer(target) && isPointer(source)) {
+			this.assertAssignable(
+				target.base ?? target.underlying?.base,
+				source.base ?? source.underlying?.base,
+				node,
+			);
+			return;
+		}
+		if (isUntyped(source) && this._isUntypedAssignable(target, source)) return;
+		if (this._isNumericCoercible(target, source)) return;
+		if (this._checkArrayAssignable(target, source, node)) return;
+		if (typeStr(target) !== typeStr(source))
+			this._assertAssignableTypeMismatch(target, source, node);
+	},
+
+	_assertAssignableEarlyReturn(target, source) {
+		return (
+			target?.kind === "typeParam" ||
+			source?.kind === "typeParam" ||
+			isAny(target) ||
+			isAny(source) ||
+			isNil(source)
+		);
+	},
+
+	_assertAssignableTypeMismatch(target, source, node) {
+		let tBase = target.kind === "named" ? target.underlying : target;
+		tBase = this.resolveType(tBase);
+		if (tBase?.kind === "interface") {
+			if (tBase.methods.size === 0) return;
+			if (!this.implements(source, tBase, node))
+				this.err(
+					`${typeStr(source)} does not implement ${typeStr(target)}`,
+					node,
+				);
+			return;
+		}
+		this.err(`Cannot assign ${typeStr(source)} to ${typeStr(target)}`, node);
+	},
+
+	_isUntypedAssignable(target, source) {
+		if (isUntyped(target)) return true;
+		if (target.kind !== "basic") return false;
+		return (
+			(UNTYPED_COMPAT[source.base]?.has(target.name) ?? false) ||
+			(isComplex(target) &&
+				(source.base === "int" || source.base === "float64"))
+		);
+	},
+
+	_isNumericCoercible(target, source) {
+		if (target.kind !== "basic" || source.kind !== "basic") return false;
+		return (
+			(target.name === "float64" && source.name === "int") ||
+			(target.name === "int" && source.name === "float64")
+		);
+	},
+
+	_checkArrayAssignable(target, source, node) {
+		if (target.kind === "array" && source.kind === "array") {
+			if (
+				target.size != null &&
+				source.size != null &&
+				target.size !== source.size
+			)
+				this.err(
+					`Cannot assign ${typeStr(source)} to ${typeStr(target)} (different array lengths)`,
+					node,
+				);
+			else this.assertAssignable(target.elem, source.elem, node);
+			return true;
+		}
+		if (
+			(target.kind === "array" && source.kind === "slice") ||
+			(target.kind === "slice" && source.kind === "array")
+		) {
+			this.err(`Cannot assign ${typeStr(source)} to ${typeStr(target)}`, node);
+			return true;
+		}
+		return false;
+	},
+
+	// ── Interface satisfaction ────────────────────────────────────────
+
+	_sigParamsMatch(reqList, actList) {
+		if (reqList.length !== actList.length) return false;
+		for (let i = 0; i < reqList.length; i++) {
+			if (typeStr(reqList[i]) !== typeStr(actList[i])) return false;
+		}
+		return true;
+	},
+
+	_implementsMethod(required, actual) {
+		if (!actual) return false;
+		const rp = required.params ?? [],
+			ap = actual.params ?? [];
+		const rr = required.returns ?? [],
+			ar = actual.returns ?? [];
+		if (!this._sigParamsMatch(rp, ap)) return false;
+		if (!!required.variadic !== !!actual.variadic) return false;
+		return this._sigParamsMatch(rr, ar);
+	},
+
+	implements(srcType, iface, _node) {
+		let base = srcType.kind === "named" ? srcType.underlying : srcType;
+		base = this.resolveType(base);
+		const methodMap =
+			base?.kind === "struct"
+				? base.methods
+				: srcType.kind === "named"
+					? srcType.methods
+					: null;
+		if (!methodMap) return false;
+		for (const [name, required] of iface.methods) {
+			if (!this._implementsMethod(required, methodMap.get(name))) return false;
+		}
+		return true;
+	},
+};