gofront 1.7.0 → 1.9.0

package/src/typechecker/index.js

@@ -3,7 +3,7 @@
 //
 // Split into sub-modules under typechecker/:
 //   types.js          — shared type constants, predicates, Scope
-//   stdlib.js         — browser globals + all built-in package registrations
+//   stdlib/index.js   — browser globals + all built-in package registrations
 //   statements.js     — checkBlock, checkStmt
 //   expressions.js    — checkExpr, checkCall, checkBuiltin, checkCompositeLit
 //   termination.js    — _isTerminating* family
@@ -11,16 +11,24 @@
 //   assignability.js  — assertAssignable, binaryResultType, implements
 
 import { assignabilityMethods } from "./assignability.js";
+import { constantCheckMethods } from "./constants.js";
 import { expressionCheckMethods } from "./expressions.js";
+import { orderPackageInits, orderVarSpecsForTyping } from "./init-order.js";
 import { resolveMethods } from "./resolve.js";
 import { statementCheckMethods } from "./statements.js";
-import { setupGlobals } from "./stdlib.js";
+import { EXCLUDED_STDLIB_PACKAGES } from "./stdlib/excluded.js";
+import { setupGlobals } from "./stdlib/index.js";
 import { terminationMethods } from "./termination.js";
 import {
 	ANY,
+	BOOL,
 	defaultType,
 	ERROR,
+	INTRINSICS,
+	isAny,
+	isBool,
 	isVoid,
+	NATIVES,
 	Scope,
 	TAINTED_ANY,
 	TypeCheckError,
@@ -29,6 +37,17 @@ import {
 	VOID,
 } from "./types.js";
 
+// Checker method per templ body node kind (see _checkTemplNodes).
+const TEMPL_NODE_CHECKS = {
+	TemplElement: "_checkTemplElement",
+	TemplExpr: "_checkTemplLeaf",
+	TemplChildren: "_checkTemplChildren",
+	TemplComponent: "_checkTemplLeaf",
+	TemplIf: "_checkTemplIf",
+	TemplFor: "_checkTemplFor",
+	TemplSwitch: "_checkTemplSwitch",
+};
+
 function rootIdentName(e) {
 	if (!e) return null;
 	if (e.kind === "Ident") return e.name;
@@ -38,13 +57,58 @@ function rootIdentName(e) {
 }
 
 // Re-export for consumers that import from typechecker.js
-export { TypeCheckError, typeStr };
+export { EXCLUDED_STDLIB_PACKAGES, TypeCheckError, typeStr };
+
+// JavaScript built-ins that generated JS relies on; a JS class of the same
+// name in the bundle would shadow them (see _checkGlobalTypeNamesPass).
+const JS_BUILTIN_CLASSES = new Set([
+	"Array",
+	"ArrayBuffer",
+	"BigInt",
+	"BigInt64Array",
+	"BigUint64Array",
+	"Boolean",
+	"DataView",
+	"Date",
+	"Error",
+	"Float32Array",
+	"Float64Array",
+	"Int16Array",
+	"Int32Array",
+	"Int8Array",
+	"JSON",
+	"Map",
+	"Math",
+	"Number",
+	"Object",
+	"Promise",
+	"RangeError",
+	"Reflect",
+	"RegExp",
+	"Set",
+	"String",
+	"Symbol",
+	"TextDecoder",
+	"TextEncoder",
+	"TypeError",
+	"Uint16Array",
+	"Uint32Array",
+	"Uint8Array",
+	"Uint8ClampedArray",
+	"WeakMap",
+	"WebAssembly",
+]);
 
 export class TypeChecker {
 	constructor() {
 		this.types = new Map(); // named types
-		this.globals = new Scope();
+		// Go's universe scope: builtins, browser globals and built-in package
+		// namespaces.  Package declarations live in `globals` above it, so they
+		// shadow predeclared names (`func Array()`, `var document int`).
+		this.universe = new Scope();
+		this.globals = new Scope(this.universe);
 		this.errors = [];
+		this._reportedAt = new WeakMap();
 		this.warnings = []; // non-fatal diagnostics (e.g. boundary-call-in-loop hints)
 		this.target = "js";
 		this.pkgName = null;
@@ -57,22 +121,41 @@ export class TypeChecker {
 		this._typeSwitchDepth = 0; // for rejecting fallthrough in type switch
 		this._deferCount = 0; // tracks defer usage in current function body
 		this._imports = []; // tracked imports for unused-import detection
+		// Lazy body checking (Go-source stdlib): with `lazyBodies` set, checkAll
+		// types declarations only and `checkBody` types a function or method
+		// body when it is first reached.
+		this.lazyBodies = false;
+		this.stats = { bodiesChecked: 0 };
+		this._lazyBodies = new Map(); // FuncDecl/MethodDecl -> its program
 		this._constExprs = new Map(); // name -> AST initializer expr
+		this._importedConsts = new Map(); // dot-imported const name -> value
+		this._externalNames = new Set(); // package-scope names from .d.ts / npm definitions
 		this._setupGlobals();
 		// Register error as a named type (interface)
 		this.types.set("error", ERROR);
 	}
 
 	_setupGlobals() {
-		setupGlobals(this.globals, this.types);
+		setupGlobals(this.universe, this.types);
 	}
 
-	addDefinitions(types, values) {
+	// `external` marks values as real JS names (.d.ts / npm definitions) that
+	// must not be renamed; dot-imported GoFront packages pass false so their
+	// browser-global-named members get the same `$` renaming as local ones.
+	// `consts` (dot-imported GoFront packages) maps constant names to their
+	// folded values.
+	addDefinitions(types, values, { external = true, consts = null } = {}) {
 		for (const [name, type] of types) {
 			this.types.set(name, type);
 		}
 		for (const [name, type] of values) {
 			this.globals.define(name, type);
+			if (external) this._externalNames.add(name);
+		}
+		for (const [name, v] of consts ?? []) {
+			if (!v || !values.has(name)) continue;
+			this.globals._consts.add(name);
+			this._importedConsts.set(name, v);
 		}
 	}
 
@@ -80,7 +163,9 @@ export class TypeChecker {
 	// e.g. addPackageNamespace('utils', symbolsMap, typesMap)
 	// lets callers type-check `utils.Foo` via SelectorExpr.
 	// `target` is the imported package's compile target ("js"/"wasm"/"both").
-	addPackageNamespace(pkgName, symbols, types, target = null) {
+	// `consts` maps the package's constant names to their folded value (see
+	// typechecker/const-fold.js), or null when the folder cannot evaluate one.
+	addPackageNamespace(pkgName, symbols, types, target = null, consts = null) {
 		const members = {};
 		for (const [name, type] of symbols) members[name] = type;
 		// _gofront: true marks this as a GoFront package — exported identifier rules apply
@@ -90,9 +175,19 @@ export class TypeChecker {
 			members,
 			_gofront: true,
 			_target: target,
+			_consts: consts,
 		});
 		for (const [name, type] of types) {
-			this.types.set(name, type);
+			const prior = this.types.get(name);
+			if (prior && prior !== type && prior.kind === "named") {
+				this._ambiguousImported ??= new WeakSet();
+				this._ambiguousImported.add(prior);
+				this._ambiguousImported.add(type);
+			}
+			// A renamed type (`Pt` declared as `Pt$$b`) never takes the bare name:
+			// another package owns it, and this package's own declaration would
+			// otherwise reuse the imported placeholder. It is reached as `pkg.Pt`.
+			if (type.name === name) this.types.set(name, type);
 			this.types.set(`${pkgName}.${name}`, type);
 		}
 	}
@@ -108,7 +203,7 @@ export class TypeChecker {
 	// Report any tracked imports whose package name was never referenced.
 	reportUnusedImports() {
 		for (const { name, node, filename, source } of this._imports) {
-			if (!this.globals._used.has(name)) {
+			if (!this.globals._used.has(name) && !this.universe._used.has(name)) {
 				const saved = [this._currentFile, this._currentSource];
 				this._currentFile = filename;
 				this._currentSource = source;
@@ -130,6 +225,15 @@ export class TypeChecker {
 		return out;
 	}
 
+	getExportedConsts() {
+		const out = new Map();
+		for (const name of this.globals._consts) {
+			if (!this.globals.lookupConstExpr(name)) continue;
+			out.set(name, this._constValue({ kind: "Ident", name }, this.globals));
+		}
+		return out;
+	}
+
 	getExportedTypes() {
 		return new Map(this.types);
 	}
@@ -164,6 +268,14 @@ export class TypeChecker {
 	}
 
 	err(msg, node, hint = null) {
+		// One diagnostic per root cause: a node revisited by a later pass (a
+		// signature resolved at declaration and again in the body) reports once.
+		if (node && typeof node === "object") {
+			const seen = this._reportedAt.get(node) ?? new Set();
+			this._reportedAt.set(node, seen);
+			if (seen.has(msg)) return TAINTED_ANY;
+			seen.add(msg);
+		}
 		const e = new TypeCheckError(
 			msg,
 			node,
@@ -269,11 +381,15 @@ export class TypeChecker {
 			}
 		}
 
+		this._checkDirectivesAndImportsPass(programs);
+		this._registerConstExprs(programs);
 		this._collectTypesPass(programs);
 		this._collectFuncsPass(programs);
+		this._checkGlobalTypeNamesPass(programs);
 		this._promoteEmbeddedMethods();
 		this._collectVarsConstsPass(programs);
 		this._checkTopDeclsPass(programs);
+		this._reportInitCycles(programs);
 
 		if (this.target === "both") {
 			this._checkMutablePackageVars(programs);
@@ -290,6 +406,42 @@ export class TypeChecker {
 		return this.errors;
 	}
 
+	_checkEmbedDirectives(directives) {
+		for (const { line, col } of directives ?? []) {
+			this.err("//go:embed is not supported yet", { line, col });
+		}
+	}
+
+	_checkDirectivesAndImportsPass(programs) {
+		this._importedPaths = new Set();
+		this._fileImports = new Map();
+		for (const p of programs) {
+			this._setCurrentFile(p);
+			const names = new Map();
+			this._fileImports.set(this._currentFile, names);
+			this._checkEmbedDirectives(p._embedDirectives);
+			for (const imp of p.imports ?? []) {
+				for (const spec of imp.imports ?? []) {
+					this._importedPaths.add(spec.path);
+					names.set(
+						spec.alias ??
+							spec.path
+								.split("/")
+								.filter((s) => !/^v\d+$/.test(s))
+								.at(-1),
+						spec.path,
+					);
+					if (EXCLUDED_STDLIB_PACKAGES.has(spec.path)) {
+						this.err(
+							`package '${spec.path}' is not available: ${EXCLUDED_STDLIB_PACKAGES.get(spec.path)}`,
+							spec,
+						);
+					}
+				}
+			}
+		}
+	}
+
 	_checkMutablePackageVars(programs) {
 		const pkgVars = new Set();
 		for (const p of programs) {
@@ -409,6 +561,18 @@ export class TypeChecker {
 			for (const d of p.decls) {
 				if (d.kind === "TypeDecl" && !d.isAlias && !this.types.has(d.name)) {
 					const placeholder = { kind: "named", name: d.name, underlying: null };
+					// A generic type is known to be generic before any field resolves,
+					// so types declared earlier can instantiate it.
+					if (d.typeParams) {
+						placeholder._generic = {
+							typeParams: d.typeParams.map((tp) => ({
+								kind: "typeParam",
+								name: tp.name,
+								constraint: tp.constraint,
+							})),
+							declNode: d,
+						};
+					}
 					this.types.set(d.name, placeholder);
 					this.globals.define(d.name, placeholder);
 				}
@@ -418,6 +582,7 @@ export class TypeChecker {
 		for (const p of programs) {
 			for (const d of p.decls) if (d.kind === "TypeDecl") all.push({ p, d });
 		}
+		this._expandGenericStructDefs(all.map((x) => x.d));
 		// Collect in dependency order so aliases, generics, embedded and by-value
 		// field types declared later (or in other files) are ready when needed.
 		let pending = all;
@@ -436,6 +601,57 @@ export class TypeChecker {
 		}
 	}
 
+	// `type S[T any] Base` with `Base` a struct declared in the package: S is a
+	// new struct type with Base's fields (and none of its methods), so its
+	// declaration becomes a copy of Base's struct type.
+	_expandGenericStructDefs(decls) {
+		const byName = new Map(decls.map((d) => [d.name, d]));
+		for (const d of decls) {
+			if (!d.typeParams || d.isAlias) continue;
+			let target = d.type;
+			for (let i = 0; i < 16 && target?.kind === "TypeName"; i++) {
+				const base = byName.get(target.name);
+				if (!base || base.typeParams || base.isAlias) break;
+				target = base.type;
+			}
+			// A struct written in place is already this declaration's own copy;
+			// cloning it would also choke on an AST a previous target pass
+			// annotated with cycles.
+			if (target?.kind === "StructType" && target !== d.type)
+				d.type = JSON.parse(JSON.stringify(target));
+		}
+	}
+
+	// A struct type, or a named type with methods, becomes a JS class of the
+	// same name in `js` and `both` packages.  Functions and variables that
+	// shadow a browser global get a `$` suffix, but type names reach the
+	// output through the checker's types (class declarations, `new T`,
+	// `instanceof T`, static methods), so a class named after a JavaScript
+	// built-in the generated code calls (`Array.isArray`, `new Error`) is
+	// rejected instead.  Interfaces and method-less named types emit no class.
+	_checkGlobalTypeNamesPass(programs) {
+		if (this.target === "wasm" || this.isStdlib) return;
+		for (const p of programs) {
+			for (const d of p.decls) {
+				if (
+					d.kind !== "TypeDecl" ||
+					d.isAlias ||
+					!JS_BUILTIN_CLASSES.has(d.name)
+				)
+					continue;
+				const t = this.types.get(d.name);
+				const isClass =
+					t?.underlying?.kind === "struct" || (t?.methods?.size ?? 0) > 0;
+				if (!isClass) continue;
+				this._setCurrentFile(p);
+				this.err(
+					`type ${d.name} shadows the JavaScript global ${d.name}; rename the type`,
+					d,
+				);
+			}
+		}
+	}
+
 	_typeDeclBlocked(decl, pendingNames) {
 		const visit = (node, indirect) => {
 			if (!node || typeof node !== "object") return false;
@@ -475,6 +691,22 @@ export class TypeChecker {
 		}
 	}
 
+	// Constant initializers are known before types are resolved, so an array
+	// length may name a constant declared later (`[N]int`, `[N + 1]T`).
+	_registerConstExprs(programs) {
+		for (const p of programs) {
+			for (const d of p.decls) {
+				if (d.kind !== "ConstDecl") continue;
+				for (const spec of d.decls) {
+					spec.names.forEach((name, i) => {
+						const expr = spec.value?.[i] ?? spec.value?.[0] ?? null;
+						if (expr) this.globals._constExprs.set(name, expr);
+					});
+				}
+			}
+		}
+	}
+
 	_collectVarsConstsPass(programs) {
 		for (const p of programs) {
 			this._setCurrentFile(p);
@@ -485,19 +717,44 @@ export class TypeChecker {
 		}
 	}
 
+	// Go rejects package variables whose initialisers depend on each other.
+	_reportInitCycles(programs) {
+		if (this.errors.length > 0) return;
+		const { cycles } = orderPackageInits(programs);
+		for (const c of cycles) {
+			const owner = programs.find((p) =>
+				p.decls?.some(
+					(d) =>
+						(d.kind === "VarDecl" || d.kind === "ConstDecl") &&
+						d.decls?.includes(c.spec),
+				),
+			);
+			if (owner) this._setCurrentFile(owner);
+			this.err(c.message, c.spec);
+		}
+	}
+
 	_checkTopDeclsPass(programs) {
-		for (const p of programs) {
-			this._setCurrentFile(p);
-			for (const d of p.decls) {
-				if (d.kind === "VarDecl" || d.kind === "ConstDecl") {
-					this.checkTopDecl(d, this.globals);
-				}
-			}
+		// A constant may name one declared later, so each is typed after those.
+		for (const e of orderPackageInits(programs).consts) {
+			this._setCurrentFile(e.program);
+			this.checkTopDecl({ ...e.decl, decls: [e.spec] }, this.globals);
+		}
+		// A variable's type may come from one declared later (`var a = b + 1;
+		// var b = f()`), so initialisers are typed after what they name.
+		for (const e of orderVarSpecsForTyping(programs)) {
+			this._setCurrentFile(e.program);
+			this.checkTopDecl({ ...e.decl, decls: [e.spec] }, this.globals);
 		}
 		for (const p of programs) {
 			this._setCurrentFile(p);
 			for (const d of p.decls) {
 				if (
+					this.lazyBodies &&
+					(d.kind === "FuncDecl" || d.kind === "MethodDecl")
+				)
+					this._deferBody(d, p);
+				else if (
 					d.kind === "FuncDecl" ||
 					d.kind === "MethodDecl" ||
 					d.kind === "TemplDecl"
@@ -508,20 +765,71 @@ export class TypeChecker {
 		}
 	}
 
+	// Lazy mode: validate what does not need the body now, check it on demand.
+	_deferBody(decl, program) {
+		if (decl.intrinsic) this._checkIntrinsic(decl);
+		if (decl.native) this._checkNative(decl);
+		this._lazyBodies.set(decl, program);
+	}
+
+	// Types the body of a function or method deferred by `lazyBodies`; a
+	// declaration checked already (or not deferred) is left alone.
+	checkBody(decl) {
+		const program = this._lazyBodies.get(decl);
+		if (!program) return;
+		this._lazyBodies.delete(decl);
+		this._setCurrentFile(program);
+		this.checkTopDecl(decl, this.globals);
+	}
+
 	// ── Shared pass helpers ──────────────────────────────────────
 
+	// Instances made while types were collected (`struct{ Inner[int] }`) have
+	// no methods yet, and a type embedding another embedder (`Deep` over `E`
+	// over `Base`) needs the inner promotion first, so repeat until nothing
+	// new is promoted.
 	_promoteEmbeddedMethods() {
+		const structs = [];
 		for (const type of this.types.values()) {
-			const struct = type.underlying;
-			if (struct?.kind === "struct" && struct._embeds) {
-				for (const embed of struct._embeds) {
-					const inner = embed.kind === "pointer" ? embed.base : embed;
-					const base = inner.kind === "named" ? inner.underlying : inner;
-					if (base?.kind !== "struct" || !base.methods) continue;
-					for (const [mName, mType] of base.methods.entries()) {
-						if (!struct.methods.has(mName)) struct.methods.set(mName, mType);
-					}
-				}
+			structs.push(type.underlying);
+			for (const inst of type._generic?._instances?.values() ?? []) {
+				this._syncInstanceMethods(type._generic, inst);
+				structs.push(inst.underlying);
+			}
+		}
+		const count = () =>
+			structs.reduce(
+				(n, st) => n + (st?.methods?.size ?? 0) + (st?.fields?.size ?? 0),
+				0,
+			);
+		let before;
+		do {
+			before = count();
+			for (const st of structs) this._promoteEmbeddedInto(st);
+		} while (count() !== before);
+	}
+
+	_promoteEmbeddedInto(struct) {
+		if (struct?.kind !== "struct" || !struct._embeds) return;
+		for (const embed of struct._embeds) {
+			const inner = embed.kind === "pointer" ? embed.base : embed;
+			const base = inner.kind === "named" ? inner.underlying : inner;
+			// Fields of an embedded type declared after the embedder were not
+			// there when the embedder's fields were collected.
+			if (base?.kind === "struct" && struct.fields)
+				for (const [k, v] of base.fields)
+					if (!struct.fields.has(k)) struct.fields.set(k, v);
+			// A named non-struct type (`time.Duration`) keeps its methods on
+			// the named type itself.
+			const methods =
+				base?.kind === "struct"
+					? base.methods
+					: inner.kind === "named" && base?.kind !== "interface"
+						? inner.methods
+						: null;
+			if (!methods) continue;
+			for (const [mName, mType] of methods.entries()) {
+				if (!struct.methods.has(mName)) struct.methods.set(mName, mType);
 			}
 		}
 	}
@@ -529,30 +837,39 @@ export class TypeChecker {
 	// ── Type collection ──────────────────────────────────────────
 
 	collectType(decl) {
+		if (decl.typeParams && decl.isAlias) {
+			this._collectGenericAlias(decl);
+			return;
+		}
 		if (decl.typeParams) {
 			// Generic type — resolve underlying with type params as ANY for struct fields
 			const typeScope = new Scope(this.globals);
-			const typeParamTypes = decl.typeParams.map((tp) => {
-				const t = {
-					kind: "typeParam",
-					name: tp.name,
-					constraint: tp.constraint,
-				};
+			const preset = this.types.get(decl.name)?._generic;
+			const typeParamTypes = decl.typeParams.map((tp, i) => {
+				const t =
+					preset?.declNode === decl
+						? preset.typeParams[i]
+						: {
+								kind: "typeParam",
+								name: tp.name,
+								constraint: tp.constraint,
+							};
 				typeScope.define(tp.name, t);
 				return t;
 			});
-			const underlying = this.resolveTypeNode(decl.type, typeScope);
 			const existing = this.types.get(decl.name);
 			const named =
 				existing?.kind === "named"
 					? existing
 					: { kind: "named", name: decl.name };
+			// Registered before the fields resolve so `Next *List[T]` finds the
+			// generic declaration it is part of.
+			if (preset?.declNode === decl) named._generic = preset;
+			else named._generic = { typeParams: typeParamTypes, declNode: decl };
+			this.types.set(decl.name, named);
+			const underlying = this.resolveTypeNode(decl.type, typeScope);
 			named.underlying = underlying;
 			named._target = this.target;
-			named._generic = {
-				typeParams: typeParamTypes,
-				declNode: decl,
-			};
 			if (underlying.kind === "struct") {
 				underlying.name = decl.name;
 				underlying.methods = new Map();
@@ -561,7 +878,18 @@ export class TypeChecker {
 			this.globals.define(decl.name, named);
 			return;
 		}
-		const underlying = this.resolveTypeNode(decl.type, this.globals);
+		// A type declared inside a function is registered before its fields
+		// resolve so `next *L` finds it; package-level types already are.
+		this._registerLocalTypePlaceholder(decl);
+		let underlying = this.resolveTypeNode(decl.type, this.globals);
+		// `type W V` with V a named array: W's underlying type is V's array.
+		if (!decl.isAlias && underlying.kind === "named") {
+			const inner = this._deepUnderlying(underlying);
+			if (inner?.kind === "array") underlying = inner;
+			// `type S Base` with Base a struct: S gets its own copy of the fields.
+			else if (inner?.kind === "struct")
+				underlying = { ...inner, name: decl.name, methods: new Map() };
+		}
 		if (decl.isAlias) {
 			// type A = B — transparent alias, A and B are identical types
 			this.types.set(decl.name, underlying);
@@ -588,6 +916,36 @@ export class TypeChecker {
 		this.globals.define(decl.name, named);
 	}
 
+	_registerLocalTypePlaceholder(decl) {
+		if (decl.isAlias || this.types.has(decl.name)) return;
+		const placeholder = { kind: "named", name: decl.name, underlying: null };
+		this.types.set(decl.name, placeholder);
+		this.globals.define(decl.name, placeholder);
+	}
+
+	// type A[P any] = T[P] — Go 1.24 generic alias. The declaration is a
+	// template only: each instantiation A[X] substitutes X into the aliased
+	// type and resolves to exactly that type (no new named type).
+	_collectGenericAlias(decl) {
+		const typeScope = new Scope(this.globals);
+		const typeParamTypes = decl.typeParams.map((tp) => {
+			const t = { kind: "typeParam", name: tp.name, constraint: tp.constraint };
+			typeScope.define(tp.name, t);
+			return t;
+		});
+		// Resolve once with the parameters in scope to report errors in the
+		// aliased type at the declaration.
+		const underlying = this.resolveTypeNode(decl.type, typeScope);
+		const alias = {
+			kind: "named",
+			name: decl.name,
+			underlying,
+			_generic: { typeParams: typeParamTypes, declNode: decl, isAlias: true },
+		};
+		this.types.set(decl.name, alias);
+		this.globals.define(decl.name, alias);
+	}
+
 	_buildCollectFuncScope(decl) {
 		let resolveScope = this.globals;
 		let typeParamTypes = null;
@@ -617,12 +975,16 @@ export class TypeChecker {
 	_registerFuncDecl(decl, funcType, typeParamTypes) {
 		if (this.globals.symbols.has(decl.name) && decl.name !== "init")
 			this.err(`${decl.name} redeclared in this block`, decl);
+		if (decl.native) funcType.native = decl.native;
+		this._funcDeclNames ??= new Set();
+		this._funcDeclNames.add(decl.name);
 		if (typeParamTypes) {
 			this.globals.define(decl.name, {
 				kind: "generic",
 				name: decl.name,
 				typeParams: typeParamTypes,
 				underlying: funcType,
+				declNode: decl,
 			});
 		} else {
 			this.globals.define(decl.name, funcType);
@@ -660,17 +1022,24 @@ export class TypeChecker {
 	}
 
 	_attachNonGenericMethod(decl, funcType) {
+		// Codegen of an importing package reads the body of a Go-source
+		// method (does it accept a nil receiver?).
+		funcType._methodDecl = decl;
 		const recvType = this.resolveTypeNodeName(decl.recvType, this.globals);
 		const base = recvType?.underlying ?? recvType;
 		if (base?.kind === "struct") {
+			base.methods ??= new Map();
 			base.methods.set(decl.name, funcType);
-		} else if (recvType?.kind === "named" && recvType.methods) {
+		}
+		if (recvType?.kind === "named") {
+			recvType.methods ??= new Map();
 			recvType.methods.set(decl.name, funcType);
 		}
 	}
 
 	_attachMethod(decl, funcType) {
 		funcType._ptrRecv = Boolean(decl.recvPointer);
+		funcType._decl = decl;
 		const recvNamedType = this.types.get(decl.recvType.name);
 		if (recvNamedType?._generic)
 			this._attachGenericMethod(recvNamedType, decl, funcType);
@@ -697,42 +1066,130 @@ export class TypeChecker {
 			case "CssDecl":
 				break;
 			case "TemplDecl":
-				this._markTemplNodesUsed(decl.body);
+				this._checkTemplDecl(decl, scope);
 				break;
 		}
 	}
 
-	_markTokensUsed(tokens) {
+	// A templ body is checked like a function body whose parameters are the
+	// templ's: every Go expression TemplParser attached to a node (`expr`,
+	// attribute `expr`, `forStmt`) is type-checked in the enclosing scope.
+	_checkTemplDecl(decl, outer) {
+		const inner = new Scope(outer);
+		for (const p of decl.params)
+			inner.define(p.name, this._paramType(p, inner));
+		this._checkTemplNodes(decl.body, inner);
+	}
+
+	_checkTemplNodes(nodes, scope) {
+		for (const n of nodes ?? []) {
+			const m = TEMPL_NODE_CHECKS[n.kind];
+			if (m) this[m](n, scope);
+		}
+	}
+
+	// A malformed expression has no AST: the code generator reports its parse
+	// error. Its names count as used so that error is not preceded by a
+	// misleading `declared and not used`.
+	_checkTemplExpr(node, tokens, scope) {
+		if (node.exprError) {
+			this._markTokensUsed(tokens, scope);
+			return null;
+		}
+		return node.expr ? this.checkExpr(node.expr, scope) : null;
+	}
+
+	_checkTemplElement(n, scope) {
+		for (const a of n.attrs ?? []) {
+			if (a.kind === "expr") this._checkTemplExpr(a, a.tokens, scope);
+			else if (a.kind === "cond-bool") this._checkTemplCondAttr(a, scope);
+		}
+		this._checkTemplNodes(n.children, scope);
+	}
+
+	// `name?={ cond }` sets the attribute when `cond` is true.
+	_checkTemplCondAttr(a, scope) {
+		const t = this._checkTemplExpr(a, a.tokens, scope);
+		if (t && !isBool(t) && !isAny(t))
+			this.err(`Conditional attribute '${a.name}' must be bool`, a.expr);
+	}
+
+	// `{ name... }` names a variadic parameter. A templ without a `children`
+	// parameter may still write `{ children... }` (it mounts nothing).
+	_checkTemplChildren(n, scope) {
+		if (n.name === "children" && !scope.lookup("children")) return;
+		this._checkTemplExpr(n, [], scope);
+	}
+
+	_checkTemplLeaf(n, scope) {
+		this._checkTemplExpr(n, n.tokens, scope);
+	}
+
+	_checkTemplIf(n, scope) {
+		const ct = this._checkTemplExpr(n, n.condTokens, scope);
+		if (ct && !isBool(ct) && !isAny(ct))
+			this.err("If condition must be bool", n.expr);
+		this._checkTemplNodes(n.then, scope);
+		this._checkTemplNodes(n.else_, scope);
+	}
+
+	_checkTemplSwitch(n, scope) {
+		this._checkTemplExpr(n, n.exprTokens, scope);
+		// A tag that failed to parse leaves `n.expr` unset: not a tagless switch.
+		const tagless = !n.exprTokens?.length;
+		for (const c of n.cases ?? []) {
+			this._checkTemplExpr(c, c.caseTokens, scope);
+			for (const e of c.exprs?.slice(1) ?? []) this.checkExpr(e, scope);
+			if (n.expr || tagless)
+				for (const e of c.exprs ?? []) this._checkCaseValue(n.expr, e);
+			this._checkTemplNodes(c.body, scope);
+		}
+	}
+
+	// A header that did not parse is reported by the code generator; its body
+	// is not checked, since the loop variables it would declare are unknown.
+	_checkTemplFor(n, scope) {
+		if (!n.forStmt) {
+			this._markTokensUsed(n.stmtTokens, scope);
+			this._markTemplNodesUsed(n.body, scope);
+			return;
+		}
+		this._checkForStmt(n.forStmt, scope, VOID, (bodyScope) =>
+			this._checkTemplNodes(n.body, bodyScope),
+		);
+	}
+
+	_markTokensUsed(tokens, scope) {
 		if (!tokens) return;
 		for (const t of tokens) {
 			if (t.type === "IDENT" || t.type?.name === "IDENT") {
-				this.globals.lookup(t.value);
+				scope.lookup(t.value);
 			}
 		}
 	}
 
-	_markTemplNodesUsed(nodes) {
+	_markTemplNodesUsed(nodes, scope) {
 		if (!nodes) return;
 		for (const n of nodes) {
 			if (n.kind === "TemplElement") {
 				for (const a of n.attrs || []) {
-					if (a.tokens) this._markTokensUsed(a.tokens);
+					if (a.tokens) this._markTokensUsed(a.tokens, scope);
 				}
-				this._markTemplNodesUsed(n.children);
+				this._markTemplNodesUsed(n.children, scope);
 			} else if (n.kind === "TemplExpr" || n.kind === "TemplComponent") {
-				this._markTokensUsed(n.tokens);
+				this._markTokensUsed(n.tokens, scope);
 			} else if (n.kind === "TemplIf") {
-				this._markTokensUsed(n.condTokens);
-				this._markTemplNodesUsed(n.then);
-				this._markTemplNodesUsed(n.else_);
+				this._markTokensUsed(n.condTokens, scope);
+				this._markTemplNodesUsed(n.then, scope);
+				this._markTemplNodesUsed(n.else_, scope);
 			} else if (n.kind === "TemplFor") {
-				this._markTokensUsed(n.stmtTokens);
-				this._markTemplNodesUsed(n.body);
+				this._markTokensUsed(n.stmtTokens, scope);
+				this._markTemplNodesUsed(n.body, scope);
 			} else if (n.kind === "TemplSwitch") {
-				this._markTokensUsed(n.exprTokens);
+				this._markTokensUsed(n.exprTokens, scope);
 				for (const c of n.cases || []) {
-					this._markTokensUsed(c.caseTokens);
-					this._markTemplNodesUsed(c.body);
+					this._markTokensUsed(c.caseTokens, scope);
+					this._markTemplNodesUsed(c.body, scope);
 				}
 			}
 		}
@@ -786,7 +1243,43 @@ export class TypeChecker {
 		this.globals.define(decl.name, funcType);
 	}
 
+	_checkIntrinsic(decl) {
+		const want = INTRINSICS.get(decl.intrinsic);
+		if (!want) return this.err(`unknown intrinsic '${decl.intrinsic}'`, decl);
+		if (!decl._bodyless)
+			return this.err(
+				`intrinsic '${decl.intrinsic}' must not have a body`,
+				decl,
+			);
+		const got = typeStr(this.globals.symbols.get(decl.name));
+		if (got !== want)
+			this.err(
+				`intrinsic '${decl.intrinsic}' must have type ${want}, not ${got}`,
+				decl,
+			);
+	}
+
+	_checkNative(decl) {
+		if (!this.isStdlib && !this.nativesChecked)
+			return this.err(
+				"//gofront:native is reserved for the standard library",
+				decl,
+			);
+		if (decl.kind !== "FuncDecl")
+			return this.err(
+				`native '${decl.native}' must mark a function, not a method`,
+				decl,
+			);
+		if (!NATIVES.has(decl.native))
+			return this.err(`unknown native '${decl.native}'`, decl);
+		if (decl._bodyless)
+			this.err(`native '${decl.native}' must have a Go body`, decl);
+	}
+
 	checkFuncDecl(decl, outer) {
+		this.stats.bodiesChecked++;
+		if (decl.intrinsic) this._checkIntrinsic(decl);
+		if (decl.native) this._checkNative(decl);
 		if (
 			(this.target === "wasm" || this.target === "both") &&
 			(decl.async || decl.isAsync)
@@ -800,9 +1293,9 @@ export class TypeChecker {
 		const inner = new Scope(outer);
 		this._injectTypeParams(decl, inner, outer);
 		for (const p of decl.params) {
-			inner.define(p.name, this.resolveTypeNode(p.type, inner));
+			inner.define(p.name, this._paramType(p, inner));
 		}
-		const returnType = this._setupFuncReturnType(decl, inner, outer);
+		const returnType = this._setupFuncReturnType(decl, inner);
 		const savedSharedAlloc = this._sharedAllocOk;
 		this._sharedAllocOk = decl.name === "init";
 		this._runFuncBody(decl, inner, returnType);
@@ -811,6 +1304,8 @@ export class TypeChecker {
 	}
 
 	checkMethodDecl(decl, outer) {
+		this.stats.bodiesChecked++;
+		if (decl.native) this._checkNative(decl);
 		if (
 			(this.target === "wasm" || this.target === "both") &&
 			(decl.async || decl.isAsync)
@@ -828,27 +1323,55 @@ export class TypeChecker {
 				: decl.recvType.name;
 		const recvNamedType = this.types.get(recvTypeName);
 		this._injectGenericReceiverTypeParams(inner, recvNamedType);
-		const recvType = this.resolveTypeNodeName(decl.recvType, outer);
+		const recvType = this._methodReceiverType(decl, recvNamedType, outer);
 		inner.define(
 			decl.recvName,
 			decl.recvPointer ? { kind: "pointer", base: recvType } : recvType,
 		);
 		for (const p of decl.params) {
-			inner.define(p.name, this.resolveTypeNode(p.type, inner));
+			inner.define(p.name, this._paramType(p, inner));
+		}
+		const returnType = this._setupFuncReturnType(decl, inner);
+		const savedRecvGeneric = this._recvGeneric;
+		this._recvGeneric = recvNamedType?._generic;
+		try {
+			this._runFuncBody(decl, inner, returnType);
+		} finally {
+			this._recvGeneric = savedRecvGeneric;
 		}
-		const returnType = this._setupFuncReturnType(decl, inner, inner);
-		this._runFuncBody(decl, inner, returnType);
 		this._checkMissingReturn(decl, returnType, "method");
 	}
 
-	_injectTypeParams(decl, inner, outer) {
+	// A variadic parameter `xs ...T` is a `[]T` inside the body (the signature
+	// keeps the element type plus the `variadic` flag).
+	_paramType(p, scope) {
+		const t = this.resolveTypeNode(p.type, scope);
+		return p.variadic ? { kind: "slice", elem: t } : t;
+	}
+
+	_injectTypeParams(decl, inner, _outer) {
 		if (!decl.typeParams) return;
-		for (const tp of decl.typeParams) {
-			const constraint = tp.constraint
-				? this.resolveTypeNode(tp.constraint, outer)
-				: ANY;
-			inner.define(tp.name, { kind: "typeParam", name: tp.name, constraint });
-		}
+		// Declare every parameter first so a constraint may mention one that
+		// comes later in the list (`[S ~[]E, E any]`).
+		const params = decl.typeParams.map((tp) => {
+			const t = { kind: "typeParam", name: tp.name, constraint: ANY };
+			inner.define(tp.name, t);
+			return t;
+		});
+		decl.typeParams.forEach((tp, i) => {
+			if (tp.constraint)
+				params[i].constraint = this.resolveTypeNode(tp.constraint, inner);
+		});
+	}
+
+	// Inside a method of `G[T]` the receiver is the instance `G[T]` over the
+	// receiver's own type parameters, so it is assignable to results and locals
+	// written as `G[T]`.
+	_methodReceiverType(decl, recvNamedType, outer) {
+		const generic = recvNamedType?._generic;
+		if (!generic || generic.isAlias || !generic.typeParams?.length)
+			return this.resolveTypeNodeName(decl.recvType, outer);
+		return this.instantiateGenericWithArgs(generic, generic.typeParams);
 	}
 
 	_injectGenericReceiverTypeParams(inner, recvNamedType) {
@@ -858,15 +1381,11 @@ export class TypeChecker {
 		}
 	}
 
-	_setupFuncReturnType(decl, inner, outer) {
+	_setupFuncReturnType(decl, inner) {
 		let returnType = decl.returnType
 			? this.resolveTypeNode(decl.returnType, inner)
 			: VOID;
-		const hasNamedReturns = this._injectNamedReturns(
-			decl.returnType,
-			inner,
-			outer,
-		);
+		const hasNamedReturns = this._injectNamedReturns(decl.returnType, inner);
 		if (hasNamedReturns && returnType)
 			returnType = { ...returnType, _hasNamedReturns: true };
 		return returnType;
@@ -883,17 +1402,23 @@ export class TypeChecker {
 	}
 
 	_checkMissingReturn(decl, returnType, kind) {
-		if (!isVoid(returnType) && !returnType._hasNamedReturns) {
+		if (
+			!decl._bodyless &&
+			!isVoid(returnType) &&
+			!returnType._hasNamedReturns
+		) {
 			if (!this._isTerminating(decl.body)) {
 				this.err(`missing return at end of ${kind} '${decl.name}'`, decl);
 			}
 		}
 	}
 
-	_injectNamedReturns(returnTypeNode, scope, outer) {
+	// Named result types resolve in the function scope, so a result of a type
+	// parameter's type (`(r T)`) sees T.
+	_injectNamedReturns(returnTypeNode, scope) {
 		if (!returnTypeNode?._namedReturns) return false;
 		for (const { name, type } of returnTypeNode._namedReturns) {
-			if (name) scope.define(name, this.resolveTypeNode(type, outer));
+			if (name) scope.define(name, this.resolveTypeNode(type, scope));
 		}
 		return true;
 	}
@@ -904,26 +1429,19 @@ export class TypeChecker {
 		for (const spec of decl.decls) {
 			let type = spec.type ? this.resolveTypeNode(spec.type, scope) : null;
 			if (spec.value) {
-				const valTypes = spec.value.map((v) => this.checkExpr(v, scope));
-				const isTuple = valTypes.length === 1 && valTypes[0]?.kind === "tuple";
-				const valTypesFlat = isTuple ? valTypes[0].types : valTypes;
-				if (spec.names.length !== valTypesFlat.length) {
-					const vars =
-						spec.names.length === 1
-							? "1 variable"
-							: `${spec.names.length} variables`;
-					const vals = isTuple
-						? `returns ${valTypesFlat.length} values`
-						: valTypesFlat.length === 1
-							? "1 value"
-							: `${valTypesFlat.length} values`;
-					this.err(`assignment mismatch: ${vars} but ${vals}`, spec);
-				}
+				const valTypesFlat = this._varSpecValueTypes(spec, scope);
 				for (let i = 0; i < spec.names.length; i++) {
 					const vt = valTypesFlat[i] ?? ANY;
 					const varType = type ?? defaultType(vt) ?? ANY;
+					if (!type && spec.names.length === spec.value.length)
+						this._checkConstDefault(vt, spec.value[i], "variable declaration");
 					if (type)
-						this.assertAssignable(type, vt, spec.value[i] ?? spec.value[0]);
+						this.assertAssignable(
+							type,
+							vt,
+							spec.value[i] ?? spec.value[0],
+							"variable declaration",
+						);
 					scope.defineLocal(spec.names[i], varType);
 				}
 			} else {
@@ -934,6 +1452,45 @@ export class TypeChecker {
 		this._sharedAllocOk = savedSharedAlloc;
 	}
 
+	// The type of each value a `var` spec binds (a multi-value call or a
+	// comma-ok form spreads over several names); reports a count mismatch.
+	_varSpecValueTypes(spec, scope) {
+		const commaOk = this._checkVarCommaOk(spec, scope);
+		const valTypes = commaOk ?? spec.value.map((v) => this.checkExpr(v, scope));
+		const isTuple =
+			!commaOk && valTypes.length === 1 && valTypes[0]?.kind === "tuple";
+		const flat = isTuple ? valTypes[0].types : valTypes;
+		if (spec.names.length !== flat.length && !flat.some((t) => t?._tainted))
+			this._reportAssignMismatch(spec.names.length, flat.length, isTuple, spec);
+		return flat;
+	}
+
+	_reportAssignMismatch(nameCount, valueCount, isTuple, node) {
+		const vars = nameCount === 1 ? "1 variable" : `${nameCount} variables`;
+		const vals = isTuple
+			? `returns ${valueCount} values`
+			: valueCount === 1
+				? "1 value"
+				: `${valueCount} values`;
+		this.err(`assignment mismatch: ${vars} but ${vals}`, node);
+	}
+
+	// `var v, ok = m[k]` / `var v, ok = x.(T)`: the comma-ok forms yield the
+	// value and a bool. Returns their types, or null for any other spec.
+	_checkVarCommaOk(spec, scope) {
+		if (spec.names.length !== 2 || spec.value.length !== 1) return null;
+		const value = spec.value[0];
+		if (value.kind === "TypeAssertExpr") {
+			value._commaOk = true;
+			spec._commaOk = true;
+			return [this.checkExpr(value, scope), BOOL];
+		}
+		const stmt = { lhs: spec.names, rhs: spec.value };
+		const types = this._checkAssignCommaOkMap(stmt, scope);
+		if (types) spec._commaOk = true;
+		return types;
+	}
+
 	checkConstDecl(decl, scope) {
 		for (const spec of decl.decls) {
 			const valTypes = spec.value.map((v) => this.checkExpr(v, scope));
@@ -944,6 +1501,15 @@ export class TypeChecker {
 			for (let i = 0; i < spec.names.length; i++) {
 				const name = spec.names[i];
 				const expr = spec.value?.[i] ?? spec.value?.[0] ?? null;
+				if (spec.type && expr)
+					this._checkConstOverflow(
+						type,
+						valTypes[i] ?? valTypes[0],
+						expr,
+						"constant declaration",
+					);
+				// `const D Duration = 1` is a BigInt in JS.
+				if (spec.type && expr) this._tag64BitNode(this.resolveType(type), expr);
 				scope.defineConst(name, type, expr);
 			}
 		}
@@ -957,3 +1523,4 @@ Object.assign(TypeChecker.prototype, expressionCheckMethods);
 Object.assign(TypeChecker.prototype, terminationMethods);
 Object.assign(TypeChecker.prototype, resolveMethods);
 Object.assign(TypeChecker.prototype, assignabilityMethods);
+Object.assign(TypeChecker.prototype, constantCheckMethods);