gofront 1.0.0 → 1.0.1

package/src/parser/index.js

@@ -1,6 +1,7 @@
 // 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
@@ -17,6 +18,7 @@
 //   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";
@@ -151,354 +153,9 @@ export class Parser {
 		this.semi();
 		return { kind: "ImportDecl", imports };
 	}
-
-	// ── Top-level declarations ───────────────────────────────────
-
-	parseTopDecl() {
-		const t = this.peek();
-		switch (t.type) {
-			case T.ASYNC:
-				return this.parseAsyncFuncOrMethod();
-			case T.FUNC:
-				return this.parseFuncOrMethod();
-			case T.TYPE:
-				return this.parseTypeDecl();
-			case T.VAR:
-				return this.parseVarDecl();
-			case T.CONST:
-				return this.parseConstDecl();
-			default:
-				this.err("Expected top-level declaration");
-		}
-	}
-
-	parseFuncOrMethod() {
-		const _line = this.peek().line;
-		this.expect(T.FUNC);
-		// method: func (recv Type) Name(...)
-		if (this.check(T.LPAREN)) {
-			this.expect(T.LPAREN);
-			const recvName =
-				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
-			const recvType = this.parseTypeName();
-			this.expect(T.RPAREN);
-			const name = this.expect(T.IDENT).value;
-			const { params, returnType } = this.parseSignature();
-			const body = this.parseBlock();
-			this.semi();
-			return {
-				kind: "MethodDecl",
-				recvName,
-				recvType,
-				name,
-				params,
-				returnType,
-				body,
-				_line,
-			};
-		}
-		// 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,
-			typeParams,
-			params,
-			returnType,
-			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) {
-		return (
-			tok &&
-			(tok.type === T.RPAREN ||
-				tok.type === T.COMMA ||
-				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),
-	// 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();
-		return { params, returnType };
-	}
-
-	// Parses (a, b int, c string) style param list
-	parseParamList() {
-		this.expect(T.LPAREN);
-		const params = [];
-		if (!this.check(T.RPAREN)) {
-			do {
-				if (this.check(T.RPAREN)) break;
-				// Collect names, then type
-				const names = [];
-				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._isNamedParam()
-					) {
-						names.push(this.advance().value);
-					}
-					// variadic: name ...T
-					const variadic = this.match(T.ELLIPSIS);
-					const type = this.parseType();
-					for (const n of names) params.push({ name: n, type, variadic });
-				} else {
-					// unnamed: just a type (possibly variadic: ...T)
-					const variadic = this.match(T.ELLIPSIS);
-					const type = this.parseType();
-					params.push({ name: "_", type, variadic });
-				}
-			} while (this.match(T.COMMA));
-		}
-		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
-	// 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;
-	}
-
-	looksLikeType(tok) {
-		return (
-			tok.type === T.LBRACKET ||
-			tok.type === T.STAR ||
-			tok.type === T.MAP ||
-			tok.type === T.FUNC ||
-			tok.type === T.INTERFACE ||
-			tok.type === T.STRUCT ||
-			(tok.type === T.IDENT && tok.value !== "_")
-		);
-	}
-
-	parseReturnType(inTypeExpr = false) {
-		// No return type
-		if (
-			this.check(T.LBRACE) ||
-			this.check(T.RBRACE) ||
-			this.check(T.SEMICOLON) ||
-			this.check(T.EOF)
-		)
-			return null;
-		// Inside a type expression (e.g. func type in a tuple), `,` and `)` also end the type
-		if (inTypeExpr && (this.check(T.COMMA) || this.check(T.RPAREN)))
-			return null;
-		// Multiple return values: (int, string) or named (result int, ok bool)
-		if (this.check(T.LPAREN)) {
-			this.advance();
-			const types = [];
-			const names = []; // non-null if named returns
-			let isNamed = false;
-			do {
-				// Named returns: only treat IDENT as a name if peek2 is an actual type token
-				if (this.check(T.IDENT) && this.looksLikeType(this.peek2())) {
-					names.push(this.advance().value);
-					isNamed = true;
-				} else {
-					names.push(null);
-				}
-				types.push(this.parseType());
-			} while (this.match(T.COMMA));
-			this.expect(T.RPAREN);
-			const typeNode =
-				types.length === 1 ? types[0] : { kind: "TupleType", types };
-			// Attach named return info so typechecker can inject them into scope
-			if (isNamed)
-				typeNode._namedReturns = names.map((n, i) => ({
-					name: n,
-					type: types[i],
-				}));
-			return typeNode;
-		}
-		return this.parseType();
-	}
-
-	parseTypeDecl() {
-		this.expect(T.TYPE);
-		if (this.match(T.LPAREN)) {
-			const decls = [];
-			while (!this.check(T.RPAREN) && !this.check(T.EOF)) {
-				const name = this.expect(T.IDENT).value;
-				const isAlias = this.match(T.ASSIGN);
-				const type = this.parseType();
-				decls.push({ kind: "TypeDecl", name, type, isAlias });
-				this.semi();
-			}
-			this.expect(T.RPAREN);
-			this.semi();
-			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, typeParams, type, isAlias };
-	}
-
-	parseVarDecl() {
-		this.expect(T.VAR);
-		const decls = [];
-		if (this.match(T.LPAREN)) {
-			while (!this.check(T.RPAREN) && !this.check(T.EOF)) {
-				decls.push(this.parseVarSpec());
-				this.semi();
-			}
-			this.expect(T.RPAREN);
-		} else {
-			decls.push(this.parseVarSpec());
-		}
-		this.semi();
-		return { kind: "VarDecl", decls };
-	}
-
-	parseVarSpec() {
-		const names = [this.expect(T.IDENT).value];
-		while (this.match(T.COMMA)) names.push(this.expect(T.IDENT).value);
-		let type = null;
-		let value = null;
-		if (
-			!this.check(T.ASSIGN) &&
-			!this.check(T.SEMICOLON) &&
-			!this.check(T.RPAREN)
-		) {
-			type = this.parseType();
-		}
-		if (this.match(T.ASSIGN)) value = this.parseExprList();
-		return { names, type, value };
-	}
-
-	parseConstDecl() {
-		this.expect(T.CONST);
-		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 rawExprs; // before iota substitution
-				if (this.check(T.ASSIGN)) {
-					this.advance();
-					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);
-					rawExprs = this.parseExprList();
-					prevRawExprs = rawExprs;
-				} else {
-					// Omitted expression — repeat previous expression with updated iota
-					rawExprs = prevRawExprs ?? [
-						{ kind: "BasicLit", litKind: "INT", value: String(iotaVal) },
-					];
-					type = prevType ?? null;
-				}
-				// 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();
-			}
-			this.expect(T.RPAREN);
-		} else {
-			const names = [this.expect(T.IDENT).value];
-			while (this.match(T.COMMA)) names.push(this.expect(T.IDENT).value);
-			let type = null;
-			if (!this.check(T.ASSIGN)) type = this.parseType();
-			this.expect(T.ASSIGN);
-			const value = this.parseExprList();
-			decls.push({ names, type, value });
-		}
-		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);
 Object.assign(Parser.prototype, statementParserMethods);
 Object.assign(Parser.prototype, expressionParserMethods);
