gofront 0.0.3 → 0.0.5

package/src/typechecker/types.js

@@ -47,7 +47,13 @@ export const BOOL = { kind: "basic", name: "bool" };
 export const ANY = { kind: "basic", name: "any" };
 export const VOID = { kind: "basic", name: "void" };
 export const NIL = { kind: "basic", name: "nil" };
-export const ERROR = { kind: "basic", name: "error" };
+export const ERROR = {
+	kind: "interface",
+	name: "error",
+	methods: new Map([
+		["Error", { kind: "func", params: [], returns: [STRING], async: false }],
+	]),
+};
 
 // ── Untyped constant types (Go spec §Constants) ─────────────
 // Untyped constants coerce to any compatible typed context.
@@ -56,6 +62,11 @@ export const UNTYPED_FLOAT = { kind: "untyped", base: "float64" };
 export const UNTYPED_STRING = { kind: "untyped", base: "string" };
 export const UNTYPED_BOOL = { kind: "untyped", base: "bool" };
 
+// ── Complex types ────────────────────────────────────────────
+export const COMPLEX128 = { kind: "basic", name: "complex128" };
+export const COMPLEX64 = { kind: "basic", name: "complex64" };
+export const UNTYPED_COMPLEX = { kind: "untyped", base: "complex128" };
+
 export const BASIC_TYPES = {
 	int: INT,
 	float64: FLOAT64,
@@ -64,7 +75,6 @@ export const BASIC_TYPES = {
 	any: ANY,
 	byte: INT,
 	rune: INT,
-	error: ERROR,
 	// Sized integer / float aliases — all map to int or float64 at runtime
 	uint: INT,
 	int8: INT,
@@ -77,19 +87,51 @@ export const BASIC_TYPES = {
 	uint64: INT,
 	uintptr: INT,
 	float32: FLOAT64,
+	complex64: COMPLEX64,
+	complex128: COMPLEX128,
 };
 
+export const COMPARABLE = { kind: "basic", name: "comparable" };
+
+export function isTypeParam(t) {
+	return t?.kind === "typeParam";
+}
+
+export function isGeneric(t) {
+	return t?.kind === "generic";
+}
+
 export function isNumeric(t) {
-	if (t?.kind === "untyped") return t.base === "int" || t.base === "float64";
-	return t?.kind === "basic" && (t.name === "int" || t.name === "float64");
+	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;
+}
+export function isComplex(t) {
+	if (!t) return false;
+	if (t.kind === "basic" && (t.name === "complex128" || t.name === "complex64"))
+		return true;
+	if (t.kind === "untyped" && t.base === "complex128") return true;
+	if (t.kind === "named") return isComplex(t.underlying);
+	return false;
+}
+export function isComplexOrNumeric(t) {
+	return isNumeric(t) || isComplex(t);
 }
 export function isString(t) {
-	if (t?.kind === "untyped") return t.base === "string";
-	return t?.kind === "basic" && t.name === "string";
+	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?.kind === "untyped") return t.base === "bool";
-	return t?.kind === "basic" && t.name === "bool";
+	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";
@@ -101,7 +143,23 @@ export function isVoid(t) {
 	return t?.kind === "basic" && t.name === "void";
 }
 export function isError(t) {
-	return t?.kind === "basic" && t.name === "error";
+	if (!t) return false;
+	if (t === ERROR) return true;
+	if (t.kind === "interface" && t.name === "error") return true;
+	if (t.kind === "named" && isError(t.underlying)) return true;
+	return false;
+}
+export function isPointer(t) {
+	if (!t) return false;
+	if (t.kind === "pointer") return true;
+	if (t.kind === "named") return t.underlying?.kind === "pointer";
+	return false;
+}
+export function isArray(t) {
+	if (!t) return false;
+	if (t.kind === "array") return true;
+	if (t.kind === "named") return t.underlying?.kind === "array";
+	return false;
 }
 export function isUntyped(t) {
 	return t?.kind === "untyped";
@@ -119,29 +177,13 @@ export function defaultType(t) {
 			return STRING;
 		case "bool":
 			return BOOL;
+		case "complex128":
+			return COMPLEX128;
 		default:
 			return ANY;
 	}
 }
 
-/** Convert a concrete basic type to its untyped equivalent (for const inference). */
-export function toUntyped(t) {
-	if (t?.kind === "untyped") return t;
-	if (t?.kind === "basic") {
-		switch (t.name) {
-			case "int":
-				return UNTYPED_INT;
-			case "float64":
-				return UNTYPED_FLOAT;
-			case "string":
-				return UNTYPED_STRING;
-			case "bool":
-				return UNTYPED_BOOL;
-		}
-	}
-	return t;
-}
-
 export function typeStr(t) {
 	if (!t) return "void";
 	if (t.kind === "basic" && t.alias) return t.alias;
@@ -153,7 +195,7 @@ export function typeStr(t) {
 		case "slice":
 			return `[]${typeStr(t.elem)}`;
 		case "array":
-			return `[${t.size}]${typeStr(t.elem)}`;
+			return `[${t.size ?? "..."}]${typeStr(t.elem)}`;
 		case "map":
 			return `map[${typeStr(t.key)}]${typeStr(t.value)}`;
 		case "struct":
@@ -170,11 +212,37 @@ export function typeStr(t) {
 			return t.name;
 		case "pointer":
 			return `*${typeStr(t.base)}`;
+		case "typeParam":
+			return t.name;
+		case "generic":
+			return t.name || `generic(${typeStr(t.underlying)})`;
 		default:
 			return "?";
 	}
 }
 
+// ── Iterator function detection (Go 1.23 range-over-func) ───
+
+/**
+ * Returns null if t is not an iterator function.
+ * Returns { yieldParams: Type[] } if it is, where yieldParams are the
+ * types the range variables will be bound to (0, 1, or 2 elements).
+ *
+ * An iterator is func(yield func(...) bool) — single param that is a
+ * func returning bool with 0-2 params.
+ */
+export function iteratorYieldParams(t) {
+	const fn = t?.kind === "named" ? t.underlying : t;
+	if (fn?.kind !== "func") return null;
+	if (fn.params.length !== 1) return null;
+	const yieldFn =
+		fn.params[0]?.kind === "named" ? fn.params[0].underlying : fn.params[0];
+	if (yieldFn?.kind !== "func") return null;
+	if (yieldFn.returns.length !== 1 || !isBool(yieldFn.returns[0])) return null;
+	if (yieldFn.params.length > 2) return null;
+	return { yieldParams: yieldFn.params };
+}
+
 // ── Scope / environment ──────────────────────────────────────
 
 export class Scope {