gofront 1.6.1 → 1.8.0

package/src/typechecker/types.js

@@ -102,7 +102,7 @@ export const BROWSER_GLOBALS = new Set([
 	"TextDecoder",
 ]);
 
-// Stdlib packages the WASM backend can emit. Extend as src/backend/wasm/emit-stdlib.js
+// Stdlib packages the WASM backend can emit. Extend as src/backend/wasm/stdlib/
 // gains support; anything not listed is rejected at import with "not yet available in
 // wasm packages".
 export const WASM_SUPPORTED_STDLIB = new Set([
@@ -126,17 +126,19 @@ export const WASM_SUPPORTED_STDLIB = new Set([
 	"time",
 	"testing",
 	"gofront/shared",
+	"gofront/simd",
 	"sync",
 	"crypto/rand",
 	"crypto/sha256",
 	"encoding/binary",
 	"encoding/hex",
 	"encoding/base64",
+	"os",
+	"encoding/json",
 ]);
 
 export const STDLIB_PACKAGES = new Set([
 	...WASM_SUPPORTED_STDLIB,
-	"os",
 	"gom",
 	"regexp",
 ]);
@@ -145,6 +147,7 @@ export const STDLIB_PACKAGES = new Set([
 // member the checker knows about. Members outside the set are rejected in
 // wasm/both packages with "'strings.Split' is not yet available in wasm packages".
 export const WASM_STDLIB_MEMBERS = new Map([
+	["os", new Set(["Stdout", "Stderr", "Stdin", "File"])],
 	[
 		"math",
 		new Set([
@@ -176,8 +179,10 @@ export const WASM_STDLIB_MEMBERS = new Map([
 			"Exp",
 			"Exp2",
 			"Log",
+			"Log1p",
 			"Log2",
 			"Log10",
+			"Expm1",
 			"Round",
 			"Remainder",
 			"Float64bits",
@@ -223,21 +228,56 @@ export const WASM_STDLIB_MEMBERS = new Map([
 	[
 		"bits",
 		new Set([
+			"Add",
+			"Add32",
+			"Add64",
+			"Sub",
+			"Sub32",
+			"Sub64",
+			"Mul",
+			"Mul32",
+			"Mul64",
+			"Div",
+			"Div32",
+			"Div64",
+			"Rem",
+			"Rem32",
+			"Rem64",
+			"LeadingZeros",
+			"LeadingZeros8",
+			"LeadingZeros16",
 			"LeadingZeros32",
 			"LeadingZeros64",
+			"TrailingZeros",
+			"TrailingZeros8",
+			"TrailingZeros16",
 			"TrailingZeros32",
 			"TrailingZeros64",
+			"OnesCount",
+			"OnesCount8",
+			"OnesCount16",
 			"OnesCount32",
 			"OnesCount64",
+			"RotateLeft",
+			"RotateLeft8",
+			"RotateLeft16",
 			"RotateLeft32",
 			"RotateLeft64",
+			"Reverse",
+			"Reverse8",
+			"Reverse16",
+			"Reverse32",
+			"Reverse64",
+			"ReverseBytes",
 			"ReverseBytes16",
 			"ReverseBytes32",
 			"ReverseBytes64",
+			"Len",
+			"Len8",
+			"Len16",
 			"Len32",
 			"Len64",
-			"Reverse32",
-			"Reverse64",
+			"UintSize",
 		]),
 	],
 	["errors", new Set(["New", "Is", "Unwrap", "As", "Join"])],
@@ -254,6 +294,15 @@ export const WASM_STDLIB_MEMBERS = new Map([
 			"RuneError",
 			"MaxRune",
 			"UTFMax",
+			"RuneSelf",
+			"EncodeRune",
+			"AppendRune",
+			"DecodeRune",
+			"DecodeLastRune",
+			"RuneCount",
+			"FullRune",
+			"Valid",
+			"RuneStart",
 		]),
 	],
 	[
@@ -275,6 +324,11 @@ export const WASM_STDLIB_MEMBERS = new Map([
 		"fmt",
 		new Set([
 			"Sprintf",
+			"Sprint",
+			"Sprintln",
+			"Append",
+			"Appendf",
+			"Appendln",
 			"Errorf",
 			"Printf",
 			"Println",
@@ -285,6 +339,7 @@ export const WASM_STDLIB_MEMBERS = new Map([
 			"Sscan",
 			"Sscanln",
 			"Sscanf",
+			"Stringer",
 		]),
 	],
 	[
@@ -334,9 +389,11 @@ export const WASM_STDLIB_MEMBERS = new Map([
 			"TrimRightFunc",
 			"FieldsFunc",
 			"NewReplacer",
+			"Replacer",
 			"Builder",
 			"NewReader",
 			"Reader",
+			"ToValidUTF8",
 		]),
 	],
 	[
@@ -360,6 +417,20 @@ export const WASM_STDLIB_MEMBERS = new Map([
 			"AppendBool",
 			"ErrSyntax",
 			"ErrRange",
+			"IntSize",
+			"NumError",
+			"QuoteRune",
+			"QuoteToASCII",
+			"QuoteRuneToASCII",
+			"AppendQuote",
+			"AppendQuoteToASCII",
+			"AppendQuoteRune",
+			"AppendQuoteRuneToASCII",
+			"CanBackquote",
+			"UnquoteChar",
+			"QuotedPrefix",
+			"IsPrint",
+			"IsGraphic",
 		]),
 	],
 	[
@@ -397,16 +468,7 @@ export const WASM_STDLIB_MEMBERS = new Map([
 	],
 	[
 		"maps",
-		new Set([
-			"Keys",
-			"Values",
-			"Clone",
-			"Copy",
-			"Equal",
-			"EqualFunc",
-			"Delete",
-			"DeleteFunc",
-		]),
+		new Set(["Clone", "Copy", "Equal", "EqualFunc", "Delete", "DeleteFunc"]),
 	],
 	[
 		"unicode",
@@ -478,8 +540,11 @@ export const WASM_STDLIB_MEMBERS = new Map([
 			"Map",
 			"SplitN",
 			"Buffer",
+			"NewBuffer",
+			"NewBufferString",
 			"NewReader",
 			"Reader",
+			"ToValidUTF8",
 		]),
 	],
 	[
@@ -519,9 +584,6 @@ export const WASM_STDLIB_MEMBERS = new Map([
 			"ReadWriter",
 			"Closer",
 			"EOF",
-			"ErrUnexpectedEOF",
-			"ErrShortWrite",
-			"ReadFull",
 			"ReadAll",
 			"Discard",
 			"WriteString",
@@ -536,10 +598,12 @@ export const WASM_STDLIB_MEMBERS = new Map([
 			"Now",
 			"Since",
 			"Parse",
+			"ParseDuration",
 			"Unix",
 			"UnixMicro",
 			"UnixMilli",
 			"Date",
+			"FixedZone",
 			"Duration",
 			"Nanosecond",
 			"Microsecond",
@@ -574,9 +638,12 @@ export const WASM_STDLIB_MEMBERS = new Map([
 			"Friday",
 			"Saturday",
 			"Time",
+			"Month",
+			"Weekday",
+			"Location",
 		]),
 	],
-	["testing", new Set(["T"])],
+	["testing", new Set(["T", "B", "M", "TB", "BenchmarkResult"])],
 	["sync", new Set(["Mutex", "RWMutex", "Once", "WaitGroup", "Locker"])],
 	["sha256", new Set(["Sum256", "New", "Size", "BlockSize"])],
 	[
@@ -622,6 +689,11 @@ export const WASM_STDLIB_MEMBERS = new Map([
 
 export const VALID_TARGETS = new Set(["js", "wasm", "both"]);
 
+// Backend-provided implementations for body-less Go-source stdlib functions
+// marked `//gofront:intrinsic <name>`: name -> required signature.  New
+// intrinsics need a plan change.
+export const INTRINSICS = new Map([]);
+
 // ── Static operator sets (module-level for reuse) ────────────
 export const CMP_OPS = new Set(["==", "!=", "<", ">", "<=", ">="]);
 export const LOG_OPS = new Set(["&&", "||"]);
@@ -666,7 +738,7 @@ export const UNTYPED_BOOL = { kind: "untyped", base: "bool" };
 
 // ── Complex types ────────────────────────────────────────────
 export const COMPLEX128 = { kind: "basic", name: "complex128" };
-const COMPLEX64 = { kind: "basic", name: "complex64" };
+export const COMPLEX64 = { kind: "basic", name: "complex64" };
 export const UNTYPED_COMPLEX = { kind: "untyped", base: "complex128" };
 
 export const BASIC_TYPES = {
@@ -747,6 +819,32 @@ const TYPED_ARRAY_CONSTRUCTORS = {
 	rune: "Int32Array",
 };
 
+// Element indices of an array or slice literal (Go spec): `i: v` puts v at
+// index i, any other element goes right after the previous one, so
+// `[5]int{1, 3: 4, 5}` fills indices 0, 3 and 4.  Array literal keys are
+// resolved by the type checker (`_index`, which handles named constants and
+// constant expressions); otherwise only integer-literal keys are known and
+// another key is treated as a positional element.
+export function compositeLitIndices(elems) {
+	const out = [];
+	let next = 0;
+	for (const e of elems) {
+		if (e.kind === "KeyValueExpr" && e._index !== undefined) next = e._index;
+		else if (e.kind === "KeyValueExpr" && e.key?.value !== undefined)
+			next = Number(e.key.value);
+		out.push(next++);
+	}
+	return out;
+}
+
+// Highest element index of an array or slice literal (-1 when empty).  A
+// loop, not `Math.max(...)`: spreading a huge literal overflows the stack.
+export function compositeLitMaxIndex(elems) {
+	let max = -1;
+	for (const i of compositeLitIndices(elems)) if (i > max) max = i;
+	return max;
+}
+
 export function typedArrayConstructorForElem(elemType) {
 	if (!elemType) return null;
 	const name = elemType.kind === "basic" ? elemType.name : null;
@@ -762,12 +860,28 @@ export function isTypedArraySlice(type) {
 
 export function isComplex(t) {
 	if (!t) return false;
-	if (t.kind === "basic" && (t.name === "complex128" || t.name === "complex64"))
+	if (
+		(t.kind === "basic" || t.kind === "TypeName" || t.kind === "Ident") &&
+		(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 isComplex64(t) {
+	if (!t) return false;
+	if (
+		(t.kind === "basic" || t.kind === "TypeName" || t.kind === "Ident") &&
+		t.name === "complex64"
+	)
+		return true;
+	if (t.kind === "untyped" && t.base === "complex64") return true;
+	if (t.kind === "named") return isComplex64(t.underlying);
+	if (t.name === "complex64") return true;
+	if (t.underlying) return isComplex64(t.underlying);
+	return false;
+}
 export function isComplexOrNumeric(t) {
 	return isNumeric(t) || isComplex(t);
 }
@@ -839,14 +953,21 @@ export function typeStr(t) {
 			return t.name || "interface{...}";
 		case "namespace":
 			return t.name || "namespace{...}";
-		case "func":
-			return `func(${t.params.map(typeStr).join(", ")}) ${typeStr(t.returns[0] ?? VOID)}`;
+		case "func": {
+			const retStr =
+				t.returns.length > 1
+					? `(${t.returns.map(typeStr).join(", ")})`
+					: typeStr(t.returns[0] ?? VOID);
+			return `func(${t.params.map(typeStr).join(", ")}) ${retStr}`;
+		}
 		case "tuple":
 			return `(${t.types.map(typeStr).join(", ")})`;
-		case "named":
+		case "named": {
+			const name = displayTypeName(t.name);
 			return t.typeArgs && t.typeArgs.length > 0
-				? `${t.name}[${t.typeArgs.map(typeStr).join(", ")}]`
-				: t.name;
+				? `${name}[${t.typeArgs.map(typeStr).join(", ")}]`
+				: name;
+		}
 		case "pointer":
 			return `*${typeStr(t.base)}`;
 		case "typeParam":
@@ -858,6 +979,17 @@ export function typeStr(t) {
 	}
 }
 
+// Go-source stdlib names are mangled to `Name$$path` (`List$$container$list`);
+// diagnostics show them qualified, as Go does (`list.List`).
+export function displayTypeName(name) {
+	const i = typeof name === "string" ? name.indexOf("$$") : -1;
+	if (i < 0) return name;
+	return `${name
+		.slice(i + 2)
+		.split("$")
+		.at(-1)}.${name.slice(0, i)}`;
+}
+
 // ── Iterator function detection (Go 1.23 range-over-func) ───
 
 /**
@@ -887,6 +1019,7 @@ export class Scope {
 		this.parent = parent;
 		this.symbols = new Map();
 		this._consts = new Set(); // names declared as const in this scope
+		this._constExprs = new Map(); // name -> AST initializer expr
 		this._locals = new Set(); // names declared as local variables (var / :=)
 		this._used = new Set(); // names referenced in this scope
 	}
@@ -897,9 +1030,15 @@ export class Scope {
 		this.symbols.set(name, type);
 		if (name !== "_") this._locals.add(name);
 	}
-	defineConst(name, type) {
+	defineConst(name, type, expr = null) {
 		this.symbols.set(name, type);
 		this._consts.add(name);
+		if (expr) this._constExprs.set(name, expr);
+	}
+	lookupConstExpr(name) {
+		if (this._constExprs.has(name)) return this._constExprs.get(name);
+		if (this.parent) return this.parent.lookupConstExpr(name);
+		return null;
 	}
 	isConst(name) {
 		if (this._consts.has(name)) return true;

package/stdlib/bytes/iter.go

@@ -0,0 +1,192 @@
+//go:build gofront
+
+//gofront:target both
+
+// Overlay on the emitter-backed bytes package: the sequence members of
+// Go 1.24 are written in Go over iter.Seq and merged into the bytes
+// namespace.  Like Go's, the slices they yield alias the input and have their
+// capacity clipped, so appending to one does not write into the original.
+package bytes
+
+import (
+	"iter"
+	"unicode"
+)
+
+const (
+	runeError = 0xFFFD
+	runeSelf  = 0x80
+)
+
+// decodeRune unpacks the first UTF-8 encoding in p and returns the rune and
+// its width in bytes, as utf8.DecodeRune does: an invalid or incomplete
+// encoding is (RuneError, 1) and p must not be empty.
+func decodeRune(p []byte) (rune, int) {
+	b0 := int(p[0])
+	if b0 < runeSelf {
+		return rune(b0), 1
+	}
+	n, lo, mask := 0, 0, 0
+	if b0 >= 0xC2 && b0 <= 0xDF {
+		n, lo, mask = 2, 0x80, 0x1F
+	} else if b0 >= 0xE0 && b0 <= 0xEF {
+		n, lo, mask = 3, 0x800, 0x0F
+	} else if b0 >= 0xF0 && b0 <= 0xF4 {
+		n, lo, mask = 4, 0x10000, 0x07
+	} else {
+		return runeError, 1
+	}
+	if len(p) < n {
+		return runeError, 1
+	}
+	r := b0 & mask
+	for i := 1; i < n; i++ {
+		b := int(p[i])
+		if b&0xC0 != 0x80 {
+			return runeError, 1
+		}
+		r = r<<6 | b&0x3F
+	}
+	if r < lo || r > 0x10FFFF || (r >= 0xD800 && r <= 0xDFFF) {
+		return runeError, 1
+	}
+	return rune(r), n
+}
+
+// index returns the byte offset of the first instance of sep in s, or -1.
+// It compares bytes: the emitter's bytes.Index goes through a decoded JS
+// string on the JS backend and so counts characters, not bytes, once s holds
+// multi-byte text.  sep must not be empty.
+func index(s, sep []byte) int {
+	first := sep[0]
+	for i := 0; i+len(sep) <= len(s); i++ {
+		if s[i] != first {
+			continue
+		}
+		j := 1
+		for j < len(sep) && s[i+j] == sep[j] {
+			j++
+		}
+		if j == len(sep) {
+			return i
+		}
+	}
+	return -1
+}
+
+// isSpace is unicode.IsSpace as a func(rune) bool (the checker types the
+// unicode predicates over int).
+func isSpace(r rune) bool {
+	return unicode.IsSpace(int(r))
+}
+
+// Lines returns an iterator over the newline-terminated lines in the byte slice s.
+// The lines yielded by the iterator include their terminating newlines.
+// If s is empty, the iterator yields no lines at all.
+// If s does not end in a newline, the final yielded line will not end in a newline.
+// The iterator yields slices of the original slice s.
+func Lines(s []byte) iter.Seq[[]byte] {
+	return func(yield func([]byte) bool) {
+		for len(s) > 0 {
+			var line []byte
+			if i := IndexByte(s, '\n'); i >= 0 {
+				line, s = s[:i+1:i+1], s[i+1:]
+			} else {
+				line, s = s[:len(s):len(s)], nil
+			}
+			if !yield(line) {
+				return
+			}
+		}
+	}
+}
+
+// explodeSeq returns an iterator over the UTF-8 encodings of the runes in s.
+func explodeSeq(s []byte) iter.Seq[[]byte] {
+	return func(yield func([]byte) bool) {
+		for len(s) > 0 {
+			_, size := decodeRune(s)
+			if !yield(s[:size:size]) {
+				return
+			}
+			s = s[size:]
+		}
+	}
+}
+
+// splitSeq is SplitSeq or SplitAfterSeq, configured by how many
+// bytes of sep to include in the results (none or all).
+func splitSeq(s, sep []byte, sepSave int) iter.Seq[[]byte] {
+	if len(sep) == 0 {
+		return explodeSeq(s)
+	}
+	return func(yield func([]byte) bool) {
+		for {
+			i := index(s, sep)
+			if i < 0 {
+				break
+			}
+			frag := s[:i+sepSave]
+			if !yield(frag[:len(frag):len(frag)]) {
+				return
+			}
+			s = s[i+len(sep):]
+		}
+		yield(s[:len(s):len(s)])
+	}
+}
+
+// SplitSeq returns an iterator over subslices of s split around sep.
+// The iterator yields the same subslices that would be returned by Split(s, sep),
+// but without constructing the slice.
+// It returns a single-use iterator.
+func SplitSeq(s, sep []byte) iter.Seq[[]byte] {
+	return splitSeq(s, sep, 0)
+}
+
+// SplitAfterSeq returns an iterator over subslices of s split after each instance of sep.
+// The iterator yields the same subslices that would be returned by SplitAfter(s, sep),
+// but without constructing the slice.
+// It returns a single-use iterator.
+func SplitAfterSeq(s, sep []byte) iter.Seq[[]byte] {
+	return splitSeq(s, sep, len(sep))
+}
+
+// FieldsSeq returns an iterator over subslices of s split around runs of
+// whitespace characters, as defined by unicode.IsSpace.
+// The iterator yields the same subslices that would be returned by Fields(s),
+// but without constructing the slice.
+func FieldsSeq(s []byte) iter.Seq[[]byte] {
+	return FieldsFuncSeq(s, isSpace)
+}
+
+// FieldsFuncSeq returns an iterator over subslices of s split around runs of
+// Unicode code points satisfying f(c).
+// The iterator yields the same subslices that would be returned by FieldsFunc(s),
+// but without constructing the slice.
+func FieldsFuncSeq(s []byte, f func(rune) bool) iter.Seq[[]byte] {
+	return func(yield func([]byte) bool) {
+		start := -1
+		for i := 0; i < len(s); {
+			size := 1
+			r := rune(s[i])
+			if r >= runeSelf {
+				r, size = decodeRune(s[i:])
+			}
+			if f(r) {
+				if start >= 0 {
+					if !yield(s[start:i:i]) {
+						return
+					}
+					start = -1
+				}
+			} else if start < 0 {
+				start = i
+			}
+			i += size
+		}
+		if start >= 0 {
+			yield(s[start:len(s):len(s)])
+		}
+	}
+}