gofront 0.0.3 → 0.0.4

package/README.md

@@ -145,7 +145,7 @@ readable and debuggable — no name mangling, no opaque wrappers.
 | `for {}` | `while (true) {}` |
 | `for i, v := range slice` | `for (const [i, v] of arr.entries())` |
 | `for k, v := range map` | `for (const [k, v] of Object.entries(m))` |
-| `for i, ch := range str` | `for (const [i, ch] of Array.from(s).entries())` |
+| `for i, r := range str` | `for (const [i, r] of Array.from(s, (c, i) => [i, c.codePointAt(0)]))` — `r` is a rune integer |
 | `for i := range n` | `for (let i = 0; i < n; i++)` |
 | `switch` / `fallthrough` | `switch` / case fall-through |
 | `switch v := x.(type)` | `if/else if` with `typeof` / `instanceof` checks |
@@ -387,6 +387,8 @@ signatures into GoFront's internal type representation.
 | `math` package | ✓ — `Sqrt`, `Pow`, `Abs`, `Floor`, `Ceil`, `Round`, `Log`, trig functions + `Pi`, `E`, `MaxInt` constants |
 | `errors` package | ✓ — `errors.New` (returns plain string) |
 | `time` package (partial) | ✓ — `Now`, `Since`, `Sleep` + `Millisecond`, `Second`, `Minute`, `Hour` constants |
+| `unicode` package | ✓ — `IsLetter`, `IsDigit`, `IsSpace`, `IsUpper`, `IsLower`, `IsPunct`, `IsControl`, `IsPrint`, `IsGraphic`, `ToUpper`, `ToLower` |
+| `os` package (partial) | ✓ — `Exit`, `Args`, `Getenv` |
 | External `.d.ts` types | ✓ |
 | npm package types | ✓ |
 | Multi-file packages | ✓ |
@@ -408,6 +410,12 @@ signatures into GoFront's internal type representation.
 | Binary / octal literals (`0b1010`, `0o777`) | ✓ — passed through to JS which supports them natively |
 | Hex float literals (`0x1.8p1`) | ✓ — evaluated at lex time to a decimal value |
 | Untyped constants | ✓ — `const x = 5` produces an untyped int that coerces to `int` or `float64` on use (Go spec §Constants) |
+| Positional (unkeyed) struct literals (`Point{1, 2}`) | ✓ |
+| Method expressions (`T.Method`) | ✓ — compiles to `(recv, ...args) => recv.Method(...args)` |
+| Method values (`x.Method`) | ✓ — compiles to `x.Method.bind(x)` |
+| Struct and array equality (`a == b`) | ✓ — deep comparison via tree-shaken `__equal` helper |
+| Multi-value function forwarding (`f(g())`) | ✓ — single multi-return call forwarded as spread |
+| Terminating statement analysis | ✓ — missing `return` in non-void functions is a type error |
 
 ---
 
@@ -435,13 +443,15 @@ developer would expect:
 - **Expressions**: all arithmetic, comparison, logical, and bitwise operators (including
   `&^`), compound assignment, increment/decrement, type conversions, type assertions
   (plain and comma-ok), slice expressions (`a[lo:hi]`, `a[lo:hi:max]`), composite
-  literals, `[...]T{...}` inference, rune literals, raw string literals, variadic
-  spread, blank identifier `_`.
+  literals (keyed and positional), `[...]T{...}` inference, rune literals, raw string
+  literals, variadic spread, blank identifier `_`, method expressions (`T.Method`),
+  method values (`x.Method`), struct/array equality, multi-value function forwarding.
 - **Builtins**: `len`, `cap`, `append`, `copy`, `make`, `delete`, `new`, `clear`, `min`,
   `max`, `print`, `println`, `panic`, `recover`, `fmt.Sprintf`/`Printf`/`Println`/`Errorf`.
 - **Standard library shims**: `strings` (20 functions), `strconv` (8 functions),
   `sort` (6 functions), `math` (20 functions + 6 constants), `errors.New`,
-  `time.Now`/`Since`/`Sleep` + duration constants.
+  `time.Now`/`Since`/`Sleep` + duration constants, `unicode` (11 functions),
+  `os.Exit`/`Args`/`Getenv`.
 - **Packages**: multi-file packages, cross-package imports, import aliases,
   dot imports, blank imports, unused import detection.
 
@@ -464,7 +474,6 @@ These features are intentional additions for the JavaScript platform:
 | Range over iterator functions (Go 1.23) | `func(yield func(K, V) bool)` protocol. | Feasible. |
 | Complex numbers (`complex64`, `complex128`, `3i`) | Would need a runtime complex type. Rarely used in frontend. | Feasible but low priority. |
 | `goto` | No clean JS translation. Rare in idiomatic Go. | Not planned. |
-| Method expressions (`T.Method`) | Requires function-wrapping with explicit receiver. | Feasible. |
 | Goroutines / channels / `select` | Go's concurrency model has no JS equivalent. A userland scheduler defeats the "no runtime" goal. | Out of scope. |
 | `unsafe`, `reflect`, `cgo` | Require memory model or runtime type metadata that JS cannot provide. | Out of scope. |
 
@@ -483,34 +492,22 @@ you know exactly what to expect.
 | Fixed-size arrays (`[n]T`) | Plain JS arrays (no length enforcement) | Fixed at compile time | Runtime enforcement adds overhead for no JS benefit. |
 | `nil` | Maps to `null` | Typed nil (distinct per type) | JS has no typed nil concept. |
 | `rune` / `byte` | Treated as `int` | Distinct types with UTF-8 encoding | JS strings are UTF-16. |
-| `range` over string | JS characters (UTF-16 via `Array.from`) | Runes (UTF-8 code points) | UTF-16 vs UTF-8 mismatch. |
+| `range` over string | Rune integers via `.codePointAt()` | Runes (UTF-8 code points) | Close match — indices are byte-sequential, values are code points. |
 | `len()` on strings | JS `.length` (UTF-16 code units) | Byte count (UTF-8) | Matching Go would require `TextEncoder` on every call. |
 | `error` type | Plain string | Interface `{ Error() string }` | Practical simplification for JS. |
 | `defer` | `try`/`finally` with a defer stack | Runtime stack unwinding | Covers most cases but not identical to Go internals. |
 | Struct field tags | Parsed, silently discarded | Available via `reflect` | No reflection = no use for tag values. |
 | Pointers (`&x`, `*p`) | Syntax accepted, semantically transparent | True memory indirection | JS has no pointer model. |
 | Three-index slice (`a[lo:hi:max]`) | `max` is parsed but ignored | Sets result capacity | JS arrays have no capacity. |
