typegpu 0.11.6 → 0.11.8

package/tgsl/wgslGenerator.js

@@ -1,14 +1,14 @@
 import { $gpuCallable, $internal, $providing, isMarkedInternal } from "../shared/symbols.js";
-import { getName } from "../shared/meta.js";
 import { Void, isBool, isNaturallyEphemeral, isNumericSchema, isPtr, isVec, isWgslArray, isWgslStruct } from "../data/wgslTypes.js";
-import { InfixDispatch, UnknownData, unptr } from "../data/dataTypes.js";
-import { fallthroughCopyOrigin, isEphemeralOrigin, isEphemeralSnippet, snip } from "../data/snippet.js";
+import { safeStringify } from "../shared/stringify.js";
+import { getName } from "../shared/meta.js";
+import { UnknownData, unptr } from "../data/dataTypes.js";
+import { fallthroughCopyOrigin, isAlias, 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, _ref } 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 { ArrayExpression, coerceToSnippet, concretize, numericLiteralToSnippet } from "./generationHelpers.js";
@@ -16,6 +16,7 @@ import { vec2u, vec3u, vec4u } from "../data/vector.js";
 import { getAttributesString } from "../data/attributes.js";
 import { AutoStruct } from "../data/autoStruct.js";
 import { add, div, mul, neg, sub } from "../std/operators.js";
+import { isInfixDispatch } from "./infixDispatch.js";
 import { accessProp } from "./accessProp.js";
 import { accessIndex } from "./accessIndex.js";
 import { constant } from "../core/constant/tgpuConstant.js";
@@ -28,6 +29,7 @@ import { mathToStd, supportedLogOps } from "./jsPolyfills.js";
 import { isTgpuRange } from "../std/range.js";
 import { getElementSnippet, getElementType, getLoopVarKind, getRangeSnippets } from "./forOfUtils.js";
 import { stringifyNode } from "../shared/tseynit.js";
+import { validSelectBranchTypes } from "../std/boolean.js";
 import * as tinyest from "tinyest";
 
 //#region src/tgsl/wgslGenerator.ts
@@ -138,6 +140,13 @@ const binaryOpCodeToCodegen = {
 	"/": div[$gpuCallable].call.bind(div),
 	"**": pow[$gpuCallable].call.bind(pow)
 };
