gofront 1.8.0 → 1.9.1

package/src/typechecker/init-order.js

@@ -8,10 +8,9 @@
 // (a constant may name one declared later).
 //
 // The checker reports cycles; both backends emit initialisers in this order.
-// Shadowing is handled conservatively: a name declared anywhere in a function
-// body (or as a parameter) is never counted as a reference to the package-level
-// name inside that function, so the analysis can miss a dependency but never
-// invents a cycle.
+// Shadowing follows Go's block scoping: a name declared by a parameter, result,
+// receiver or statement hides the package-level one from the next statement to
+// the end of its block, and not outside it.
 
 function forEachChildNode(node, fn) {
 	for (const key of Object.keys(node)) {
@@ -21,34 +20,35 @@ function forEachChildNode(node, fn) {
 	}
 }
 
-// Names declared inside a function-like node (parameters, results, locals).
-function declaredNames(node, out = new Set()) {
-	if (!node || typeof node !== "object") return out;
-	if (Array.isArray(node)) {
-		for (const n of node) declaredNames(n, out);
-		return out;
+// A lexical scope of locally declared names.
+class Shadow {
+	constructor(parent = null) {
+		this.parent = parent;
+		this.names = new Set();
 	}
-	if (node.kind === "DefineStmt") {
-		for (const l of [node.lhs].flat()) if (l?.kind === "Ident") out.add(l.name);
-	} else if (node.kind === "VarDecl" || node.kind === "ConstDecl") {
-		for (const spec of node.decls ?? []) for (const n of spec.names) out.add(n);
-	} else if (node.kind === "RangeStmt" || node.kind === "ForRangeStmt") {
-		for (const k of [node.key, node.value, node.keyVar, node.valueVar])
-			if (k?.kind === "Ident") out.add(k.name);
-		if (typeof node.key === "string") out.add(node.key);
-		if (typeof node.value === "string") out.add(node.value);
-	} else if (node.kind === "TypeSwitchStmt" && node.assign) {
-		out.add(node.assign);
+
+	has(name) {
+		for (let s = this; s; s = s.parent) if (s.names.has(name)) return true;
+		return false;
 	}
-	if (Array.isArray(node.params))
-		for (const p of node.params) if (p?.name) out.add(p.name);
-	if (node.recvName) out.add(node.recvName);
-	for (const r of node.returnType?._namedReturns ?? [])
-		if (r.name) out.add(r.name);
-	forEachChildNode(node, (c) => declaredNames(c, out));
+
+	add(...names) {
+		for (const n of names) if (n) this.names.add(n);
+	}
+}
+
+// Names a function-like node declares for its body: receiver, parameters and
+// named results.
+function signatureNames(node) {
+	const out = [];
+	if (node.recvName) out.push(node.recvName);
+	for (const p of node.params ?? []) if (p?.name) out.push(p.name);
+	for (const r of node.returnType?._namedReturns ?? []) out.push(r.name);
 	return out;
 }
 
+const lhsName = (l) => (typeof l === "string" ? l : l?.name);
+
 // The `Type.method` key of the declaration `name` selects on a value of type
 // `t`, found the way the checker finds it: on the type itself, else on an
 // embedded type (through pointers too).  Interface methods have no body to
@@ -83,6 +83,60 @@ function litHasExprKeys(lit) {
 	return ["MapType", "SliceType", "ArrayType"].includes(lit.typeExpr?.kind);
 }
 
+// Statements that open a scope and declare names as they run.  Each handler
+// walks the node's children in order, adding declarations to `shadow` after
+// the expressions that cannot see them.
+const SCOPED = {
+	FuncDecl: walkFunc,
+	MethodDecl: walkFunc,
+	FuncLit: walkFunc,
+	Block: (node, shadow, ctx, out) =>
+		walkRefs(node.stmts, new Shadow(shadow), ctx, out),
+	DefineStmt: (node, shadow, ctx, out) => {
+		walkRefs(node.rhs, shadow, ctx, out);
+		shadow.add(...[node.lhs].flat().map(lhsName));
+	},
+	VarDecl: walkDeclSpecs,
+	ConstDecl: walkDeclSpecs,
+	IfStmt: (node, shadow, ctx, out) => {
+		const inner = new Shadow(shadow);
+		for (const c of [node.init, node.cond, node.body, node.elseBody])
+			walkRefs(c, inner, ctx, out);
+	},
+	ForStmt: (node, shadow, ctx, out) => {
+		const inner = new Shadow(shadow);
+		for (const c of [node.init, node.cond, node.post, node.body])
+			walkRefs(c, inner, ctx, out);
+	},
+	SwitchStmt: walkSwitch,
+	TypeSwitchStmt: walkSwitch,
+};
+
+function walkFunc(node, shadow, ctx, out) {
+	const inner = new Shadow(shadow);
+	inner.add(...signatureNames(node));
+	walkRefs(node.body, inner, ctx, out);
+}
+
+function walkDeclSpecs(node, shadow, ctx, out) {
+	for (const spec of node.decls ?? []) {
+		walkRefs(spec.value, shadow, ctx, out);
+		shadow.add(...(spec.names ?? []));
+	}
+}
+
+function walkSwitch(node, shadow, ctx, out) {
+	const inner = new Shadow(shadow);
+	walkRefs(node.init, inner, ctx, out);
+	walkRefs(node.tag ?? node.expr, inner, ctx, out);
+	for (const c of node.cases ?? []) {
+		const clause = new Shadow(inner);
+		if (node.assign) clause.add(node.assign);
+		walkRefs(c.list, clause, ctx, out);
+		walkRefs(c.stmts, clause, ctx, out);
+	}
+}
+
 function walkRefs(node, shadow, ctx, out) {
 	if (!node || typeof node !== "object") return;
 	if (Array.isArray(node)) {
@@ -90,10 +144,17 @@ function walkRefs(node, shadow, ctx, out) {
 		return;
 	}
 	if (node.kind === "Ident") {
-		if (ctx.pkgNames.has(node.name) && !shadow.has(node.name))
+		// The blank identifier names nothing, whatever `var _` the package has.
+		if (
+			node.name !== "_" &&
+			ctx.pkgNames.has(node.name) &&
+			!shadow.has(node.name)
+		)
 			out.names.add(node.name);
 		return;
 	}
+	const scoped = SCOPED[node.kind];
+	if (scoped) return scoped(node, shadow, ctx, out);
 	if (node.kind === "SelectorExpr") {
 		const key = methodKeyOf(node.expr?._type, node.field, ctx.funcs);
 		if (key) out.methods.add(key);
@@ -118,11 +179,10 @@ function walkRefs(node, shadow, ctx, out) {
 /**
  * Collects what `root` (an initialiser expression or a function declaration)
  * refers to: package-level names (`names`) and declarations selected as methods
- * (`methods`, keyed `Type.method`).  The single place shadowing is decided:
- * a name declared anywhere inside `root` never counts as the package-level one.
+ * (`methods`, keyed `Type.method`), honouring block-scoped shadowing.
  */
 function collectRefs(root, ctx, out) {
-	walkRefs(root, declaredNames(root), ctx, out);
+	walkRefs(root, new Shadow(), ctx, out);
 }
 
 const emptyRefs = () => ({ names: new Set(), methods: new Set() });
@@ -261,24 +321,52 @@ function orderVars(varEntries, depsOf) {
 	return { vars, cycles: [] };
 }
 
-// Constants depend on other constants only.
+// Constants depend on other constants only; a constant that reaches itself is
+// a cycle (reported once, at the constant where the walk closed it).
 function orderConsts(constEntries) {
 	const constNames = new Set(constEntries.flatMap((e) => e.names));
 	const ctx = { pkgNames: constNames, funcs: new Map() };
 	const owner = new Map();
 	for (const e of constEntries) for (const n of e.names) owner.set(n, e);
 	const consts = [];
-	const state = new Set();
+	const cycles = [];
+	const state = new Map(); // entry -> 1 while on the walk's path, 2 when done
+	const path = [];
 	const visit = (e) => {
-		if (state.has(e)) return;
-		state.add(e);
+		state.set(e, 1);
+		path.push(e);
 		const refs = emptyRefs();
 		for (const v of e.spec.value ?? []) collectRefs(v, ctx, refs);
-		for (const n of refs.names) if (owner.has(n)) visit(owner.get(n));
+		for (const n of refs.names) {
+			const dep = owner.get(n);
+			if (!dep) continue;
+			if (state.get(dep) === 1) {
+				const names = path.slice(path.indexOf(dep)).map((p) => p.names[0]);
+				const chain = names.length === 1 ? names : [...names, names[0]];
+				cycles.push({ spec: dep.spec, message: cycleMessage(dep, chain) });
+			} else if (!state.has(dep)) visit(dep);
+		}
+		path.pop();
+		state.set(e, 2);
 		consts.push(e);
 	};
-	for (const e of constEntries) visit(e);
-	return consts;
+	for (const e of constEntries) if (!state.has(e)) visit(e);
+	return { consts, cycles };
+}
+
+// A literal initialiser (or none: the zero value) reads nothing and has no
+// effect, and gc initialises it statically, so a function that runs during
+// another variable's initialiser sees it set even when it is declared later
+// (an interface method call adds no dependency in the spec).
+const isStaticValue = (v) =>
+	v?.kind === "BasicLit" ||
+	(v?.kind === "UnaryExpr" &&
+		["-", "+"].includes(v.op) &&
+		isStaticValue(v.operand));
+
+function staticInitsFirst(vars) {
+	const isStatic = (e) => (e.spec.value ?? []).every(isStaticValue);
+	return [...vars.filter(isStatic), ...vars.filter((e) => !isStatic(e))];
 }
 
 /**
@@ -290,8 +378,16 @@ function orderConsts(constEntries) {
 export function orderPackageInits(programs) {
 	const decls = collectDecls(programs);
 	const depsOf = buildVarDeps(decls);
-	const { vars, cycles } = orderVars(decls.varEntries, depsOf);
-	return { consts: orderConsts(decls.constEntries), vars, cycles };
+	const ordered = orderVars(decls.varEntries, depsOf);
+	const { cycles } = ordered;
+	const vars =
+		cycles.length === 0 ? staticInitsFirst(ordered.vars) : ordered.vars;
+	const constOrder = orderConsts(decls.constEntries);
+	return {
+		consts: constOrder.consts,
+		vars,
+		cycles: [...constOrder.cycles, ...cycles],
+	};
 }
 
 /**

package/src/typechecker/operand-text.js

@@ -0,0 +1,41 @@
+// Source-like text of an expression for diagnostics ("cannot use y (variable
+// of type float64) as int value"). Only the common shapes are printed in full;
+// anything else falls back to "expression".
+
+function litText(node) {
+	switch (node.litKind) {
+		case "STRING":
+			return JSON.stringify(node.value);
+		case "NIL":
+			return "nil";
+		default:
+			return String(node.value);
+	}
+}
+
+const PRINTERS = {
+	Ident: (n) => n.name,
+	BasicLit: litText,
+	ImagLit: (n) => `${n.value}i`,
+	ParenExpr: (n) => `(${exprText(n.expr)})`,
+	SelectorExpr: (n) => `${exprText(n.expr)}.${n.field}`,
+	UnaryExpr: (n) => `${n.op}${exprText(n.operand)}`,
+	BinaryExpr: (n) => `${exprText(n.left)} ${n.op} ${exprText(n.right)}`,
+	CallExpr: (n) =>
+		`${exprText(n.func)}(${(n.args ?? []).map(exprText).join(", ")})`,
+	IndexExpr: (n) => `${exprText(n.expr)}[${exprText(n.index)}]`,
+};
+
+export function exprText(node) {
+	const print = node && PRINTERS[node.kind];
+	return print ? print(node) : "expression";
+}
+
+// "variable of type float64", "untyped int constant", "value of type float64".
+export function operandKind(node, typeName, isUntypedConst) {
+	if (isUntypedConst)
+		return `untyped ${typeName === "float64" ? "float" : typeName} constant`;
+	return node?.kind === "Ident"
+		? `variable of type ${typeName}`
+		: `value of type ${typeName}`;
+}