typegpu 0.11.2 → 0.11.4

package/tgsl/consoleLog/logGenerator.js

@@ -1,16 +1,17 @@
 import { $internal } from "../../shared/symbols.js";
 import { Void } from "../../data/wgslTypes.js";
-import { UnknownData } from "../../data/dataTypes.js";
+import { UnknownData, unptr } from "../../data/dataTypes.js";
 import { snip } from "../../data/snippet.js";
+import { invariant } from "../../errors.js";
 import { stitch } from "../../core/resolve/stitch.js";
+import { convertToCommonType } from "../conversion.js";
 import { u32 } from "../../data/numeric.js";
-import { concretizeSnippets } from "../generationHelpers.js";
+import { concretizeSnippet } from "../generationHelpers.js";
 import { struct } from "../../data/struct.js";
 import { shaderStageSlot } from "../../core/slot/internalSlots.js";
 import { arrayOf } from "../../data/array.js";
 import { atomic } from "../../data/atomic.js";
 import { createLoggingFunction } from "./serializers.js";
-import { supportedLogOps } from "./types.js";
 
 //#region src/tgsl/consoleLog/logGenerator.ts
 const defaultOptions = {
@@ -54,23 +55,24 @@ var LogGeneratorImpl = class {
 	*/
 	generateLog(ctx, op, args) {
 		if (shaderStageSlot.$ === "vertex") {
-			console.warn(`'console.${op}' is not supported in vertex shaders.`);
+			console.warn(`'console' operations are not supported in vertex shaders.`);
 			return fallbackSnippet;
 		}
-		if (!supportedLogOps.includes(op)) {
-			console.warn(`Unsupported log method '${op}'.`);
-			return fallbackSnippet;
-		}
-		const concreteArgs = concretizeSnippets(args);
 		const id = this.#firstUnusedId++;
-		const nonStringArgs = concreteArgs.filter((e) => e.dataType !== UnknownData);
-		const logFn = createLoggingFunction(id, nonStringArgs.map((e) => e.dataType), this.#dataBuffer, this.#indexBuffer, this.#options);
-		const argTypes = concreteArgs.map((e) => e.dataType === UnknownData ? e.value : e.dataType);
+		const concreteArgsWithStrings = args.map((arg) => {
+			if (arg.dataType === UnknownData) return arg;
+			const converted = convertToCommonType(ctx, [arg], [unptr(arg.dataType)])?.[0];
+			invariant(converted, `Internal error. Expected type ${arg.dataType} to be convertible to ${unptr(arg.dataType)}`);
+			return converted;
+		}).map(concretizeSnippet);
+		const concreteArgs = concreteArgsWithStrings.filter((arg) => arg.dataType !== UnknownData);
+		const logFn = createLoggingFunction(id, concreteArgs.map((e) => e.dataType), this.#dataBuffer, this.#indexBuffer, this.#options);
+		const functionSnippet = snip(stitch`${ctx.resolve(logFn).value}(${concreteArgs})`, Void, "runtime");
 		this.#logIdToMeta.set(id, {
 			op,
-			argTypes
+			argTypes: concreteArgsWithStrings.map((e) => e?.dataType === UnknownData ? e?.value : e?.dataType)
 		});
-		return snip(stitch`${ctx.resolve(logFn).value}(${nonStringArgs})`, Void, "runtime");
+		return functionSnippet;
 	}
 	get logResources() {
 		return this.#firstUnusedId === 1 ? void 0 : {

package/tgsl/consoleLog/types.d.ts

@@ -1,10 +1,11 @@
 import "../../data/snippet.js";
 import { TgpuMutable } from "../../core/buffer/bufferShorthand.js";
 import "../generationHelpers.js";
+import { supportedLogOps } from "../jsPolyfills.js";
 import { AnyWgslData, Atomic, U32, WgslArray, WgslStruct } from "../../data/wgslTypes.js";
 
 //#region src/tgsl/consoleLog/types.d.ts
-
+type SupportedLogOp = ReturnType<typeof supportedLogOps>[number];
 /**
  * Options for configuring GPU log generation.
  */
@@ -32,7 +33,7 @@ type SerializedLogCallData = WgslStruct<{
   serializedData: WgslArray<U32>;
 }>;
 interface LogMeta {
-  op: SupportedLogOps;
+  op: SupportedLogOp;
   argTypes: (string | AnyWgslData)[];
 }
 /**
@@ -49,7 +50,5 @@ interface LogResources {
   options: Required<LogGeneratorOptions>;
   logIdToMeta: Map<number, LogMeta>;
 }
-declare const supportedLogOps: readonly ["log", "debug", "info", "warn", "error", "clear"];
-type SupportedLogOps = (typeof supportedLogOps)[number];
 //#endregion
-export { LogGeneratorOptions, LogResources };
+export { LogGeneratorOptions, LogResources, SupportedLogOp };

package/tgsl/conversion.js

@@ -90,14 +90,19 @@ function getImplicitConversionRank(src, dest) {
 			};
 		}
 	}
+	if ((trueSrc.type === "u32" || trueSrc.type === "i32") && trueDst.type === "abstractFloat") return {
+		rank: 1,
+		action: "cast",
+		targetType: trueDst.concretized
+	};
 	if (trueSrc.type === "abstractFloat") {
-		if (trueDst.type === "u32") return {
+		if (trueDst.type === "i32") return {
 			rank: 2,
 			action: "cast",
 			targetType: trueDst
 		};
-		if (trueDst.type === "i32") return {
-			rank: 1,
+		if (trueDst.type === "u32") return {
+			rank: 3,
 			action: "cast",
 			targetType: trueDst
 		};
@@ -113,6 +118,10 @@ function getConversionRank(src, dest, allowImplicit) {
 function findBestType(types, uniqueTypes, allowImplicit) {
 	let bestResult;
 	for (const targetType of uniqueTypes) {
+		/**
+		* The type we end up converting to. Will be different than `targetType` if `targetType === abstractFloat`
+		*/
+		let destType = targetType;
 		const details = [];
 		let sum = 0;
 		for (const sourceType of types) {
@@ -120,9 +129,10 @@ function findBestType(types, uniqueTypes, allowImplicit) {
 			sum += conversion.rank;
 			if (conversion.rank === Number.POSITIVE_INFINITY) break;
 			details.push(conversion);
+			if (conversion.action === "cast") destType = conversion.targetType;
 		}
 		if (sum < (bestResult?.sum ?? Number.POSITIVE_INFINITY)) bestResult = {
-			type: targetType,
+			type: destType,
 			details,
 			sum
 		};
@@ -168,7 +178,7 @@ function convertToCommonType(ctx, values, restrictTo, verbose = true) {
 	if (DEV && Array.isArray(restrictTo) && restrictTo.length === 0) console.warn("convertToCommonType was called with an empty restrictTo array, which prevents any conversions from being made. If you intend to allow all conversions, pass undefined instead. If this was intended call the function conditionally since the result will always be undefined.");
 	const conversion = getBestConversion(types, restrictTo);
 	if (!conversion) return;
-	if ((TEST || DEV) && verbose && conversion.hasImplicitConversions) console.warn(`Implicit conversions from [\n${values.map((v) => `  ${v.value}: ${safeStringify(v.dataType)}`).join(",\n")}\n] to ${conversion.targetType.type} are supported, but not recommended.
+	if ((TEST || DEV) && verbose && conversion.hasImplicitConversions) console.warn(`Implicit conversions from [\n${values.map((v) => `  ${ctx.resolveSnippet(v).value}: ${safeStringify(v.dataType)}`).join(",\n")}\n] to ${conversion.targetType.type} are supported, but not recommended.
 Consider using explicit conversions instead.`);
 	return values.map((value, index) => {
 		const action = conversion.actions[index];

package/tgsl/forOfUtils.js

@@ -33,12 +33,20 @@ function getElementType(elementSnippet, iterableSnippet) {
 }
 function getRangeSnippets(ctx, iterableSnippet, unroll = false) {
 	const { value, dataType } = iterableSnippet;
-	if (isTgpuRange(value)) return {
-		start: snip(value.start, i32, "constant"),
-		end: snip(value.end, i32, "constant"),
-		step: snip(value.step, i32, "constant"),
-		comparison: value.step < 0 ? ">" : "<"
-	};
+	if (isTgpuRange(value)) {
+		const { start, end, step } = value;
+		const dataType$1 = [
+			start,
+			end,
+			step
+		].every((v) => v >= 0) ? u32 : i32;
+		return {
+			start: snip(start, dataType$1, "constant"),
+			end: snip(end, dataType$1, "constant"),
+			step: snip(step, dataType$1, "constant"),
+			comparison: step < 0 ? ">" : "<"
+		};
+	}
 	if (!unroll && isEphemeralSnippet(iterableSnippet)) throw new Error(`\`for ... of ...\` loops only support std.range or iterables stored in variables.
 -----
 You can wrap iterable with \`tgpu.unroll(...)\`. If iterable is known at comptime, the loop will be unrolled.

package/tgsl/generationHelpers.d.ts

@@ -1,5 +1,6 @@
 import { Snippet } from "../data/snippet.js";
 import { ShelllessRepository } from "./shellless.js";
+import { SupportedLogOp } from "./consoleLog/types.js";
 import { FunctionScopeLayer, ResolutionCtx } from "../types.js";
 import { BaseData } from "../data/wgslTypes.js";
 
@@ -21,7 +22,7 @@ type GenerationCtx = ResolutionCtx & {
   dedent(): string;
   pushBlockScope(): void;
   popBlockScope(): void;
-  generateLog(op: string, args: Snippet[]): Snippet;
+  generateLog(op: SupportedLogOp, args: Snippet[]): Snippet;
   getById(id: string): Snippet | null;
   defineVariable(id: string, snippet: Snippet): void;
   setBlockExternals(externals: Record<string, Snippet>): void;

package/tgsl/generationHelpers.js

@@ -25,9 +25,6 @@ function concretize(type) {
 function concretizeSnippet(snippet) {
 	return snip(snippet.value, concretize(snippet.dataType), snippet.origin);
 }
-function concretizeSnippets(args) {
-	return args.map(concretizeSnippet);
-}
 function coerceToSnippet(value) {
 	if (isSnippet(value)) return value;
 	if (isRef(value)) throw new Error("Cannot use refs (d.ref(...)) from the outer scope.");
@@ -66,4 +63,4 @@ var ArrayExpression = class {
 };
 
 //#endregion
-export { ArrayExpression, coerceToSnippet, concretize, concretizeSnippets, numericLiteralToSnippet };
+export { ArrayExpression, coerceToSnippet, concretize, concretizeSnippet, numericLiteralToSnippet };

package/tgsl/jsPolyfills.d.ts

@@ -0,0 +1,25 @@
+import "../core/function/fnTypes.js";
+import "../types.js";
+
+//#region src/tgsl/jsPolyfills.d.ts
+declare const supportedLogOps: () => readonly [{
+  (...data: any[]): void;
+  (message?: any, ...optionalParams: any[]): void;
+}, {
+  (...data: any[]): void;
+  (message?: any, ...optionalParams: any[]): void;
+}, {
+  (...data: any[]): void;
+  (message?: any, ...optionalParams: any[]): void;
+}, {
+  (...data: any[]): void;
+  (message?: any, ...optionalParams: any[]): void;
+}, {
+  (...data: any[]): void;
+  (message?: any, ...optionalParams: any[]): void;
+}, {
+  (): void;
+  (): void;
+}];
+//#endregion
+export { supportedLogOps };

package/tgsl/jsPolyfills.js

@@ -0,0 +1,44 @@
+import { f32 } from "../data/numeric.js";
+import { abs, acos, acosh, asin, asinh, atan, atan2, atanh, ceil, cos, cosh, countLeadingZeros, exp, floor, log, log2, max, min, pow, sign, sin, sinh, sqrt, tan, tanh, trunc } from "../std/numeric.js";
+
+//#region src/tgsl/jsPolyfills.ts
+const mathToStd = new Map([
+	[Math.abs, abs],
+	[Math.acos, acos],
+	[Math.acosh, acosh],
+	[Math.asin, asin],
+	[Math.asinh, asinh],
+	[Math.atan, atan],
+	[Math.atan2, atan2],
+	[Math.atanh, atanh],
+	[Math.ceil, ceil],
+	[Math.cos, cos],
+	[Math.cosh, cosh],
+	[Math.exp, exp],
+	[Math.floor, floor],
+	[Math.fround, f32],
+	[Math.clz32, countLeadingZeros],
+	[Math.trunc, trunc],
+	[Math.log, log],
+	[Math.log2, log2],
+	[Math.pow, pow],
+	[Math.sign, sign],
+	[Math.sin, sin],
+	[Math.sinh, sinh],
+	[Math.sqrt, sqrt],
+	[Math.tan, tan],
+	[Math.tanh, tanh],
+	[Math.max, max],
+	[Math.min, min]
+]);
+const supportedLogOps = () => [
+	console.log,
+	console.debug,
+	console.info,
+	console.warn,
+	console.error,
+	console.clear
+];
+
+//#endregion
+export { mathToStd, supportedLogOps };

package/tgsl/shaderGenerator.d.ts

@@ -1,8 +1,7 @@
 import { ResolvedSnippet, Snippet } from "../data/snippet.js";
 import { GenerationCtx } from "./generationHelpers.js";
-import "./shaderGenerator_members.js";
+import { FunctionDefinitionOptions } from "./shaderGenerator_members.js";
 import { BaseData } from "../data/wgslTypes.js";
-import { Block } from "tinyest";
 
 //#region src/tgsl/shaderGenerator.d.ts
 
@@ -14,7 +13,7 @@ import { Block } from "tinyest";
  */
 interface ShaderGenerator {
   initGenerator(ctx: GenerationCtx): void;
-  functionDefinition(body: Block): string;
+  functionDefinition(options: FunctionDefinitionOptions): string;
   typeInstantiation(schema: BaseData, args: readonly Snippet[]): ResolvedSnippet;
   typeAnnotation(schema: BaseData): string;
 }

package/tgsl/shaderGenerator_members.d.ts

@@ -1,2 +1,15 @@
-import { ResolutionCtx } from "../types.js";
-import { UnknownData } from "../data/dataTypes.js";
+import { Origin, Snippet } from "../data/snippet.js";
+import { FunctionArgument, ResolutionCtx, TgpuShaderStage } from "../types.js";
+import { BaseData } from "../data/wgslTypes.js";
+import { UnknownData } from "../data/dataTypes.js";
+import { Block } from "tinyest";
+
+//#region src/tgsl/shaderGenerator_members.d.ts
+interface FunctionDefinitionOptions {
+  readonly functionType: 'normal' | TgpuShaderStage;
+  readonly args: readonly FunctionArgument[];
+  readonly body: Block;
+  determineReturnType(): BaseData;
+}
+//#endregion
+export { FunctionDefinitionOptions };

package/tgsl/wgslGenerator.d.ts

@@ -1,5 +1,6 @@
 import { Origin, ResolvedSnippet, Snippet } from "../data/snippet.js";
 import { GenerationCtx } from "./generationHelpers.js";
+import { FunctionDefinitionOptions } from "./shaderGenerator_members.js";
 import { ShaderGenerator } from "./shaderGenerator.js";
 import { BaseData, StorableData } from "../data/wgslTypes.js";
 import { UnknownData } from "../data/dataTypes.js";
@@ -22,7 +23,7 @@ declare class WgslGenerator implements ShaderGenerator {
    */
   _typedExpression(expression: tinyest.Expression, expectedType: BaseData | BaseData[]): Snippet;
   _expression(expression: tinyest.Expression): Snippet;
-  functionDefinition(body: tinyest.Block): string;
+  functionDefinition(options: FunctionDefinitionOptions): string;
   /**
    * Generates a WGSL type string for the given data type, and adds necessary
    * definitions to the shader preamble. This shouldn't be called directly, only
@@ -30,6 +31,7 @@ declare class WgslGenerator implements ShaderGenerator {
    */
   typeAnnotation(data: BaseData): string;
   typeInstantiation(schema: BaseData, args: readonly Snippet[]): ResolvedSnippet;
+  _return(statement: tinyest.Return): string;
   _statement(statement: tinyest.Statement): string;
 }
 //#endregion

package/tgsl/wgslGenerator.js

@@ -1,7 +1,7 @@
 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 { ConsoleLog, InfixDispatch, UnknownData, isLooseData, unptr } from "../data/dataTypes.js";
+import { InfixDispatch, UnknownData, unptr } from "../data/dataTypes.js";
 import { fallthroughCopyOrigin, isEphemeralOrigin, isEphemeralSnippet, snip } from "../data/snippet.js";
 import { ResolutionError, WgslTypeError, invariant } from "../errors.js";
 import { isGPUCallable, isKnownAtComptime } from "../types.js";
@@ -13,6 +13,7 @@ import { convertStructValues, convertToCommonType, tryConvertSnippet } from "./c
 import { bool, i32, u32 } from "../data/numeric.js";
 import { ArrayExpression, coerceToSnippet, concretize, numericLiteralToSnippet } from "./generationHelpers.js";
 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 { accessProp } from "./accessProp.js";
@@ -23,9 +24,10 @@ 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 { mathToStd } from "./math.js";
+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 * as tinyest from "tinyest";
 
 //#region src/tgsl/wgslGenerator.ts
@@ -224,8 +226,9 @@ ${this.ctx.pre}}`;
 				return snip(rhsStr$1, bool, "runtime");
 			}
 			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 (rhsExpr.value instanceof RefOperator) throw new WgslTypeError(stitch`Cannot assign a ref to an existing variable '${stringifyNode(lhs)}', define a new variable instead.`);
 			if (op === "==") throw new Error("Please use the === operator instead of ==");
+			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`);
@@ -249,10 +252,13 @@ ${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") 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-----`);
+				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.`);
+				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");
 		}
@@ -273,37 +279,28 @@ ${this.ctx.pre}}`;
 		}
 		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)}`);
+			const accessed = accessProp(this._expression(targetNode), property);
+			if (!accessed) throw new Error(`Property '${property}' not found on '${stringifyNode(targetNode)}'`);
 			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.`);
