bonsai-js 1.0.0 → 1.2.0

package/dist/check/checker.mjs

@@ -1,11 +1,12 @@
 import { BonsaiLimitError } from "../errors.mjs";
 import { BLOCKED_NAMES } from "../syntax/lexer.mjs";
-import { TypeBudgetExceeded, chargeTypeWork, exactObject, fieldOf, formatType, freshLiteral, isAssignable, isExact, isNullable, isProvenAssignable, nonNull, overlaps, sameType, t, unionMembers, unionOf, widen, widenFresh, withFields, withTypeBudget } from "../types.mjs";
-import { isItemLambdaPosition, isLambdaPosition } from "../functions/define.mjs";
-import { RESULT_REFINERS } from "../functions/builtins.mjs";
+import { TypeBudgetExceeded, chargeTypeWork, exactObject, fieldOf, freshLiteral, isAssignable, isExact, isNullable, isProvenAssignable, nonNull, overlaps, sameType, t, typeText, unionMembers, unionOf, widen, widenFresh, withFields, withTypeBudget } from "../types.mjs";
+import { signatureText } from "../functions/define.mjs";
+import { forEachChild } from "../syntax/ast.mjs";
+import { bindImplicit } from "./bind.mjs";
+import { BUILTINS, RESULT_REFINERS } from "../functions/builtins.mjs";
 import { isStackOverflow, tooDeep } from "../runtime/overflow.mjs";
 import { closest, didYouMean } from "../suggest.mjs";