+const usageToVarTemplateMap = {
+	private: "private",
+	workgroup: "workgroup",
+	uniform: "uniform",
+	mutable: "storage, read_write",
+	readonly: "storage, read"
+};
 var WgslGenerator = class {
 	#ctx = void 0;
 	#unrolling = false;
@@ -175,25 +184,12 @@ ${this.ctx.pre}}`;
 		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.makeUniqueIdentifier(id, "block"), dataType, varOrigin);
-		this.ctx.defineVariable(id, snippet);
-		return snippet;
-	}
 	/**
 	* Creates a variable declaration string.
 	* `keyword` may be a placeholder filled in later.
 	*/
-	emitVarDecl(pre, keyword, name, _dataType, rhsStr) {
-		return `${pre}${keyword} ${name} = ${rhsStr};`;
+	_emitVarDecl(keyword, name, _dataType, rhsStr) {
+		return `${this.ctx.pre}${keyword} ${name} = ${rhsStr};`;
 	}
 	_identifier(id) {
 		if (!id) throw new Error("Cannot resolve an empty identifier");
@@ -261,8 +257,7 @@ ${this.ctx.pre}}`;
 			if (exprType === NODE.assignmentExpr) {
 				validateSnippetMutation(convLhs, expression);
 				this.tryMarkModified(lhs);
-				if (op === "=" && rhsExpr.origin === "argument" && !isNaturallyEphemeral(rhsExpr.dataType)) throw new WgslTypeError(`'${stringifyNode(expression)}' is invalid, because argument references cannot be assigned.\n-----\nTry '${stringifyNode(lhs)} = ${this.ctx.resolve(rhsExpr.dataType).value}(${stringifyNode(rhs)})' to copy the value instead.\n-----`);
-				if (op === "=" && !isEphemeralSnippet(rhsExpr)) throw new WgslTypeError(`'${stringifyNode(expression)}' is invalid, because references cannot be assigned.\n-----\nTry '${stringifyNode(lhs)} = ${this.ctx.resolve(rhsExpr.dataType).value}(${stringifyNode(rhs)})' to copy the value instead.\n-----`);
+				if (op === "=" && isAlias(rhsExpr) && !isNaturallyEphemeral(rhsExpr.dataType)) throw new WgslTypeError(`'${stringifyNode(expression)}' is invalid, because references cannot be assigned.\n-----\nTry '${stringifyNode(lhs)} = ${this.ctx.resolve(rhsExpr.dataType).value}(${stringifyNode(rhs)})' 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");
 		}
@@ -314,10 +309,11 @@ ${this.ctx.pre}}`;
 				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`);
+			if (isInfixDispatch(callee.value)) {
+				if (!argNodes[0]) throw new WgslTypeError(`An infix operator '${getName(callee.value.operator)}' was called without any arguments`);
+				const lhs = coerceToSnippet(callee.value.lhs);
 				const rhs = this._expression(argNodes[0]);
-				return callee.value.operator(this.ctx, [callee.value.lhs, rhs]);
+				return callee.value.operator[$gpuCallable].call(this.ctx, [lhs, rhs]);
 			}
 			if ((callee.value === _ref || callee.value === unroll) && argNodes[0]) this.tryMarkModified(argNodes[0]);
 			if (isGPUCallable(callee.value)) {
@@ -413,15 +409,37 @@ ${this.ctx.pre}}`;
 			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 '${stringifyNode(expression)}' is invalid, because only comptime-known checks are supported. For runtime checks, please use 'std.select' or if/else statements.`);
+			const [_, testNode, consequentNode, alternativeNode] = expression;
+			const test = this._expression(testNode);
+			if (isKnownAtComptime(test)) return test.value ? this._expression(consequentNode) : this._expression(alternativeNode);
+			else {
+				const consequent = this._expression(consequentNode);
+				const alternative = this._expression(alternativeNode);
+				const [con, alt] = convertToCommonType(this.ctx, [consequent, alternative], validSelectBranchTypes) ?? [];
+				if (!con || !alt || consequent.possibleSideEffects || alternative.possibleSideEffects) throw new Error(`Ternary operator '${stringifyNode(expression)}' is invalid. For more complex branching, please use 'std.select' or if/else statements.`);
+				return snip(stitch`select(${alt}, ${con}, ${test})`, con.dataType, "runtime", test.possibleSideEffects);
+			}
 		}
 		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);
 	}
+	declareGlobalConst(options) {
+		const resolvedDataType = this.ctx.resolve(options.dataType).value;
+		const resolvedValue = this.ctx.resolveSnippet(options.init).value;
+		this.ctx.addDeclaration(`const ${options.id}: ${resolvedDataType} = ${resolvedValue};`);
+		return snip(options.id, options.dataType, "constant-immutable-def");
+	}
+	declareGlobalVar(options) {
+		let pre = "";
+		if (options.group !== void 0) pre += `@group(${options.group}) `;
+		if (options.binding !== void 0) pre += `@binding(${options.binding}) `;
+		if (options.scope in usageToVarTemplateMap) pre += `var<${usageToVarTemplateMap[options.scope]}> `;
+		else pre += `var `;
+		pre += `${options.id}: ${this.ctx.resolve(options.dataType).value}`;
+		this.ctx.addDeclaration(options.init ? `${pre} = ${this.ctx.resolveSnippet(options.init).value};` : `${pre};`);
+		return snip(options.id, options.dataType, options.scope);
+	}
 	functionDefinition(options) {
 		let body = this._block(options.body);
 		const scope = this.ctx.topFunctionScope;
@@ -435,7 +453,14 @@ ${this.ctx.pre}}`;
 		const argList = options.args.filter((arg) => arg.used || options.functionType === "normal").map((arg) => {
 			return `${getAttributesString(arg.decoratedType)}${arg.name}: ${this.ctx.resolve(arg.decoratedType).value}`;
 		}).join(", ");
-		return `${returnType.type !== "void" ? `(${argList}) -> ${getAttributesString(returnType)}${this.ctx.resolve(returnType).value} ` : `(${argList}) `}${body}`;
+		const head = returnType.type !== "void" ? `(${argList}) -> ${getAttributesString(returnType)}${this.ctx.resolve(returnType).value} ` : `(${argList}) `;
+		let attributes = "";
+		if (options.functionType === "compute") {
+			if (!options.workgroupSize) throw new Error("Compute shaders must have a workgroup size");
+			attributes = `@compute @workgroup_size(${options.workgroupSize.join(", ")}) `;
+		} else if (options.functionType === "vertex") attributes = `@vertex `;
+		else if (options.functionType === "fragment") attributes = `@fragment `;
+		return `${attributes}fn ${options.name}${head}${body}`;
 	}
 	/**
 	* Generates a WGSL type string for the given data type, and adds necessary
@@ -449,6 +474,17 @@ ${this.ctx.pre}}`;
 		if (args.length === 1 && args[0]?.dataType === schema) return snip(stitch`${args[0]}`, schema, fallthroughCopyOrigin(args[0].origin));
 		return snip(stitch`${this.ctx.resolve(schema).value}(${args})`, schema, "runtime");
 	}
+	numericLiteral(value, schema) {
+		if (schema.type === "abstractInt") return snip(`${value}`, schema, "constant");
+		if (schema.type === "u32") return snip(`${value}u`, schema, "constant");
+		if (schema.type === "i32") return snip(`${value}i`, schema, "constant");
+		const exp = value.toExponential();
+		const decimal = schema.type === "abstractFloat" && Number.isInteger(value) ? `${value}.` : `${value}`;
+		const base = exp.length < decimal.length ? exp : decimal;
+		if (schema.type === "f32") return snip(`${base}f`, schema, "constant");
+		if (schema.type === "f16") return snip(`${base}h`, schema, "constant");
+		return snip(base, schema, "constant");
+	}
 	_return(statement) {
 		const returnNode = statement[1];
 		if (returnNode !== void 0) {
@@ -456,7 +492,7 @@ ${this.ctx.pre}}`;
 			let returnSnippet = expectedReturnType ? this._typedExpression(returnNode, expectedReturnType) : this._expression(returnNode);
 			if (returnSnippet.value instanceof RefOperator) throw new WgslTypeError(`Cannot return '${stringifyNode(returnNode)}' because it is a d.ref`);
 			if (returnSnippet.origin === "argument" && !isNaturallyEphemeral(returnSnippet.dataType) && this.ctx.topFunctionScope?.functionType === "normal") throw new WgslTypeError(`'${stringifyNode(statement)}' is invalid, cannot return references to arguments. Copy the argument before returning it.`);
-			if (!expectedReturnType && !isEphemeralSnippet(returnSnippet) && returnSnippet.origin !== "this-function") {
+			if (!expectedReturnType && isAlias(returnSnippet) && !isNaturallyEphemeral(returnSnippet.dataType) && returnSnippet.origin !== "local-def") {
 				const str = stringifyNode(returnNode);
 				const typeStr = this.ctx.resolve(unptr(returnSnippet.dataType)).value;
 				throw new WgslTypeError(`'return ${str};' is invalid, cannot return references.
@@ -471,6 +507,106 @@ Try 'return ${typeStr}(${str});' instead.
 		}
 		return `${this.ctx.pre}return;`;
 	}
+	_letStatement(statement) {
+		const [_, rawId, eqNode] = statement;
+		if (eqNode === void 0) throw new Error(`'${stringifyNode(statement)}' is invalid because all variables need initializers.`);
+		const eq = this._expression(eqNode);
+		if (eq.value instanceof RefOperator) {
+			const rhsStr$1 = stringifyNode(eqNode);
+			throw new WgslTypeError(`'let ${rawId} = ${rhsStr$1}' is invalid, cannot initialize 'let' variables with d.ref()
+-----
+- Try 'const ${rawId} = ${rhsStr$1}'.
+-----`);
+		}
+		const definitionDataType = eq.dataType;
+		if (definitionDataType === UnknownData) {
+			const rhsStr$1 = stringifyNode(eqNode);
+			throw new WgslTypeError(`'let ${rawId} = ${rhsStr$1}' is invalid, cannot determine WGSL type of '${rhsStr$1}'
+-----
+- Try using or defining a schema that matches your desired value the most, and wrap the value with it: 'let ${rawId} = Schema(${rhsStr$1})'
+-----`);
+		}
+		if (isAlias(eq) && !isNaturallyEphemeral(eq.dataType)) {
+			const rhsStr$1 = stringifyNode(eqNode);
+			const rhsTypeStr = this.ctx.resolve(unptr(eq.dataType)).value;
+			throw new WgslTypeError(`'let ${rawId} = ${rhsStr$1}' is invalid, because references cannot be assigned to 'let' variable declarations.
+-----
+- Try 'let ${rawId} = ${rhsTypeStr}(${rhsStr$1})' if you need to reassign '${rawId}' later
+- Try 'const ${rawId} = ${rhsStr$1}' if you won't reassign '${rawId}' later.
+-----`);
+		}
+		const concreteType = concretize(definitionDataType);
+		const snippet = snip(this.ctx.makeUniqueIdentifier(rawId, "block"), concreteType, "local-def", false);
+		this.ctx.defineVariable(rawId, snippet);
+		const rhsSnippet = tryConvertSnippet(this.ctx, eq, definitionDataType, false);
+		const rhsStr = this.ctx.resolve(rhsSnippet.value, rhsSnippet.dataType).value;
+		const scope = this.ctx.topFunctionScope;
+		invariant(scope, `Expected function scope to be present for ${rawId}`);
+		const emittedVarType = `#VAR_${scope.placeholderForVariable.size}#`;
+		scope.placeholderForVariable.set(snippet, emittedVarType);
+		return this._emitVarDecl(emittedVarType, snippet.value, concreteType, rhsStr);
+	}
+	_constStatement(statement) {
+		const [_, rawId, eqNode] = statement;
+		if (eqNode === void 0) throw new Error(`'${stringifyNode(statement)}' is invalid because all variables need initializers.`);
+		const eq = this._expression(eqNode);
+		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)};`;
+		}
+		const rhsNaturallyEphemeral = isNaturallyEphemeral(eq.dataType);
+		let varOrigin = "local-def";
+		let varType = "<deferred>";
+		let definitionDataType = eq.dataType;
+		if (definitionDataType === UnknownData) {
+			const rhsStr$1 = stringifyNode(eqNode);
+			throw new WgslTypeError(`'const ${rawId} = ${rhsStr$1}' is invalid, cannot determine WGSL type of '${rhsStr$1}'
+-----
+- Try using or defining a schema that matches your desired value the most, and wrap the value with it: 'const ${rawId} = Schema(${rhsStr$1})'
+-----`);
+		}
+		if (eq.origin === "argument") {
+			varType = "let";
+			varOrigin = rhsNaturallyEphemeral ? "local-def" : "argument";
+		} else if (eq.origin === "constant-immutable-def") {
+			varType = "const";
+			varOrigin = "constant-immutable-def";
+		} else if (eq.origin === "runtime-immutable-def") {
+			varType = "let";
+			varOrigin = "runtime-immutable-def";
+		} else if (rhsNaturallyEphemeral) {
+			varType = eq.origin === "constant" ? "const" : "let";
+			varOrigin = "local-def";
+		} else if (!isAlias(eq)) {
+			varType = "<deferred>";
+			varOrigin = "local-def";
+		} else {
+			varType = "let";
+			varOrigin = eq.origin;
+			if (!isPtr(eq.dataType)) {
+				const ptrType = createPtrFromOrigin(eq.origin, concretize(eq.dataType));
+				invariant(ptrType !== void 0, `Creating pointer type from origin ${eq.origin}`);
+				definitionDataType = ptrType;
+			}
+			definitionDataType = implicitFrom(definitionDataType);
+			this.tryMarkModified(eqNode);
+		}
+		const concreteType = concretize(definitionDataType);
+		const snippet = snip(this.ctx.makeUniqueIdentifier(rawId, "block"), concreteType, varOrigin, false);
+		this.ctx.defineVariable(rawId, snippet);
+		const rhsSnippet = tryConvertSnippet(this.ctx, eq, definitionDataType, false);
+		const rhsStr = this.ctx.resolve(rhsSnippet.value, rhsSnippet.dataType).value;
+		let emittedVarType;
+		if (varType === "<deferred>") {
+			const scope = this.ctx.topFunctionScope;
+			invariant(scope, `Expected function scope to be present for ${rawId}`);
+			emittedVarType = `#VAR_${scope.placeholderForVariable.size}#`;
+			scope.placeholderForVariable.set(snippet, emittedVarType);
+		} else emittedVarType = varType;
+		return this._emitVarDecl(emittedVarType, snippet.value, concreteType, rhsStr);
+	}
 	_statement(statement) {
 		if (typeof statement === "string") {
 			const id = this._identifier(statement);
@@ -497,70 +633,8 @@ Try 'return ${typeStr}(${str});' instead.
 ${this.ctx.pre}if (${condition}) ${consequent}
 ${this.ctx.pre}else ${alternate}`;
 		}
-		if (statement[0] === NODE.let || statement[0] === NODE.const) {
-			let varType = "<deferred>";
-			const [stmtType, rawId, rawValue] = statement;
-			const eq = rawValue !== void 0 ? this._expression(rawValue) : void 0;
-			if (!eq) throw new Error(`'${stringifyNode(statement)}' is invalid because all variables need initializers.`);
-			const ephemeral = isEphemeralSnippet(eq);
-			let dataType = eq.dataType;
-			const naturallyEphemeral = isNaturallyEphemeral(dataType);
-			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$1 = stringifyNode(rawValue ?? "");
-					const rhsTypeStr = this.ctx.resolve(unptr(eq.dataType)).value;
-					throw new WgslTypeError(`'let ${rawId} = ${rhsStr$1}' is invalid, because references cannot be assigned to 'let' variable declarations.
------
-- Try 'let ${rawId} = ${rhsTypeStr}(${rhsStr$1})' if you need to reassign '${rawId}' later
-- Try 'const ${rawId} = ${rhsStr$1}' 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);
-						this.tryMarkModified(rawValue);
-					}
-				}
-			} 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$1 = stringifyNode(rawValue ?? "");
-					const rhsTypeStr = this.ctx.resolve(unptr(eq.dataType)).value;
-					throw new WgslTypeError(`'let ${rawId} = ${rhsStr$1}' is invalid, because references to arguments cannot be assigned to 'let' variable declarations.
-  -----
-  - Try 'let ${rawId} = ${rhsTypeStr}(${rhsStr$1})' if you need to reassign '${rawId}' later
-  - Try 'const ${rawId} = ${rhsStr$1}' if you won't reassign '${rawId}' later.
-  -----`);
-				}
-			}
-			const snippet = this.blockVariable(varType, rawId, concretize(dataType), eq.origin);
-			const rhsSnippet = tryConvertSnippet(this.ctx, eq, dataType, false);
-			const rhsStr = this.ctx.resolve(rhsSnippet.value, rhsSnippet.dataType).value;
-			let emittedVarType;
-			if (varType === "<deferred>") {
-				const scope = this.ctx.topFunctionScope;
-				invariant(scope, `Expected function scope to be present for ${rawId}`);
-				emittedVarType = `#VAR_${scope.placeholderForVariable.size}#`;
-				scope.placeholderForVariable.set(snippet, emittedVarType);
-			} else emittedVarType = varType;
-			return this.emitVarDecl(this.ctx.pre, emittedVarType, snippet.value, concretize(dataType), rhsStr);
-		}
+		if (statement[0] === NODE.let) return this._letStatement(statement);
+		if (statement[0] === NODE.const) return this._constStatement(statement);
 		if (statement[0] === NODE.block) return this._blockStatement(statement);
 		if (statement[0] === NODE.for) {
 			const [_, init, condition, update, body] = statement;
@@ -616,7 +690,8 @@ ${this.ctx.pre}else ${alternate}`;
 					if (length === 0) return "";
 					const { value } = iterableSnippet;
 					const elements = isTgpuRange(value) ? value.map((i) => coerceToSnippet(i)) : value instanceof ArrayExpression ? value.elements : Array.from({ length }, (_$1, i) => getElementSnippet(iterableSnippet, snip(i, u32, "constant")));
-					if (isEphemeralSnippet(elements[0]) && !isNaturallyEphemeral(elements[0]?.dataType)) throw new WgslTypeError(`Cannot unroll '${stringifyNode(iterable)}'. The elements of iterable are constructed in place but are not value types.`);
+					const firstElement = elements[0];
+					if (!isAlias(firstElement) && !isNaturallyEphemeral(firstElement.dataType)) throw new WgslTypeError(`Cannot unroll '${stringifyNode(iterable)}'. The elements of iterable are constructed in place but are not value types.`);
 					return elements.map((e, i) => `${this.ctx.pre}// unrolled iteration #${i}\n${this._blockStatement(blockified, { [originalLoopVarName]: e })}`).join("\n");
 				}
 				this.#unrolling = false;
@@ -686,10 +761,12 @@ ${this.ctx.pre}else ${alternate}`;
 	}
 };
 function validateSnippetMutation(mutated, expr) {
-	if (mutated.origin === "constant" || mutated.origin === "constant-tgpu-const-ref" || mutated.origin === "runtime-tgpu-const-ref") {
+	if (mutated.origin === "constant" || mutated.origin === "constant-immutable-def" || mutated.origin === "runtime-immutable-def") {
 		if (isKnownAtComptime(mutated)) throw new WgslTypeError(`'${stringifyNode(expr)}' is invalid, because the left side is defined outside of the shader, and therefore is immutable during its execution. Try using tgpu.privateVar or buffers.`);
 		throw new WgslTypeError(`'${stringifyNode(expr)}' is invalid, because the left side is a constant.`);
 	}
+	if (mutated.origin === "uniform") throw new WgslTypeError(`'${stringifyNode(expr)}' is invalid, because uniform buffers cannot be mutated.`);
+	if (mutated.origin === "readonly") throw new WgslTypeError(`'${stringifyNode(expr)}' is invalid, because readonly buffers cannot be mutated.`);
 	if (mutated.origin === "argument") throw new WgslTypeError(`'${stringifyNode(expr)}' is invalid, because non-pointer arguments cannot be mutated.`);
 }
 function assertExhaustive(value) {

package/types.d.ts

@@ -16,7 +16,7 @@ import { ShaderGenerator } from "./tgsl/shaderGenerator.js";
 import { TgpuBuffer } from "./core/buffer/buffer.js";
 import { TgpuDeclare } from "./core/declare/tgpuDeclare.js";
 import { TgpuFn } from "./core/function/tgpuFn.js";
-import { WgslExtension } from "./wgslExtensions.js";
+import { WgslEnableExtension } from "./wgslExtensions.js";
 import { AnyMatInstance, AnyVecInstance, BaseData } from "./data/wgslTypes.js";
 import { TgpuTexture, TgpuTextureView } from "./core/texture/texture.js";
 import { Infer } from "./shared/repr.js";
@@ -28,8 +28,10 @@ import { Block, FuncParameter } from "tinyest";
 type ResolvableObject = SelfResolvable | TgpuBufferUsage | TgpuConst | TgpuDeclare | TgpuBindGroupLayout | TgpuFn | TgpuComputeFn | TgpuFragmentFn | TgpuComputePipeline | TgpuRenderPipeline | TgpuVertexFn | TgpuSampler | TgpuAccessor | TgpuExternalTexture | TgpuTexture | TgpuTextureView | TgpuVar | AnyVecInstance | AnyMatInstance | AnyData | ((...args: never[]) => unknown);
 type Wgsl = Eventual<string | number | boolean | ResolvableObject>;
 type TgpuShaderStage = 'compute' | 'vertex' | 'fragment';
-interface FnToWgslOptions {
+interface ResolveFunctionOptions {
   functionType: 'normal' | TgpuShaderStage;
+  workgroupSize?: readonly number[] | undefined;
+  name: string;
   argTypes: BaseData[];
   /**
    * The return type of the function. If undefined, the type should be inferred
@@ -196,7 +198,7 @@ interface ResolutionCtx {
     itemStateStack: ItemStateStack;
   };
   readonly mode: ExecState;
-  readonly enableExtensions: WgslExtension[] | undefined;
+  readonly enableExtensions: WgslEnableExtension[] | undefined;
   readonly gen: ShaderGenerator;
   addDeclaration(declaration: string): void;
   withResetIndentLevel<T>(callback: () => T): T;
@@ -232,7 +234,7 @@ interface ResolutionCtx {
    * Equivalent to `snip(ctx.resolve(snippet.value, snippet.dataType).value, snippet.dataType, snippet.origin)`.
    */
   resolveSnippet(snippet: Snippet): ResolvedSnippet;
-  fnToWgsl(options: FnToWgslOptions): {
+  resolveFunction(options: ResolveFunctionOptions): {
     code: string;
     returnType: BaseData;
   };

package/wgslExtensions.d.ts

@@ -1,5 +1,5 @@
 //#region src/wgslExtensions.d.ts
-declare const wgslExtensions: readonly ["f16", "clip_distances", "dual_source_blending", "subgroups", "primitive_index"];
-type WgslExtension = (typeof wgslExtensions)[number];
+declare const wgslEnableExtensions: readonly ["f16", "clip_distances", "dual_source_blending", "subgroups", "primitive_index"];
+type WgslEnableExtension = (typeof wgslEnableExtensions)[number];
 //#endregion
-export { WgslExtension };
+export { WgslEnableExtension };

package/wgslExtensions.js

@@ -1,12 +1,12 @@
 //#region src/wgslExtensions.ts
-const wgslExtensions = [
+const wgslEnableExtensions = [
 	"f16",
 	"clip_distances",
 	"dual_source_blending",
 	"subgroups",
 	"primitive_index"
 ];
-const wgslExtensionToFeatureName = {
+const wgslEnableExtensionToFeatureName = {
 	f16: "shader-f16",
 	clip_distances: "clip-distances",
 	dual_source_blending: "dual-source-blending",
@@ -15,4 +15,4 @@ const wgslExtensionToFeatureName = {
 };
 
 //#endregion
-export { wgslExtensionToFeatureName, wgslExtensions };
+export { wgslEnableExtensionToFeatureName, wgslEnableExtensions };