-| Exported / unexported | Uppercase names exported across packages | Access enforced per-identifier | Cross-package access to lowercase names is not yet an error. |
+| Exported / unexported | Enforced for GoFront packages; external `.d.ts`/npm namespaces are exempt | Access enforced uniformly | External JS APIs use lowercase names by convention. |
 
 ---
 
 ## Roadmap
 
-These are the open items roughly in priority order. GoFront's guiding principle is
-**no runtime** — features that need a scheduler, runtime type descriptors, or raw memory
-access are out of scope.
-
-| Feature | Difficulty | Notes |
-|---|---|---|
-| Generics (`[T any]`) | High | Biggest modern Go feature gap. Touches every compiler stage but has low runtime pressure. |
-| Range over iterator functions | Medium | Go 1.23 `func(yield func(K, V) bool)` protocol. Low runtime pressure. |
-| Complex number types | Medium | New type kind + builtins (`complex`, `real`, `imag`). Shimmed with a two-field object. |
-| Richer error values | Medium | Move `error` from plain string to an interface-like value. |
-| Better array semantics | Medium | Arrays are currently indistinguishable from slices at runtime. |
-| Better pointer model | High | Current `{ value: T }` boxing is useful but shallow. |
-
-Explicitly **out of scope**: goroutines, channels, `select`, `unsafe`, full `reflect`,
-`cgo`, exact integer overflow, Go-equivalent map semantics.
+See [`docs/ROADMAP.md`](docs/ROADMAP.md) for the full roadmap and release history.
+Design documents for planned features are organised by release under `docs/v*/`
+(e.g. [`docs/v0.0.5/`](docs/v0.0.5/)).
 
 ---
 
@@ -520,7 +517,7 @@ Explicitly **out of scope**: goroutines, channels, `select`, `unsafe`, full `ref
 npm test
 ```
 
