gofront 1.0.0 → 1.0.1

package/src/index.js

@@ -13,27 +13,15 @@
 //   gofront <file.go> --tokens     — dump tokens of first file (debug)
 //   gofront init [dir]             — scaffold a new GoFront project
 
-import {
-	existsSync,
-	mkdirSync,
-	readFileSync,
-	statSync,
-	watch,
-	writeFileSync,
-} from "node:fs";
 import { createRequire } from "node:module";
 
 const _require = createRequire(import.meta.url);
 const { version } = _require("../package.json");
 
-import { basename, dirname, join, relative, resolve } from "node:path";
-import { CodeGen } from "./codegen/index.js";
-import { compileDir, resolveImports } from "./compiler.js";
+import { statSync, watch, writeFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { handleInit, maybeMinify, runCompile } from "./cli-core.js";
 import { createDevServer, liveReloadClient } from "./dev-server.js";
-import { Lexer } from "./lexer.js";
-import { minify } from "./minifier.js";
-import { Parser } from "./parser/index.js";
-import { TypeChecker } from "./typechecker/index.js";
 
 // ── Parse CLI args ───────────────────────────────────────────
 
@@ -73,40 +61,13 @@ Usage:
 if (args[0] === "init") {
 	const targetArg = args[1] ?? ".";
 	const targetDir = resolve(targetArg);
-
-	if (targetArg !== ".") {
-		try {
-			mkdirSync(targetDir, { recursive: true });
-		} catch (e) {
-			console.error(`gofront: cannot create '${targetArg}': ${e.message}`);
-			process.exit(1);
-		}
-	}
-
-	const mainPath = join(targetDir, "main.go");
-	if (existsSync(mainPath)) {
-		console.error(`gofront: ${mainPath} already exists — nothing written`);
-		process.exit(1);
-	}
-
-	const pkgName =
-		targetArg === "." ? basename(resolve(".")) : basename(targetDir);
-	// package names must be valid identifiers
-	const safePkg = pkgName.replace(/[^a-zA-Z0-9_]/g, "_").replace(/^[0-9]/, "_");
-
-	const template = `package ${safePkg}
-
-func main() {
-\tconsole.log("Hello from GoFront!")
-}
-`;
+	let mainPath;
 	try {
-		writeFileSync(mainPath, template);
+		({ mainPath } = handleInit(targetDir));
 	} catch (e) {
-		console.error(`gofront: cannot write '${mainPath}': ${e.message}`);
+		console.error(`gofront: ${e.message}`);
 		process.exit(1);
 	}
-
 	console.error(`gofront: created ${mainPath}`);
 	console.error(
 		`gofront: run  gofront ${targetArg === "." ? "main.go" : `${targetArg}/main.go`}  to compile`,
@@ -139,95 +100,32 @@ try {
 	process.exit(1);
 }
 
-// ── Compile function (used for initial build and re-builds) ──
-
-function runCompile() {
-	if (isDir) {
-		const outputDir = outputFile ? dirname(resolve(outputFile)) : resolve(".");
-		return compileDir(inputPath, { sourceMap, outputDir });
-	}
-
-	// Single-file mode
-	let source;
-	try {
-		source = readFileSync(inputPath, "utf8");
-	} catch (e) {
-		throw new Error(`cannot read '${inputArg}': ${e.message}`);
-	}
-
-	const tokens = new Lexer(source, basename(inputPath)).tokenize();
-
-	if (dumpTokens) {
-		for (const tok of tokens) console.log(tok.toString());
-		process.exit(0);
-	}
-
-	const ast = new Parser(tokens, basename(inputPath), source).parse();
-	ast._source = source;
-
-	if (dumpAst) {
-		console.log(JSON.stringify(ast, null, 2));
-		process.exit(0);
-	}
-
-	const checker = new TypeChecker();
-	const jsImports = new Map();
-	const bundledPackages = new Set();
-	const preambles = [];
-
-	resolveImports(
-		[ast],
-		inputPath,
-		checker,
-		jsImports,
-		bundledPackages,
-		preambles,
-	);
-
-	const errors = checker.check(ast);
-	checker.reportUnusedImports();
-	if (errors.length > 0) {
-		throw new Error(errors.map((e) => e.message).join("\n"));
-	}
-
-	const cg = new CodeGen(checker, jsImports, bundledPackages);
-	let js = cg.generate(ast);
-
-	if (sourceMap) {
-		const outputDir = outputFile ? dirname(resolve(outputFile)) : resolve(".");
-		const srcPath = relative(outputDir, inputPath);
-		const map = cg.getSourceMap(srcPath, [source]);
-		const b64 = Buffer.from(map).toString("base64");
-		js += `\n//# sourceMappingURL=data:application/json;base64,${b64}`;
-	}
-
-	const output = preambles.length > 0 ? `${preambles.join("\n")}\n${js}` : js;
-	return { js: output };
-}
-
-// ── Minify helper ────────────────────────────────────────────
-
-function maybeMinify(js) {
-	if (!minifyOutput) return js;
-	if (sourceMap) {
-		console.error("gofront: --source-map and --minify cannot be used together");
-		process.exit(1);
-	}
-	return minify(js, { mangle: mangleOutput });
-}
-
 // ── Single-shot mode ─────────────────────────────────────────
 
 if (!watchMode) {
 	let result;
 	const startMs = performance.now();
 	try {
-		result = runCompile();
+		result = runCompile(inputPath, isDir, {
+			sourceMap,
+			outputFile,
+			dumpTokens,
+			dumpAst,
+		});
 	} catch (e) {
 		console.error(`gofront: ${e.message}`);
 		process.exit(1);
 	}
 
+	if (result.tokens) {
+		for (const tok of result.tokens) console.log(tok.toString());
+		process.exit(0);
+	}
+	if (result.ast) {
+		console.log(JSON.stringify(result.ast, null, 2));
+		process.exit(0);
+	}
+
 	if (checkOnly) {
 		const elapsedMs = (performance.now() - startMs).toFixed(0);
 		console.error(`gofront: ${inputArg} — OK (${elapsedMs}ms)`);
@@ -236,7 +134,11 @@ if (!watchMode) {
 
 	let js;
 	try {
-		js = maybeMinify(result.js);
+		js = maybeMinify(result.js, {
+			minify: minifyOutput,
+			mangle: mangleOutput,
+			sourceMap,
+		});
 	} catch (e) {
 		console.error(`gofront: minify failed: ${e.message}`);
 		process.exit(1);
@@ -278,8 +180,12 @@ if (serveMode) {
 function buildOnce(changedFile = null) {
 	try {
 		const startMs = performance.now();
-		const result = runCompile();
-		let js = maybeMinify(result.js);
+		const result = runCompile(inputPath, isDir, { sourceMap, outputFile });
+		let js = maybeMinify(result.js, {
+			minify: minifyOutput,
+			mangle: mangleOutput,
+			sourceMap,
+		});
 		if (serveMode) {
 			// Insert live reload client before the source map comment so it stays last
 			const smIdx = js.lastIndexOf("\n//# sourceMappingURL=");

package/src/parser/declarations.js

@@ -0,0 +1,347 @@
+import { T } from "../tokens.js";
+
+export const declarationParseMethods = {
+	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;
+	},
+};