typegpu 0.10.0 → 0.10.2

package/tgsl/wgslGenerator.js

@@ -0,0 +1,585 @@
+import { $gpuCallable, $internal, $providing, isMarkedInternal } from "../shared/symbols.js";
+import { getName } from "../shared/meta.js";
+import { Void, isNaturallyEphemeral, isPtr, isWgslArray, isWgslStruct } from "../data/wgslTypes.js";
+import { ConsoleLog, InfixDispatch, UnknownData, isLooseData, unptr } from "../data/dataTypes.js";
+import { isEphemeralOrigin, isEphemeralSnippet, snip } from "../data/snippet.js";
+import { ResolutionError, WgslTypeError, invariant } from "../errors.js";
+import { isGPUCallable, isKnownAtComptime } from "../types.js";
+import { stitch } from "../core/resolve/stitch.js";
+import { createPtrFromOrigin, implicitFrom, ptrFn } from "../data/ptr.js";
+import { RefOperator } from "../data/ref.js";
+import { safeStringify } from "../shared/stringify.js";
+import { convertStructValues, convertToCommonType, tryConvertSnippet } from "./conversion.js";
+import { bool, i32, u32 } from "../data/numeric.js";
+import { AutoStruct } from "../data/autoStruct.js";
+import { ArrayExpression, coerceToSnippet, concretize, numericLiteralToSnippet } from "./generationHelpers.js";
+import { add, div, mul, neg, sub } from "../std/operators.js";
+import { accessProp } from "./accessProp.js";
+import { accessIndex } from "./accessIndex.js";
+import { constant } from "../core/constant/tgpuConstant.js";
+import { isGenericFn } from "../core/function/tgpuFn.js";
+import { arrayOf } from "../data/array.js";
+import { pow } from "../std/numeric.js";
+import { UnrollableIterable } from "../core/unroll/tgpuUnroll.js";
+import { mathToStd } from "./math.js";
+import { getElementCountSnippet, getElementSnippet, getElementType, getLoopVarKind } from "./forOfUtils.js";
+import * as tinyest from "tinyest";
+
+//#region src/tgsl/wgslGenerator.ts
+const { NodeTypeCatalog: NODE } = tinyest;
+const parenthesizedOps = [
+	"==",
+	"!=",
+	"===",
+	"!==",
+	"<",
+	"<=",
+	">",
+	">=",
+	"<<",
+	">>",
+	"+",
+	"-",
+	"*",
+	"/",
+	"%",
+	"|",
+	"^",
+	"&",
+	"&&",
+	"||"
+];
+const binaryLogicalOps = [
+	"&&",
+	"||",
+	"==",
+	"!=",
+	"===",
+	"!==",
+	"<",
+	"<=",
+	">",
+	">="
+];
+const OP_MAP = {
+	"===": "==",
+	"!==": "!=",
+	get ">>>"() {
+		throw new Error("The `>>>` operator is unsupported in TypeGPU functions.");
+	},
+	get in() {
+		throw new Error("The `in` operator is unsupported in TypeGPU functions.");
+	},
+	get instanceof() {
+		throw new Error("The `instanceof` operator is unsupported in TypeGPU functions.");
+	},
+	get "|>"() {
+		throw new Error("The `|>` operator is unsupported in TypeGPU functions.");
+	},
+	get "??"() {
+		throw new Error("The `??` operator is unsupported in TypeGPU functions.");
+	},
+	get ">>>="() {
+		throw new Error("The `>>>=` operator is unsupported in TypeGPU functions.");
+	},
+	get "**="() {
+		throw new Error("The `**=` operator is unsupported in TypeGPU functions.");
+	},
+	get "??="() {
+		throw new Error("The `??=` operator is unsupported in TypeGPU functions.");
+	},
+	get "&&="() {
+		throw new Error("The `&&=` operator is unsupported in TypeGPU functions.");
+	},
+	get "||="() {
+		throw new Error("The `||=` operator is unsupported in TypeGPU functions.");
+	}
+};
+function operatorToType(lhs, op, rhs) {
+	if (!rhs) {
+		if (op === "!") return bool;
+		return lhs;
+	}
+	if (binaryLogicalOps.includes(op)) return bool;
+	if (op === "=") return rhs;
+	return lhs;
+}
+const unaryOpCodeToCodegen = {
+	"-": neg[$gpuCallable].call.bind(neg),
+	void: () => snip(void 0, Void, "constant")
+};
+const binaryOpCodeToCodegen = {
+	"+": add[$gpuCallable].call.bind(add),
+	"-": sub[$gpuCallable].call.bind(sub),
+	"*": mul[$gpuCallable].call.bind(mul),
+	"/": div[$gpuCallable].call.bind(div),
+	"**": pow[$gpuCallable].call.bind(pow)
+};
+var WgslGenerator = class {
+	#ctx = void 0;
+	#unrolling = false;
+	initGenerator(ctx) {
+		this.#ctx = ctx;
+	}
+	get ctx() {
+		if (!this.#ctx) throw new Error("WGSL Generator has not yet been initialized. Please call initialize(ctx) before using the generator.");
+		return this.#ctx;
+	}
+	block([_, statements], externalMap) {
+		this.ctx.pushBlockScope();
+		if (externalMap) {
+			const externals = Object.fromEntries(Object.entries(externalMap).map(([id, value]) => [id, coerceToSnippet(value)]));
+			this.ctx.setBlockExternals(externals);
+		}
+		try {
+			this.ctx.indent();
+			const body = statements.map((statement) => this.statement(statement)).filter((statement) => statement.length > 0).join("\n");
+			this.ctx.dedent();
+			return `{
+${body}
+${this.ctx.pre}}`;
+		} finally {
+			this.ctx.popBlockScope();
+		}
+	}
+	refVariable(id, dataType) {
+		const varName = this.ctx.makeNameValid(id);
+		const ptrType = ptrFn(dataType);
+		const snippet = snip(new RefOperator(snip(varName, dataType, "function"), ptrType), ptrType, "function");
+		this.ctx.defineVariable(id, snippet);
+		return varName;
+	}
+	blockVariable(varType, id, dataType, origin) {
+		const naturallyEphemeral = isNaturallyEphemeral(dataType);
+		let varOrigin;
+		if (origin === "constant-tgpu-const-ref" || origin === "runtime-tgpu-const-ref") varOrigin = origin;
+		else if (origin === "argument") if (naturallyEphemeral) varOrigin = "runtime";
+		else varOrigin = "argument";
+		else if (!naturallyEphemeral) varOrigin = isEphemeralOrigin(origin) ? "this-function" : origin;
+		else if (origin === "constant" && varType === "const") varOrigin = "constant";
+		else varOrigin = "runtime";
+		const snippet = snip(this.ctx.makeNameValid(id), dataType, varOrigin);
+		this.ctx.defineVariable(id, snippet);
+		return snippet;
+	}
+	identifier(id) {
+		if (!id) throw new Error("Cannot resolve an empty identifier");
+		if (id === "undefined") return snip(void 0, Void, "constant");
+		const res = this.ctx.getById(id);
+		if (!res) throw new Error(`Identifier ${id} not found`);
+		return res;
+	}
+	/**
+	* A wrapper for `generateExpression` that updates `ctx.expectedType`
+	* and tries to convert the result when it does not match the expected type.
+	*/
+	typedExpression(expression, expectedType) {
+		const prevExpectedType = this.ctx.expectedType;
+		this.ctx.expectedType = expectedType;
+		try {
+			const result = this.expression(expression);
+			if (expectedType instanceof AutoStruct) return result;
+			return tryConvertSnippet(this.ctx, result, expectedType);
+		} finally {
+			this.ctx.expectedType = prevExpectedType;
+		}
+	}
+	expression(expression) {
+		if (typeof expression === "string") return this.identifier(expression);
+		if (typeof expression === "boolean") return snip(expression, bool, "constant");
+		if (expression[0] === NODE.logicalExpr || expression[0] === NODE.binaryExpr || expression[0] === NODE.assignmentExpr) {
+			const [exprType, lhs, op, rhs] = expression;
+			const lhsExpr = this.expression(lhs);
+			const rhsExpr = this.expression(rhs);
+			if (rhsExpr.value instanceof RefOperator) throw new WgslTypeError(stitch`Cannot assign a ref to an existing variable '${lhsExpr}', define a new variable instead.`);
+			if (op === "==") throw new Error("Please use the === operator instead of ==");
+			if (op === "===" && isKnownAtComptime(lhsExpr) && isKnownAtComptime(rhsExpr)) return snip(lhsExpr.value === rhsExpr.value, bool, "constant");
+			if (lhsExpr.dataType === UnknownData) throw new WgslTypeError(`Left-hand side of '${op}' is of unknown type`);
+			if (rhsExpr.dataType === UnknownData) throw new WgslTypeError(`Right-hand side of '${op}' is of unknown type`);
+			const codegen = binaryOpCodeToCodegen[op];
+			if (codegen) return codegen(this.ctx, [lhsExpr, rhsExpr]);
+			const forcedType = exprType === NODE.assignmentExpr ? [lhsExpr.dataType] : void 0;
+			const [convLhs, convRhs] = convertToCommonType(this.ctx, [lhsExpr, rhsExpr], forcedType) ?? [lhsExpr, rhsExpr];
+			const lhsStr = this.ctx.resolve(convLhs.value, convLhs.dataType).value;
+			const rhsStr = this.ctx.resolve(convRhs.value, convRhs.dataType).value;
+			const type = operatorToType(convLhs.dataType, op, convRhs.dataType);
+			if (exprType === NODE.assignmentExpr) {
+				if (convLhs.origin === "constant" || convLhs.origin === "constant-tgpu-const-ref" || convLhs.origin === "runtime-tgpu-const-ref") throw new WgslTypeError(`'${lhsStr} = ${rhsStr}' is invalid, because ${lhsStr} is a constant. This error may also occur when assigning to a value defined outside of a TypeGPU function's scope.`);
+				if (lhsExpr.origin === "argument") throw new WgslTypeError(`'${lhsStr} ${op} ${rhsStr}' is invalid, because non-pointer arguments cannot be mutated.`);
+				if (op === "=" && rhsExpr.origin === "argument" && !isNaturallyEphemeral(rhsExpr.dataType)) throw new WgslTypeError(`'${lhsStr} = ${rhsStr}' is invalid, because argument references cannot be assigned.\n-----\nTry '${lhsStr} = ${this.ctx.resolve(rhsExpr.dataType).value}(${rhsStr})' to copy the value instead.\n-----`);
+				if (op === "=" && !isEphemeralSnippet(rhsExpr)) throw new WgslTypeError(`'${lhsStr} = ${rhsStr}' is invalid, because references cannot be assigned.\n-----\nTry '${lhsStr} = ${this.ctx.resolve(rhsExpr.dataType).value}(${rhsStr})' to copy the value instead.\n-----`);
+			}
+			return snip(parenthesizedOps.includes(op) ? `(${lhsStr} ${OP_MAP[op] ?? op} ${rhsStr})` : `${lhsStr} ${OP_MAP[op] ?? op} ${rhsStr}`, type, "runtime");
+		}
+		if (expression[0] === NODE.postUpdate) {
+			const [_, op, arg] = expression;
+			const argExpr = this.expression(arg);
+			const argStr = this.ctx.resolve(argExpr.value, argExpr.dataType).value;
+			return snip(`${argStr}${op}`, argExpr.dataType, "runtime");
+		}
+		if (expression[0] === NODE.unaryExpr) {
+			const [_, op, arg] = expression;
+			const argExpr = this.expression(arg);
+			const codegen = unaryOpCodeToCodegen[op];
+			if (codegen) return codegen(this.ctx, [argExpr]);
+			const argStr = this.ctx.resolve(argExpr.value, argExpr.dataType).value;
+			const type = operatorToType(argExpr.dataType, op);
+			return snip(`${op}${argStr}`, type, "runtime");
+		}
+		if (expression[0] === NODE.memberAccess) {
+			const [_, targetNode, property] = expression;
+			const target = this.expression(targetNode);
+			if (target.value === console) return snip(new ConsoleLog(property), UnknownData, "runtime");
+			if (target.value === Math) {
+				if (property in mathToStd && mathToStd[property]) return snip(mathToStd[property], UnknownData, "runtime");
+				if (typeof Math[property] === "function") throw new Error(`Unsupported functionality 'Math.${property}'. Use an std alternative, or implement the function manually.`);
+			}
+			const accessed = accessProp(target, property);
+			if (!accessed) throw new Error(stitch`Property '${property}' not found on value '${target}' of type ${this.ctx.resolve(target.dataType)}`);
+			return accessed;
+		}
+		if (expression[0] === NODE.indexAccess) {
+			const [_, targetNode, propertyNode] = expression;
+			const target = this.expression(targetNode);
+			const inProperty = this.expression(propertyNode);
+			const property = convertToCommonType(this.ctx, [inProperty], [u32, i32], false)?.[0] ?? inProperty;
+			const accessed = accessIndex(target, property);
+			if (!accessed) {
+				const targetStr = this.ctx.resolve(target.value, target.dataType).value;
+				const propertyStr = this.ctx.resolve(property.value, property.dataType).value;
+				throw new Error(`Unable to index value ${targetStr} of unknown type with index ${propertyStr}. If the value is an array, to address this, consider one of the following approaches: (1) declare the array using 'tgpu.const', (2) store the array in a buffer, or (3) define the array within the GPU function scope.`);
+			}
+			return accessed;
+		}
+		if (expression[0] === NODE.numericLiteral) {
+			const type = typeof expression[1] === "string" ? numericLiteralToSnippet(parseNumericString(expression[1])) : numericLiteralToSnippet(expression[1]);
+			if (!type) throw new Error(`Invalid numeric literal ${expression[1]}`);
+			return type;
+		}
+		if (expression[0] === NODE.call) {
+			const [_, calleeNode, argNodes] = expression;
+			const callee = this.expression(calleeNode);
+			if (isWgslStruct(callee.value)) {
+				if (argNodes.length > 1) throw new WgslTypeError("Struct schemas should always be called with at most 1 argument");
+				if (!argNodes[0]) return snip(`${this.ctx.resolve(callee.value).value}()`, callee.value, "runtime");
+				const arg = this.typedExpression(argNodes[0], callee.value);
+				return snip(this.ctx.resolve(arg.value, callee.value).value, callee.value, "runtime");
+			}
+			if (isWgslArray(callee.value)) {
+				if (argNodes.length > 1) throw new WgslTypeError("Array schemas should always be called with at most 1 argument");
+				if (!argNodes[0]) return snip(`${this.ctx.resolve(callee.value).value}()`, callee.value, "runtime");
+				const arg = this.typedExpression(argNodes[0], callee.value);
+				if (arg.value instanceof ArrayExpression) return snip(stitch`${this.ctx.resolve(callee.value).value}(${arg.value.elements})`, arg.dataType, "runtime");
+				return snip(this.ctx.resolve(arg.value, callee.value).value, callee.value, "runtime");
+			}
+			if (callee.value === constant) throw new Error("Constants cannot be defined within TypeGPU function scope. To address this, move the constant definition outside the function scope.");
+			if (callee.value instanceof InfixDispatch) {
+				if (!argNodes[0]) throw new WgslTypeError(`An infix operator '${callee.value.name}' was called without any arguments`);
+				const rhs = this.expression(argNodes[0]);
+				return callee.value.operator(this.ctx, [callee.value.lhs, rhs]);
+			}
+			if (callee.value instanceof ConsoleLog) return this.ctx.generateLog(callee.value.op, argNodes.map((arg) => this.expression(arg)));
+			if (isGPUCallable(callee.value)) {
+				const callable = callee.value[$gpuCallable];
+				const strictSignature = callable.strictSignature;
+				let convertedArguments;
+				if (strictSignature) convertedArguments = argNodes.map((arg, i) => {
+					const argType = strictSignature.argTypes[i];
+					if (!argType) throw new WgslTypeError(`Function '${getName(callee.value)}' was called with too many arguments`);
+					return this.typedExpression(arg, argType);
+				});
+				else convertedArguments = argNodes.map((arg) => this.expression(arg));
+				try {
+					return callable.call(this.ctx, convertedArguments);
+				} catch (err) {
+					if (err instanceof ResolutionError) throw err;
+					throw new ResolutionError(err, [{ toString: () => `fn:${getName(callee.value)}` }]);
+				}
+			}
+			const isGeneric = isGenericFn(callee.value);
+			if (!isMarkedInternal(callee.value) || isGeneric) {
+				const slotPairs = isGeneric ? callee.value[$providing]?.pairs ?? [] : [];
+				const callback = isGeneric ? callee.value[$internal].inner : callee.value;
+				const shelllessCall = this.ctx.withRenamed(callback, getName(callee.value), () => this.ctx.withSlots(slotPairs, () => {
+					const args = argNodes.map((arg) => this.expression(arg));
+					const shellless = this.ctx.shelllessRepo.get(callback, args);
+					if (!shellless) return;
+					const converted = args.map((s, idx) => {
+						const argType = shellless.argTypes[idx];
+						return tryConvertSnippet(this.ctx, s, argType, false);
+					});
+					return this.ctx.withResetIndentLevel(() => {
+						const snippet = this.ctx.resolve(shellless);
+						return snip(stitch`${snippet.value}(${converted})`, snippet.dataType, "runtime");
+					});
+				}));
+				if (shelllessCall) return shelllessCall;
+			}
+			throw new Error(`Function '${getName(callee.value) ?? String(callee.value)}' is not marked with the 'use gpu' directive and cannot be used in a shader`);
+		}
+		if (expression[0] === NODE.objectExpr) {
+			const obj = expression[1];
+			const structType = this.ctx.expectedType;
+			if (structType instanceof AutoStruct) {
+				const entries = Object.fromEntries(Object.entries(obj).map(([key, value]) => {
+					let accessed = structType.accessProp(key);
+					let expr;
+					if (accessed) expr = this.typedExpression(value, accessed.type);
+					else {
+						expr = this.expression(value);
+						if (expr.dataType === UnknownData) throw new WgslTypeError(stitch`Property ${key} in object literal has a value of unknown type: '${expr}'`);
+						accessed = structType.provideProp(key, concretize(expr.dataType));
+					}
+					return [accessed.prop, expr];
+				}));
+				const completeStruct = structType.completeStruct;
+				const convertedSnippets = convertStructValues(this.ctx, completeStruct, entries);
+				return snip(stitch`${this.ctx.resolve(structType).value}(${convertedSnippets})`, completeStruct, "runtime");
+			}
+			if (isWgslStruct(structType)) {
+				const entries = Object.fromEntries(Object.entries(structType.propTypes).map(([key, value]) => {
+					const val = obj[key];
+					if (val === void 0) throw new WgslTypeError(`Missing property ${key} in object literal for struct ${structType}`);
+					return [key, this.typedExpression(val, value)];
+				}));
+				const convertedSnippets = convertStructValues(this.ctx, structType, entries);
+				return snip(stitch`${this.ctx.resolve(structType).value}(${convertedSnippets})`, structType, "runtime");
+			}
+			throw new WgslTypeError(`No target type could be inferred for object with keys [${Object.keys(obj).join(", ")}], please wrap the object in the corresponding schema.`);
+		}
+		if (expression[0] === NODE.arrayExpr) {
+			const [_, valueNodes] = expression;
+			const arrType = this.ctx.expectedType;
+			let elemType;
+			let values;
+			if (isWgslArray(arrType)) {
+				elemType = arrType.elementType;
+				values = valueNodes.map((value) => this.typedExpression(value, elemType));
+				if (values.length !== arrType.elementCount) throw new WgslTypeError(`Cannot create value of type '${arrType}' from an array of length: ${values.length}`);
+			} else {
+				const valuesSnippets = valueNodes.map((value) => this.expression(value));
+				if (valuesSnippets.length === 0) throw new WgslTypeError("Cannot infer the type of an empty array literal.");
+				const converted = convertToCommonType(this.ctx, valuesSnippets);
+				if (!converted) throw new WgslTypeError("The given values cannot be automatically converted to a common type. Consider wrapping the array in an appropriate schema");
+				values = converted;
+				elemType = concretize(values[0]?.dataType);
+			}
+			const arrayType = arrayOf(elemType, values.length);
+			return snip(new ArrayExpression(arrayType, values), arrayType, "runtime");
+		}
+		if (expression[0] === NODE.conditionalExpr) {
+			const [_, test, consequent, alternative] = expression;
+			const testExpression = this.expression(test);
+			if (isKnownAtComptime(testExpression)) return testExpression.value ? this.expression(consequent) : this.expression(alternative);
+			else throw new Error(`Ternary operator is only supported for comptime-known checks (used with '${testExpression.value}'). For runtime checks, please use 'std.select' or if/else statements.`);
+		}
+		if (expression[0] === NODE.stringLiteral) return snip(expression[1], UnknownData, "constant");
+		if (expression[0] === NODE.preUpdate) throw new Error("Cannot use pre-updates in TypeGPU functions.");
+		assertExhaustive(expression);
+	}
+	functionDefinition(body) {
+		return this.block(body);
+	}
+	statement(statement) {
+		if (typeof statement === "string") {
+			const id = this.identifier(statement);
+			const resolved = id.value && this.ctx.resolve(id.value).value;
+			return resolved ? `${this.ctx.pre}${resolved};` : "";
+		}
+		if (typeof statement === "boolean") return `${this.ctx.pre}${statement ? "true" : "false"};`;
+		if (statement[0] === NODE.return) {
+			const returnNode = statement[1];
+			if (returnNode !== void 0) {
+				const expectedReturnType = this.ctx.topFunctionReturnType;
+				let returnSnippet = expectedReturnType ? this.typedExpression(returnNode, expectedReturnType) : this.expression(returnNode);
+				if (returnSnippet.value instanceof RefOperator) throw new WgslTypeError(stitch`Cannot return references, returning '${returnSnippet.value.snippet}'`);
+				if (returnSnippet.origin === "argument" && !isNaturallyEphemeral(returnSnippet.dataType) && this.ctx.topFunctionScope?.functionType === "normal") throw new WgslTypeError(stitch`Cannot return references to arguments, returning '${returnSnippet}'. Copy the argument before returning it.`);
+				if (!expectedReturnType && !isEphemeralSnippet(returnSnippet) && returnSnippet.origin !== "this-function") {
+					const str = this.ctx.resolve(returnSnippet.value, returnSnippet.dataType).value;
+					const typeStr = this.ctx.resolve(unptr(returnSnippet.dataType)).value;
+					throw new WgslTypeError(`'return ${str};' is invalid, cannot return references.
+-----
+Try 'return ${typeStr}(${str});' instead.
+-----`);
+				}
+				returnSnippet = tryConvertSnippet(this.ctx, returnSnippet, unptr(returnSnippet.dataType), false);
+				invariant(returnSnippet.dataType !== UnknownData, "Return type should be known");
+				this.ctx.reportReturnType(returnSnippet.dataType);
+				return stitch`${this.ctx.pre}return ${returnSnippet};`;
+			}
+			return `${this.ctx.pre}return;`;
+		}
+		if (statement[0] === NODE.if) {
+			const [_, condNode, consNode, altNode] = statement;
+			const condition = this.typedExpression(condNode, bool);
+			const consequent = condition.value === false ? void 0 : this.block(blockifySingleStatement(consNode));
+			const alternate = condition.value === true || !altNode ? void 0 : this.block(blockifySingleStatement(altNode));
+			if (condition.value === true) return `${this.ctx.pre}${consequent}`;
+			if (condition.value === false) return alternate ? `${this.ctx.pre}${alternate}` : "";
+			if (!alternate) return stitch`${this.ctx.pre}if (${condition}) ${consequent}`;
+			return stitch`\
+${this.ctx.pre}if (${condition}) ${consequent}
+${this.ctx.pre}else ${alternate}`;
+		}
+		if (statement[0] === NODE.let || statement[0] === NODE.const) {
+			let varType = "var";
+			const [stmtType, rawId, rawValue] = statement;
+			const eq = rawValue !== void 0 ? this.expression(rawValue) : void 0;
+			if (!eq) throw new Error(`Cannot create variable '${rawId}' without an initial value.`);
+			const ephemeral = isEphemeralSnippet(eq);
+			let dataType = eq.dataType;
+			const naturallyEphemeral = isNaturallyEphemeral(dataType);
+			if (isLooseData(eq.dataType)) throw new Error(`Cannot create variable '${rawId}' with loose data type.`);
+			if (eq.value instanceof RefOperator) {
+				if (eq.dataType !== UnknownData) throw new WgslTypeError(`Cannot store d.ref() in a variable if it references another value. Copy the value passed into d.ref() instead.`);
+				const refSnippet = eq.value.snippet;
+				const varName = this.refVariable(rawId, concretize(refSnippet.dataType));
+				return stitch`${this.ctx.pre}var ${varName} = ${tryConvertSnippet(this.ctx, refSnippet, refSnippet.dataType, false)};`;
+			}
+			if (!ephemeral) {
+				if (stmtType === NODE.let) {
+					const rhsStr = this.ctx.resolve(eq.value).value;
+					const rhsTypeStr = this.ctx.resolve(unptr(eq.dataType)).value;
+					throw new WgslTypeError(`'let ${rawId} = ${rhsStr}' is invalid, because references cannot be assigned to 'let' variable declarations.
+-----
+- Try 'let ${rawId} = ${rhsTypeStr}(${rhsStr})' if you need to reassign '${rawId}' later
+- Try 'const ${rawId} = ${rhsStr}' if you won't reassign '${rawId}' later.
+-----`);
+				}
+				if (eq.origin === "constant-tgpu-const-ref") varType = "const";
+				else if (eq.origin === "runtime-tgpu-const-ref") varType = "let";
+				else {
+					varType = "let";
+					if (!isPtr(dataType)) {
+						const ptrType = createPtrFromOrigin(eq.origin, concretize(dataType));
+						invariant(ptrType !== void 0, `Creating pointer type from origin ${eq.origin}`);
+						dataType = ptrType;
+					}
+					if (!(eq.value instanceof RefOperator)) dataType = implicitFrom(dataType);
+				}
+			} else if (stmtType === NODE.const) {
+				if (eq.origin === "argument") varType = "let";
+				else if (naturallyEphemeral) varType = eq.origin === "constant" ? "const" : "let";
+			} else if (eq.origin === "argument") {
+				if (!naturallyEphemeral) {
+					const rhsStr = this.ctx.resolve(eq.value).value;
+					const rhsTypeStr = this.ctx.resolve(unptr(eq.dataType)).value;
+					throw new WgslTypeError(`'let ${rawId} = ${rhsStr}' is invalid, because references to arguments cannot be assigned to 'let' variable declarations.
+  -----
+  - Try 'let ${rawId} = ${rhsTypeStr}(${rhsStr})' if you need to reassign '${rawId}' later
+  - Try 'const ${rawId} = ${rhsStr}' if you won't reassign '${rawId}' later.
+  -----`);
+				}
+			}
+			const snippet = this.blockVariable(varType, rawId, concretize(dataType), eq.origin);
+			return stitch`${this.ctx.pre}${varType} ${snippet.value} = ${tryConvertSnippet(this.ctx, eq, dataType, false)};`;
+		}
+		if (statement[0] === NODE.block) return `${this.ctx.pre}${this.block(statement)}`;
+		if (statement[0] === NODE.for) {
+			const [_, init, condition, update, body] = statement;
+			const prevUnrollingFlag = this.#unrolling;
+			this.#unrolling = false;
+			try {
+				this.ctx.pushBlockScope();
+				const [initStatement, conditionExpr, updateStatement] = this.ctx.withResetIndentLevel(() => [
+					init ? this.statement(init) : void 0,
+					condition ? this.typedExpression(condition, bool) : void 0,
+					update ? this.statement(update) : void 0
+				]);
+				const initStr = initStatement ? initStatement.slice(0, -1) : "";
+				const updateStr = updateStatement ? updateStatement.slice(0, -1) : "";
+				const bodyStr = this.block(blockifySingleStatement(body));
+				return stitch`${this.ctx.pre}for (${initStr}; ${conditionExpr}; ${updateStr}) ${bodyStr}`;
+			} finally {
+				this.#unrolling = prevUnrollingFlag;
+				this.ctx.popBlockScope();
+			}
+		}
+		if (statement[0] === NODE.while) {
+			const prevUnrollingFlag = this.#unrolling;
+			this.#unrolling = false;
+			try {
+				const [_, condition, body] = statement;
+				const condSnippet = this.typedExpression(condition, bool);
+				const conditionStr = this.ctx.resolve(condSnippet.value).value;
+				const bodyStr = this.block(blockifySingleStatement(body));
+				return `${this.ctx.pre}while (${conditionStr}) ${bodyStr}`;
+			} finally {
+				this.#unrolling = prevUnrollingFlag;
+			}
+		}
+		if (statement[0] === NODE.forOf) {
+			const [_, loopVar, iterable, body] = statement;
+			if (loopVar[0] !== NODE.const) throw new WgslTypeError("Only `for (const ... of ... )` loops are supported");
+			let ctxIndent = false;
+			const prevUnrollingFlag = this.#unrolling;
+			try {
+				this.ctx.pushBlockScope();
+				const iterableExpr = this.expression(iterable);
+				const shouldUnroll = iterableExpr.value instanceof UnrollableIterable;
+				const iterableSnippet = shouldUnroll ? iterableExpr.value.snippet : iterableExpr;
+				const elementCountSnippet = getElementCountSnippet(this.ctx, iterableSnippet, shouldUnroll);
+				const originalLoopVarName = loopVar[1];
+				const blockified = blockifySingleStatement(body);
+				if (shouldUnroll) {
+					if (!isKnownAtComptime(elementCountSnippet)) throw new Error("Cannot unroll loop. Length of iterable is unknown at comptime.");
+					this.#unrolling = true;
+					const length = elementCountSnippet.value;
+					if (length === 0) return "";
+					const { value } = iterableSnippet;
+					const elements = value instanceof ArrayExpression ? value.elements : Array.from({ length }, (_, i) => getElementSnippet(iterableSnippet, snip(i, u32, "constant")));
+					if (isEphemeralSnippet(elements[0]) && !isNaturallyEphemeral(elements[0]?.dataType)) throw new WgslTypeError("Cannot unroll loop. The elements of iterable are emphemeral but not naturally ephemeral.");
+					return elements.map((e, i) => `${this.ctx.pre}// unrolled iteration #${i}\n${this.ctx.pre}${this.block(blockified, { [originalLoopVarName]: e })}`).join("\n");
+				}
+				if (isEphemeralSnippet(iterableSnippet)) throw new Error(`\`for ... of ...\` loops only support iterables stored in variables.
+  -----
+  You can wrap iterable with \`tgpu.unroll(...)\`. If iterable is known at comptime, the loop will be unrolled.
+  -----`);
+				this.#unrolling = false;
+				const index = this.ctx.makeNameValid("i");
+				const elementSnippet = getElementSnippet(iterableSnippet, snip(index, u32, "runtime"));
+				const loopVarName = this.ctx.makeNameValid(originalLoopVarName);
+				const loopVarKind = getLoopVarKind(elementSnippet);
+				const elementType = getElementType(elementSnippet, iterableSnippet);
+				const forHeaderStr = stitch`${this.ctx.pre}for (var ${index} = 0u; ${index} < ${elementCountSnippet}; ${index}++) {`;
+				this.ctx.indent();
+				ctxIndent = true;
+				const loopVarDeclStr = stitch`${this.ctx.pre}${loopVarKind} ${loopVarName} = ${tryConvertSnippet(this.ctx, elementSnippet, elementType, false)};`;
+				const bodyStr = `${this.ctx.pre}${this.block(blockified, { [originalLoopVarName]: snip(loopVarName, elementType, elementSnippet.origin) })}`;
+				this.ctx.dedent();
+				ctxIndent = false;
+				return stitch`${forHeaderStr}\n${loopVarDeclStr}\n${bodyStr}\n${this.ctx.pre}}`;
+			} finally {
+				if (ctxIndent) this.ctx.dedent();
+				this.#unrolling = prevUnrollingFlag;
+				this.ctx.popBlockScope();
+			}
+		}
+		if (statement[0] === NODE.continue) {
+			if (this.#unrolling) throw new WgslTypeError("Cannot unroll loop containing `continue`");
+			return `${this.ctx.pre}continue;`;
+		}
+		if (statement[0] === NODE.break) {
+			if (this.#unrolling) throw new WgslTypeError("Cannot unroll loop containing `break`");
+			return `${this.ctx.pre}break;`;
+		}
+		const expr = this.expression(statement);
+		const resolved = expr.value && this.ctx.resolve(expr.value).value;
+		return resolved ? `${this.ctx.pre}${resolved};` : "";
+	}
+};
+function assertExhaustive(value) {
+	throw new Error(`'${safeStringify(value)}' was not handled by the WGSL generator.`);
+}
+function parseNumericString(str) {
+	if (/^0x[0-9a-f]+$/i.test(str)) return Number.parseInt(str);
+	if (/^0b[01]+$/i.test(str)) return Number.parseInt(str.slice(2), 2);
+	return Number.parseFloat(str);
+}
+function blockifySingleStatement(statement) {
+	return typeof statement !== "object" || statement[0] !== NODE.block ? [NODE.block, [statement]] : statement;
+}
+const wgslGenerator = new WgslGenerator();
+
+//#endregion
+export { wgslGenerator as default };