-import { forEachChild, mapChildren } from "../syntax/ast.mjs";
 import { writtenWithExponent } from "../syntax/parser.mjs";
 //#region src/check/checker.ts
 function hasFact(facts, key) {
@@ -21,14 +22,6 @@ function hasFact(facts, key) {
 * limits admit, small enough that a pathological one fails fast.
 */
 const CHECK_BUDGET = 5e5;
-function containsIt(node) {
-	if (node.type === "It") return true;
-	let found = false;
-	forEachChild(node, (child) => {
-		if (!found && containsIt(child)) found = true;
-	});
-	return found;
-}
 /** Whether a type explicitly admits null (unlike `any`, which admits everything). */
 function mayBeNull(type) {
 	return type.kind === "null" || type.kind === "union" && type.types.some(mayBeNull);
@@ -393,85 +386,19 @@ function analyzeWithin(root, env, options) {
 	* this node writes the entries for its subtree.
 	*/
 	const callMemo = /* @__PURE__ */ new WeakMap();
-	const bound = containsIt(root) ? bind(root) : {
-		node: root,
-		free: false
-	};
-	if (bound.free) report("INVALID_LAMBDA", "\".\" (the current item) must be inside an argument of a function that takes a lambda, e.g. items.filter(.active)", findIt(bound.node) ?? bound.node);
-	/** Rewrites implicit lambdas as explicit ones; `free` when a `.` is left unbound. */
-	function bind(node) {
-		if (node.type === "It") return {
-			node,
-			free: true
-		};
-		if (node.type === "Call") return bindCall(node);
-		let free = false;
-		return {
-			node: mapChildren(node, (child) => {
-				const r = bind(child);
-				free ||= r.free;
-				return r.node;
-			}),
-			free: node.type === "Lambda" ? false : free
-		};
-	}
-	function bindCall(node) {
-		const def = env.lookup(node.name);
-		let free = false;
-		let sawSpread = false;
-		const args = node.args.map((arg, index) => {
-			if (arg.type === "Spread") {
-				sawSpread = true;
-				const r = bind(arg.argument);
-				free ||= r.free;
-				return {
-					...arg,
-					argument: r.node
-				};
-			}
-			const lambdaPosition = !sawSpread && (def === void 0 || isLambdaPosition(def, index));
-			if (arg.type === "Lambda") {
-				const body = bind(arg.body);
-				if (body.free) report("INVALID_LAMBDA", "Use the lambda parameter instead of \".\" inside an explicit lambda", findIt(body.node) ?? arg);
-				return {
-					...arg,
-					body: body.node
-				};
-			}
-			const r = bind(arg);
-			if (lambdaPosition && r.free) {
-				if (def !== void 0 && !isItemLambdaPosition(def, index)) report("INVALID_LAMBDA", `"." is the current item, but the first parameter of ${def.name}'s lambda is not; write the parameters, e.g. (acc, x) => acc + x`, findIt(r.node) ?? arg);
-				return {
-					type: "Lambda",
-					params: [],
-					implicit: true,
-					body: r.node,
-					start: r.node.start,
-					end: r.node.end
-				};
-			}
-			free ||= r.free;
-			return r.node;
-		});
-		return {
-			node: {
-				...node,
-				args
-			},
-			free
-		};
-	}
-	const rootScope = {
+	const binding = bindImplicit(root, (name) => env.lookup(name));
+	for (const problem of binding.problems) report("INVALID_LAMBDA", problem.message, problem.at);
+	const boundRoot = binding.root;
+	const raw = check(boundRoot, {
 		locals: /* @__PURE__ */ new Map(),
 		it: void 0
-	};
-	const raw = check(bound.node, rootScope, options.expected);
+	}, options.expected);
 	let checkResult = false;
 	if (options.expected !== void 0) {
 		const problem = expectationProblem(raw, options.expected);
-		if (problem !== void 0) report("EXPECTED_TYPE", problem, resultSpan(bound.node));
+		if (problem !== void 0) report("EXPECTED_TYPE", problem, resultSpan(boundRoot));
 		const extra = unexpectedFields(raw, options.expected);
-		if (extra !== void 0) report("EXPECTED_TYPE", extra, resultSpan(bound.node), "warning");
+		if (extra !== void 0) report("EXPECTED_TYPE", extra, resultSpan(boundRoot), "warning");
 		checkResult = containsAny(raw) || !isProvenAssignable(raw, options.expected);
 	}
 	const type = widen(raw);
@@ -993,9 +920,25 @@ function analyzeWithin(root, env, options) {
 			return argType;
 		});
 		if (def === void 0) {
-			const alias = Object.hasOwn(FUNCTION_ALIASES, node.name) ? FUNCTION_ALIASES[node.name] : void 0;
-			const suggestion = alias === void 0 ? suggest(node.name, () => env.functionNames()) : /"(?<name>[^"]+)"/u.exec(alias)?.groups?.name;
-			const hint = alias === void 0 ? didYouMean(suggestion) : `; ${alias}`;
+			const excluded = BUILTINS.has(node.name);
+			let alias = !excluded && Object.hasOwn(FUNCTION_ALIASES, node.name) ? FUNCTION_ALIASES[node.name] : void 0;
+			const replacement = alias === void 0 ? void 0 : /"(?<name>[^"]+)"/u.exec(alias)?.groups?.name;
+			let leftOut;
+			if (replacement !== void 0 && env.lookup(replacement) === void 0) {
+				alias = void 0;
+				if (BUILTINS.has(replacement)) leftOut = replacement;
+			}
+			let suggestion;
+			let hint;
+			if (excluded) hint = `; ${node.name} is a built-in this environment does not include (add it to builtins)`;
+			else if (leftOut !== void 0) hint = `; the built-in for this is ${leftOut}, which this environment does not include (add it to builtins)`;
+			else if (alias === void 0) {
+				suggestion = suggest(node.name, () => env.functionNames());
+				hint = didYouMean(suggestion);
+			} else {
+				suggestion = replacement;
+				hint = `; ${alias}`;
+			}
 			report("UNKNOWN_FUNCTION", `Unknown function "${node.name}"${hint}`, {
 				start: node.nameStart ?? node.start,
 				end: node.nameEnd ?? node.end
@@ -1268,12 +1211,12 @@ function analyzeWithin(root, env, options) {
 		report("NO_OVERLOAD", `${node.name}(${shown}) does not match ${def.overloads.length > 1 ? "any of " : ""}${signatures}`, node);
 	}
 	return {
-		root: bound.node,
+		root: boundRoot,
 		type,
 		diagnostics,
 		calls,
 		types,
-		async: asyncNodes.has(bound.node),
+		async: asyncNodes.has(boundRoot),
 		checkResult,
 		references: {
 			variables: [...variables],
@@ -1504,22 +1447,6 @@ function substitute(type, b) {
 		default: return type;
 	}
 }
-function signatureText(name, candidate) {
-	const required = candidate.required ?? candidate.params.length;
-	const params = candidate.params.map((param, i) => `${typeText(param)}${i >= required ? "?" : ""}`);
-	if (candidate.rest !== void 0) params.push(`...${typeText(candidate.rest)}`);
-	return `${name}(${params.join(", ")}): ${typeText(candidate.result)}`;
-}
-function findIt(node) {
-	if (node.type === "It") return node;
-	let found;
-	const visit = (child) => {
-		found ??= findIt(child);
-	};
-	if (node.type === "Lambda") return void 0;
-	forEachChild(node, visit);
-	return found;
-}
 /** Names from other languages, with the Bonsai spelling. */
 const FUNCTION_ALIASES = {
 	length: "length is a property: write x.length",
@@ -1566,19 +1493,6 @@ const JS_GLOBALS = {
 	String: "use toString(x)",
 	Array: "use a list literal [...]"
 };
-/**
-* Longest type text in a diagnostic message. A message can name a large object
-* type, and a source can repeat the mistake thousands of times, so a short cap
-* keeps diagnostics (and their JSON) near the size of the source.
-*/
-const MESSAGE_TYPE_TEXT = 120;
-const typeTexts = /* @__PURE__ */ new WeakMap();
-/** A type's text for a diagnostic message, shortened with an ellipsis. */
-function typeText(type) {
-	let text = typeTexts.get(type);
-	if (text === void 0) typeTexts.set(type, text = formatType(type, MESSAGE_TYPE_TEXT));
-	return text;
-}
 /** Longest receiver path a diagnostic message names instead of its type. */
 const MESSAGE_PATH_TEXT = 60;
 /**
@@ -1632,6 +1546,6 @@ function suggest(name, candidatesOf) {
 	return closest(name, candidatesOf());
 }
 //#endregion
-export { acceptsArgument, analyze, signatureText };
+export { acceptsArgument, analyze };
 
 //# sourceMappingURL=checker.mjs.map