typegpu 0.11.4 → 0.11.5

package/package.js

@@ -1,5 +1,5 @@
 //#region package.json
-var version = "0.11.4";
+var version = "0.11.5";
 
 //#endregion
 export { version };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typegpu",
-  "version": "0.11.4",
+  "version": "0.11.5",
   "description": "A thin layer between JS and WebGPU/WGSL that improves development experience and allows for faster iteration.",
   "keywords": [
     "compute",

package/resolutionCtx.js

@@ -12,12 +12,12 @@ import { safeStringify } from "./shared/stringify.js";
 import { getBestConversion } from "./tgsl/conversion.js";
 import { bool } from "./data/numeric.js";
 import { coerceToSnippet, concretize, numericLiteralToSnippet } from "./tgsl/generationHelpers.js";
+import { sanitizePrimer, validateIdentifier } from "./nameUtils.js";
 import { createIoSchema } from "./core/function/ioSchema.js";
 import { AutoStruct } from "./data/autoStruct.js";
 import { EntryInputRouter } from "./core/function/entryInputRouter.js";
 import { accessProp } from "./tgsl/accessProp.js";
 import { isTgpuFn } from "./core/function/tgpuFn.js";
-import { getUniqueName } from "./core/resolve/namespace.js";
 import { ConfigurableImpl } from "./core/root/configurableImpl.js";
 import { naturalsExcept } from "./shared/generators.js";
 import { TgpuBindGroupImpl, bindGroupLayout } from "./tgpuBindGroupLayout.js";
@@ -50,6 +50,9 @@ var ItemStateStackImpl = class {
 	get topFunctionScope() {
 		return this._stack.findLast((e) => e.type === "functionScope");
 	}
+	get topBlockScope() {
+		return this._stack.findLast((e) => e.type === "blockScope");
+	}
 	pushItem() {
 		this._itemDepth++;
 		this._stack.push({
@@ -70,7 +73,9 @@ var ItemStateStackImpl = class {
 			argAccess,
 			returnType,
 			externalMap,
-			reportedReturnTypes: /* @__PURE__ */ new Set()
+			reportedReturnTypes: /* @__PURE__ */ new Set(),
+			placeholderForVariable: /* @__PURE__ */ new Map(),
+			modifiedVariables: /* @__PURE__ */ new Set()
 		};
 		this._stack.push(scope);
 		return scope;
@@ -78,6 +83,7 @@ var ItemStateStackImpl = class {
 	pushBlockScope() {
 		this._stack.push({
 			type: "blockScope",
+			takenLocalIdentifiers: /* @__PURE__ */ new Set(),
 			declarations: /* @__PURE__ */ new Map(),
 			externals: /* @__PURE__ */ new Map()
 		});
@@ -116,6 +122,16 @@ var ItemStateStackImpl = class {
 			}
 		}
 	}
+	isIdentifierTakenLocally(id) {
+		for (let i = this._stack.length - 1; i >= 0; --i) {
+			const layer = this._stack[i];
+			if (layer?.type === "functionScope") return false;
+			if (layer?.type === "blockScope") {
+				if (layer.takenLocalIdentifiers.has(id)) return true;
+			}
+		}
+		return false;
+	}
 	defineBlockVariable(id, snippet) {
 		if (snippet.dataType === UnknownData) throw Error(`Tried to define variable '${id}' of unknown type`);
 		for (let i = this._stack.length - 1; i >= 0; --i) {
@@ -232,17 +248,41 @@ var ResolutionCtxImpl = class {
 	fixedBindings = [];
 	enableExtensions;
 	expectedType;
+	/**
+	* A counter used to generate unique identifiers for globally-scoped definitions in the 'random' strategy.
+	*/
+	#lastUniqueId = 0;
 	constructor(opts) {
 		this.enableExtensions = opts.enableExtensions;
 		this.gen = opts.shaderGenerator ?? wgslGenerator_default;
 		this.#logGenerator = opts.root ? new LogGeneratorImpl(opts.root) : new LogGeneratorNullImpl();
 		this.#namespaceInternal = opts.namespace[$internal];
 	}
-	getUniqueName(resource) {
-		return getUniqueName(this.#namespaceInternal, resource);
+	isIdentifierTaken(name) {
+		return this.#namespaceInternal.takenGlobalIdentifiers.has(name) || this._itemStateStack.isIdentifierTakenLocally(name);
 	}
-	makeNameValid(name) {
-		return this.#namespaceInternal.nameRegistry.makeValid(name);
+	makeUniqueIdentifier(primer = "item", scope) {
+		if (scope === "block" && (/* @__PURE__ */ validateIdentifier(primer)).success && !this.isIdentifierTaken(primer)) {
+			this.reserveIdentifier(primer, "block");
+			return primer;
+		}
+		const base = /* @__PURE__ */ sanitizePrimer(primer);
+		let index = 0;
+		const random = this.#namespaceInternal.strategy === "random";
+		let name = random ? `${base}_${this.#lastUniqueId++}` : base;
+		while (this.isIdentifierTaken(name)) name = random ? `${base}_${this.#lastUniqueId++}` : `${base}_${++index}`;
+		this.reserveIdentifier(name, scope);
+		return name;
+	}
+	reserveIdentifier(name, scope) {
+		if (scope === "block") {
+			const blockScope = this._itemStateStack.topBlockScope;
+			if (blockScope) {
+				blockScope.takenLocalIdentifiers.add(name);
+				return;
+			}
+		}
+		this.#namespaceInternal.takenGlobalIdentifiers.add(name);
 	}
 	get pre() {
 		return this._indentController.pre;
@@ -281,11 +321,9 @@ var ResolutionCtxImpl = class {
 		scope.reportedReturnTypes.add(dataType);
 	}
 	pushBlockScope() {
-		this.#namespaceInternal.nameRegistry.pushBlockScope();
 		this._itemStateStack.pushBlockScope();
 	}
 	popBlockScope() {
-		this.#namespaceInternal.nameRegistry.popBlockScope();
 		this._itemStateStack.pop("blockScope");
 	}
 	setBlockExternals(externals) {
@@ -301,28 +339,27 @@ var ResolutionCtxImpl = class {
 		return this.#logGenerator.logResources;
 	}
 	fnToWgsl(options) {
-		let fnScopePushed = false;
 		try {
-			this.#namespaceInternal.nameRegistry.pushFunctionScope();
+			const scope = this._itemStateStack.pushFunctionScope(options.functionType, {}, options.returnType, options.externalMap);
+			this._itemStateStack.pushBlockScope();
 			const args = [];
-			const argAccess = {};
 			if (options.entryInput) {
 				const { dataSchema, positionalArgs } = options.entryInput;
 				const firstParam = options.params[0];
-				const structArg = dataSchema ? createArgument(this.makeNameValid("_arg_0"), dataSchema) : void 0;
+				const structArg = dataSchema ? createArgument(this.makeUniqueIdentifier("_arg_0", "block"), dataSchema) : void 0;
 				if (structArg) args.push(structArg);
 				if (firstParam?.type === FuncParameterType.destructuredObject) for (const { name, alias } of firstParam.props) {
 					const argInfo = positionalArgs.find((a) => a.schemaKey === name);
 					if (argInfo) {
-						const arg = createArgument(this.makeNameValid(alias), argInfo.type);
+						const arg = createArgument(this.makeUniqueIdentifier(alias, "block"), argInfo.type);
 						args.push(arg);
-						argAccess[alias] = arg.access;
-					} else if (structArg) argAccess[alias] = createArgumentPropAccess(structArg.access, name);
+						scope.argAccess[alias] = arg.access;
+					} else if (structArg) scope.argAccess[alias] = createArgumentPropAccess(structArg.access, name);
 				}
 				else if (firstParam?.type === FuncParameterType.identifier) {
 					const proxyEntries = [];
 					for (const a of positionalArgs) {
-						const arg = createArgument(this.makeNameValid(`_arg_${a.schemaKey}`), a.type);
+						const arg = createArgument(this.makeUniqueIdentifier(`_arg_${a.schemaKey}`, "block"), a.type);
 						args.push(arg);
 						proxyEntries.push({
 							schemaKey: a.schemaKey,
@@ -330,31 +367,31 @@ var ResolutionCtxImpl = class {
 						});
 					}
 					const router = new EntryInputRouter(structArg?.access, proxyEntries);
-					argAccess[firstParam.name] = () => snip("N/A", router, "argument");
+					scope.argAccess[firstParam.name] = () => snip("N/A", router, "argument");
 				} else for (const a of positionalArgs) {
-					const argName = this.makeNameValid(`_arg_${a.schemaKey}`);
+					const argName = this.makeUniqueIdentifier(`_arg_${a.schemaKey}`, "block");
 					const arg = createArgument(argName, a.type);
 					args.push(arg);
-					argAccess[argName] = arg.access;
+					scope.argAccess[argName] = arg.access;
 				}
 			} else for (const [i, argType] of options.argTypes.entries()) {
 				const astParam = options.params[i];
 				const origin = isPtr(argType) ? argType.addressSpace === "storage" ? argType.access === "read" ? "readonly" : "mutable" : argType.addressSpace : "argument";
 				switch (astParam?.type) {
 					case FuncParameterType.identifier: {
-						const arg = createArgument(this.makeNameValid(astParam.name), argType, origin);
+						const arg = createArgument(this.makeUniqueIdentifier(astParam.name, "block"), argType, origin);
 						args.push(arg);
-						argAccess[astParam.name] = arg.access;
+						scope.argAccess[astParam.name] = arg.access;
 						break;
 					}
 					case FuncParameterType.destructuredObject: {
-						const objArg = createArgument(this.makeNameValid(`_arg_${i}`), argType, origin);
+						const objArg = createArgument(this.makeUniqueIdentifier(`_arg_${i}`, "block"), argType, origin);
 						args.push(objArg);
-						for (const { name, alias } of astParam.props) argAccess[alias] = createArgumentPropAccess(objArg.access, name);
+						for (const { name, alias } of astParam.props) scope.argAccess[alias] = createArgumentPropAccess(objArg.access, name);
 						break;
 					}
 					case void 0: if (!(argType instanceof AutoStruct)) args.push({
-						name: this.makeNameValid(`_arg_${i}`),
+						name: this.makeUniqueIdentifier(`_arg_${i}`, "block"),
 						access: () => {
 							throw new Error(`Unreachable: Accessing an argument that wasn't named in the function signature`);
 						},
@@ -363,8 +400,6 @@ var ResolutionCtxImpl = class {
 					});
 				}
 			}
-			const scope = this._itemStateStack.pushFunctionScope(options.functionType, argAccess, options.returnType, options.externalMap);
-			fnScopePushed = true;
 			let returnType;
 			const code = this.gen.functionDefinition({
 				functionType: options.functionType,
@@ -395,8 +430,8 @@ var ResolutionCtxImpl = class {
 				returnType
 			};
 		} finally {
-			if (fnScopePushed) this._itemStateStack.pop("functionScope");
-			this.#namespaceInternal.nameRegistry.popFunctionScope();
+			this._itemStateStack.pop("blockScope");
+			this._itemStateStack.pop("functionScope");
 		}
 	}
 	addDeclaration(declaration) {

package/std/copy.d.ts

@@ -0,0 +1,7 @@
+import { DualFn } from "../types.js";
+
+//#region src/std/copy.d.ts
+declare function cpuCopy<T>(e: T): T;
+declare const copy: DualFn<typeof cpuCopy>;
+//#endregion
+export { copy };

package/std/copy.js

@@ -0,0 +1,27 @@
+import { WORKAROUND_getSchema, isMatInstance, isVecInstance } from "../data/wgslTypes.js";
+import { stitch } from "../core/resolve/stitch.js";
+import { dualImpl } from "../core/function/dualImpl.js";
+
+//#region src/std/copy.ts
+function cpuCopy(e) {
+	if (isVecInstance(e) || isMatInstance(e)) return WORKAROUND_getSchema(e)(e);
+	if (Array.isArray(e)) return e.map(cpuCopy);
+	if (typeof e === "object" && e !== null) return Object.fromEntries(Object.entries(e).map(([key, value]) => [key, cpuCopy(value)]));
+	return e;
+}
+const copy = dualImpl({
+	name: "copy",
+	signature: (arg) => {
+		return {
+			argTypes: [arg],
+			returnType: arg
+		};
+	},
+	normalImpl: cpuCopy,
+	codegenImpl(_ctx, [a]) {
+		return stitch`${a}`;
+	}
+});
+
+//#endregion
+export { copy };

package/std/index.d.ts

@@ -1,4 +1,5 @@
 import { identity2, identity3, identity4, rotationX4, rotationY4, rotationZ4, scaling4, translation4 } from "../data/matrix.js";
+import { copy } from "./copy.js";
 import { discard } from "./discard.js";
 import { abs, acos, acosh, asin, asinh, atan, atan2, atanh, ceil, clamp, cos, cosh, countLeadingZeros, countOneBits, countTrailingZeros, cross, degrees, determinant, distance, dot, dot4I8Packed, dot4U8Packed, exp, exp2, extractBits, faceForward, firstLeadingBit, firstTrailingBit, floor, fma, fract, frexp, insertBits, inverseSqrt, ldexp, length, log, log2, max, min, mix, modf, normalize, pow, quantizeToF16, radians, reflect, refract, reverseBits, round, saturate, sign, sin, sinh, smoothstep, sqrt, step, tan, tanh, transpose, trunc } from "./numeric.js";
 import { add, bitShiftLeft, bitShiftRight, div, mod, mul, neg, sub } from "./operators.js";
@@ -16,7 +17,7 @@ import { range } from "./range.js";
 
 //#region src/std/index.d.ts
 declare namespace index_d_exports {
-  export { abs, acos, acosh, add, all, allEq, and, any, arrayLength, asin, asinh, atan, atan2, atanh, atomicAdd, atomicAnd, atomicLoad, atomicMax, atomicMin, atomicOr, atomicStore, atomicSub, atomicXor, bitShiftLeft, bitShiftRight, bitcastU32toF32, bitcastU32toI32, ceil, clamp, cos, cosh, countLeadingZeros, countOneBits, countTrailingZeros, cross, degrees, determinant, discard, distance, div, dot, dot4I8Packed, dot4U8Packed, dpdx, dpdxCoarse, dpdxFine, dpdy, dpdyCoarse, dpdyFine, eq, exp, exp2, extensionEnabled, extractBits, faceForward, firstLeadingBit, firstTrailingBit, floor, fma, fract, frexp, fwidth, fwidthCoarse, fwidthFine, ge, gt, identity2, identity3, identity4, insertBits, inverseSqrt, isCloseTo, ldexp, le, length, log, log2, lt, max, min, mix, mod, modf, mul, ne, neg, normalize, not, or, pack2x16float, pack4x8unorm, pow, quantizeToF16, radians, range, reflect, refract, reverseBits, rotateX4, rotateY4, rotateZ4, rotationX4, rotationY4, rotationZ4, round, saturate, scale4, scaling4, select, sign, sin, sinh, smoothstep, sqrt, step, storageBarrier, sub, subgroupAdd, subgroupAll, subgroupAnd, subgroupAny, subgroupBallot, subgroupBroadcast, subgroupBroadcastFirst, subgroupElect, subgroupExclusiveAdd, subgroupExclusiveMul, subgroupInclusiveAdd, subgroupInclusiveMul, subgroupMax, subgroupMin, subgroupMul, subgroupOr, subgroupShuffle, subgroupShuffleDown, subgroupShuffleUp, subgroupShuffleXor, subgroupXor, tan, tanh, textureBarrier, textureDimensions, textureGather, textureLoad, textureSample, textureSampleBaseClampToEdge, textureSampleBias, textureSampleCompare, textureSampleCompareLevel, textureSampleGrad, textureSampleLevel, textureStore, translate4, translation4, transpose, trunc, unpack2x16float, unpack4x8unorm, workgroupBarrier };
+  export { abs, acos, acosh, add, all, allEq, and, any, arrayLength, asin, asinh, atan, atan2, atanh, atomicAdd, atomicAnd, atomicLoad, atomicMax, atomicMin, atomicOr, atomicStore, atomicSub, atomicXor, bitShiftLeft, bitShiftRight, bitcastU32toF32, bitcastU32toI32, ceil, clamp, copy, cos, cosh, countLeadingZeros, countOneBits, countTrailingZeros, cross, degrees, determinant, discard, distance, div, dot, dot4I8Packed, dot4U8Packed, dpdx, dpdxCoarse, dpdxFine, dpdy, dpdyCoarse, dpdyFine, eq, exp, exp2, extensionEnabled, extractBits, faceForward, firstLeadingBit, firstTrailingBit, floor, fma, fract, frexp, fwidth, fwidthCoarse, fwidthFine, ge, gt, identity2, identity3, identity4, insertBits, inverseSqrt, isCloseTo, ldexp, le, length, log, log2, lt, max, min, mix, mod, modf, mul, ne, neg, normalize, not, or, pack2x16float, pack4x8unorm, pow, quantizeToF16, radians, range, reflect, refract, reverseBits, rotateX4, rotateY4, rotateZ4, rotationX4, rotationY4, rotationZ4, round, saturate, scale4, scaling4, select, sign, sin, sinh, smoothstep, sqrt, step, storageBarrier, sub, subgroupAdd, subgroupAll, subgroupAnd, subgroupAny, subgroupBallot, subgroupBroadcast, subgroupBroadcastFirst, subgroupElect, subgroupExclusiveAdd, subgroupExclusiveMul, subgroupInclusiveAdd, subgroupInclusiveMul, subgroupMax, subgroupMin, subgroupMul, subgroupOr, subgroupShuffle, subgroupShuffleDown, subgroupShuffleUp, subgroupShuffleXor, subgroupXor, tan, tanh, textureBarrier, textureDimensions, textureGather, textureLoad, textureSample, textureSampleBaseClampToEdge, textureSampleBias, textureSampleCompare, textureSampleCompareLevel, textureSampleGrad, textureSampleLevel, textureStore, translate4, translation4, transpose, trunc, unpack2x16float, unpack4x8unorm, workgroupBarrier };
 }
 //#endregion
-export { abs, acos, acosh, add, all, allEq, and, any, arrayLength, asin, asinh, atan, atan2, atanh, atomicAdd, atomicAnd, atomicLoad, atomicMax, atomicMin, atomicOr, atomicStore, atomicSub, atomicXor, bitShiftLeft, bitShiftRight, bitcastU32toF32, bitcastU32toI32, ceil, clamp, cos, cosh, countLeadingZeros, countOneBits, countTrailingZeros, cross, degrees, determinant, discard, distance, div, dot, dot4I8Packed, dot4U8Packed, dpdx, dpdxCoarse, dpdxFine, dpdy, dpdyCoarse, dpdyFine, eq, exp, exp2, extensionEnabled, extractBits, faceForward, firstLeadingBit, firstTrailingBit, floor, fma, fract, frexp, fwidth, fwidthCoarse, fwidthFine, ge, gt, identity2, identity3, identity4, index_d_exports, insertBits, inverseSqrt, isCloseTo, ldexp, le, length, log, log2, lt, max, min, mix, mod, modf, mul, ne, neg, normalize, not, or, pack2x16float, pack4x8unorm, pow, quantizeToF16, radians, range, reflect, refract, reverseBits, rotateX4, rotateY4, rotateZ4, rotationX4, rotationY4, rotationZ4, round, saturate, scale4, scaling4, select, sign, sin, sinh, smoothstep, sqrt, step, storageBarrier, sub, subgroupAdd, subgroupAll, subgroupAnd, subgroupAny, subgroupBallot, subgroupBroadcast, subgroupBroadcastFirst, subgroupElect, subgroupExclusiveAdd, subgroupExclusiveMul, subgroupInclusiveAdd, subgroupInclusiveMul, subgroupMax, subgroupMin, subgroupMul, subgroupOr, subgroupShuffle, subgroupShuffleDown, subgroupShuffleUp, subgroupShuffleXor, subgroupXor, tan, tanh, textureBarrier, textureDimensions, textureGather, textureLoad, textureSample, textureSampleBaseClampToEdge, textureSampleBias, textureSampleCompare, textureSampleCompareLevel, textureSampleGrad, textureSampleLevel, textureStore, translate4, translation4, transpose, trunc, unpack2x16float, unpack4x8unorm, workgroupBarrier };
+export { abs, acos, acosh, add, all, allEq, and, any, arrayLength, asin, asinh, atan, atan2, atanh, atomicAdd, atomicAnd, atomicLoad, atomicMax, atomicMin, atomicOr, atomicStore, atomicSub, atomicXor, bitShiftLeft, bitShiftRight, bitcastU32toF32, bitcastU32toI32, ceil, clamp, copy, cos, cosh, countLeadingZeros, countOneBits, countTrailingZeros, cross, degrees, determinant, discard, distance, div, dot, dot4I8Packed, dot4U8Packed, dpdx, dpdxCoarse, dpdxFine, dpdy, dpdyCoarse, dpdyFine, eq, exp, exp2, extensionEnabled, extractBits, faceForward, firstLeadingBit, firstTrailingBit, floor, fma, fract, frexp, fwidth, fwidthCoarse, fwidthFine, ge, gt, identity2, identity3, identity4, index_d_exports, insertBits, inverseSqrt, isCloseTo, ldexp, le, length, log, log2, lt, max, min, mix, mod, modf, mul, ne, neg, normalize, not, or, pack2x16float, pack4x8unorm, pow, quantizeToF16, radians, range, reflect, refract, reverseBits, rotateX4, rotateY4, rotateZ4, rotationX4, rotationY4, rotationZ4, round, saturate, scale4, scaling4, select, sign, sin, sinh, smoothstep, sqrt, step, storageBarrier, sub, subgroupAdd, subgroupAll, subgroupAnd, subgroupAny, subgroupBallot, subgroupBroadcast, subgroupBroadcastFirst, subgroupElect, subgroupExclusiveAdd, subgroupExclusiveMul, subgroupInclusiveAdd, subgroupInclusiveMul, subgroupMax, subgroupMin, subgroupMul, subgroupOr, subgroupShuffle, subgroupShuffleDown, subgroupShuffleUp, subgroupShuffleXor, subgroupXor, tan, tanh, textureBarrier, textureDimensions, textureGather, textureLoad, textureSample, textureSampleBaseClampToEdge, textureSampleBias, textureSampleCompare, textureSampleCompareLevel, textureSampleGrad, textureSampleLevel, textureStore, translate4, translation4, transpose, trunc, unpack2x16float, unpack4x8unorm, workgroupBarrier };

package/std/index.js

@@ -7,6 +7,7 @@ import { range } from "./range.js";
 import { bitcastU32toF32, bitcastU32toI32 } from "./bitcast.js";
 import { pack2x16float, pack4x8unorm, unpack2x16float, unpack4x8unorm } from "./packing.js";
 import { all, allEq, and, any, eq, ge, gt, isCloseTo, le, lt, ne, not, or, select } from "./boolean.js";
+import { copy } from "./copy.js";
 import { discard } from "./discard.js";
 import { rotateX4, rotateY4, rotateZ4, scale4, translate4 } from "./matrix.js";
 import { atomicAdd, atomicAnd, atomicLoad, atomicMax, atomicMin, atomicOr, atomicStore, atomicSub, atomicXor, storageBarrier, textureBarrier, workgroupBarrier } from "./atomic.js";
@@ -46,6 +47,7 @@ var std_exports = /* @__PURE__ */ __export({
 	bitcastU32toI32: () => bitcastU32toI32,
 	ceil: () => ceil,
 	clamp: () => clamp,
+	copy: () => copy,
 	cos: () => cos,
 	cosh: () => cosh,
 	countLeadingZeros: () => countLeadingZeros,
@@ -179,4 +181,4 @@ var std_exports = /* @__PURE__ */ __export({
 });
 
 //#endregion
-export { abs, acos, acosh, add, all, allEq, and, any, arrayLength, asin, asinh, atan, atan2, atanh, atomicAdd, atomicAnd, atomicLoad, atomicMax, atomicMin, atomicOr, atomicStore, atomicSub, atomicXor, bitShiftLeft, bitShiftRight, bitcastU32toF32, bitcastU32toI32, ceil, clamp, cos, cosh, countLeadingZeros, countOneBits, countTrailingZeros, cross, degrees, determinant, discard, distance, div, dot, dot4I8Packed, dot4U8Packed, dpdx, dpdxCoarse, dpdxFine, dpdy, dpdyCoarse, dpdyFine, eq, exp, exp2, extensionEnabled, extractBits, faceForward, firstLeadingBit, firstTrailingBit, floor, fma, fract, frexp, fwidth, fwidthCoarse, fwidthFine, ge, gt, identity2, identity3, identity4, insertBits, inverseSqrt, isCloseTo, ldexp, le, length, log, log2, lt, max, min, mix, mod, modf, mul, ne, neg, normalize, not, or, pack2x16float, pack4x8unorm, pow, quantizeToF16, radians, range, reflect, refract, reverseBits, rotateX4, rotateY4, rotateZ4, rotationX4, rotationY4, rotationZ4, round, saturate, scale4, scaling4, select, sign, sin, sinh, smoothstep, sqrt, std_exports, step, storageBarrier, sub, subgroupAdd, subgroupAll, subgroupAnd, subgroupAny, subgroupBallot, subgroupBroadcast, subgroupBroadcastFirst, subgroupElect, subgroupExclusiveAdd, subgroupExclusiveMul, subgroupInclusiveAdd, subgroupInclusiveMul, subgroupMax, subgroupMin, subgroupMul, subgroupOr, subgroupShuffle, subgroupShuffleDown, subgroupShuffleUp, subgroupShuffleXor, subgroupXor, tan, tanh, textureBarrier, textureDimensions, textureGather, textureLoad, textureSample, textureSampleBaseClampToEdge, textureSampleBias, textureSampleCompare, textureSampleCompareLevel, textureSampleGrad, textureSampleLevel, textureStore, translate4, translation4, transpose, trunc, unpack2x16float, unpack4x8unorm, workgroupBarrier };
+export { abs, acos, acosh, add, all, allEq, and, any, arrayLength, asin, asinh, atan, atan2, atanh, atomicAdd, atomicAnd, atomicLoad, atomicMax, atomicMin, atomicOr, atomicStore, atomicSub, atomicXor, bitShiftLeft, bitShiftRight, bitcastU32toF32, bitcastU32toI32, ceil, clamp, copy, cos, cosh, countLeadingZeros, countOneBits, countTrailingZeros, cross, degrees, determinant, discard, distance, div, dot, dot4I8Packed, dot4U8Packed, dpdx, dpdxCoarse, dpdxFine, dpdy, dpdyCoarse, dpdyFine, eq, exp, exp2, extensionEnabled, extractBits, faceForward, firstLeadingBit, firstTrailingBit, floor, fma, fract, frexp, fwidth, fwidthCoarse, fwidthFine, ge, gt, identity2, identity3, identity4, insertBits, inverseSqrt, isCloseTo, ldexp, le, length, log, log2, lt, max, min, mix, mod, modf, mul, ne, neg, normalize, not, or, pack2x16float, pack4x8unorm, pow, quantizeToF16, radians, range, reflect, refract, reverseBits, rotateX4, rotateY4, rotateZ4, rotationX4, rotationY4, rotationZ4, round, saturate, scale4, scaling4, select, sign, sin, sinh, smoothstep, sqrt, std_exports, step, storageBarrier, sub, subgroupAdd, subgroupAll, subgroupAnd, subgroupAny, subgroupBallot, subgroupBroadcast, subgroupBroadcastFirst, subgroupElect, subgroupExclusiveAdd, subgroupExclusiveMul, subgroupInclusiveAdd, subgroupInclusiveMul, subgroupMax, subgroupMin, subgroupMul, subgroupOr, subgroupShuffle, subgroupShuffleDown, subgroupShuffleUp, subgroupShuffleXor, subgroupXor, tan, tanh, textureBarrier, textureDimensions, textureGather, textureLoad, textureSample, textureSampleBaseClampToEdge, textureSampleBias, textureSampleCompare, textureSampleCompareLevel, textureSampleGrad, textureSampleLevel, textureStore, translate4, translation4, transpose, trunc, unpack2x16float, unpack4x8unorm, workgroupBarrier };

package/tgpuUnstable.js

@@ -2,9 +2,9 @@ import { __export } from "./_virtual/rolldown_runtime.js";
 import { comptime } from "./core/function/comptime.js";
 import { constant } from "./core/constant/tgpuConstant.js";
 import { fn } from "./core/function/tgpuFn.js";
-import { namespace } from "./core/resolve/namespace.js";
 import { slot } from "./core/slot/slot.js";
 import { privateVar, workgroupVar } from "./core/variable/tgpuVariable.js";
+import { namespace } from "./core/resolve/namespace.js";
 import { computeFn } from "./core/function/tgpuComputeFn.js";
 import { vertexLayout } from "./core/vertexLayout/vertexLayout.js";
 import { lazy } from "./core/slot/lazy.js";

package/tgsl/conversion.js

@@ -158,7 +158,10 @@ function getBestConversion(types, targetTypes) {
 	if (implicitResult) return implicitResult;
 }
 function applyActionToSnippet(ctx, snippet, action, targetType) {
-	if (action.action === "none") return snip(snippet.value, targetType, snippet.origin);
+	if (action.action === "none") {
+		if (targetType === snippet.dataType) return snippet;
+		return snip(snippet.value, targetType, snippet.origin);
+	}
 	switch (action.action) {
 		case "ref": return snip(new RefOperator(snippet, targetType), targetType, snippet.origin);
 		case "deref": return derefSnippet(snippet);

package/tgsl/wgslGenerator.d.ts

@@ -13,9 +13,14 @@ declare class WgslGenerator implements ShaderGenerator {
   initGenerator(ctx: GenerationCtx): void;
   protected get ctx(): GenerationCtx;
   _block([_, statements]: tinyest.Block, externalMap?: ExternalMap): string;
+  _blockStatement(block: tinyest.Block, externalMap?: ExternalMap): string;
   refVariable(id: string, dataType: StorableData): string;
-  blockVariable(varType: 'var' | 'let' | 'const', id: string, dataType: BaseData | UnknownData, origin: Origin): Snippet;
-  protected emitVarDecl(pre: string, keyword: 'var' | 'let' | 'const', name: string, _dataType: BaseData | UnknownData, rhsStr: string): string;
+  blockVariable(varType: 'var' | 'let' | 'const' | '<deferred>', id: string, dataType: BaseData | UnknownData, origin: Origin): Snippet;
+  /**
+   * Creates a variable declaration string.
+   * `keyword` may be a placeholder filled in later.
+   */
+  protected emitVarDecl(pre: string, keyword: 'var' | 'let' | 'const' | `#VAR_${number}#`, name: string, _dataType: BaseData | UnknownData, rhsStr: string): string;
   _identifier(id: string): Snippet;
   /**
    * A wrapper for `generateExpression` that updates `ctx.expectedType`
@@ -33,6 +38,19 @@ declare class WgslGenerator implements ShaderGenerator {
   typeInstantiation(schema: BaseData, args: readonly Snippet[]): ResolvedSnippet;
   _return(statement: tinyest.Return): string;
   _statement(statement: tinyest.Statement): string;
+  /**
+   * Attempts a member access lookup to mark a variable as modified.
+   * @example
+   * // given `let a; a = 1;`
+   * tryMarkModified('a') // `a` is marked in the function scope
+   *
+   * // given `const obj; obj.prop = 1;`
+   * tryMarkModified('obj.prop') // `obj` is marked in the function scope
+   *
+   * // given `this.buffer.$;`
+   * tryMarkModified('this.buffer.$') // `this` is not marked, since there is no placeholder for it
+   */
+  private tryMarkModified;
 }
 //#endregion
 export { WgslGenerator };

package/tgsl/wgslGenerator.js

@@ -7,7 +7,7 @@ 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 { 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";
@@ -23,7 +23,7 @@ import { isGenericFn } from "../core/function/tgpuFn.js";
 import { arrayOf } from "../data/array.js";
 import { pow } from "../std/numeric.js";
 import { resolveData } from "../core/resolve/resolveData.js";
-import { UnrollableIterable } from "../core/unroll/tgpuUnroll.js";
+import { UnrollableIterable, unroll } from "../core/unroll/tgpuUnroll.js";
 import { mathToStd, supportedLogOps } from "./jsPolyfills.js";
 import { isTgpuRange } from "../std/range.js";
 import { getElementSnippet, getElementType, getLoopVarKind, getRangeSnippets } from "./forOfUtils.js";
@@ -165,8 +165,11 @@ ${this.ctx.pre}}`;
 			this.ctx.popBlockScope();
 		}
 	}
+	_blockStatement(block, externalMap) {
+		return `${this.ctx.pre}${this._block(block, externalMap)}`;
+	}
 	refVariable(id, dataType) {
-		const varName = this.ctx.makeNameValid(id);
+		const varName = this.ctx.makeUniqueIdentifier(id, "block");
 		const ptrType = ptrFn(dataType);
 		const snippet = snip(new RefOperator(snip(varName, dataType, "function"), ptrType), ptrType, "function");
 		this.ctx.defineVariable(id, snippet);
@@ -181,10 +184,14 @@ ${this.ctx.pre}}`;
 		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);
+		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};`;
 	}
@@ -252,22 +259,14 @@ ${this.ctx.pre}}`;
 			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") {
-					if (isKnownAtComptime(convLhs)) throw new WgslTypeError(`'${stringifyNode(expression)}' 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(expression)}' is invalid, because the left side is a constant.`);
-				}
-				if (lhsExpr.origin === "argument") throw new WgslTypeError(`'${stringifyNode(expression)}' is invalid, because non-pointer arguments cannot be mutated.`);
+				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-----`);
 			}
 			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.postUpdate) throw new Error(`'${stringifyNode(expression)}' is invalid because update is only allowed as a statement.`);
 		if (expression[0] === NODE.unaryExpr) {
 			const [_, op, arg] = expression;
 			const argExpr = this._expression(arg);
@@ -320,6 +319,7 @@ ${this.ctx.pre}}`;
 				const rhs = this._expression(argNodes[0]);
 				return callee.value.operator(this.ctx, [callee.value.lhs, rhs]);
 			}
+			if ((callee.value === _ref || callee.value === unroll) && argNodes[0]) this.tryMarkModified(argNodes[0]);
 			if (isGPUCallable(callee.value)) {
 				const callable = callee.value[$gpuCallable];
 				const strictSignature = callable.strictSignature;
@@ -423,7 +423,14 @@ ${this.ctx.pre}}`;
 		assertExhaustive(expression);
 	}
 	functionDefinition(options) {
-		const body = this._block(options.body);
+		let body = this._block(options.body);
+		const scope = this.ctx.topFunctionScope;
+		invariant(scope, "Expected function scope to be present");
+		const replacements = Object.fromEntries(scope.placeholderForVariable.entries().map(([variable, placeholder]) => [placeholder, scope.modifiedVariables.has(variable) ? "var" : "let"]));
+		if (Object.keys(replacements).length > 0) {
+			const regex = new RegExp(Object.keys(replacements).join("|"), "gi");
+			body = body.replace(regex, (match) => replacements[match] ?? "#ERR");
+		}
 		const returnType = options.determineReturnType();
 		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}`;
@@ -481,7 +488,7 @@ Try 'return ${typeStr}(${str});' instead.
 				if (!Array.isArray(node)) node = blockifySingleStatement(node);
 				if (node[0] === NODE.block && node[1].length === 1 && node[1][0][0] === NODE.if) return this._statement(node[1][0]);
 				if (node[0] === NODE.if) return this._statement(node);
-				return `${this.ctx.pre}${this._block(blockifySingleStatement(node))}`;
+				return this._blockStatement(blockifySingleStatement(node));
 			}
 			const consequent = this._block(blockifySingleStatement(consNode));
 			const alternate = !altNode ? void 0 : this._block(blockifySingleStatement(altNode));
@@ -491,7 +498,7 @@ ${this.ctx.pre}if (${condition}) ${consequent}
 ${this.ctx.pre}else ${alternate}`;
 		}
 		if (statement[0] === NODE.let || statement[0] === NODE.const) {
-			let varType = "var";
+			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.`);
@@ -523,7 +530,10 @@ ${this.ctx.pre}else ${alternate}`;
 						invariant(ptrType !== void 0, `Creating pointer type from origin ${eq.origin}`);
 						dataType = ptrType;
 					}
-					if (!(eq.value instanceof RefOperator)) dataType = implicitFrom(dataType);
+					if (!(eq.value instanceof RefOperator)) {
+						dataType = implicitFrom(dataType);
+						this.tryMarkModified(rawValue);
+					}
 				}
 			} else if (stmtType === NODE.const) {
 				if (eq.origin === "argument") varType = "let";
@@ -542,9 +552,16 @@ ${this.ctx.pre}else ${alternate}`;
 			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;
-			return this.emitVarDecl(this.ctx.pre, varType, snippet.value, concretize(dataType), rhsStr);
+			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.block) return `${this.ctx.pre}${this._block(statement)}`;
+		if (statement[0] === NODE.block) return this._blockStatement(statement);
 		if (statement[0] === NODE.for) {
 			const [_, init, condition, update, body] = statement;
 			const prevUnrollingFlag = this.#unrolling;
@@ -581,6 +598,7 @@ ${this.ctx.pre}else ${alternate}`;
 		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");
+			this.tryMarkModified(iterable);
 			let ctxIndent = false;
 			const prevUnrollingFlag = this.#unrolling;
 			try {
@@ -599,21 +617,21 @@ ${this.ctx.pre}else ${alternate}`;
 					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.`);
-					return elements.map((e, i) => `${this.ctx.pre}// unrolled iteration #${i}\n${this.ctx.pre}${this._block(blockified, { [originalLoopVarName]: e })}`).join("\n");
+					return elements.map((e, i) => `${this.ctx.pre}// unrolled iteration #${i}\n${this._blockStatement(blockified, { [originalLoopVarName]: e })}`).join("\n");
 				}
 				this.#unrolling = false;
-				const index = this.ctx.makeNameValid("i");
+				const index = this.ctx.makeUniqueIdentifier("i", "block");
 				const forHeaderStr = stitch`${this.ctx.pre}for (var ${index} = ${range.start}; ${index} ${range.comparison} ${range.end}; ${index} += ${range.step})`;
 				let bodyStr = "";
 				if (isTgpuRange(iterableSnippet.value)) bodyStr = this._block(blockified, { [originalLoopVarName]: snip(index, range.start.dataType, "runtime") });
 				else {
 					this.ctx.indent();
 					ctxIndent = true;
-					const loopVarName = this.ctx.makeNameValid(originalLoopVarName);
+					const loopVarName = this.ctx.makeUniqueIdentifier(originalLoopVarName, "block");
 					const elementSnippet = getElementSnippet(iterableSnippet, snip(index, u32, "runtime"));
 					const loopVarKind = getLoopVarKind(elementSnippet);
 					const elementType = getElementType(elementSnippet, iterableSnippet);
-					bodyStr = `{\n${stitch`${this.ctx.pre}${loopVarKind} ${loopVarName} = ${tryConvertSnippet(this.ctx, elementSnippet, elementType, false)};`}\n${this.ctx.pre}${this._block(blockified, { [originalLoopVarName]: snip(loopVarName, elementType, elementSnippet.origin) })}\n`;
+					bodyStr = `{\n${stitch`${this.ctx.pre}${loopVarKind} ${loopVarName} = ${tryConvertSnippet(this.ctx, elementSnippet, elementType, false)};`}\n${this._blockStatement(blockified, { [originalLoopVarName]: snip(loopVarName, elementType, elementSnippet.origin) })}\n`;
 					this.ctx.dedent();
 					bodyStr += `${this.ctx.pre}}`;
 					ctxIndent = false;
@@ -625,6 +643,14 @@ ${this.ctx.pre}else ${alternate}`;
 				this.ctx.popBlockScope();
 			}
 		}
+		if (statement[0] === NODE.postUpdate) {
+			const [_, op, arg] = statement;
+			const argExpr = this._expression(arg);
+			const argStr = this.ctx.resolve(argExpr.value, argExpr.dataType).value;
+			validateSnippetMutation(argExpr, statement);
+			this.tryMarkModified(arg);
+			return `${this.ctx.pre}${argStr}${op};`;
+		}
 		if (statement[0] === NODE.continue) {
 			if (this.#unrolling) throw new WgslTypeError("Cannot unroll loop containing `continue`");
 			return `${this.ctx.pre}continue;`;
@@ -637,7 +663,35 @@ ${this.ctx.pre}else ${alternate}`;
 		const resolved = expr.value && this.ctx.resolve(expr.value).value;
 		return resolved ? `${this.ctx.pre}${resolved};` : "";
 	}
+	/**
+	* Attempts a member access lookup to mark a variable as modified.
+	* @example
+	* // given `let a; a = 1;`
+	* tryMarkModified('a') // `a` is marked in the function scope
+	*
+	* // given `const obj; obj.prop = 1;`
+	* tryMarkModified('obj.prop') // `obj` is marked in the function scope
+	*
+	* // given `this.buffer.$;`
+	* tryMarkModified('this.buffer.$') // `this` is not marked, since there is no placeholder for it
+	*/
+	tryMarkModified(expr) {
+		if (!expr) return;
+		const maybeObject = extractObject(expr);
+		if (maybeObject !== void 0) {
+			const snippet = this.ctx.getById(maybeObject);
+			const scope = this.ctx.topFunctionScope;
+			if (snippet && scope && scope.placeholderForVariable.has(snippet)) scope.modifiedVariables.add(snippet);
+		}
+	}
 };
+function validateSnippetMutation(mutated, expr) {
+	if (mutated.origin === "constant" || mutated.origin === "constant-tgpu-const-ref" || mutated.origin === "runtime-tgpu-const-ref") {
+		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 === "argument") throw new WgslTypeError(`'${stringifyNode(expr)}' is invalid, because non-pointer arguments cannot be mutated.`);
+}
 function assertExhaustive(value) {
 	throw new Error(`'${safeStringify(value)}' was not handled by the WGSL generator.`);
 }
@@ -649,6 +703,11 @@ function parseNumericString(str) {
 function blockifySingleStatement(statement) {
 	return typeof statement !== "object" || statement[0] !== NODE.block ? [NODE.block, [statement]] : statement;
 }
+function extractObject(expr) {
+	let object = expr;
+	while (Array.isArray(object) && (object[0] === NODE.memberAccess || object[0] === NODE.indexAccess)) object = object[1];
+	if (typeof object === "string") return object;
+}
 const wgslGenerator = new WgslGenerator();
 var wgslGenerator_default = wgslGenerator;