gofront 0.0.5 → 0.0.7

package/src/typechecker/types.js

@@ -101,13 +101,22 @@ export function isGeneric(t) {
 	return t?.kind === "generic";
 }
 
-export function isNumeric(t) {
-	if (!t) return false;
-	if (t.kind === "untyped") return t.base === "int" || t.base === "float64";
-	if (t.kind === "basic") return t.name === "int" || t.name === "float64";
-	if (t.kind === "named") return isNumeric(t.underlying);
-	return false;
+function makeBasicPredicate(...names) {
+	const set = new Set(names);
+	const pred = (t) => {
+		if (!t) return false;
+		if (t.kind === "untyped") return set.has(t.base);
+		if (t.kind === "basic") return set.has(t.name);
+		if (t.kind === "named") return pred(t.underlying);
+		return false;
+	};
+	return pred;
 }
+
+export const isNumeric = makeBasicPredicate("int", "float64");
+export const isString = makeBasicPredicate("string");
+export const isBool = makeBasicPredicate("bool");
+
 export function isComplex(t) {
 	if (!t) return false;
 	if (t.kind === "basic" && (t.name === "complex128" || t.name === "complex64"))
@@ -119,20 +128,6 @@ export function isComplex(t) {
 export function isComplexOrNumeric(t) {
 	return isNumeric(t) || isComplex(t);
 }
-export function isString(t) {
-	if (!t) return false;
-	if (t.kind === "untyped") return t.base === "string";
-	if (t.kind === "basic") return t.name === "string";
-	if (t.kind === "named") return isString(t.underlying);
-	return false;
-}
-export function isBool(t) {
-	if (!t) return false;
-	if (t.kind === "untyped") return t.base === "bool";
-	if (t.kind === "basic") return t.name === "bool";
-	if (t.kind === "named") return isBool(t.underlying);
-	return false;
-}
 export function isAny(t) {
 	return t?.kind === "basic" && t.name === "any";
 }

package/src/typechecker.js

@@ -3,11 +3,13 @@
 //
 // Split into sub-modules under typechecker/:
 //   types.js        — shared type constants, predicates, Scope
+//   stdlib.js       — browser globals + all built-in package registrations
 //   statements.js   — checkBlock, checkStmt
 //   expressions.js  — checkExpr, checkCall, checkBuiltin, checkCompositeLit
 
 import { expressionCheckMethods } from "./typechecker/expressions.js";
 import { statementCheckMethods } from "./typechecker/statements.js";
+import { setupGlobals } from "./typechecker/stdlib.js";
 import {
 	ANY,
 	BASIC_TYPES,
@@ -59,396 +61,7 @@ export class TypeChecker {
 	}
 
 	_setupGlobals() {
-		// Browser globals — typed as 'any' so any access/call is permitted
-		const browserGlobals = [
-			"console",
-			"document",
-			"window",
-			"navigator",
-			"location",
-			"history",
-			"screen",
-			"performance",
-			"crypto",
-			"indexedDB",
-			"fetch",
-			"setTimeout",
-			"setInterval",
-			"clearTimeout",
-			"clearInterval",
-			"requestAnimationFrame",
-			"cancelAnimationFrame",
-			"Math",
-			"JSON",
-			"Date",
-			"RegExp",
-			"Promise",
-			"Error",
-			"Symbol",
-			"String",
-			"Number",
-			"Boolean",
-			"Array",
-			"Object",
-			"parseInt",
-			"parseFloat",
-			"isNaN",
-			"isFinite",
-			"encodeURIComponent",
-			"decodeURIComponent",
-			"atob",
-			"btoa",
-			"alert",
-			"confirm",
-			"prompt",
-			"localStorage",
-			"sessionStorage",
-			"WebSocket",
-			"Worker",
-			"HTMLElement",
-			"Element",
-			"Event",
-			"CustomEvent",
-			"URL",
-			"URLSearchParams",
-			"FormData",
-			"Headers",
-			"Request",
-			"Response",
-			"Blob",
-			"File",
-			"FileReader",
-			"ArrayBuffer",
-			"Uint8Array",
-			"TextEncoder",
-			"TextDecoder",
-			"WebGLRenderingContext",
-			"WebGL2RenderingContext",
-			"GPUDevice",
-			"GPUAdapter",
-		];
-		for (const g of browserGlobals) this.globals.define(g, ANY);
-
-		// Built-in functions
-		// fmt package — string formatting (variadic: format string + any args)
-		const fmtVariadic = (ret) => ({
-			kind: "func",
-			params: [STRING, ANY],
-			returns: [ret],
-			variadic: true,
-		});
-		this.globals.define("fmt", {
-			kind: "namespace",
-			name: "fmt",
-			members: {
-				Sprintf: fmtVariadic(STRING),
-				Errorf: fmtVariadic(ERROR),
-				Printf: fmtVariadic(VOID),
-				Println: fmtVariadic(VOID),
-				Print: fmtVariadic(VOID),
-			},
-		});
-
-		// strings package
-		const strFn1 = (ret) => ({
-			kind: "func",
-			params: [STRING],
-			returns: [ret],
-		});
-		const strFn2 = (p2, ret) => ({
-			kind: "func",
-			params: [STRING, p2],
-			returns: [ret],
-		});
-		const strFn3 = (p2, p3, ret) => ({
-			kind: "func",
-			params: [STRING, p2, p3],
-			returns: [ret],
-		});
-		this.globals.define("strings", {
-			kind: "namespace",
-			name: "strings",
-			members: {
-				Contains: strFn2(STRING, BOOL),
-				HasPrefix: strFn2(STRING, BOOL),
-				HasSuffix: strFn2(STRING, BOOL),
-				Index: strFn2(STRING, INT),
-				LastIndex: strFn2(STRING, INT),
-				Count: strFn2(STRING, INT),
-				Repeat: strFn2(INT, STRING),
-				Replace: {
-					kind: "func",
-					params: [STRING, STRING, STRING, INT],
-					returns: [STRING],
-				},
-				ReplaceAll: strFn3(STRING, STRING, STRING),
-				ToUpper: strFn1(STRING),
-				ToLower: strFn1(STRING),
-				TrimSpace: strFn1(STRING),
-				Trim: strFn2(STRING, STRING),
-				TrimPrefix: strFn2(STRING, STRING),
-				TrimSuffix: strFn2(STRING, STRING),
-				TrimLeft: strFn2(STRING, STRING),
-				TrimRight: strFn2(STRING, STRING),
-				Split: strFn2(STRING, { kind: "slice", elem: STRING }),
-				Join: {
-					kind: "func",
-					params: [{ kind: "slice", elem: STRING }, STRING],
-					returns: [STRING],
-				},
-				EqualFold: strFn2(STRING, BOOL),
-			},
-		});
-
-		// bytes package — operates on []byte (JS arrays of numbers)
-		const BYTE_SLICE = { kind: "slice", elem: INT };
-		const byFn1 = (ret) => ({
-			kind: "func",
-			params: [BYTE_SLICE],
-			returns: [ret],
-		});
-		const byFn2 = (p2, ret) => ({
-			kind: "func",
-			params: [BYTE_SLICE, p2],
-			returns: [ret],
-		});
-		this.globals.define("bytes", {
-			kind: "namespace",
-			name: "bytes",
-			members: {
-				Contains: byFn2(BYTE_SLICE, BOOL),
-				HasPrefix: byFn2(BYTE_SLICE, BOOL),
-				HasSuffix: byFn2(BYTE_SLICE, BOOL),
-				Index: byFn2(BYTE_SLICE, INT),
-				Count: byFn2(BYTE_SLICE, INT),
-				Repeat: byFn2(INT, BYTE_SLICE),
-				Replace: {
-					kind: "func",
-					params: [BYTE_SLICE, BYTE_SLICE, BYTE_SLICE, INT],
-					returns: [BYTE_SLICE],
-				},
-				ToUpper: byFn1(BYTE_SLICE),
-				ToLower: byFn1(BYTE_SLICE),
-				TrimSpace: byFn1(BYTE_SLICE),
-				Trim: byFn2(STRING, BYTE_SLICE),
-				Equal: byFn2(BYTE_SLICE, BOOL),
-				Split: byFn2(BYTE_SLICE, { kind: "slice", elem: BYTE_SLICE }),
-				Join: {
-					kind: "func",
-					params: [{ kind: "slice", elem: BYTE_SLICE }, BYTE_SLICE],
-					returns: [BYTE_SLICE],
-				},
-			},
-		});
-
-		// strconv package
-		this.globals.define("strconv", {
-			kind: "namespace",
-			name: "strconv",
-			members: {
-				Itoa: { kind: "func", params: [INT], returns: [STRING] },
-				Atoi: {
-					kind: "func",
-					params: [STRING],
-					returns: [INT, ERROR],
-				},
-				FormatFloat: {
-					kind: "func",
-					params: [FLOAT64, INT, INT, INT],
-					returns: [STRING],
-				},
-				FormatBool: { kind: "func", params: [BOOL], returns: [STRING] },
-				FormatInt: { kind: "func", params: [INT, INT], returns: [STRING] },
-				ParseFloat: {
-					kind: "func",
-					params: [STRING, INT],
-					returns: [FLOAT64, ERROR],
-				},
-				ParseInt: {
-					kind: "func",
-					params: [STRING, INT, INT],
-					returns: [INT, ERROR],
-				},
-				ParseBool: {
-					kind: "func",
-					params: [STRING],
-					returns: [BOOL, ERROR],
-				},
-			},
-		});
-
-		// sort package
-		this.globals.define("sort", {
-			kind: "namespace",
-			name: "sort",
-			members: {
-				Ints: {
-					kind: "func",
-					params: [{ kind: "slice", elem: INT }],
-					returns: [VOID],
-				},
-				Float64s: {
-					kind: "func",
-					params: [{ kind: "slice", elem: FLOAT64 }],
-					returns: [VOID],
-				},
-				Strings: {
-					kind: "func",
-					params: [{ kind: "slice", elem: STRING }],
-					returns: [VOID],
-				},
-				Slice: {
-					kind: "func",
-					params: [ANY, ANY],
-					returns: [VOID],
-				},
-				SliceStable: {
-					kind: "func",
-					params: [ANY, ANY],
-					returns: [VOID],
-				},
-				SliceIsSorted: {
-					kind: "func",
-					params: [ANY, ANY],
-					returns: [BOOL],
-				},
-			},
-		});
-
-		// math package
-		this.globals.define("math", {
-			kind: "namespace",
-			name: "math",
-			members: {
-				Abs: { kind: "func", params: [FLOAT64], returns: [FLOAT64] },
-				Floor: { kind: "func", params: [FLOAT64], returns: [FLOAT64] },
-				Ceil: { kind: "func", params: [FLOAT64], returns: [FLOAT64] },
-				Round: { kind: "func", params: [FLOAT64], returns: [FLOAT64] },
-				Sqrt: { kind: "func", params: [FLOAT64], returns: [FLOAT64] },
-				Cbrt: { kind: "func", params: [FLOAT64], returns: [FLOAT64] },
-				Pow: {
-					kind: "func",
-					params: [FLOAT64, FLOAT64],
-					returns: [FLOAT64],
-				},
-				Log: { kind: "func", params: [FLOAT64], returns: [FLOAT64] },
-				Log2: { kind: "func", params: [FLOAT64], returns: [FLOAT64] },
-				Log10: { kind: "func", params: [FLOAT64], returns: [FLOAT64] },
-				Sin: { kind: "func", params: [FLOAT64], returns: [FLOAT64] },
-				Cos: { kind: "func", params: [FLOAT64], returns: [FLOAT64] },
-				Tan: { kind: "func", params: [FLOAT64], returns: [FLOAT64] },
-				Min: {
-					kind: "func",
-					params: [FLOAT64, FLOAT64],
-					returns: [FLOAT64],
-				},
-				Max: {
-					kind: "func",
-					params: [FLOAT64, FLOAT64],
-					returns: [FLOAT64],
-				},
-				Mod: {
-					kind: "func",
-					params: [FLOAT64, FLOAT64],
-					returns: [FLOAT64],
-				},
-				Inf: { kind: "func", params: [INT], returns: [FLOAT64] },
-				IsNaN: { kind: "func", params: [FLOAT64], returns: [BOOL] },
-				IsInf: {
-					kind: "func",
-					params: [FLOAT64, INT],
-					returns: [BOOL],
-				},
-				NaN: { kind: "func", params: [], returns: [FLOAT64] },
-				// Constants (typed as func with no params for namespace member access)
-				Pi: FLOAT64,
-				E: FLOAT64,
-				MaxFloat64: FLOAT64,
-				SmallestNonzeroFloat64: FLOAT64,
-				MaxInt: INT,
-				MinInt: INT,
-			},
-		});
-
-		// errors package
-		this.globals.define("errors", {
-			kind: "namespace",
-			name: "errors",
-			members: {
-				New: { kind: "func", params: [STRING], returns: [ERROR] },
-				Is: { kind: "func", params: [ERROR, ERROR], returns: [BOOL] },
-				Unwrap: { kind: "func", params: [ERROR], returns: [ERROR] },
-			},
-		});
-
-		// time package (partial — JS-friendly subset)
-		this.globals.define("time", {
-			kind: "namespace",
-			name: "time",
-			members: {
-				Now: { kind: "func", params: [], returns: [ANY] },
-				Since: { kind: "func", params: [ANY], returns: [ANY] },
-				Sleep: { kind: "func", params: [ANY], returns: [VOID], async: true },
-				Millisecond: INT,
-				Second: INT,
-				Minute: INT,
-				Hour: INT,
-			},
-		});
-
-		// unicode package
-		const runeToStr = { kind: "func", params: [INT], returns: [BOOL] };
-		const runeTrans = { kind: "func", params: [INT], returns: [INT] };
-		this.globals.define("unicode", {
-			kind: "namespace",
-			name: "unicode",
-			members: {
-				IsLetter: runeToStr,
-				IsDigit: runeToStr,
-				IsSpace: runeToStr,
-				IsUpper: runeToStr,
-				IsLower: runeToStr,
-				IsPunct: runeToStr,
-				IsControl: runeToStr,
-				IsPrint: runeToStr,
-				IsGraphic: runeToStr,
-				ToUpper: runeTrans,
-				ToLower: runeTrans,
-			},
-		});
-
-		// os package (JS-friendly subset)
-		this.globals.define("os", {
-			kind: "namespace",
-			name: "os",
-			members: {
-				Exit: { kind: "func", params: [INT], returns: [VOID] },
-				Args: { kind: "slice", elem: STRING },
-				Getenv: { kind: "func", params: [STRING], returns: [STRING] },
-				Stdout: ANY,
-				Stderr: ANY,
-				Stdin: ANY,
-			},
-		});
-
-		this.globals.define("append", { kind: "builtin", name: "append" });
-		this.globals.define("len", { kind: "builtin", name: "len" });
-		this.globals.define("cap", { kind: "builtin", name: "cap" });
-		this.globals.define("make", { kind: "builtin", name: "make" });
-		this.globals.define("delete", { kind: "builtin", name: "delete" });
-		this.globals.define("print", { kind: "builtin", name: "print" });
-		this.globals.define("println", { kind: "builtin", name: "println" });
-		this.globals.define("panic", { kind: "builtin", name: "panic" });
-		this.globals.define("recover", { kind: "builtin", name: "recover" });
-		this.globals.define("new", { kind: "builtin", name: "new" });
-		this.globals.define("copy", { kind: "builtin", name: "copy" });
-		this.globals.define("error", { kind: "builtin", name: "error" });
-		this.globals.define("min", { kind: "builtin", name: "min" });
-		this.globals.define("max", { kind: "builtin", name: "max" });
-		this.globals.define("clear", { kind: "builtin", name: "clear" });
-		this.globals.define("complex", { kind: "builtin", name: "complex" });
-		this.globals.define("real", { kind: "builtin", name: "real" });
-		this.globals.define("imag", { kind: "builtin", name: "imag" });
+		setupGlobals(this.globals, this.types);
 	}
 
 	addDefinitions(types, values) {
@@ -473,7 +86,10 @@ export class TypeChecker {
 			members,
 			_gofront: true,
 		});
-		for (const [name, type] of types) this.types.set(name, type);
+		for (const [name, type] of types) {
+			this.types.set(name, type);
+			this.types.set(`${pkgName}.${name}`, type);
+		}
 	}
 
 	// Register an import for unused-import detection.
@@ -677,6 +293,8 @@ export class TypeChecker {
 		if (underlying.kind === "struct") {
 			underlying.name = decl.name;
 			underlying.methods = new Map();
+		} else if (underlying.kind !== "interface") {
+			named.methods = new Map();
 		}
 		if (underlying.kind === "interface") {
 			underlying.name = decl.name;
@@ -745,7 +363,7 @@ export class TypeChecker {
 				this.globals.define(decl.name, funcType);
 			}
 		} else {
-			// Method: attach to struct type
+			// Method: attach to struct or named non-struct type
 			const recvTypeName =
 				decl.recvType.kind === "GenericTypeName"
 					? decl.recvType.name
@@ -765,6 +383,8 @@ export class TypeChecker {
 				const base = recvType?.underlying ?? recvType;
 				if (base?.kind === "struct") {
 					base.methods.set(decl.name, funcType);
+				} else if (recvType?.kind === "named" && recvType.methods) {
+					recvType.methods.set(decl.name, funcType);
 				}
 			}
 		}
@@ -1360,6 +980,19 @@ export class TypeChecker {
 	fieldType(baseType, field, node) {
 		baseType = this.resolveType(baseType);
 		if (!baseType || isAny(baseType)) return ANY;
+		// Transparent pointer dereference for named-type method calls: (*T).Method works like T.Method
+		// (only unwrap when the pointer's base is a named type that has methods)
+		if (
+			baseType.kind === "pointer" &&
+			field !== "value" &&
+			baseType.base?.kind === "named"
+		) {
+			baseType = this.resolveType(baseType.base);
+		}
+		// Check methods on named type itself (for non-struct named types)
+		if (baseType.kind === "named" && baseType.methods?.has(field)) {
+			return baseType.methods.get(field);
+		}
 		let base = baseType.kind === "named" ? baseType.underlying : baseType;
 		base = this.resolveType(base);
 		if (base?.kind === "struct") {
@@ -1597,9 +1230,16 @@ export class TypeChecker {
 	implements(srcType, iface, _node) {
 		let base = srcType.kind === "named" ? srcType.underlying : srcType;
 		base = this.resolveType(base);
-		if (base?.kind !== "struct") return false;
+		// For non-struct named types, methods live on the named type itself
+		const methodMap =
+			base?.kind === "struct"
+				? base.methods
+				: srcType.kind === "named"
+					? srcType.methods
+					: null;
+		if (!methodMap) return false;
 		for (const [name, required] of iface.methods) {
-			const actual = base.methods?.get(name);
+			const actual = methodMap.get(name);
 			if (!actual) return false;
 
 			// Check parameter count matches