-			}
+			const accessed = accessIndex(target, convertToCommonType(this.ctx, [inProperty], [u32, i32], false)?.[0] ?? inProperty);
+			if (!accessed) throw new Error(`Index access '${stringifyNode(expression)}' is invalid. 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]}`);
+			invariant(type, `Expected ${stringifyNode(expression)} to be valid numeric literal`);
 			return type;
 		}
 		if (expression[0] === NODE.call) {
 			const [_, calleeNode, argNodes] = expression;
-			const callee = this._expression(calleeNode);
+			const _callee = this._expression(calleeNode);
+			const callee = mathToStd.has(_callee.value) ? snip(mathToStd.get(_callee.value), UnknownData, "runtime") : _callee;
+			if (supportedLogOps().includes(callee.value)) return this.ctx.generateLog(callee.value, argNodes.map((arg) => this._expression(arg)));
 			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");
@@ -323,14 +320,13 @@ ${this.ctx.pre}}`;
 				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`);
+					if (!argType) throw new WgslTypeError(`Call '${stringifyNode(expression)}' is invalid since the function expected fewer arguments`);
 					return this._typedExpression(arg, argType);
 				});
 				else convertedArguments = argNodes.map((arg) => this._expression(arg));
@@ -360,6 +356,10 @@ ${this.ctx.pre}}`;
 				}));
 				if (shelllessCall) return shelllessCall;
 			}
+			const maybeMathMethod = Object.getOwnPropertyNames(Math).find((prop) => Math[prop] === callee.value);
+			if (maybeMathMethod) throw new Error(`Unsupported Math functionality 'Math.${maybeMathMethod}()'. Use an std alternative, or implement the function manually.`);
+			const maybeConsoleMethod = Object.getOwnPropertyNames(console).find((prop) => console[prop] === callee.value);
+			if (maybeConsoleMethod) throw new Error(`Unsupported console functionality 'console.${maybeConsoleMethod}()'.`);
 			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) {
@@ -390,7 +390,7 @@ ${this.ctx.pre}}`;
 				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.`);
+			throw new WgslTypeError(`No target type could be inferred for object '${stringifyNode(expression)}', please wrap the object in the corresponding schema.`);
 		}
 		if (expression[0] === NODE.arrayExpr) {
 			const [_, valueNodes] = expression;
@@ -405,7 +405,7 @@ ${this.ctx.pre}}`;
 				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");
