gofront 1.8.0 → 1.9.1

package/src/backend/shared/fixed-float.js

@@ -0,0 +1,20 @@
+// The host half of strconv's fixed-point float formatting: a JS function,
+// as source text, that both backends embed (src/backend/js/natives.js and the
+// WASM host imports in src/backend/wasm/boundary.js).
+//
+// `toFixed` is exact except that it rounds a tie (a value whose decimal
+// expansion ends in a 5 right after the digits kept) up, where Go rounds it
+// to even; the extra digits of a second call tell the two apart. A tie is a
+// multiple of 2^-(p+1), so any other value needs no second call. "" declines.
+export const FIXED_FLOAT_JS = `(x, p) => {
+  if (!(x < 1e21)) return "";
+  const s = x.toFixed(p);
+  if (x % 1 === 0 || (x * 2 ** (p + 1)) % 1 !== 0) return s;
+  const t = x.toFixed(p + 30);
+  const dot = t.indexOf(".");
+  if (/^50*$/.test(t.slice(dot + 1 + p))) {
+    const down = t.slice(0, p === 0 ? dot : dot + 1 + p);
+    return (down.charCodeAt(down.length - 1) - 48) % 2 === 0 ? down : s;
+  }
+  return s;
+}`;

package/src/backend/shared/fmt-types.js

@@ -1,188 +1,109 @@
-// Static type descriptors for `fmt` (Task 3.1c), shared by the JS and WASM
-// backends.  `%T` and `%#v` need the Go type of an operand, which the runtime
-// values do not carry (an `int` and a `float64` holding 3 are both the number
-// 3, a `Color` is a raw number inside a slice).  Where a format string is a
-// literal that needs them (`fmtWantsTypes`), codegen passes the operand's
-// static type next to its value as a plain JSON-compatible tree, which
-// `__sprintf` reads (`__ft` on JS, `fmt_arg_type` on WASM).
-//
-// Descriptor shapes (`k`): `b` basic `{ n }`, `named` `{ n, u }` (a named
-// non-struct type, `u` its underlying type), `struct` `{ n, f: [[name, T]] }`
-// (`n` is "" for an anonymous struct), `ptr` `{ e }`, `slice` `{ e }`,
-// `array` `{ e, len }`, `map` `{ key, val }`, `i` an interface `{ n }`,
-// `func` `{ p, r }`, `chan` `{ e }`.  A type that is too deep or unknown is
-// `null`; the runtime then derives a best-effort type from the value.
+// Go's `reflect` spelling of a type used as a type argument (the monomorphiser
+// records it for `%T` of a type-parameter operand), shared by the JS and WASM
+// backends.
 
-const MAX_DEPTH = 4;
-const FLAGS = "#+\\- 0";
-const VERBS = "vTtcdoObxXUeEfFgGsqp";
+const qualify = (name) =>
+	name.split("[")[0].includes(".") ? name : `main.${name}`;
 
-const qualify = (name) => (name.includes(".") ? name : `main.${name}`);
+const PREDECLARED = new Set([
+	"bool",
+	"string",
+	"int",
+	"int8",
+	"int16",
+	"int32",
+	"int64",
+	"uint",
+	"uint8",
+	"uint16",
+	"uint32",
+	"uint64",
+	"uintptr",
+	"float32",
+	"float64",
+	"complex64",
+	"complex128",
+	"byte",
+	"rune",
+	"error",
+]);
 
 /**
- * @param {any} t checker type
- * @param {(t: any) => any} [resolve] resolves a type reference
- * @param {number} [depth]
- * @returns {object | null}
+ * Go's `reflect` spelling of a type used as a type argument: `int`,
+ * `main.Foo`, `[]main.Foo`.  Takes checker types and parsed type nodes;
+ * `specialized` maps the names of monomorphised instances to their spelling.
+ * @param {any} t
+ * @param {Map<string, string>} [specialized]
+ * @returns {string}
  */