+Object.assign(Parser.prototype, declarationParseMethods);

package/src/typechecker/assignability.js

@@ -24,6 +24,8 @@ import {
 	UNTYPED_INT,
 } from "./types.js";
 
+/** @typedef {import('./index.js').TypeChecker} TypeChecker */
+
 // Untyped constant assignability: maps source.base → Set of compatible target.name values
 const UNTYPED_COMPAT = {
 	int: new Set(["int", "float64", "complex128", "complex64"]),
@@ -33,6 +35,7 @@ const UNTYPED_COMPAT = {
 	complex128: new Set(["complex128", "complex64"]),
 };
 
+/** @type {ThisType<TypeChecker>} */
 export const assignabilityMethods = {
 	// ── Binary result types ───────────────────────────────────────────
 

package/src/typechecker/expressions.js

@@ -17,6 +17,7 @@ import {
 	NIL,
 	Scope,
 	STRING,
+	TAINTED_ANY,
 	typeStr,
 	UNTYPED_BOOL,
 	UNTYPED_COMPLEX,
@@ -26,6 +27,8 @@ import {
 	VOID,
 } from "./types.js";
 
+/** @typedef {import('./index.js').TypeChecker} TypeChecker */
+
 // Dispatch table for builtin function type checking.
 // Each value is (self, name, expr, argTypes, scope) => returnType.
 const BUILTIN_CHECK = {
@@ -80,6 +83,7 @@ const CHECK_EXPR_DELEGATE = {
 	InstantiationExpr: "_checkInstantiationExpr",
 };
 
+/** @type {ThisType<TypeChecker>} */
 export const expressionCheckMethods = {
 	checkExpr(expr, scope) {
 		const t = this._checkExpr(expr, scope);
@@ -115,6 +119,7 @@ export const expressionCheckMethods = {
 			case "BinaryExpr": {
 				const lt = this.checkExpr(expr.left, scope);
 				const rt = this.checkExpr(expr.right, scope);
+				if (lt?._tainted || rt?._tainted) return TAINTED_ANY;
 				if (isAny(lt) || isAny(rt))
 					return this.binaryResultType(expr.op, ANY, ANY, expr);
 				return this.binaryResultType(expr.op, lt, rt, expr);
@@ -185,6 +190,7 @@ export const expressionCheckMethods = {
 
 	_checkSelectorExpr(expr, scope) {
 		const baseType = this.checkExpr(expr.expr, scope);
+		if (baseType?._tainted) return TAINTED_ANY;
 		if (expr.expr._isTypeRef) {
 			let base = baseType.kind === "named" ? baseType.underlying : baseType;
 			base = this.resolveType(base);
@@ -230,6 +236,7 @@ export const expressionCheckMethods = {
 	_checkIndexExpr(expr, scope) {
 		const bt = this.checkExpr(expr.expr, scope);
 		this.checkExpr(expr.index, scope);
+		if (bt?._tainted) return TAINTED_ANY;
 		if (isAny(bt)) return ANY;
 		const btu =
 			bt.kind === "named"
@@ -252,6 +259,7 @@ export const expressionCheckMethods = {
 		if (expr.low) this.checkExpr(expr.low, scope);
 		if (expr.high) this.checkExpr(expr.high, scope);
 		if (expr.max) this.checkExpr(expr.max, scope);
+		if (bt?._tainted) return TAINTED_ANY;
 		if (isAny(bt)) return ANY;
 		if (bt.kind === "slice" || bt.kind === "array")
 			return { kind: "slice", elem: bt.elem };
@@ -468,6 +476,7 @@ export const expressionCheckMethods = {
 
 		const argTypes = this._resolveCallArgTypes(expr, scope);
 
+		if (fnType?._tainted) return TAINTED_ANY;
 		if (isAny(fnType)) return ANY;
 
 		// Named type used as a constructor/conversion: Greeter(fn), NodeFunc(fn)

package/src/typechecker/index.js

@@ -22,6 +22,7 @@ import {
 	ERROR,
 	isVoid,
 	Scope,
+	TAINTED_ANY,
 	TypeCheckError,
 	typeStr,
 	VOID,
@@ -124,7 +125,7 @@ export class TypeChecker {
 			this._currentSource,
 		);
 		this.errors.push(e);
-		return ANY; // recovery type
+		return TAINTED_ANY; // tainted recovery type — suppresses downstream cascade errors
 	}
 
 	_reportUnused(scope, node) {

package/src/typechecker/resolve.js

@@ -7,10 +7,13 @@ import {
 	defaultType,
 	isAny,
 	Scope,
+	TAINTED_ANY,
 	typeStr,
 	VOID,
 } from "./types.js";
 
+/** @typedef {import('./index.js').TypeChecker} TypeChecker */
+
 // Dispatch table for substituteType — keyed by type.kind.
 const SUBSTITUTE_DISPATCH = {
 	basic: (_s, type) => type,
@@ -69,6 +72,7 @@ const SUBSTITUTE_DISPATCH = {
 	}),
 };
 
+/** @type {ThisType<TypeChecker>} */
 export const resolveMethods = {
 	resolveTypeNode(node, scope) {
 		if (!node) return ANY;
@@ -217,7 +221,9 @@ export const resolveMethods = {
 				}
 			}
 		}
-		return { kind: "interface", methods };
+		const result = { kind: "interface", methods };
+		if (node.unionConstraint) result.unionConstraint = node.unionConstraint;
+		return result;
 	},
 
 	// ── Generics — substitution, instantiation, inference ────────────
@@ -354,7 +360,8 @@ export const resolveMethods = {
 
 	fieldType(baseType, field, node) {
 		baseType = this.resolveType(baseType);
-		if (!baseType || isAny(baseType)) return ANY;
+		if (!baseType || isAny(baseType))
+			return baseType?._tainted ? TAINTED_ANY : ANY;
 		if (this._isTransparentPointerField(baseType, field))
 			baseType = this.resolveType(baseType.base);
 		if (baseType.kind === "named" && baseType.methods?.has(field))

package/src/typechecker/statements.js

@@ -26,6 +26,9 @@ import {
 	Scope,
 } from "./types.js";
 
+/** @typedef {import('./index.js').TypeChecker} TypeChecker */
+
+/** @type {ThisType<TypeChecker>} */
 export const statementCheckMethods = {
 	checkBlock(block, scope, returnType) {
 		for (const stmt of block.stmts) {

package/src/typechecker/termination.js

@@ -1,6 +1,9 @@
 // Termination analysis — determines whether a statement/block always returns.
 // Installed as a mixin on TypeChecker.prototype.
 
+/** @typedef {import('./index.js').TypeChecker} TypeChecker */
+
+/** @type {ThisType<TypeChecker>} */
 export const terminationMethods = {
 	_isPanicCall(expr) {
 		return (

package/src/typechecker/types.js

@@ -48,6 +48,7 @@ export const FLOAT64 = { kind: "basic", name: "float64" };
 export const STRING = { kind: "basic", name: "string" };
 export const BOOL = { kind: "basic", name: "bool" };
 export const ANY = { kind: "basic", name: "any" };
+export const TAINTED_ANY = { kind: "basic", name: "any", _tainted: true };
 export const VOID = { kind: "basic", name: "void" };
 export const NIL = { kind: "basic", name: "nil" };
 export const ERROR = {