-611 tests covering language features, type errors, edge cases, DOM (jsdom), external
+655 tests covering language features, type errors, edge cases, DOM (jsdom), external
 `.d.ts`, npm resolver, multi-file compilation, embedded structs, string formatting, map
 iteration order, integer overflow semantics, unused variable detection, unused import
 detection, semantic difference verification, stdlib shim packages, and both example apps.

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "gofront",
-	"version": "0.0.3",
+	"version": "0.0.4",
 	"author": "Luuk van Venrooij",
 	"license": "MIT",
 	"repository": {

package/src/codegen/expressions.js

@@ -48,6 +48,15 @@ export const expressionGenMethods = {
 				if (expr.op === "&^") {
 					return `${l} & ~${r}`;
 				}
+				// Struct/array equality: use __equal for value comparison
+				if (expr.op === "==" || expr.op === "!=") {
+					const lt = expr.left._type;
+					if (this._isStructOrArrayType(lt)) {
+						this._usesEqual = true;
+						const cmp = `__equal(${l}, ${r})`;
+						return expr.op === "==" ? cmp : `!${cmp}`;
+					}
+				}
 				// Go == and != are strict — map to JS === / !==
 				const op =
 					expr.op === "==" ? "===" : expr.op === "!=" ? "!==" : expr.op;
@@ -58,6 +67,11 @@ export const expressionGenMethods = {
 				return this.genCall(expr);
 
 			case "SelectorExpr": {
+				// Method expression: TypeName.MethodName → (recv, ...args) => recv.method(...args)
+				if (expr._isMethodExpr) {
+					const method = expr.field;
+					return `((recv, ...args) => recv.${method}(...args))`;
+				}
 				// math constants
 				if (expr.expr.kind === "Ident" && expr.expr.name === "math") {
 					switch (expr.field) {
@@ -75,6 +89,13 @@ export const expressionGenMethods = {
 							return "Number.MIN_SAFE_INTEGER";
 					}
 				}
+				// os constants/vars
+				if (expr.expr.kind === "Ident" && expr.expr.name === "os") {
+					switch (expr.field) {
+						case "Args":
+							return "process.argv";
+					}
+				}
 				// time constants (nanosecond durations)
 				if (expr.expr.kind === "Ident" && expr.expr.name === "time") {
 					switch (expr.field) {
@@ -93,9 +114,15 @@ export const expressionGenMethods = {
 				if (this.bundledPackages.has(base)) return expr.field;
 				// Pointer types are wrapped as { value: T }; route through .value
 				if (expr.expr._type?.kind === "pointer" && expr.field !== "value") {
-					return `${base}.value.${expr.field}`;
+					const sel = `${base}.value.${expr.field}`;
+					if (expr._isMethodValue && !expr._callee)
+						return `${sel}.bind(${base}.value)`;
+					return sel;
 				}
-				return `${base}.${expr.field}`;
+				const sel = `${base}.${expr.field}`;
+				// Method used as value (not called) — bind the receiver
+				if (expr._isMethodValue && !expr._callee) return `${sel}.bind(${base})`;
+				return sel;
 			}
 
 			case "IndexExpr": {
@@ -110,6 +137,14 @@ export const expressionGenMethods = {
 					}
 					return `(${base}[${idx}] ?? ${zero})`;
 				}
+				// String indexing returns a byte (charCodeAt), not a JS character
+				const exprType = expr.expr._type;
+				const isStr =
+					(exprType?.kind === "basic" && exprType.name === "string") ||
+					(exprType?.kind === "untyped" && exprType.base === "string");
+				if (isStr && !expr._lvalue) {
+					return `${base}.charCodeAt(${idx})`;
+				}
 				return `${base}[${idx}]`;
 			}
 
@@ -295,20 +330,16 @@ export const expressionGenMethods = {
 			const fmtArgs = expr.args.map((a) => this.genExpr(a)).join(", ");
 			switch (expr.func.field) {
 				case "Sprintf":
-					this._usesSprintf = true;
-					return `__sprintf(${fmtArgs})`;
 				case "Errorf":
 					this._usesSprintf = true;
 					return `__sprintf(${fmtArgs})`;
 				case "Printf":
+				case "Print":
 					this._usesSprintf = true;
 					return `process?.stdout?.write(__sprintf(${fmtArgs}))`;
 				case "Println":
 					this._usesSprintf = true;
 					return `console.log(__sprintf(${fmtArgs}))`;
-				case "Print":
-					this._usesSprintf = true;
-					return `process?.stdout?.write(__sprintf(${fmtArgs}))`;
 			}
 		}
 
@@ -463,6 +494,54 @@ export const expressionGenMethods = {
 			}
 		}
 
+		// unicode.* — rune/character classification
+		if (
+			expr.func.kind === "SelectorExpr" &&
+			expr.func.expr.kind === "Ident" &&
+			expr.func.expr.name === "unicode"
+		) {
+			const a = expr.args.map((e) => this.genExpr(e));
+			switch (expr.func.field) {
+				case "IsLetter":
+					return `/\\p{L}/u.test(String.fromCodePoint(${a[0]}))`;
+				case "IsDigit":
+					return `/\\p{Nd}/u.test(String.fromCodePoint(${a[0]}))`;
+				case "IsSpace":
+					return `/\\s/.test(String.fromCodePoint(${a[0]}))`;
+				case "IsUpper":
+					return `((__c) => __c === __c.toUpperCase() && /\\p{L}/u.test(__c))(String.fromCodePoint(${a[0]}))`;
+				case "IsLower":
+					return `((__c) => __c === __c.toLowerCase() && /\\p{L}/u.test(__c))(String.fromCodePoint(${a[0]}))`;
+				case "IsPunct":
+					return `/\\p{P}/u.test(String.fromCodePoint(${a[0]}))`;
+				case "IsControl":
+					return `/\\p{Cc}/u.test(String.fromCodePoint(${a[0]}))`;
+				case "IsPrint":
+					return `!/\\p{Cc}/u.test(String.fromCodePoint(${a[0]}))`;
+				case "IsGraphic":
+					return `!/\\p{Cc}/u.test(String.fromCodePoint(${a[0]}))`;
+				case "ToUpper":
+					return `String.fromCodePoint(${a[0]}).toUpperCase().codePointAt(0)`;
+				case "ToLower":
+					return `String.fromCodePoint(${a[0]}).toLowerCase().codePointAt(0)`;
+			}
+		}
+
+		// os.* — process/environment access
+		if (
+			expr.func.kind === "SelectorExpr" &&
+			expr.func.expr.kind === "Ident" &&
+			expr.func.expr.name === "os"
+		) {
+			const a = expr.args.map((e) => this.genExpr(e));
+			switch (expr.func.field) {
+				case "Exit":
+					return `process.exit(${a[0]})`;
+				case "Getenv":
+					return `(process.env[${a[0]}] ?? "")`;
+			}
+		}
+
 		// errors.New — identity (errors are plain strings)
 		if (
 			expr.func.kind === "SelectorExpr" &&
@@ -490,9 +569,15 @@ export const expressionGenMethods = {
 			}
 		}
 
+		// Mark the callee so SelectorExpr knows it's being called, not used as a value
+		expr.func._callee = true;
 		const rawFn = this.genExpr(expr.func);
 		// Wrap function literals in parens so `function(){}()` → `(function(){})()`
 		const fn = expr.func.kind === "FuncLit" ? `(${rawFn})` : rawFn;
+		// Multi-value forwarding: f(g()) where g() returns multiple values → f(...g())
+		if (expr._multiForward) {
+			return `${fn}(...${this.genExpr(expr.args[0])})`;
+		}
 		const args = expr.args
 			.map((a) => (a._spread ? `...${this.genExpr(a)}` : this.genExpr(a)))
 			.join(", ");
@@ -537,34 +622,40 @@ export const expressionGenMethods = {
 		return "{}";
 	},
 
-	// Render KeyValueExpr elements as a JS field list string.
-	// Handles embedded-spread (_isEmbedInit) and plain key: value pairs.
+	// Render struct elements as a JS field list string.
+	// Handles positional (_positionalField), embedded-spread (_isEmbedInit), and keyed (KeyValueExpr).
 	_genStructFields(elems) {
 		return elems
-			.filter((e) => e.kind === "KeyValueExpr")
-			.map((e) =>
-				e._isEmbedInit
-					? `...${this.genExpr(e.value)}`
-					: `${e.key.name ?? this.genExpr(e.key)}: ${this.genExpr(e.value)}`,
-			)
+			.map((e) => {
+				if (e._positionalField) {
+					return `${e._positionalField}: ${this.genExpr(e)}`;
+				}
+				if (e.kind !== "KeyValueExpr") return null;
+				if (e._isEmbedInit) return `...${this.genExpr(e.value)}`;
+				return `${e.key.name ?? this.genExpr(e.key)}: ${this.genExpr(e.value)}`;
+			})
+			.filter((s) => s !== null)
 			.join(", ");
 	},
 
 	genCompositeLit(expr) {
 		const t = expr.typeExpr;
 
-		// Implicit composite literal: {X: 1} inside a slice/map — type inferred from context
+		// Implicit composite literal: {X: 1} or {1, 2} inside a slice/map — type inferred from context
 		if (t === null) {
-			if (expr.elems.length > 0 && expr.elems[0]?.kind === "KeyValueExpr") {
-				const typeName = expr._type?.name ?? expr._type?.underlying?.name;
+			const typeName = expr._type?.name ?? expr._type?.underlying?.name;
+			const hasPositional = expr.elems.some((e) => e._positionalField);
+			const hasKeyed = expr.elems.some((e) => e.kind === "KeyValueExpr");
+			if (hasPositional || hasKeyed) {
 				if (typeName && this.structNames.has(typeName)) {
 					return `new ${typeName}({ ${this._genStructFields(expr.elems)} })`;
 				}
 				const fields = expr.elems
-					.map(
-						(e) =>
-							`${e.key.name ?? this.genExpr(e.key)}: ${this.genExpr(e.value)}`,
-					)
+					.map((e) => {
+						if (e._positionalField)
+							return `${e._positionalField}: ${this.genExpr(e)}`;
+						return `${e.key.name ?? this.genExpr(e.key)}: ${this.genExpr(e.value)}`;
+					})
 					.join(", ");
 				return `{ ${fields} }`;
 			}
@@ -573,11 +664,18 @@ export const expressionGenMethods = {
 
 		const typeName = this.getTypeName(t);
 
-		// Struct: new Foo({ X: 1, Y: 2 })
+		// Struct: new Foo({ X: 1, Y: 2 }) — keyed or positional
 		if (typeName && this.structNames.has(typeName)) {
 			return `new ${typeName}({ ${this._genStructFields(expr.elems)} })`;
 		}
 
+		// Fallback: named type that's not a struct but has positional elements → treat as struct
+		if (expr.elems.some((e) => e._positionalField)) {
+			if (typeName) {
+				return `new ${typeName}({ ${this._genStructFields(expr.elems)} })`;
+			}
+		}
+
 		// Slice/array: [1, 2, 3]
 		if (t?.kind === "SliceType" || t?.kind === "ArrayType") {
 			const elems = expr.elems
@@ -710,10 +808,8 @@ export const expressionGenMethods = {
 	zeroValueForType(t) {
 		if (!t) return "null";
 		switch (t.kind) {
-			case "basic": {
-				const basic = this._zeroForBasicName(t.name);
-				return basic !== null ? basic : "null";
-			}
+			case "basic":
+				return this._zeroForBasicName(t.name) ?? "null";
 			case "slice":
 				return "null";
 			case "map":
@@ -788,6 +884,13 @@ export const expressionGenMethods = {
 		return "null";
 	},
 
+	// Returns true if the type is a struct or array (uses value comparison with __equal).
+	_isStructOrArrayType(t) {
+		if (!t) return false;
+		const base = t.kind === "named" ? t.underlying : t;
+		return base?.kind === "struct" || base?.kind === "array";
+	},
+
 	typeComment(typeNode) {
 		if (!typeNode) return "unknown";
 		switch (typeNode.kind) {

package/src/codegen/statements.js

@@ -75,14 +75,69 @@ export const statementGenMethods = {
 			}
 
 			case "AssignStmt": {
+				// comma-ok map index: v, ok = m["key"]
+				if (stmt._commaOkMap) {
+					const rhsNode = stmt.rhs[0];
+					const mapExpr = this.genExpr(rhsNode.expr);
+					const keyExpr = this.genExpr(rhsNode.index);
+					const [vName, okName] = stmt.lhs.map(
+						(e) => e.name ?? this.genExpr(e),
+					);
+					if (vName !== "_") {
+						const zero = rhsNode._mapValueType
+							? this.zeroValueForType(rhsNode._mapValueType)
+							: "undefined";
+						this.line(
+							`${vName} = (${keyExpr}) in ${mapExpr} ? ${mapExpr}[${keyExpr}] : ${zero};`,
+						);
+					}
+					if (okName !== "_")
+						this.line(`${okName} = (${keyExpr}) in ${mapExpr};`);
+					break;
+				}
+				// comma-ok type assertion: v, ok = x.(T)
+				if (
+					stmt.lhs.length === 2 &&
+					stmt.rhs.length === 1 &&
+					stmt.rhs[0]._commaOk
+				) {
+					const val = this.genExpr(stmt.rhs[0]);
+					const [vName, okName] = stmt.lhs.map(
+						(e) => e.name ?? this.genExpr(e),
+					);
+					const tmp = "__ta";
+					this.line(`let ${tmp} = ${val};`);
+					if (vName !== "_") this.line(`${vName} = ${tmp}[0];`);
+					if (okName !== "_") this.line(`${okName} = ${tmp}[1];`);
+					break;
+				}
 				const rhs = stmt.rhs.map((e) => this.genExpr(e));
 				for (const e of stmt.lhs) if (e.kind === "IndexExpr") e._lvalue = true;
-				const lhs = stmt.lhs.map((e) => this.genExpr(e));
-				if (lhs.length === 1) {
-					this.line(`${lhs[0]} ${stmt.op} ${rhs[0]};`);
+				const lhs = stmt.lhs.map((e) => e.name ?? this.genExpr(e));
+				// Filter out blank identifier assignments entirely
+				const pairs = lhs.map((l, i) => ({ l, r: rhs[i] ?? rhs[0] }));
+				const active = pairs.filter((p) => p.l !== "_");
+				if (active.length === 0) {
+					// All _ — still need to evaluate rhs for side effects
+					if (rhs.length > 0) this.line(`${rhs[0]};`);
+				} else if (lhs.length === 1) {
+					this.line(`${active[0].l} ${stmt.op} ${active[0].r};`);
 				} else {
+					// multi-assign: emit only non-blank targets
 					const rhsStr = rhs.length === 1 ? rhs[0] : `[${rhs.join(", ")}]`;
-					this.line(`[${lhs.join(", ")}] = ${rhsStr};`);
+					if (active.length === pairs.length) {
+						this.line(`[${lhs.join(", ")}] = ${rhsStr};`);
+					} else {
+						// Some blanks — use temp and assign only non-blank
+						const tmp = "__t";
+						this.line(`let ${tmp} = ${rhsStr};`);
+						for (let i = 0; i < lhs.length; i++) {
+							if (lhs[i] !== "_") {
+								const src = rhs.length === 1 ? `${tmp}[${i}]` : rhs[i];
+								this.line(`${lhs[i]} ${stmt.op} ${src};`);
+							}
+						}
+					}
 				}
 				break;
 			}
@@ -275,11 +330,14 @@ export const statementGenMethods = {
 			(iterType?.kind === "basic" && iterType.name === "string") ||
 			(iterType?.kind === "untyped" && iterType.base === "string")
 		) {
-			// string: for i, ch := range s  → for (const [i, ch] of s.split('').entries())
-			iterExpr =
-				lhs.length === 1
-					? `Array.from(${iteree}).keys()`
-					: `Array.from(${iteree}).entries()`;
+			// string: for i, r := range s  → rune (code point), not JS character
+			// Go spec: iterating a string yields (byte-index, rune) pairs
+			if (lhs.length === 1) {
+				iterExpr = `Array.from(${iteree}).keys()`;
+			} else {
+				// Wrap code points so the value is an integer (rune), not a JS string
+				iterExpr = `Array.from(${iteree}, (__c, __i) => [__i, __c.codePointAt(0)])`;
+			}
 		} else {
 			// slice/array: for i, v := range arr → for (const [i, v] of __s(arr).entries())
 			// null-guard handles nil slices (zero value) gracefully.

package/src/codegen.js

@@ -43,6 +43,7 @@ export class CodeGen {
 		this._usesAppend = false;
 		this._usesSliceGuard = false;
 		this._usesSprintf = false;
+		this._usesEqual = false;
 	}
 
 	// ── Output helpers ───────────────────────────────────────────
@@ -120,10 +121,7 @@ export class CodeGen {
 				if (d.name === "init") {
 					const renamed = initCount === 0 ? "init" : `init$${initCount}`;
 					initNames.push(renamed);
-					const saved = d.name;
-					d.name = renamed;
-					this.genFuncDecl(d);
-					d.name = saved;
+					this.genFuncDecl(d, renamed);
 					initCount++;
 				} else {
 					this.genFuncDecl(d);
@@ -149,6 +147,10 @@ export class CodeGen {
 			);
 		if (this._usesSliceGuard)
 			helpers.push("function __s(a) { return a || []; }");
+		if (this._usesEqual)
+			helpers.push(
+				'function __equal(a,b){if(a===b)return true;if(a===null||b===null)return false;if(Array.isArray(a)&&Array.isArray(b)){if(a.length!==b.length)return false;for(let i=0;i<a.length;i++)if(!__equal(a[i],b[i]))return false;return true;}if(typeof a==="object"&&typeof b==="object"){const ka=Object.keys(a),kb=Object.keys(b);if(ka.length!==kb.length)return false;for(const k of ka)if(!__equal(a[k],b[k]))return false;return true;}return false;}',
+			);
 		if (this._usesSprintf)
 			helpers.push(
 				[
@@ -287,7 +289,8 @@ export class CodeGen {
 
 	// ── Function declarations ────────────────────────────────────
 
-	genFuncDecl(decl) {
+	genFuncDecl(decl, nameOverride) {
+		const name = nameOverride ?? decl.name;
 		const params = decl.params
 			.map((p, i) =>
 				p.variadic && i === decl.params.length - 1 ? `...${p.name}` : p.name,
@@ -296,7 +299,7 @@ export class CodeGen {
 		const asyncPrefix = decl.async ? "async " : "";
 		const srcLine = decl._line ?? null;
 		this.line(
-			`${asyncPrefix}function ${decl.name}(${params}) {`,
+			`${asyncPrefix}function ${name}(${params}) {`,
 			srcLine ? srcLine - 1 : null,
 		);
 		this.indented(() =>

package/src/parser.js

@@ -172,7 +172,7 @@ export class Parser {
 		if (this.check(T.LPAREN)) {
 			this.expect(T.LPAREN);
 			const recvName =
-				this.check(T.IDENT) && !this.isTypeName(this.peek2())
+				this.check(T.IDENT) && !this.isReceiverTerminator(this.peek2())
 					? this.advance().value
 					: "_";
 			this.match(T.STAR); // pointer receiver: (c *Counter) — strip *, treat same as value receiver
@@ -208,8 +208,8 @@ export class Parser {
 		return decl;
 	}
 
-	// Returns true if tok looks like a type name token (for receiver parsing)
-	isTypeName(tok) {
+	// Returns true if tok is a receiver-list terminator (i.e. not a type name)
+	isReceiverTerminator(tok) {
 		return (
 			tok &&
 			(tok.type === T.RPAREN ||
@@ -383,31 +383,34 @@ export class Parser {
 		const decls = [];
 		if (this.match(T.LPAREN)) {
 			let iotaVal = 0;
+			let prevRawExprs = null; // raw AST (with iota Idents) from the previous spec
+			let prevType = null;
 			while (!this.check(T.RPAREN) && !this.check(T.EOF)) {
 				const names = [this.expect(T.IDENT).value];
 				while (this.match(T.COMMA)) names.push(this.expect(T.IDENT).value);
 				let type = null;
-				let value;
+				let rawExprs; // before iota substitution
 				if (this.check(T.ASSIGN)) {
 					this.advance();
-					value = this.parseExprList();
+					rawExprs = this.parseExprList();
+					prevRawExprs = rawExprs;
+					prevType = null;
 				} else if (!this.check(T.SEMICOLON) && !this.check(T.RPAREN)) {
 					// optional type annotation before =
 					type = this.parseType();
+					prevType = type;
 					this.expect(T.ASSIGN);
-					value = this.parseExprList();
+					rawExprs = this.parseExprList();
+					prevRawExprs = rawExprs;
 				} else {
-					// implicit iota
-					value = [
+					// Omitted expression — repeat previous expression with updated iota
+					rawExprs = prevRawExprs ?? [
 						{ kind: "BasicLit", litKind: "INT", value: String(iotaVal) },
 					];
+					type = prevType ?? null;
 				}
-				// Replace iota identifier with current counter value
-				value = value.map((v) =>
-					v.kind === "Ident" && v.name === "iota"
-						? { kind: "BasicLit", litKind: "INT", value: String(iotaVal) }
-						: v,
-				);
+				// Substitute iota deeply in a cloned expression AST
+				const value = rawExprs.map((v) => this._substituteIota(v, iotaVal));
 				decls.push({ names, type, value });
 				iotaVal++;
 				this.semi();
@@ -425,6 +428,25 @@ export class Parser {
 		this.semi();
 		return { kind: "ConstDecl", decls };
 	}
+
+	// Deep-clone an expression AST, replacing `iota` identifiers with the given integer.
+	_substituteIota(node, val) {
+		if (!node || typeof node !== "object") return node;
+		if (node.kind === "Ident" && node.name === "iota") {
+			return { kind: "BasicLit", litKind: "INT", value: String(val) };
+		}
+		// Shallow-clone the node, then recursively substitute in all child properties
+		const clone = { ...node };
+		for (const key of Object.keys(clone)) {
+			const v = clone[key];
+			if (Array.isArray(v)) {
+				clone[key] = v.map((item) => this._substituteIota(item, val));
+			} else if (v && typeof v === "object" && v.kind) {
+				clone[key] = this._substituteIota(v, val);
+			}
+		}
+		return clone;
+	}
 }
 
 Object.assign(Parser.prototype, typeParserMethods);

package/src/typechecker/expressions.js

@@ -48,6 +48,8 @@ export const expressionCheckMethods = {
 			case "Ident": {
 				const t = scope.lookup(expr.name);
 				if (!t) return this.err(`Undefined: '${expr.name}'`, expr);
+				// Mark type-name identifiers so SelectorExpr can detect method expressions
+				if (this.types.has(expr.name)) expr._isTypeRef = true;
 				return t;
 			}
 
@@ -68,7 +70,8 @@ export const expressionCheckMethods = {
 			case "BinaryExpr": {
 				const lt = this.checkExpr(expr.left, scope);
 				const rt = this.checkExpr(expr.right, scope);
-				if (isAny(lt) || isAny(rt)) return this.binaryResultType(expr.op, ANY);
+				if (isAny(lt) || isAny(rt))
+					return this.binaryResultType(expr.op, ANY, ANY, expr);
 				return this.binaryResultType(expr.op, lt, rt, expr);
 			}
 
@@ -78,7 +81,33 @@ export const expressionCheckMethods = {
 
 			case "SelectorExpr": {
 				const baseType = this.checkExpr(expr.expr, scope);
-				return this.fieldType(baseType, expr.field, expr);
+				// Method expression: TypeName.MethodName → func(ReceiverType, ...params) ret
+				if (expr.expr._isTypeRef) {
+					let base = baseType.kind === "named" ? baseType.underlying : baseType;
+					base = this.resolveType(base);
+					if (base?.kind === "struct" && base.methods?.has(expr.field)) {
+						const methodType = base.methods.get(expr.field);
+						// Return a func type with the receiver prepended to params
+						expr._isMethodExpr = true;
+						expr._methodExprRecv = baseType;
+						return {
+							kind: "func",
+							params: [baseType, ...(methodType.params ?? [])],
+							returns: methodType.returns ?? [],
+							variadic: methodType.variadic,
+						};
+					}
+				}
+				const ft = this.fieldType(baseType, expr.field, expr);
+				// Mark method selectors so codegen can emit .bind() when used as a value
+				if (ft?.kind === "func") {
+					let base = baseType.kind === "named" ? baseType.underlying : baseType;
+					base = this.resolveType(base);
+					if (base?.kind === "struct" && base.methods?.has(expr.field)) {
+						expr._isMethodValue = true;
+					}
+				}
+				return ft;
 			}
 
 			case "IndexExpr": {
@@ -170,7 +199,29 @@ export const expressionCheckMethods = {
 
 			case "RangeExpr": {
 				// Type-check the iterated expression so its _type is annotated
-				return this.checkExpr(expr.expr, scope);
+				const collType = this.checkExpr(expr.expr, scope);
+				const resolved =
+					collType?.kind === "named" ? collType.underlying : collType;
+				// Return a tuple of (index/key type, value type) so DefineStmt can
+				// assign the correct types to range variables.
+				const isString =
+					(resolved?.kind === "basic" && resolved.name === "string") ||
+					(resolved?.kind === "untyped" && resolved.base === "string");
+				if (isString) {
+					// string range: (int index, rune value) — rune is an alias for int
+					return { kind: "tuple", types: [INT, INT] };
+				}
+				if (resolved?.kind === "slice") {
+					return { kind: "tuple", types: [INT, resolved.elem ?? ANY] };
+				}
+				if (resolved?.kind === "map") {
+					return {
+						kind: "tuple",
+						types: [resolved.key ?? ANY, resolved.value ?? ANY],
+					};
+				}
+				// integer range or unknown — return single-element tuple
+				return { kind: "tuple", types: [collType] };
 			}
 
 			default:
@@ -193,7 +244,20 @@ export const expressionCheckMethods = {
 			return this.checkBuiltin(fnType.name, expr, argTypes, scope);
 		}
 
-		const argTypes = expr.args.map((a) => this.checkExpr(a, scope));
+		// Multi-value forwarding: f(g()) where g() returns multiple values
+		// When a single argument is a multi-return call, flatten its tuple into args.
+		let argTypes;
+		if (expr.args.length === 1 && expr.args[0].kind === "CallExpr") {
+			const argType = this.checkExpr(expr.args[0], scope);
+			if (argType?.kind === "tuple") {
+				expr._multiForward = true; // flag for codegen
+				argTypes = argType.types;
+			} else {
+				argTypes = [argType];
+			}
+		} else {
+			argTypes = expr.args.map((a) => this.checkExpr(a, scope));
+		}
 
 		if (isAny(fnType)) return ANY;
 
@@ -284,6 +348,30 @@ export const expressionCheckMethods = {
 		const base = t.kind === "named" ? t.underlying : t;
 
 		if (base?.kind === "struct") {
+			// Detect positional (unkeyed) literal: all elements must be non-KeyValueExpr
+			const hasPositional = expr.elems.some((e) => e.kind !== "KeyValueExpr");
+			const hasKeyed = expr.elems.some((e) => e.kind === "KeyValueExpr");
+			if (hasPositional && hasKeyed) {
+				this.err("mixture of field:value and value initializers", expr);
+			}
+			if (hasPositional) {
+				// Map positional elements to struct fields by declaration order
+				const fieldNames = [...(base.fields?.keys() ?? [])];
+				for (let i = 0; i < expr.elems.length; i++) {
+					const elem = expr.elems[i];
+					const fieldName = fieldNames[i];
+					if (!fieldName) {
+						this.err("too many values in struct literal", elem);
+						continue;
+					}
+					const fieldType = base.fields.get(fieldName);
+					const vt = this.checkExpr(elem, scope);
+					if (fieldType) this.assertAssignable(fieldType, vt, elem);
+					// Annotate for codegen
+					elem._positionalField = fieldName;
+				}
+				return t;
+			}
 			for (const elem of expr.elems) {
 				if (elem.kind === "KeyValueExpr") {
 					const keyName = elem.key.name;

package/src/typechecker/statements.js

@@ -72,9 +72,37 @@ export const statementCheckMethods = {
 			}
 
 			case "AssignStmt": {
+				// comma-ok map index: v, ok = m["key"]
+				// Evaluate map expr first so _type is populated, then detect the pattern.
+				if (
+					stmt.lhs.length === 2 &&
+					stmt.rhs.length === 1 &&
+					stmt.rhs[0].kind === "IndexExpr"
+				) {
+					const mapBaseType = this.checkExpr(stmt.rhs[0].expr, scope);
+					const resolvedBase =
+						mapBaseType?.kind === "named"
+							? mapBaseType.underlying
+							: mapBaseType;
+					if (resolvedBase?.kind === "map") {
+						this.checkExpr(stmt.rhs[0].index, scope);
+						stmt._commaOkMap = true;
+						// Store the map value type so codegen can emit the zero-value fallback
+						stmt.rhs[0]._mapValueType = resolvedBase.value;
+						break;
+					}
+				}
+				// comma-ok type assertion: v, ok = x.(T)
+				if (
+					stmt.lhs.length === 2 &&
+					stmt.rhs.length === 1 &&
+					stmt.rhs[0].kind === "TypeAssertExpr"
+				) {
+					stmt.rhs[0]._commaOk = true;
+				}
 				// Check for const reassignment before evaluating RHS
 				for (const lhs of stmt.lhs) {
-					if (lhs.kind === "Ident") {
+					if (lhs.kind === "Ident" && lhs.name !== "_") {
 						const ownerScope = scope.lookupScope(lhs.name);
 						if (ownerScope?.isConst(lhs.name))
 							this.err(`cannot assign to const '${lhs.name}'`, lhs);
@@ -83,8 +111,13 @@ export const statementCheckMethods = {
 				const rhs = stmt.rhs.map((e) => this.checkExpr(e, scope));
 				const rhsFlat =
 					rhs.length === 1 && rhs[0]?.kind === "tuple" ? rhs[0].types : rhs;
-				const lhsTypes = stmt.lhs.map((e) => this.checkExpr(e, scope));
+				const lhsTypes = stmt.lhs.map((e) => {
+					if (e.kind === "Ident" && e.name === "_") return ANY;
+					return this.checkExpr(e, scope);
+				});
 				for (let i = 0; i < lhsTypes.length; i++) {
+					if (stmt.lhs[i]?.kind === "Ident" && stmt.lhs[i]?.name === "_")
+						continue;
 					const r = rhsFlat[i] ?? ANY;
 					if (!isAny(lhsTypes[i]) && !isAny(r)) {
 						this.assertAssignable(lhsTypes[i], r, stmt.lhs[i]);
@@ -200,6 +233,10 @@ export const statementCheckMethods = {
 								? this.resolveTypeNode(c.types[0], inner)
 								: ANY;
 						caseScope.defineLocal(stmt.assign, bindType);
+						// The capture variable is always considered used — it's the whole
+						// point of the switch-with-assign form. Each case body uses its own
+						// typed copy of the variable.
+						caseScope.lookup(stmt.assign);
 					}
 					for (const s of c.stmts) this.checkStmt(s, caseScope, returnType);
 					this._reportUnused(caseScope, stmt);

package/src/typechecker/types.js

@@ -124,24 +124,6 @@ export function defaultType(t) {
 	}
 }
 
-/** 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;

package/src/typechecker.js

@@ -23,6 +23,7 @@ import {
 	isNumeric,
 	isString,
 	isUntyped,
+	isVoid,
 	LOG_OPS,
 	Scope,
 	STRING,
@@ -346,6 +347,41 @@ export class TypeChecker {
 			},
 		});
 
+		// 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,
+			},
+		});
+
 		this.globals.define("append", { kind: "builtin", name: "append" });
 		this.globals.define("len", { kind: "builtin", name: "len" });
 		this.globals.define("cap", { kind: "builtin", name: "cap" });
@@ -378,7 +414,13 @@ export class TypeChecker {
 	addPackageNamespace(pkgName, symbols, types) {
 		const members = {};
 		for (const [name, type] of symbols) members[name] = type;
-		this.globals.define(pkgName, { kind: "namespace", name: pkgName, members });
+		// _gofront: true marks this as a GoFront package — exported identifier rules apply
+		this.globals.define(pkgName, {
+			kind: "namespace",
+			name: pkgName,
+			members,
+			_gofront: true,
+		});
 		for (const [name, type] of types) this.types.set(name, type);
 	}
 
@@ -618,7 +660,7 @@ export class TypeChecker {
 		for (const p of decl.params) {
 			inner.define(p.name, this.resolveTypeNode(p.type, outer));
 		}
-		const returnType = decl.returnType
+		let returnType = decl.returnType
 			? this.resolveTypeNode(decl.returnType, outer)
 			: VOID;
 		const hasNamedReturns = this._injectNamedReturns(
@@ -626,7 +668,9 @@ export class TypeChecker {
 			inner,
 			outer,
 		);
-		if (hasNamedReturns && returnType) returnType._hasNamedReturns = true;
+		// Wrap the return type to avoid mutating the shared singleton
+		if (hasNamedReturns && returnType)
+			returnType = { ...returnType, _hasNamedReturns: true };
 		const savedDefer = this._deferCount;
 		this._deferCount = 0;
 		this.checkBlock(decl.body, inner, returnType);
@@ -634,6 +678,12 @@ export class TypeChecker {
 		if (this._deferCount > 0) decl.body._hasDefer = true;
 		this._deferCount = savedDefer;
 		decl._returnType = returnType;
+		// Missing return check: non-void functions must terminate on all paths
+		if (!isVoid(returnType) && !returnType._hasNamedReturns) {
+			if (!this._isTerminating(decl.body)) {
+				this.err(`missing return at end of function '${decl.name}'`, decl);
+			}
+		}
 	}
 
 	checkMethodDecl(decl, outer) {
@@ -643,7 +693,7 @@ export class TypeChecker {
 		for (const p of decl.params) {
 			inner.define(p.name, this.resolveTypeNode(p.type, outer));
 		}
-		const returnType = decl.returnType
+		let returnType = decl.returnType
 			? this.resolveTypeNode(decl.returnType, outer)
 			: VOID;
 		const hasNamedReturns = this._injectNamedReturns(
@@ -651,7 +701,8 @@ export class TypeChecker {
 			inner,
 			outer,
 		);
-		if (hasNamedReturns && returnType) returnType._hasNamedReturns = true;
+		if (hasNamedReturns && returnType)
+			returnType = { ...returnType, _hasNamedReturns: true };
 		const savedDefer = this._deferCount;
 		this._deferCount = 0;
 		this.checkBlock(decl.body, inner, returnType);
@@ -659,6 +710,92 @@ export class TypeChecker {
 		if (this._deferCount > 0) decl.body._hasDefer = true;
 		this._deferCount = savedDefer;
 		decl._returnType = returnType;
+		// Missing return check
+		if (!isVoid(returnType) && !returnType._hasNamedReturns) {
+			if (!this._isTerminating(decl.body)) {
+				this.err(`missing return at end of method '${decl.name}'`, decl);
+			}
+		}
+	}
+
+	// Go spec §Terminating statements — returns true if the statement always terminates.
+	_isTerminating(stmt) {
+		if (!stmt) return false;
+		switch (stmt.kind) {
+			case "ReturnStmt":
+				return true;
+			case "BranchStmt":
+				// panic() is in ExprStmt, not BranchStmt — but "goto" could be here
+				return false;
+			case "ExprStmt":
+				// panic(...) is a terminating call
+				if (
+					stmt.expr?.kind === "CallExpr" &&
+					stmt.expr?.func?.kind === "Ident" &&
+					stmt.expr?.func?.name === "panic"
+				)
+					return true;
+				return false;
+			case "Block":
+				return this._isTerminatingBlock(stmt);
+			case "IfStmt":
+				// Terminating if: has else, and both branches terminate
+				if (!stmt.elseBody) return false;
+				return (
+					this._isTerminatingBlock(stmt.body) &&
+					(stmt.elseBody.kind === "Block"
+						? this._isTerminatingBlock(stmt.elseBody)
+						: this._isTerminating(stmt.elseBody))
+				);
+			case "ForStmt":
+				// Infinite loop (no condition) with no break — terminating
+				if (!stmt.cond && !this._blockHasBreak(stmt.body)) return true;
+				return false;
+			case "SwitchStmt":
+				// Terminating switch: has default and every case terminates
+				return this._isTerminatingSwitch(stmt);
+			case "TypeSwitchStmt":
+				return this._isTerminatingTypeSwitch(stmt);
+			case "LabeledStmt":
+				return this._isTerminating(stmt.body);
+			default:
+				return false;
+		}
+	}
+
+	_isTerminatingBlock(block) {
+		if (!block?.stmts?.length) return false;
+		return this._isTerminating(block.stmts[block.stmts.length - 1]);
+	}
+
+	_blockHasBreak(block) {
+		if (!block?.stmts) return false;
+		for (const s of block.stmts) {
+			if (s.kind === "BranchStmt" && s.keyword === "break") return true;
+		}
+		return false;
+	}
+
+	_isTerminatingSwitch(stmt) {
+		let hasDefault = false;
+		for (const c of stmt.cases ?? []) {
+			if (!c.list) hasDefault = true;
+			if (!c.stmts?.length) return false;
+			const last = c.stmts[c.stmts.length - 1];
+			if (!this._isTerminating(last)) return false;
+		}
+		return hasDefault;
+	}
+
+	_isTerminatingTypeSwitch(stmt) {
+		let hasDefault = false;
+		for (const c of stmt.cases ?? []) {
+			if (!c.types) hasDefault = true;
+			if (!c.stmts?.length) return false;
+			const last = c.stmts[c.stmts.length - 1];
+			if (!this._isTerminating(last)) return false;
+		}
+		return hasDefault;
 	}
 
 	_injectNamedReturns(returnTypeNode, scope, outer) {
@@ -852,6 +989,18 @@ export class TypeChecker {
 			return this.err(`No field '${field}' on ${typeStr(baseType)}`, node);
 		}
 		if (base?.kind === "namespace") {
+			// Enforce exported identifier rule for GoFront packages only
+			if (
+				base._gofront &&
+				field.length > 0 &&
+				field[0] >= "a" &&
+				field[0] <= "z"
+			) {
+				return this.err(
+					`cannot refer to unexported name ${base.name}.${field}`,
+					node,
+				);
+			}
 			if (field in base.members) return base.members[field];
 			return this.err(`No member '${field}' in namespace ${base.name}`, node);
 		}
@@ -875,7 +1024,26 @@ export class TypeChecker {
 	}
 
 	binaryResultType(op, lt, rt, node) {
-		if (CMP_OPS.has(op)) return BOOL;
+		if (CMP_OPS.has(op)) {
+			// Reject slice/map/func comparisons unless one side is nil (Go spec)
+			if (op === "==" || op === "!=") {
+				const lNil = isNil(lt);
+				const rNil = isNil(rt);
+				if (!lNil && !rNil) {
+					for (const t of [lt, rt]) {
+						const base = t?.kind === "named" ? t.underlying : t;
+						if (
+							base?.kind === "slice" ||
+							base?.kind === "map" ||
+							base?.kind === "func"
+						) {
+							this.err(`operator ${op} not defined on ${typeStr(t)}`, node);
+						}
+					}
+				}
+			}
+			return BOOL;
+		}
 		if (LOG_OPS.has(op)) return BOOL;
 		if (isAny(lt) || isAny(rt)) return ANY;
 		if (isNumeric(lt) && isNumeric(rt)) {
@@ -946,6 +1114,8 @@ export class TypeChecker {
 			tBase = this.resolveType(tBase);
 			sBase = this.resolveType(sBase);
 			if (tBase?.kind === "interface") {
+				// Empty interface (interface{}) accepts any type
+				if (tBase.methods.size === 0) return;
 				if (!this.implements(source, tBase, node)) {
 					this.err(
 						`${typeStr(source)} does not implement ${typeStr(target)}`,