gofront 0.0.2 → 0.0.4

package/src/compiler.js

@@ -113,35 +113,49 @@ export function compileFiles(files, options = {}) {
 
 	// local GoFront packages (./subdir)
 	const seenLocalPaths = new Set();
-	for (const imp of allImports) {
-		for (const { path, alias } of imp.imports) {
-			if (!isLocalPath(path) || seenLocalPaths.has(path)) continue;
-			seenLocalPaths.add(path);
-
-			const depDir = resolveGwDir(path, dummyFromFile);
-			if (!depDir) {
-				console.error(
-					`gofront: warning: cannot find local package '${path}' relative to ${fromDir}`,
+	for (const p of programs) {
+		for (const imp of p.imports) {
+			for (const { path, alias, _line } of imp.imports) {
+				if (!isLocalPath(path) || seenLocalPaths.has(path)) continue;
+				seenLocalPaths.add(path);
+
+				const depDir = resolveGwDir(path, dummyFromFile);
+				if (!depDir) {
+					console.error(
+						`gofront: warning: cannot find local package '${path}' relative to ${fromDir}`,
+					);
+					continue;
+				}
+
+				// Recursively compile dependency
+				const dep = compileDir(depDir);
+				preambles.push(dep.js);
+				if (alias === "_") continue; // side-effect import — bundle code but don't expose namespace
+
+				// Dot import: flatten all exported symbols into global scope
+				if (alias === ".") {
+					checker.addDefinitions(dep.exportedTypes, dep.exportedSymbols);
+					// All dep symbols must be treated as bundled so codegen
+					// can emit them without a qualifier.  We DON'T add a
+					// namespace, so SelectorExpr never appears for these.
+					continue;
+				}
+
+				const nameUsed = alias ?? dep.pkgName;
+				bundledPackages.add(nameUsed);
+				checker.addPackageNamespace(
+					nameUsed,
+					dep.exportedSymbols,
+					dep.exportedTypes,
 				);
-				continue;
+				checker.trackImport(nameUsed, { _line }, p._filename, p._source);
 			}
-
-			// Recursively compile dependency
-			const dep = compileDir(depDir);
-			preambles.push(dep.js);
-			if (alias === "_") continue; // side-effect import — bundle code but don't expose namespace
-			const nameUsed = alias ?? dep.pkgName;
-			bundledPackages.add(nameUsed);
-			checker.addPackageNamespace(
-				nameUsed,
-				dep.exportedSymbols,
-				dep.exportedTypes,
-			);
 		}
 	}
 
 	// ── 3. Type-check ─────────────────────────────────────────────
 	const errors = checker.checkAll(programs);
+	checker.reportUnusedImports();
 	if (errors.length > 0) {
 		const msgs = errors.map((e) => e.message).join("\n");
 		throw new Error(msgs);

package/src/index.js

@@ -290,7 +290,7 @@ function timestamp() {
 	return new Date().toLocaleTimeString();
 }
 
-async function buildOnce(_label) {
+async function buildOnce() {
 	try {
 		const startMs = performance.now();
 		const result = runCompile();
@@ -314,7 +314,7 @@ async function buildOnce(_label) {
 }
 
 // Initial build
-buildOnce("initial");
+buildOnce();
 
 // Determine what to watch
 const watchTarget = isDir ? inputPath : dirname(inputPath);
@@ -323,7 +323,7 @@ let debounce = null;
 watch(watchTarget, { recursive: true }, (_event, filename) => {
 	if (filename && !filename.endsWith(".go")) return;
 	clearTimeout(debounce);
-	debounce = setTimeout(() => buildOnce(filename ?? "change"), 80);
+	debounce = setTimeout(() => buildOnce(), 80);
 });
 
 console.error(`[${timestamp()}] gofront: watching ${inputArg} ...`);

package/src/lexer.js

@@ -35,6 +35,9 @@ export const T = {
 	DEFER: "defer",
 	ASYNC: "async",
 	AWAIT: "await",
+	GO: "go",
+	CHAN: "chan",
+	SELECT: "select",
 
 	// Operators
 	PLUS: "+",
@@ -68,6 +71,7 @@ export const T = {
 	AMP: "&",
 	PIPE: "|",
 	CARET: "^",
+	AND_NOT: "&^",
 	LSHIFT: "<<",
 	RSHIFT: ">>",
 	ELLIPSIS: "...",
@@ -136,6 +140,9 @@ const KEYWORDS = new Set([
 	"defer",
 	"async",
 	"await",
+	"go",
+	"chan",
+	"select",
 ]);
 
 export class Token {
@@ -217,16 +224,28 @@ export class Lexer {
 				while (this.pos < this.src.length && this.peek() !== "\n")
 					this.advance();
 			} else if (ch === "/" && this.peek(1) === "*") {
+				const startLine = this.line,
+					startCol = this.col;
 				this.advance();
 				this.advance();
+				let closed = false;
 				while (this.pos < this.src.length) {
 					if (this.peek() === "*" && this.peek(1) === "/") {
 						this.advance();
 						this.advance();
+						closed = true;
 						break;
 					}
 					this.advance();
 				}
+				if (!closed)
+					throw new LexError(
+						"Unterminated block comment",
+						startLine,
+						startCol,
+						this.filename,
+						this.src,
+					);
 			} else {
 				break;
 			}
@@ -343,20 +362,88 @@ export class Lexer {
 	readNumber() {
 		let n = "";
 		let isFloat = false;
-		while (this.pos < this.src.length && /[0-9]/.test(this.peek()))
-			n += this.advance();
+
+		// Check for prefix: 0b, 0o, 0x
+		const first = this.advance();
+		n += first;
+		if (first === "0") {
+			const p = this.peek();
+			if (p === "b" || p === "B") {
+				n += this.advance();
+				while (this.pos < this.src.length && /[01_]/.test(this.peek())) {
+					const ch = this.advance();
+					if (ch !== "_") n += ch;
+				}
+				return { n, isFloat: false };
+			}
+			if (p === "o" || p === "O") {
+				n += this.advance();
+				while (this.pos < this.src.length && /[0-7_]/.test(this.peek())) {
+					const ch = this.advance();
+					if (ch !== "_") n += ch;
+				}
+				return { n, isFloat: false };
+			}
+			if (p === "x" || p === "X") {
+				n += this.advance();
+				while (this.pos < this.src.length && /[0-9a-fA-F_]/.test(this.peek())) {
+					const ch = this.advance();
+					if (ch !== "_") n += ch;
+				}
+				// Hex float: 0x1.Fp10 or 0xAp-2
+				if (this.peek() === "." || this.peek() === "p" || this.peek() === "P") {
+					let frac = "";
+					if (this.peek() === ".") {
+						this.advance(); // skip the dot (don't add to n)
+						while (
+							this.pos < this.src.length &&
+							/[0-9a-fA-F_]/.test(this.peek())
+						) {
+							const ch = this.advance();
+							if (ch !== "_") frac += ch;
+						}
+					}
+					if (this.peek() === "p" || this.peek() === "P") {
+						this.advance(); // skip p/P
+						let exp = "";
+						if (this.peek() === "+" || this.peek() === "-")
+							exp += this.advance();
+						while (this.pos < this.src.length && /[0-9]/.test(this.peek()))
+							exp += this.advance();
+						// Evaluate: JS can't parse hex floats, so convert manually
+						// n is "0x1" (integer hex part), frac is hex fractional digits
+						let mantissa = Number(n);
+						if (frac) {
+							mantissa += Number.parseInt(frac, 16) / 16 ** frac.length;
+						}
+						const value = mantissa * 2 ** Number(exp);
+						return { n: String(value), isFloat: true };
+					}
+				}
+				return { n, isFloat: false };
+			}
+		}
+
+		while (this.pos < this.src.length && /[0-9_]/.test(this.peek())) {
+			const ch = this.advance();
+			if (ch !== "_") n += ch;
+		}
 		if (this.peek() === "." && /[0-9]/.test(this.peek(1))) {
 			isFloat = true;
 			n += this.advance();
-			while (this.pos < this.src.length && /[0-9]/.test(this.peek()))
-				n += this.advance();
+			while (this.pos < this.src.length && /[0-9_]/.test(this.peek())) {
+				const ch = this.advance();
+				if (ch !== "_") n += ch;
+			}
 		}
 		if (this.peek() === "e" || this.peek() === "E") {
 			isFloat = true;
 			n += this.advance();
 			if (this.peek() === "+" || this.peek() === "-") n += this.advance();
-			while (this.pos < this.src.length && /[0-9]/.test(this.peek()))
-				n += this.advance();
+			while (this.pos < this.src.length && /[0-9_]/.test(this.peek())) {
+				const ch = this.advance();
+				if (ch !== "_") n += ch;
+			}
 		}
 		return { n, isFloat };
 	}
@@ -474,6 +561,7 @@ export class Lexer {
 					break;
 				case "&":
 					if (this.match("&")) this.push(T.AND, "&&", l, c);
+					else if (this.match("^")) this.push(T.AND_NOT, "&^", l, c);
 					else if (this.match("=")) this.push(T.AMP_ASSIGN, "&=", l, c);
 					else this.push(T.AMP, "&", l, c);
 					break;

package/src/parser/expressions.js

@@ -0,0 +1,389 @@
+// Parser expression methods — installed as a mixin on Parser.prototype.
+
+import { T } from "../lexer.js";
+
+// Binary operator precedence (higher = binds tighter, matching Go spec)
+const PREC = {
+	[T.OR]: 1,
+	[T.AND]: 2,
+	[T.EQ]: 3,
+	[T.NEQ]: 3,
+	[T.LT]: 3,
+	[T.GT]: 3,
+	[T.LTE]: 3,
+	[T.GTE]: 3,
+	[T.PLUS]: 4,
+	[T.MINUS]: 4,
+	[T.PIPE]: 4,
+	[T.CARET]: 4,
+	[T.STAR]: 5,
+	[T.SLASH]: 5,
+	[T.PERCENT]: 5,
+	[T.LSHIFT]: 5,
+	[T.RSHIFT]: 5,
+	[T.AMP]: 5,
+	[T.AND_NOT]: 5,
+};
+
+const TYPE_KEYWORDS = new Set([
+	"int",
+	"float64",
+	"string",
+	"bool",
+	"any",
+	"byte",
+	"rune",
+	"error",
+]);
+
+const BUILTIN_KEYWORDS = new Set([
+	"new",
+	"make",
+	"len",
+	"cap",
+	"append",
+	"delete",
+	"copy",
+	"print",
+	"println",
+	"panic",
+	"error",
+]);
+
+export const expressionParserMethods = {
+	parseExprList() {
+		const exprs = [this.parseExpr()];
+		while (this.match(T.COMMA)) exprs.push(this.parseExpr());
+		return exprs;
+	},
+
+	// noCompLit=true disables composite literal parsing in if/for/switch conditions
+	// to resolve the ambiguity between "if x {" and "if Type{ } {"
+	parseExpr(minPrec = 0, noCompLit = false) {
+		let left = this.parseUnary(noCompLit);
+		while (true) {
+			const prec = PREC[this.peek().type];
+			if (!prec || prec <= minPrec) break;
+			const op = this.advance().value;
+			const right = this.parseExpr(prec, noCompLit);
+			left = { kind: "BinaryExpr", left, op, right };
+		}
+		return left;
+	},
+
+	parseUnary(noCompLit = false) {
+		const t = this.peek();
+		if (
+			t.type === T.NOT ||
+			t.type === T.MINUS ||
+			t.type === T.PLUS ||
+			t.type === T.CARET ||
+			t.type === T.AMP ||
+			t.type === T.STAR
+		) {
+			const op = this.advance().value;
+			return { kind: "UnaryExpr", op, operand: this.parseUnary(noCompLit) };
+		}
+		if (t.type === T.AWAIT) {
+			this.advance();
+			return { kind: "AwaitExpr", expr: this.parseUnary(noCompLit) };
+		}
+		return this.parsePostfix(noCompLit);
+	},
+
+	parsePostfix(noCompLit = false) {
+		let expr = this.parsePrimary();
+		while (true) {
+			const t = this.peek();
+			if (t.type === T.DOT) {
+				this.advance();
+				// type assertion: expr.(Type)
+				if (this.check(T.LPAREN)) {
+					this.advance();
+					// x.(type) — type switch guard expression
+					if (this.check(T.TYPE)) {
+						this.advance();
+						this.expect(T.RPAREN);
+						expr = { kind: "TypeSwitchExpr", expr };
+					} else {
+						const type = this.parseType();
+						this.expect(T.RPAREN);
+						expr = { kind: "TypeAssertExpr", expr, type };
+					}
+				} else {
+					const field = this.advance().value;
+					expr = { kind: "SelectorExpr", expr, field };
+				}
+			} else if (t.type === T.LBRACKET) {
+				this.advance();
+				const low = this.check(T.COLON) ? null : this.parseExpr();
+				if (this.match(T.COLON)) {
+					const high =
+						this.check(T.RBRACKET) || this.check(T.COLON)
+							? null
+							: this.parseExpr();
+					let max = null;
+					if (this.match(T.COLON)) {
+						max = this.parseExpr();
+					}
+					this.expect(T.RBRACKET);
+					expr = { kind: "SliceExpr", expr, low, high, max };
+				} else {
+					this.expect(T.RBRACKET);
+					expr = { kind: "IndexExpr", expr, index: low };
+				}
+			} else if (t.type === T.LPAREN) {
+				expr = this.parseCall(expr);
+			} else if (
+				t.type === T.LBRACE &&
+				!noCompLit &&
+				this.isCompositeLitContext(expr)
+			) {
+				expr = this.parseCompositeLit(expr);
+			} else {
+				break;
+			}
+		}
+		return expr;
+	},
+
+	// Composite literals are only allowed after a type name (not arbitrary exprs)
+	isCompositeLitContext(expr) {
+		return (
+			expr.kind === "Ident" ||
+			expr.kind === "SelectorExpr" ||
+			expr.kind === "TypeExpr" ||
+			expr.kind === "StructType"
+		);
+	},
+
+	parseCall(fn) {
+		this.expect(T.LPAREN);
+		const args = [];
+		if (!this.check(T.RPAREN)) {
+			do {
+				if (this.check(T.RPAREN)) break;
+				// map[K]V and []T as call args must be parsed as types, not expressions,
+				// when they are NOT followed by { (which would make them composite literals).
+				// Needed for make(map[K]V), make([]T, n), new(T), etc.
+				const t = this.peek();
+				const isSliceOrArrayType =
+					t.type === T.LBRACKET &&
+					(this.peek2()?.type === T.RBRACKET || // []T
+						this.peek2()?.type === T.INT); // [n]T
+				if (
+					(t.type === T.MAP || isSliceOrArrayType) &&
+					!this.looksLikeCompositeLitArg()
+				) {
+					const typeNode = this.parseType();
+					// []byte(s) / []rune(s) used as a call argument — it's a type conversion
+					if (this.check(T.LPAREN)) {
+						this.advance();
+						const convExpr = this.parseExpr();
+						this.expect(T.RPAREN);
+						args.push({
+							kind: "TypeConversion",
+							targetType: typeNode,
+							expr: convExpr,
+						});
+					} else {
+						args.push({ kind: "TypeExpr", type: typeNode });
+					}
+				} else {
+					const arg = this.parseExpr();
+					if (this.match(T.ELLIPSIS)) arg._spread = true;
+					args.push(arg);
+				}
+			} while (this.match(T.COMMA));
+		}
+		this.expect(T.RPAREN);
+		return { kind: "CallExpr", func: fn, args };
+	},
+
+	// Returns true if the current position looks like a composite literal argument,
+	// e.g. []int{1,2,3} or map[string]int{"a":1}.  We scan ahead past the type
+	// tokens to check whether a { follows, without advancing this.pos permanently.
+	looksLikeCompositeLitArg() {
+		let i = this.pos;
+		const src = this.tokens;
+		// Skip over the type tokens: [, ], map, [, K, ], V, ident, etc.
+		// Simple approach: skip until we hit something that can't be part of a type
+		let depth = 0;
+		while (i < src.length) {
+			const tt = src[i].type;
+			if (tt === T.LBRACKET) {
+				depth++;
+				i++;
+				continue;
+			}
+			if (tt === T.RBRACKET) {
+				depth--;
+				i++;
+				continue;
+			}
+			if (depth > 0) {
+				i++;
+				continue;
+			}
+			if (
+				tt === T.MAP ||
+				tt === T.IDENT ||
+				tt === T.STAR ||
+				tt === T.INT ||
+				tt === T.FLOAT ||
+				tt === T.STRING
+			) {
+				i++;
+				continue;
+			}
+			break;
+		}
+		// Skip whitespace tokens (shouldn't exist post-lex, but be safe)
+		while (i < src.length && src[i].type === T.SEMICOLON) i++;
+		return i < src.length && src[i].type === T.LBRACE;
+	},
+
+	parseCompositeLit(typeExpr) {
+		this.expect(T.LBRACE);
+		const elems = [];
+		while (!this.check(T.RBRACE) && !this.check(T.EOF)) {
+			// Implicit composite literal: {X: 1} inside []Point{{X:1}} or map[string]Point{"a": {X:1}}
+			if (this.check(T.LBRACE)) {
+				elems.push(this.parseCompositeLit(null)); // null typeExpr = inferred
+			} else {
+				const first = this.parseExpr();
+				if (this.match(T.COLON)) {
+					// Map key: value — value may also be an implicit composite lit
+					const val = this.check(T.LBRACE)
+						? this.parseCompositeLit(null)
+						: this.parseExpr();
+					elems.push({ kind: "KeyValueExpr", key: first, value: val });
+				} else {
+					elems.push(first);
+				}
+			}
+			this.match(T.COMMA);
+		}
+		this.expect(T.RBRACE);
+		return { kind: "CompositeLit", typeExpr, elems };
+	},
+
+	parsePrimary() {
+		const line = this.peek().line;
+		const expr = this._parsePrimary();
+		if (!expr._line) expr._line = line;
+		return expr;
+	},
+
+	_parsePrimary() {
+		const t = this.peek();
+
+		// Literals
+		if (t.type === T.INT) {
+			this.advance();
+			return { kind: "BasicLit", litKind: "INT", value: t.value };
+		}
+		if (t.type === T.FLOAT) {
+			this.advance();
+			return { kind: "BasicLit", litKind: "FLOAT", value: t.value };
+		}
+		if (t.type === T.STRING) {
+			this.advance();
+			return { kind: "BasicLit", litKind: "STRING", value: t.value };
+		}
+		if (t.type === T.TRUE) {
+			this.advance();
+			return { kind: "BasicLit", litKind: "BOOL", value: "true" };
+		}
+		if (t.type === T.FALSE) {
+			this.advance();
+			return { kind: "BasicLit", litKind: "BOOL", value: "false" };
+		}
+		if (t.type === T.NIL) {
+			this.advance();
+			return { kind: "BasicLit", litKind: "NIL", value: "null" };
+		}
+
+		// Parenthesised expression
+		if (t.type === T.LPAREN) {
+			this.advance();
+			const expr = this.parseExpr();
+			this.expect(T.RPAREN);
+			return expr;
+		}
+
+		// Function literal (sync or async)
+		if (t.type === T.FUNC || t.type === T.ASYNC) {
+			const isAsync = t.type === T.ASYNC;
+			this.advance();
+			if (isAsync) this.expect(T.FUNC);
+			const params = this.parseParamList();
+			const returnType = this.parseReturnType();
+			const body = this.parseBlock();
+			return { kind: "FuncLit", params, returnType, body, async: isAsync };
+		}
+
+		// range expression (only valid inside a for statement)
+		if (t.type === T.RANGE) {
+			this.advance();
+			// Always use noCompLit here: "range slice {" — { is the for body, not a composite lit
+			return { kind: "RangeExpr", expr: this.parseExpr(0, true) };
+		}
+
+		// Builtin / identifier
+		if (
+			t.type === T.IDENT ||
+			this.isTypeKeyword(t) ||
+			this.isBuiltinKeyword(t)
+		) {
+			this.advance();
+			// Type conversion or composite lit: Type(expr) or Type{...}
+			if (this.isTypeKeyword(t) && this.check(T.LPAREN)) {
+				// type conversion: int(x), string(x), etc.
+				this.advance();
+				const expr = this.parseExpr();
+				this.expect(T.RPAREN);
+				return {
+					kind: "TypeConversion",
+					targetType: { kind: "TypeName", name: t.value },
+					expr,
+				};
+			}
+			return { kind: "Ident", name: t.value };
+		}
+
+		// Slice/array/map composite literals or type conversions:
+		//   []int{1,2}           → CompositeLit
+		//   []byte(s), []rune(s) → TypeConversion
+		if (t.type === T.LBRACKET || t.type === T.MAP) {
+			const typeExpr = this.parseType();
+			if (this.check(T.LPAREN)) {
+				this.advance();
+				const expr = this.parseExpr();
+				this.expect(T.RPAREN);
+				return { kind: "TypeConversion", targetType: typeExpr, expr };
+			}
+			return this.parseCompositeLit(typeExpr);
+		}
+
+		// Anonymous struct composite literal: struct{Name string}{Name: "Alice"}
+		if (t.type === T.STRUCT) {
+			const typeExpr = this.parseStructType();
+			return this.parseCompositeLit(typeExpr);
+		}
+
+		if (t.type === T.CHAN) {
+			this.err("channels are not supported in GoFront");
+		}
+
+		this.err(`Unexpected token in expression: '${t.value}'`);
+	},
+
+	isTypeKeyword(t) {
+		return TYPE_KEYWORDS.has(t.value);
+	},
+
+	isBuiltinKeyword(t) {
+		return BUILTIN_KEYWORDS.has(t.value);
+	},
+};