-export function fmtTypeDesc(t, resolve = (x) => x, depth = 0) {
-	t = resolve(t) ?? t;
-	if (!t) return null;
-	const sub = (x) => fmtTypeDesc(x, resolve, depth + 1);
-	switch (t.kind) {
+export function goTypeName(t, specialized = null) {
+	const go = (x) => goTypeName(x, specialized);
+	switch (t?.kind) {
 		case "basic":
-			if (t.name === "any") return { k: "i", n: "interface {}" };
-			if (t.name === "nil" || t.name === "void") return null;
-			return { k: "b", n: t.name };
+			return t.name === "any" ? "interface {}" : t.name;
 		case "untyped":
-			return { k: "b", n: t.base };
-		case "interface":
-			return { k: "i", n: t.name ? qualify(t.name) : "interface {}" };
+			return t.base;
+		case "TypeName":
+		case "Ident":
+			if (specialized?.has(t.name)) return qualify(specialized.get(t.name));
+			if (t.name === "any") return "interface {}";
+			return PREDECLARED.has(t.name) ? t.name : qualify(t.name);
+		case "GenericTypeName":
+			return qualify(`${t.name}[${t.typeArgs.map(go).join(",")}]`);
 		case "named":
-			return namedDesc(t, resolve, depth, sub);
-		case "struct":
-			return depth > MAX_DEPTH ? null : structDesc("", t, sub);
+			return qualify(instanceName(t, specialized));
+		case "interface":
+			return t.name ? qualify(t.name) : "interface {}";
 		case "pointer":
-			return depth > MAX_DEPTH ? null : { k: "ptr", e: sub(t.base) };
+		case "PointerType":
+			return `*${go(t.base)}`;
 		case "slice":
-			return depth > MAX_DEPTH ? null : { k: "slice", e: sub(t.elem) };
+		case "SliceType":
+			return `[]${go(t.elem)}`;
 		case "array":
-			return depth > MAX_DEPTH
-				? null
-				: { k: "array", e: sub(t.elem), len: t.size ?? 0 };
+		case "ArrayType":
+			// A parsed array type carries its length as a literal node.
+			return `[${typeof t.size === "object" ? (t.size?.value ?? 0) : (t.size ?? 0)}]${go(t.elem)}`;
 		case "map":
-			return depth > MAX_DEPTH
-				? null
-				: { k: "map", key: sub(t.key), val: sub(t.value) };
-		case "func":
-			return {
-				k: "func",
-				p: (t.params ?? []).map(sub),
-				r: (t.returns ?? []).map(sub),
-				v: Boolean(t.variadic),
-			};
-		case "chan":
-			return { k: "chan", e: sub(t.elem) };
-		default:
-			return null;
-	}
-}
-
-/**
- * The fields a struct declares itself, in declaration order: named fields and
- * one entry per embedded type.  Fields promoted from an embedded struct are
- * not listed (`fields` also holds them for selector lookup).
- * @param {any} st checker struct type
- * @returns {[string, any][]}
- */
-export function structOwnFields(st) {
-	if (!st._structFields) return [...(st.fields ?? [])];
-	const own = [];
-	for (const sf of st._structFields) {
-		if (!sf.embedded) {
-			for (const n of sf.names) own.push([n, st.fields.get(n)]);
-			continue;
+		case "MapType":
+			return `map[${go(t.key)}]${go(t.value)}`;
+		case "func": {
+			// A func without results is `func()`, not `func() void`.
+			const rets = (t.returns ?? [])
+				.filter((r) => !(r?.kind === "basic" && r.name === "void"))
+				.map(go);
+			const ret =
+				rets.length === 0
+					? ""
+					: rets.length === 1
+						? ` ${rets[0]}`
+						: ` (${rets.join(", ")})`;
+			return `func(${(t.params ?? []).map(go).join(", ")})${ret}`;
+		}
+		case "FuncType": {
+			// A parsed func type: parameters and the result as written.
+			const rt = t.returnType;
+			const rets = !rt ? [] : rt.kind === "TupleType" ? rt.types : [rt];
+			const ret =
+				rets.length === 0
+					? ""
+					: rets.length === 1
+						? ` ${go(rets[0])}`
+						: ` (${rets.map(go).join(", ")})`;
+			const params = (t.params ?? []).map((p) =>
+				p.variadic ? `...${go(p.type)}` : go(p.type),
+			);
+			return `func(${params.join(", ")})${ret}`;
 		}
-		const inner = sf.type?.kind === "pointer" ? sf.type.base : sf.type;
-		const name = (
-			sf.embeddedName ??
-			sf.astType?.name ??
-			sf.type?.name ??
-			sf.type?.base?.name ??
-			(inner?.kind === "named" ? inner.name : "")
-		)
-			.split(".")
-			.pop();
-		if (name) own.push([name, st.fields.get(name) ?? sf.type]);
-	}
-	return own;
-}
-
-function structDesc(n, st, sub) {
-	const f = [];
-	for (const [name, ft] of structOwnFields(st)) f.push([name, sub(ft)]);
-	return { k: "struct", n, f };
-}
-
-function namedDesc(t, resolve, depth, sub) {
-	const n = qualify(t.name ?? "");
-	const u = resolve(t.underlying) ?? t.underlying;
-	if (!u) return { k: "named", n, u: null };
-	if (u.kind === "struct")
-		return depth > MAX_DEPTH
-			? { k: "struct", n, f: null }
-			: structDesc(n, u, sub);
-	if (u.kind === "interface") return { k: "i", n };
-	return { k: "named", n, u: depth > MAX_DEPTH ? null : sub(u) };
-}
-
-/**
- * Whether a type descriptor mentions a float32 or float64.  Such operands
- * travel with their static type: a number alone cannot tell `float64(1e6)`
- * (Go prints 1e+06) from an `int`, or a float32 from the float64 holding the
- * same bits.
- * @param {any} desc result of fmtTypeDesc
- * @returns {boolean}
- */
-export function fmtDescHasFloat(desc) {
-	if (!desc || typeof desc !== "object") return false;
-	switch (desc.k) {
-		case "b":
-			return desc.n === "float32" || desc.n === "float64";
-		case "named":
-			return fmtDescHasFloat(desc.u);
-		case "struct":
-			return (desc.f ?? []).some(([, ft]) => fmtDescHasFloat(ft));
-		case "ptr":
-		case "slice":
-		case "array":
-			return fmtDescHasFloat(desc.e);
-		case "map":
-			return fmtDescHasFloat(desc.key) || fmtDescHasFloat(desc.val);
 		default:
-			return false;
+			return "interface {}";
 	}
 }
 
-/**
- * Whether a type descriptor is a slice or array (possibly named).  `%s`, `%q`
- * and `%x` read a byte slice as text, which a plain list of numbers cannot
- * tell from any other slice of small numbers.
- * @param {any} desc result of fmtTypeDesc
- * @returns {boolean}
- */
-export function fmtDescIsSeq(desc) {
-	let d = desc;
-	while (d?.k === "named") d = d.u;
-	return d?.k === "slice" || d?.k === "array";
-}
-
-/**
- * Whether a call with this literal format string needs operand types: `%T`,
- * `%#v`, an unknown verb (`%!z(int=5)`), or more operands than verbs
- * (`%!(EXTRA int=1)`).
- * @param {unknown} format
- * @param {number} nargs operand count, -1 when not known statically
- * @param {boolean} [seqArgs] some operand is a slice or array, whose element
- *   type decides how `%s`, `%q`, `%x` and `%X` read it
- */
-export function fmtWantsTypes(format, nargs, seqArgs = false) {
-	if (typeof format !== "string") return false;
-	const re = new RegExp(
-		`%([${FLAGS}]*)((?:\\[\\d+\\])?(?:\\*|\\d+)?(?:\\.(?:\\[\\d+\\])?(?:\\*|\\d*))?(?:\\[\\d+\\])?)([^]?)`,
-		"g",
-	);
-	let count = 0;
-	let indexed = false;
-	for (const m of format.matchAll(re)) {
-		const verb = m[3];
-		if (verb === "%") continue;
-		if (verb === "T" || verb === "p") return true;
-		if (verb === "v" && m[1].includes("#")) return true;
-		if (seqArgs && "sqxX".includes(verb)) return true;
-		if (verb !== "" && !VERBS.includes(verb) && verb !== "w") return true;
-		if (/[[*]/.test(m[2])) indexed = true;
-		count++;
-	}
-	return nargs >= 0 && !indexed && nargs > count;
+// `Box[int]` for a generic instance: the checker's type arguments on JS, the
+// spelling the monomorphiser recorded on WASM.
+function instanceName(t, specialized = null) {
+	if (t._goName) return t._goName;
+	if (!t.typeArgs?.length) return t.name ?? "";
+	return `${t.name}[${t.typeArgs.map((a) => goTypeName(a, specialized)).join(",")}]`;
 }

package/src/backend/shared/host-unicode.js

@@ -0,0 +1,36 @@
+// JS bodies of the host side of the unicode intrinsics (unicode_is,
+// unicode_to_upper, unicode_to_lower).  The JS backend inlines them as the
+// intrinsic bodies and the WASM boundary ships them as `env` imports, so
+// both targets answer from the same tables.  Each takes the names of the
+// parameters it reads and returns statements ending in a `return`.
+
+// Classes, in the order of the constants in stdlib/unicode/unicode.go: the
+// test of the one-code-point string `c`.
+const CLASS_TESTS = [
+	"/\\p{L}/u.test(c)", // Letter
+	"/\\p{Nd}/u.test(c)", // Digit
+	"/[ \\t\\n\\v\\f\\r\\u0085\\u00A0\\u1680\\u2000-\\u200A\\u2028\\u2029\\u202F\\u205F\\u3000]/.test(c)", // Space
+	"/\\p{Lu}/u.test(c)", // Upper
+	"/\\p{Ll}/u.test(c)", // Lower
+	"/\\p{P}/u.test(c)", // Punct
+	"/\\p{Cc}/u.test(c)", // Control
+	"!/\\p{Cc}/u.test(c)", // Print
+	"!/\\p{Cc}/u.test(c)", // Graphic
+];
+
+export function unicodeIsJs(r, cls) {
+	const cases = CLASS_TESTS.map((test, i) => `case ${i}: return ${test};`).join(
+		" ",
+	);
+	return `const c = String.fromCodePoint(${r}); switch (${cls}) { ${cases} } return false;`;
+}
+
+// A letter whose upper case spans several code points (the German sharp s)
+// stays as it is.
+export function unicodeToUpperJs(r) {
+	return `const m = String.fromCodePoint(${r}).toUpperCase(); const u = m.codePointAt(0); return m.length > (u > 0xffff ? 2 : 1) ? ${r} : u;`;
+}
+
+export function unicodeToLowerJs(r) {
+	return `return String.fromCodePoint(${r}).toLowerCase().codePointAt(0);`;
+}