+				if (!converted) throw new WgslTypeError(`Values '${stringifyNode(expression)}' cannot be automatically converted to a common type. Consider wrapping the array in an appropriate schema`);
 				values = converted;
 				elemType = concretize(values[0]?.dataType);
 			}
@@ -416,14 +416,19 @@ ${this.ctx.pre}}`;
 			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.`);
+			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.`);
 		}
 		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);
+	functionDefinition(options) {
+		const body = this._block(options.body);
+		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}`;
+		}).join(", ");
+		return `${returnType.type !== "void" ? `(${argList}) -> ${getAttributesString(returnType)}${this.ctx.resolve(returnType).value} ` : `(${argList}) `}${body}`;
 	}
 	/**
 	* Generates a WGSL type string for the given data type, and adds necessary
@@ -437,6 +442,28 @@ ${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");
 	}
+	_return(statement) {
+		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(`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") {
+				const str = stringifyNode(returnNode);
+				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;`;
+	}
 	_statement(statement) {
 		if (typeof statement === "string") {
 			const id = this._identifier(statement);
@@ -444,28 +471,7 @@ ${this.ctx.pre}}`;
 			return resolved$1 ? `${this.ctx.pre}${resolved$1};` : "";
 		}
 		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.return) return this._return(statement);
 		if (statement[0] === NODE.if) {
 			const [_, condNode, consNode, altNode] = statement;
 			const condition = this._typedExpression(condNode, bool);
@@ -488,11 +494,10 @@ ${this.ctx.pre}else ${alternate}`;
 			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.`);
+			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 (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;
@@ -501,7 +506,7 @@ ${this.ctx.pre}else ${alternate}`;
 			}
 			if (!ephemeral) {
 				if (stmtType === NODE.let) {
-					const rhsStr$1 = this.ctx.resolve(eq.value).value;
+					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.
 -----
@@ -525,7 +530,7 @@ ${this.ctx.pre}else ${alternate}`;
 				else if (naturallyEphemeral) varType = eq.origin === "constant" ? "const" : "let";
 			} else if (eq.origin === "argument") {
 				if (!naturallyEphemeral) {
-					const rhsStr$1 = this.ctx.resolve(eq.value).value;
+					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.
   -----
@@ -593,14 +598,14 @@ ${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 loop. The elements of iterable are emphemeral but not naturally ephemeral.");
+					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");
 				}
 				this.#unrolling = false;
 				const index = this.ctx.makeNameValid("i");
 				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, u32, "runtime") });
+				if (isTgpuRange(iterableSnippet.value)) bodyStr = this._block(blockified, { [originalLoopVarName]: snip(index, range.start.dataType, "runtime") });
 				else {
 					this.ctx.indent();
 					ctxIndent = true;