gofront 0.0.6 → 0.0.7

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,603 +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),
-				Fprintf: {
-					kind: "func",
-					params: [ANY, STRING],
-					returns: [INT, ERROR],
-					variadic: true,
-				},
-				Fprintln: {
-					kind: "func",
-					params: [ANY],
-					returns: [INT, ERROR],
-					variadic: true,
-				},
-				Fprint: {
-					kind: "func",
-					params: [ANY],
-					returns: [INT, ERROR],
-					variadic: true,
-				},
-			},
-		});
-
-		// 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,
-			},
-		});
-
-		// slices package (Go 1.21)
-		// Functions are generic — use ANY for slice params so any concrete slice type
-		// is accepted without an assignability error (same pattern as sort.Slice).
-		this.globals.define("slices", {
-			kind: "namespace",
-			name: "slices",
-			members: {
-				Contains: { kind: "func", params: [ANY, ANY], returns: [BOOL] },
-				Index: { kind: "func", params: [ANY, ANY], returns: [INT] },
-				Equal: { kind: "func", params: [ANY, ANY], returns: [BOOL] },
-				Compare: { kind: "func", params: [ANY, ANY], returns: [INT] },
-				Sort: { kind: "func", params: [ANY], returns: [VOID] },
-				SortFunc: { kind: "func", params: [ANY, ANY], returns: [VOID] },
-				SortStableFunc: { kind: "func", params: [ANY, ANY], returns: [VOID] },
-				IsSorted: { kind: "func", params: [ANY], returns: [BOOL] },
-				IsSortedFunc: { kind: "func", params: [ANY, ANY], returns: [BOOL] },
-				Reverse: { kind: "func", params: [ANY], returns: [VOID] },
-				Max: { kind: "func", params: [ANY], returns: [ANY] },
-				Min: { kind: "func", params: [ANY], returns: [ANY] },
-				MaxFunc: { kind: "func", params: [ANY, ANY], returns: [ANY] },
-				MinFunc: { kind: "func", params: [ANY, ANY], returns: [ANY] },
-				Clone: { kind: "func", params: [ANY], returns: [ANY] },
-				Compact: { kind: "func", params: [ANY], returns: [ANY] },
-				CompactFunc: { kind: "func", params: [ANY, ANY], returns: [ANY] },
-				Concat: { kind: "func", params: [ANY], returns: [ANY], variadic: true },
-				Delete: { kind: "func", params: [ANY, INT, INT], returns: [ANY] },
-				DeleteFunc: { kind: "func", params: [ANY, ANY], returns: [ANY] },
-				Insert: {
-					kind: "func",
-					params: [ANY, INT, ANY],
-					returns: [ANY],
-					variadic: true,
-				},
-				Replace: {
-					kind: "func",
-					params: [ANY, INT, INT, ANY],
-					returns: [ANY],
-					variadic: true,
-				},
-				Grow: { kind: "func", params: [ANY, INT], returns: [ANY] },
-				Clip: { kind: "func", params: [ANY], returns: [ANY] },
-			},
-		});
-
-		// html package
-		this.globals.define("html", {
-			kind: "namespace",
-			name: "html",
-			members: {
-				EscapeString: { kind: "func", params: [STRING], returns: [STRING] },
-				UnescapeString: { kind: "func", params: [STRING], returns: [STRING] },
-			},
-		});
-
-		// maps package (Go 1.21)
-		this.globals.define("maps", {
-			kind: "namespace",
-			name: "maps",
-			members: {
-				Keys: { kind: "func", params: [ANY], returns: [ANY] },
-				Values: { kind: "func", params: [ANY], returns: [ANY] },
-				Clone: { kind: "func", params: [ANY], returns: [ANY] },
-				Copy: { kind: "func", params: [ANY, ANY], returns: [VOID] },
-				Equal: { kind: "func", params: [ANY, ANY], returns: [BOOL] },
-				EqualFunc: { kind: "func", params: [ANY, ANY, ANY], returns: [BOOL] },
-				Delete: { kind: "func", params: [ANY, ANY], returns: [VOID] },
-				DeleteFunc: { kind: "func", params: [ANY, ANY], returns: [VOID] },
-			},
-		});
-
-		// regexp package
-		const REGEXP_T = {
-			kind: "named",
-			name: "regexp.Regexp",
-			underlying: { kind: "struct", fields: new Map(), methods: new Map() },
-		};
-		const REGEXP_PTR = { kind: "pointer", base: REGEXP_T };
-		const STR_SLICE = { kind: "slice", elem: STRING };
-		const INT_SLICE = { kind: "slice", elem: INT };
-		const regexpMethods = new Map([
-			["MatchString", { kind: "func", params: [STRING], returns: [BOOL] }],
-			["FindString", { kind: "func", params: [STRING], returns: [STRING] }],
-			[
-				"FindStringIndex",
-				{ kind: "func", params: [STRING], returns: [INT_SLICE] },
-			],
-			[
-				"FindAllString",
-				{ kind: "func", params: [STRING, INT], returns: [STR_SLICE] },
-			],
-			[
-				"FindStringSubmatch",
-				{ kind: "func", params: [STRING], returns: [STR_SLICE] },
-			],
-			[
-				"FindAllStringSubmatch",
-				{
-					kind: "func",
-					params: [STRING, INT],
-					returns: [{ kind: "slice", elem: STR_SLICE }],
-				},
-			],
-			[
-				"ReplaceAllString",
-				{ kind: "func", params: [STRING, STRING], returns: [STRING] },
-			],
-			[
-				"ReplaceAllLiteralString",
-				{ kind: "func", params: [STRING, STRING], returns: [STRING] },
-			],
-			["Split", { kind: "func", params: [STRING, INT], returns: [STR_SLICE] }],
-			["String", { kind: "func", params: [], returns: [STRING] }],
-		]);
-		REGEXP_T.underlying.methods = regexpMethods;
-		this.types.set("regexp.Regexp", REGEXP_T);
-		this.globals.define("regexp", {
-			kind: "namespace",
-			name: "regexp",
-			members: {
-				MustCompile: { kind: "func", params: [STRING], returns: [REGEXP_PTR] },
-				Compile: {
-					kind: "func",
-					params: [STRING],
-					returns: [REGEXP_PTR, ERROR],
-				},
-				MatchString: {
-					kind: "func",
-					params: [STRING, STRING],
-					returns: [BOOL, ERROR],
-				},
-				QuoteMeta: { kind: "func", params: [STRING], returns: [STRING] },
-			},
-		});
-
-		// strings.Builder
-		const BYTE_SLICE_T = { kind: "slice", elem: INT };
-		const strBuilderMethods = new Map([
-			[
-				"WriteString",
-				{ kind: "func", params: [STRING], returns: [INT, ERROR] },
-			],
-			["WriteByte", { kind: "func", params: [INT], returns: [ERROR] }],
-			["WriteRune", { kind: "func", params: [INT], returns: [INT, ERROR] }],
-			[
-				"Write",
-				{ kind: "func", params: [BYTE_SLICE_T], returns: [INT, ERROR] },
-			],
-			["String", { kind: "func", params: [], returns: [STRING] }],
-			["Len", { kind: "func", params: [], returns: [INT] }],
-			["Reset", { kind: "func", params: [], returns: [VOID] }],
-			["Grow", { kind: "func", params: [INT], returns: [VOID] }],
-		]);
-		this.types.set("strings.Builder", {
-			kind: "named",
-			name: "strings.Builder",
-			underlying: {
-				kind: "struct",
-				fields: new Map(),
-				methods: strBuilderMethods,
-			},
-		});
-
-		// bytes.Buffer
-		const bytesBufferMethods = new Map([
-			[
-				"WriteString",
-				{ kind: "func", params: [STRING], returns: [INT, ERROR] },
-			],
-			["WriteByte", { kind: "func", params: [INT], returns: [ERROR] }],
-			[
-				"Write",
-				{ kind: "func", params: [BYTE_SLICE_T], returns: [INT, ERROR] },
-			],
-			["String", { kind: "func", params: [], returns: [STRING] }],
-			["Bytes", { kind: "func", params: [], returns: [BYTE_SLICE_T] }],
-			["Len", { kind: "func", params: [], returns: [INT] }],
-			["Reset", { kind: "func", params: [], returns: [VOID] }],
-			["Grow", { kind: "func", params: [INT], returns: [VOID] }],
-		]);
-		this.types.set("bytes.Buffer", {
-			kind: "named",
-			name: "bytes.Buffer",
-			underlying: {
-				kind: "struct",
-				fields: new Map(),
-				methods: bytesBufferMethods,
-			},
-		});
-
-		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) {
@@ -680,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.
@@ -884,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;
@@ -952,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
@@ -972,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);
 				}
 			}
 		}
@@ -1576,6 +989,10 @@ export class TypeChecker {
 		) {
 			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") {
@@ -1813,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