gofront 0.0.1 → 0.0.3

package/src/compiler.js

@@ -86,8 +86,9 @@ export function compileFiles(files, options = {}) {
 
 	// js: prefix — local .d.ts files
 	for (const imp of allImports) {
-		for (const path of imp.paths) {
+		for (const { path, alias } of imp.imports) {
 			if (!path.startsWith("js:")) continue;
+			if (alias === "_") continue; // side-effect import — no type definitions
 			const dtsPath = join(fromDir, path.slice(3));
 			try {
 				const { types, values } = parseDts(readFileSync(dtsPath, "utf8"));
@@ -98,8 +99,12 @@ export function compileFiles(files, options = {}) {
 		}
 	}
 
-	// npm packages
-	const resolved = resolveAll(allImports, dummyFromFile, parseDts);
+	// npm packages — exclude side-effect imports (alias "_") from type resolution
+	const allImportsNoSideEffect = allImports.map((imp) => ({
+		...imp,
+		imports: imp.imports.filter(({ alias }) => alias !== "_"),
+	}));
+	const resolved = resolveAll(allImportsNoSideEffect, dummyFromFile, parseDts);
 	for (const [path, info] of resolved) {
 		if (!info) continue;
 		checker.addDefinitions(info.types, info.values);
@@ -108,33 +113,49 @@ export function compileFiles(files, options = {}) {
 
 	// local GoFront packages (./subdir)
 	const seenLocalPaths = new Set();
-	for (const imp of allImports) {
-		for (const path of imp.paths) {
-			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);
-			bundledPackages.add(dep.pkgName);
-			checker.addPackageNamespace(
-				dep.pkgName,
-				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/dts-parser.js

@@ -404,13 +404,11 @@ export class DtsParser {
 		if (this.eof() || this.ch() === "}") return;
 
 		// Skip modifiers (export, declare, static, readonly, etc.)
-		let _exported = false;
 		while (true) {
 			this.skip();
 			let found = false;
 			for (const mod of SKIP_MODIFIERS) {
 				if (this.matchKw(mod)) {
-					if (mod === "export") _exported = true;
 					found = true;
 					break;
 				}
@@ -604,13 +602,11 @@ export class DtsParser {
 			if (this.eof() || this.ch() === "}") break;
 
 			// Collect modifiers
-			let _isExport = false;
 			while (true) {
 				this.skip();
 				let found = false;
 				for (const mod of SKIP_MODIFIERS) {
 					if (this.matchKw(mod)) {
-						if (mod === "export") _isExport = true;
 						found = true;
 						break;
 					}

package/src/index.js

@@ -148,16 +148,14 @@ function runCompile() {
 		throw new Error(`cannot read '${inputArg}': ${e.message}`);
 	}
 
-	let tokens;
-	tokens = new Lexer(source, basename(inputPath)).tokenize();
+	const tokens = new Lexer(source, basename(inputPath)).tokenize();
 
 	if (dumpTokens) {
 		for (const tok of tokens) console.log(tok.toString());
 		process.exit(0);
 	}
 
-	let ast;
-	ast = new Parser(tokens, basename(inputPath), source).parse();
+	const ast = new Parser(tokens, basename(inputPath), source).parse();
 	ast._source = source;
 
 	if (dumpAst) {
@@ -170,7 +168,7 @@ function runCompile() {
 	const jsImports = new Map();
 
 	for (const imp of ast.imports) {
-		for (const path of imp.paths) {
+		for (const { path } of imp.imports) {
 			if (!path.startsWith("js:")) continue;
 			const dtsPath = join(fromDir, path.slice(3));
 			try {
@@ -193,7 +191,7 @@ function runCompile() {
 	const preambles = [];
 
 	for (const imp of ast.imports) {
-		for (const path of imp.paths) {
+		for (const { path, alias } of imp.imports) {
 			if (!isLocalPath(path)) continue;
 			const depDir = resolveGwDir(path, inputPath);
 			if (!depDir) {
@@ -204,9 +202,10 @@ function runCompile() {
 			}
 			const dep = compileDir(depDir);
 			preambles.push(dep.js);
-			bundledPackages.add(dep.pkgName);
+			const nameUsed = alias ?? dep.pkgName;
+			bundledPackages.add(nameUsed);
 			checker.addPackageNamespace(
-				dep.pkgName,
+				nameUsed,
 				dep.exportedSymbols,
 				dep.exportedTypes,
 			);
@@ -228,15 +227,7 @@ function runCompile() {
 	}
 
 	const output = preambles.length > 0 ? `${preambles.join("\n")}\n${js}` : js;
-	return { js: output, _cg: cg };
-}
-
-function _writeOutput(js) {
-	if (outputFile) {
-		writeFileSync(outputFile, `${js}\n`);
-	} else {
-		console.log(js);
-	}
+	return { js: output };
 }
 
 // ── Minify helper ────────────────────────────────────────────
@@ -299,7 +290,7 @@ function timestamp() {
 	return new Date().toLocaleTimeString();
 }
 
-async function buildOnce(_label) {
+async function buildOnce() {
 	try {
 		const startMs = performance.now();
 		const result = runCompile();
@@ -323,7 +314,7 @@ async function buildOnce(_label) {
 }
 
 // Initial build
-buildOnce("initial");
+buildOnce();
 
 // Determine what to watch
 const watchTarget = isDir ? inputPath : dirname(inputPath);
@@ -332,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: "+",
@@ -58,11 +61,17 @@ export const T = {
 	STAR_ASSIGN: "*=",
 	SLASH_ASSIGN: "/=",
 	PERCENT_ASSIGN: "%=",
+	AMP_ASSIGN: "&=",
+	PIPE_ASSIGN: "|=",
+	CARET_ASSIGN: "^=",
+	LSHIFT_ASSIGN: "<<=",
+	RSHIFT_ASSIGN: ">>=",
 	INC: "++",
 	DEC: "--",
 	AMP: "&",
 	PIPE: "|",
 	CARET: "^",
+	AND_NOT: "&^",
 	LSHIFT: "<<",
 	RSHIFT: ">>",
 	ELLIPSIS: "...",
@@ -131,6 +140,9 @@ const KEYWORDS = new Set([
 	"defer",
 	"async",
 	"await",
+	"go",
+	"chan",
+	"select",
 ]);
 
 export class Token {
@@ -212,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;
 			}
@@ -267,7 +291,7 @@ export class Lexer {
 			}
 		}
 		if (this.pos >= this.src.length)
-			throw new LexError("Unterminated string", l, c, this.filename);
+			throw new LexError("Unterminated string", l, c, this.filename, this.src);
 		this.advance(); // closing "
 		return s;
 	}
@@ -281,23 +305,145 @@ export class Lexer {
 		return s;
 	}
 
+	readRuneLiteral() {
+		const l = this.line,
+			c = this.col;
+		this.advance(); // opening '
+		let code;
+		if (this.peek() === "\\") {
+			this.advance();
+			const esc = this.advance();
+			switch (esc) {
+				case "n":
+					code = 10;
+					break;
+				case "t":
+					code = 9;
+					break;
+				case "r":
+					code = 13;
+					break;
+				case "'":
+					code = 39;
+					break;
+				case "\\":
+					code = 92;
+					break;
+				case "0":
+					code = 0;
+					break;
+				default:
+					throw new LexError(
+						`Unknown escape in rune literal: \\${esc}`,
+						l,
+						c,
+						this.filename,
+						this.src,
+					);
+			}
+		} else if (this.peek() !== "'") {
+			code = this.src.codePointAt(this.pos);
+			this.advance();
+		} else {
+			throw new LexError("Empty rune literal", l, c, this.filename, this.src);
+		}
+		if (this.peek() !== "'")
+			throw new LexError(
+				"Rune literal must contain exactly one character",
+				l,
+				c,
+				this.filename,
+				this.src,
+			);
+		this.advance(); // closing '
+		return String(code);
+	}
+
 	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 };
 	}
@@ -347,6 +493,10 @@ export class Lexer {
 				this.push(T.STRING, this.readRawString(), l, c);
 				continue;
 			}
+			if (ch === "'") {
+				this.push(T.INT, this.readRuneLiteral(), l, c);
+				continue;
+			}
 
 			// Numbers
 			if (/[0-9]/.test(ch)) {
@@ -396,25 +546,33 @@ export class Lexer {
 					else this.push(T.NOT, "!", l, c);
 					break;
 				case "<":
-					if (this.match("<")) this.push(T.LSHIFT, "<<", l, c);
-					else if (this.match("=")) this.push(T.LTE, "<=", l, c);
+					if (this.match("<")) {
+						if (this.match("=")) this.push(T.LSHIFT_ASSIGN, "<<=", l, c);
+						else this.push(T.LSHIFT, "<<", l, c);
+					} else if (this.match("=")) this.push(T.LTE, "<=", l, c);
 					else this.push(T.LT, "<", l, c);
 					break;
 				case ">":
-					if (this.match(">")) this.push(T.RSHIFT, ">>", l, c);
-					else if (this.match("=")) this.push(T.GTE, ">=", l, c);
+					if (this.match(">")) {
+						if (this.match("=")) this.push(T.RSHIFT_ASSIGN, ">>=", l, c);
+						else this.push(T.RSHIFT, ">>", l, c);
+					} else if (this.match("=")) this.push(T.GTE, ">=", l, c);
 					else this.push(T.GT, ">", l, c);
 					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;
 				case "|":
 					if (this.match("|")) this.push(T.OR, "||", l, c);
+					else if (this.match("=")) this.push(T.PIPE_ASSIGN, "|=", l, c);
 					else this.push(T.PIPE, "|", l, c);
 					break;
 				case "^":
-					this.push(T.CARET, "^", l, c);
+					if (this.match("=")) this.push(T.CARET_ASSIGN, "^=", l, c);
+					else this.push(T.CARET, "^", l, c);
 					break;
 				case ":":
 					if (this.match("=")) this.push(T.DEFINE, ":=", l, c);