gofront 1.9.0 → 1.9.2

package/src/backend/js/index.js

@@ -24,20 +24,27 @@ import {
 	markRedundantNilChecks,
 	normalizeDefers,
 	scanAddressTaken,
+	splitForwardedTuples,
 	takesElementAddress,
 } from "../../lower/index.js";
 import { orderPackageInits } from "../../typechecker/init-order.js";
 import {
 	BROWSER_GLOBALS,
 	isComplex,
+	isMethodPromotedOverField,
 	isNumeric,
 } from "../../typechecker/types.js";
+import { goTypeName } from "../shared/fmt-types.js";
 import {
 	unicodeIsJs,
 	unicodeToLowerJs,
 	unicodeToUpperJs,
 } from "../shared/host-unicode.js";
-import { comparesToNil, expressionGenMethods } from "./expressions.js";
+import {
+	comparesToNil,
+	derefsReceiverFirst,
+	expressionGenMethods,
+} from "./expressions.js";
 import {
 	HELPER_APPEND,
 	HELPER_BOUNDS,
@@ -367,7 +374,9 @@ export class CodeGen {
 		this._precisionWarned = new Set();
 		// Defer lowering (argument/receiver hoisting, recover-target marking) is
 		// idempotent and owned by the backends: the wasm path runs it via
-		// `lower()`, the JS path here.
+		// `lower()`, the JS path here.  So is splitting multi-value calls
+		// forwarded into interfaces into temps.
+		splitForwardedTuples(program);
 		normalizeDefers(program);
 		// Strict mode: index checks the loop shape proves unnecessary are elided.
 		if (this.strict) {
@@ -584,13 +593,35 @@ export class CodeGen {
 				const name = d.recvType.name;
 				if (!methods.has(name)) methods.set(name, []);
 				methods.get(name).push(d);
-				if (d.recvPointer && comparesToNil(d.body, d.recvName))
-					this.nilSafeMethods.add(`${name}.${d.name}`);
 			}
 		}
+		this._markNilSafeMethods(methods);
 		return methods;
 	}
 
+	// Pointer-receiver methods that can run with a nil receiver: they compare
+	// it with nil, or do not read through it before anything could skip the
+	// read (a method that does panics on nil either way, so it keeps the
+	// faster direct call). Calls to these go through the prototype (see
+	// _nilSafeMethodClass).
+	_markNilSafeMethods(methods) {
+		for (const [name, decls] of methods) {
+			const safe = new Set();
+			const ptr = decls.filter((d) => d.recvPointer);
+			for (const d of ptr) safe.add(d.name);
+			for (let changed = true; changed; ) {
+				changed = false;
+				for (const d of ptr) {
+					if (!safe.has(d.name) || comparesToNil(d.body, d.recvName)) continue;
+					if (!derefsReceiverFirst(d.body?.stmts, d.recvName, safe)) continue;
+					safe.delete(d.name);
+					changed = true;
+				}
+			}
+			for (const m of safe) this.nilSafeMethods.add(`${name}.${m}`);
+		}
+	}
+
 	_collectNamedWrappers(program, methods) {
 		for (const d of program.decls) {
 			if (
@@ -703,6 +734,30 @@ export class CodeGen {
 	}
 
 	genTypeDeclWithMethods(decl, methodDecls) {
+		this._genTypeDeclBody(decl, methodDecls);
+		this._genUnhashableMark(decl.name);
+	}
+
+	// Marks a defined type Go cannot hash so `__ik` can name it in the panic
+	// of an interface-keyed map insert: a struct class carries `__uh`, a
+	// defined slice or map type registers its interface tag.
+	_genUnhashableMark(name) {
+		const t = this.checker?.types.get(name);
+		if (t?.kind !== "named" || t.typeParams?.length || t.typeArgs?.length)
+			return;
+		if (!this._isUnhashableType(t)) return;
+		const goName = JSON.stringify(goTypeName(t));
+		if (this.structNames.has(name)) {
+			this.line(
+				`Object.defineProperty(${name}, "__uh", { value: ${goName} });`,
+			);
+		} else if (this._isNamedComposite(t)) {
+			this.useHelper("structKey");
+			this.line(`__uht.set(${JSON.stringify(name)}, ${goName});`);
+		}
+	}
+
+	_genTypeDeclBody(decl, methodDecls) {
 		const definedStruct =
 			decl.type.kind === "StructType" ? null : this._definedStructAst(decl);
 		if (decl.type.kind === "StructType") {
@@ -816,8 +871,11 @@ export class CodeGen {
 		if (this.checker) {
 			const resolved = this.checker.types.get(name)?.underlying;
 			if (resolved?.kind === "struct") {
-				for (const [fName, fType] of resolved.fields.entries())
+				for (const [fName, fType] of resolved.fields.entries()) {
+					// A method promoted shallower shadows the deeper field.
+					if (isMethodPromotedOverField(resolved, fName)) continue;
 					fields.push({ name: fName, zero: this.zeroValueForType(fType) });
+				}
 			}
 		} else {
 			for (const f of structTypeAst.fields) {
@@ -837,8 +895,10 @@ export class CodeGen {
 			const fields = [];
 			// Cached per type name, so never bound to the current generic body.
 			this._withTypeParamZeros(null, () => {
-				for (const [name, type] of resolved.fields.entries())
+				for (const [name, type] of resolved.fields.entries()) {
+					if (isMethodPromotedOverField(resolved, name)) continue;
 					fields.push({ name, zero: this.zeroValueForType(type) });
+				}
 			});
 			this.structFields.set(typeName, fields);
 			return fields;
@@ -1038,7 +1098,17 @@ export class CodeGen {
 	// A promoted method runs on the embedded value (`this.In`), so it and the
 	// outer struct's promoted-field accesses see the same storage.  Embedded
 	// types that are not compiled Go structs keep the borrowed-`this` form.
-	_embedStub(method, embedName, valueEmbed = false, fieldName = null) {
+	_embedStub(
+		method,
+		embedName,
+		valueEmbed = false,
+		fieldName = null,
+		nilPtrRecv = false,
+		ifaceEmbed = false,
+	) {
+		// An embedded interface forwards to the interface value in its field.
+		if (ifaceEmbed)
+			return `${method}(...__a) { return this.${fieldName}.${method}(...__a); }`;
 		// The field is named after the type without its package suffix
 		// (`Mutex$$sync` is the field `Mutex`), or after the alias it embeds.
 		const field = fieldName || embedName.replace(/\$\$.*$/, "");
@@ -1046,12 +1116,20 @@ export class CodeGen {
 		// the value as the receiver.
 		if (valueEmbed)
 			return `${method}(...__a) { return ${embedName}.$${method}(this.${field}, ...__a); }`;
-		const call = this.structNames.has(embedName)
-			? `this.${field}.${method}(...__a)`
-			: `${embedName}.prototype.${method}.call(this, ...__a)`;
+		const call = this._embedStubCall(method, embedName, field, nilPtrRecv);
 		return `${method}(...__a) { return ${call}; }`;
 	}
 
+	_embedStubCall(method, embedName, field, nilPtrRecv) {
+		if (!this.structNames.has(embedName))
+			return `${embedName}.prototype.${method}.call(this, ...__a)`;
+		// A nil embedded pointer still reaches a pointer-receiver method, as in
+		// Go: call it through the prototype instead of reading it off null.
+		return nilPtrRecv
+			? `${embedName}.prototype.${method}.call(this.${field}, ...__a)`
+			: `this.${field}.${method}(...__a)`;
+	}
+
 	_genEmbeddedMethodStubs(name, methodDecls) {
 		const stubs = computeEmbeddedStubs(name, methodDecls, this.checker);
 		for (const stub of stubs) {
@@ -1062,6 +1140,8 @@ export class CodeGen {
 					stub.embedName,
 					stub.valueEmbed,
 					stub.fieldName,
+					stub.nilPtrRecv,
+					stub.ifaceEmbed,
 				),
 			);
 		}

package/src/backend/js/runtime.js

@@ -311,11 +311,21 @@ export const HELPER_VCLONE = `var __vclone = __vclone || function __vclone(z, x)
   if (x === null || typeof x !== "object") return x;
   const zero = z?.();
   if (zero === null || zero === undefined || typeof zero !== "object") return x;
+  // A copy keeps the hidden tags (__t, __map, ...) that name the value's type
+  // in an interface: the generic code boxes the value first and copies after.
+  const keep = (v, c) => {
+    for (const k of Object.getOwnPropertyNames(v)) {
+      const d = Object.getOwnPropertyDescriptor(v, k);
+      if (!d.enumerable && k !== "length") Object.defineProperty(c, k, d);
+    }
+    return c;
+  };
   const cp = (v) => {
     if (v === null || typeof v !== "object") return v;
-    if (Array.isArray(v)) return v.map(cp);
-    if (typeof v.__clone === "function") return v.__clone();
-    return Object.assign(Object.create(Object.getPrototypeOf(v)), v);
+    if (v.__nilm === true) return v;
+    if (Array.isArray(v)) return keep(v, v.map(cp));
+    if (typeof v.__clone === "function") return keep(v, v.__clone());
+    return keep(v, Object.assign(Object.create(Object.getPrototypeOf(v)), v));
   };
   return cp(x);
 };`;
@@ -439,25 +449,41 @@ var __ifps = __ifps || function(x) {
   }
   return x;
 };
-var __ity = __ity || function(x, t, ptr) {
+var __tfn = __tfn || function(f, t) {
+  // A defined func type tags a fresh wrapper, so the shared func keeps its own type.
+  if (typeof f !== "function" || f.__t === t) return f;
+  const w = function(...a) { return f.apply(this, a); };
+  Object.defineProperty(w, "__t", { value: t, configurable: true, writable: true });
+  return w;
+};
+var __tnm = __tnm || function(f) {
+  // The type name of a type argument's info factory, spelled as a static tag.
+  const id = f?.nm ?? f?.id;
+  return typeof id === "string" ? id.replace(/ void\\b/g, "").replace(/\\bbyte\\b/g, "uint8").replace(/\\brune\\b/g, "int32").replace(/\\bany\\b/g, "interface {}") : undefined;
+};
+var __ity = __ity || function(x, t, ptr, sl) {
+  if (t === undefined) return x;
   // The frozen nil map cannot carry a tag: a copy of it keeps its map type.
   if (x !== null && x !== undefined && x.__nilm === true && x.__t === undefined)
     return Object.freeze(Object.defineProperties({}, { __map: { value: true }, __nilm: { value: true }, __t: { value: t } }));
   if (x === null || x === undefined) {
     // A nil slice keeps its type as an empty tagged array (not a nil interface).
-    if (!ptr && t.charCodeAt(0) !== 91) return x;
+    if (!ptr && !sl && t.charCodeAt(0) !== 91) return x;
     const n = ptr ? {} : [];
     if (!ptr) Object.defineProperty(n, "__nils", { value: true });
     Object.defineProperty(n, "__nilp", { value: true });
     Object.defineProperty(n, "__t", { value: t });
     return n;
   }
+  // A func already tagged with another type keeps it: tag a fresh wrapper.
+  if (typeof x === "function" && x.__t !== undefined && x.__t !== t) x = __tfn(x, undefined);
   if ((typeof x === "object" || typeof x === "function") && Object.isExtensible(x))
     Object.defineProperty(x, "__t", { value: t, configurable: true, writable: true });
   return x;
 };
 var __isty = __isty || function(v, t, k, c, n) {
   if (v === null || v === undefined || (typeof v !== "object" && typeof v !== "function")) return false;
+  if (k === "namedfunc") return typeof v === "function" && v.__t === t;
   if (k === "func") return typeof v === "function" && (v.__t === undefined || t === "" || v.__t === t);
   if (v.__t !== undefined && t !== "") return v.__t === t;
   if (v.__nilp === true) return false;
@@ -605,9 +631,9 @@ var __zu64 = __zu64 || Object.assign(() => 0n, { k: "uint64" });
 var __tbox = __tbox || function(f, x) {
   return f && f.b ? f.b(x) : x;
 };
-var __ti = __ti || function(f, k, id, is, u, b, fb) {
+var __ti = __ti || function(f, k, id, is, u, b, fb, nm) {
   const g = () => f();
-  g.k = k; g.id = id; g.is = is; g.u = u; g.b = b; g.fb = fb;
+  g.k = k; g.id = id; g.is = is; g.u = u; g.b = b; g.fb = fb; g.nm = nm;
   return g;
 };
 var __tar = __tar || function(f, op, a, b) {
@@ -707,6 +733,8 @@ var __isnm = __isnm || function(m) {
 // through `toString` to an injective encoding, and the key value is kept in
 // a table so ranging and fmt can recover it.
 export const HELPER_STRUCT_KEY = `var __kt = __kt || new Map();
+// Tags of defined slice and map types Go cannot hash, with their Go names.
+var __uht = __uht || new Map();
 var __kcl = __kcl || function(o) {
   if (o === null || typeof o !== "object") return o;
   if (typeof o.__clone === "function") return o.__clone();
@@ -739,10 +767,11 @@ var __pk = __pk || function(p) {
 };
 var __ik = __ik || function(k, tag) {
   const t = typeof k;
+  // A nil slice, map or func of a static type Go cannot hash panics too.
+  if (tag !== undefined && tag.charCodeAt(0) === 33) throw new Error("runtime error: hash of unhashable type " + tag.slice(1));
   if (k === null || k === undefined) return "\\u0001nil";
   if (tag !== undefined) {
     if (tag === "*") return __pk(k);
-    if (tag.charCodeAt(0) === 33) throw new Error("runtime error: hash of unhashable type " + tag.slice(1));
     if (t === "number" || t === "bigint") {
       const s = "\\u0001" + tag + ":" + String(k);
       if (!__kt.has(s)) __kt.set(s, k);
@@ -752,7 +781,13 @@ var __ik = __ik || function(k, tag) {
   if (t === "number" || t === "boolean" || t === "bigint") return "\\u0001" + t + ":" + String(k);
   // A slice, map or func in an \`any\` carries its type tag: Go cannot hash it.
   if ((t === "object" || t === "function") && typeof k.__t === "string" && /^(\\[\\]|map\\[|func\\()/.test(k.__t))
-    throw new Error("runtime error: hash of unhashable type " + k.__t.replace(/ void$/, ""));
+    throw new Error("runtime error: hash of unhashable type " + k.__t);
+  // A struct class or defined slice/map type that Go cannot hash is marked
+  // once at its declaration, so this is one lookup per insert.
+  if (t === "object") {
+    const uh = k.constructor?.__uh ?? __uht.get(k.__t);
+    if (uh !== undefined) throw new Error("runtime error: hash of unhashable type " + uh);
+  }
   if (k !== null && t === "object" && typeof k.__gfUnbox === "function" && !k.constructor.name.endsWith("$Ptr")) {
     const v = k.__gfUnbox(), vt = typeof v;
     if (vt === "string" || vt === "number" || vt === "boolean" || vt === "bigint") {
@@ -834,6 +869,13 @@ export const HELPER_IFEQ = `var __ifeq = __ifeq || function(a, b) {
   if (typeof a === "object" && typeof b === "object" && a.__v === true && b.__v === true && a.constructor === b.constructor) {
     return __equal(a, b);
   }
+  // Array values of the same type compare element by element; slices and
+  // defined slice types (registered in __uht) are not comparable.
+  if (typeof a === "object" && typeof b === "object" && typeof a.__t === "string" && a.__t === b.__t &&
+      (Array.isArray(a) || ArrayBuffer.isView(a)) && (Array.isArray(b) || ArrayBuffer.isView(b)) &&
+      !a.__t.startsWith("[]") && (typeof __uht === "undefined" || !__uht.has(a.__t))) {
+    return __equal(a, b);
+  }
   return false;
 };`;