[tint][intrinsics] Change intrinsic template syntax from <...> to [...]
[...] will be used to declare a list of implicit template arguments.
The resolver special cases certain intrinsics so that the first template
argument is explicitly pre-defined. This special-casing will be moved
into the definition file, by re-introducing <...> as an explicit
template list in a later CL.
Change-Id: Ib0b5f5870fe2bc727df758142c724d85e205b4a3
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/175243
Reviewed-by: James Price <jrprice@google.com>
Kokoro: Kokoro <noreply+kokoro@google.com>
Commit-Queue: Ben Clayton <bclayton@google.com>
Reviewed-by: dan sinclair <dsinclair@chromium.org>
diff --git a/src/tint/lang/core/core.def b/src/tint/lang/core/core.def
index f4350ec..001ebd0 100644
--- a/src/tint/lang/core/core.def
+++ b/src/tint/lang/core/core.def
@@ -366,7 +366,7 @@
// //
// * Template type example without constraint: //
// //
-// fn arrayLength<T>(array<T>) -> u32 //
+// fn arrayLength[T](array<T>) -> u32 //
// //
// Declares an overload of the function 'arrayLength' that accepts a //
// single argument of an array type with no constraints on the array //
@@ -375,7 +375,7 @@
// //
// * Template type example with constraint: //
// //
-// fn abs<T: fiu32>(T) -> T //
+// fn abs[T: fiu32](T) -> T //
// //
// Declares an overload of the function 'abs' that accepts a single //
// argument of type 'f32', 'i32' or 'u32', which returns a value of the //
@@ -386,7 +386,7 @@
// //
// * Template number example: //
// //
-// fn dpdx<N: num>(vec<N, f32>) -> vec<N, f32> //
+// fn dpdx[N: num](vec<N, f32>) -> vec<N, f32> //
// //
// Declares an overload of the function 'dpdx' that accepts a single //
// argument of a variable-sized vector of 'f32', which returns a value of //
@@ -420,7 +420,7 @@
// To better understand, let's consider the following hypothetical overload //
// declaration: //
// //
-// fn foo<T: scalar>(T, T); //
+// fn foo[T: scalar](T, T); //
// //
// T - is the template type name //
// scalar - is a matcher for the types 'f32', 'i32', 'u32' or 'bool' //
@@ -491,21 +491,21 @@
// Note: Parameter names are used by Tint to infer parameter order for //
// some builtin functions //
// //
-// fn F<T>(T) //
+// fn F[T](T) //
// - Single parameter of unconstrained template type T (any type) //
// //
-// fn F<T: scalar>(T) //
+// fn F[T: scalar](T) //
// - Single parameter of constrained template type T (must be a scalar) //
// //
-// fn F<T: fiu32>(T) -> T //
+// fn F[T: fiu32](T) -> T //
// - Single parameter of constrained template type T (must be a one of //
// fiu32) Return type matches parameter type //
// //
-// fn F<T, N: num>(vec<N, T>) //
+// fn F[T, N: num](vec<N, T>) //
// - Single parameter of vector type with template number size N and //
// element template type T //
// //
-// fn F<A: access>(texture_storage_1d<f32_texel_format, A>) //
+// fn F[A: access](texture_storage_1d<f32_texel_format, A>) //
// - Single parameter of texture_storage_1d type with template number //
// access-control C, and of a texel format that is listed in //
// f32_texel_format //
@@ -513,109 +513,109 @@
////////////////////////////////////////////////////////////////////////////////
// https://gpuweb.github.io/gpuweb/wgsl/#builtin-functions
-@must_use @const fn abs<T: fiu32_f16>(T) -> T
-@must_use @const fn abs<N: num, T: fiu32_f16>(vec<N, T>) -> vec<N, T>
-@must_use @const fn acos<T: f32_f16>(@test_value(0.96891242171) T) -> T
-@must_use @const fn acos<N: num, T: f32_f16>(@test_value(0.96891242171) vec<N, T>) -> vec<N, T>
-@must_use @const fn acosh<T: f32_f16>(@test_value(1.5430806348) T) -> T
-@must_use @const fn acosh<N: num, T: f32_f16>(@test_value(1.5430806348) vec<N, T>) -> vec<N, T>
+@must_use @const fn abs[T: fiu32_f16](T) -> T
+@must_use @const fn abs[N: num, T: fiu32_f16](vec<N, T>) -> vec<N, T>
+@must_use @const fn acos[T: f32_f16](@test_value(0.96891242171) T) -> T
+@must_use @const fn acos[N: num, T: f32_f16](@test_value(0.96891242171) vec<N, T>) -> vec<N, T>
+@must_use @const fn acosh[T: f32_f16](@test_value(1.5430806348) T) -> T
+@must_use @const fn acosh[N: num, T: f32_f16](@test_value(1.5430806348) vec<N, T>) -> vec<N, T>
@must_use @const fn all(bool) -> bool
-@must_use @const fn all<N: num>(vec<N, bool>) -> bool
+@must_use @const fn all[N: num](vec<N, bool>) -> bool
@must_use @const fn any(bool) -> bool
-@must_use @const fn any<N: num>(vec<N, bool>) -> bool
-@must_use fn arrayLength<T, A: access>(ptr<storage, array<T>, A>) -> u32
-@must_use @const fn asin<T: f32_f16>(@test_value(0.479425538604) T) -> T
-@must_use @const fn asin<N: num, T: f32_f16>(@test_value(0.479425538604) vec<N, T>) -> vec<N, T>
-@must_use @const fn asinh<T: f32_f16>(T) -> T
-@must_use @const fn asinh<N: num, T: f32_f16>(vec<N, T>) -> vec<N, T>
-@must_use @const fn atan<T: f32_f16>(T) -> T
-@must_use @const fn atan<N: num, T: f32_f16>(vec<N, T>) -> vec<N, T>
-@must_use @const fn atan2<T: f32_f16>(T, T) -> T
-@must_use @const fn atan2<T: f32_f16, N: num>(vec<N, T>, vec<N, T>) -> vec<N, T>
-@must_use @const fn atanh<T: f32_f16>(@test_value(0.5) T) -> T
-@must_use @const fn atanh<N: num, T: f32_f16>(@test_value(0.5) vec<N, T>) -> vec<N, T>
-@must_use @const fn ceil<T: f32_f16>(@test_value(1.5) T) -> T
-@must_use @const fn ceil<N: num, T: f32_f16>(@test_value(1.5) vec<N, T>) -> vec<N, T>
-@must_use @const fn clamp<T: fiu32_f16>(T, T, T) -> T
-@must_use @const fn clamp<T: fiu32_f16, N: num>(vec<N, T>, vec<N, T>, vec<N, T>) -> vec<N, T>
-@must_use @const fn cos<T: f32_f16>(@test_value(0) T) -> T
-@must_use @const fn cos<N: num, T: f32_f16>(@test_value(0) vec<N, T>) -> vec<N, T>
-@must_use @const fn cosh<T: f32_f16>(@test_value(0) T) -> T
-@must_use @const fn cosh<N: num, T: f32_f16>(@test_value(0) vec<N, T>) -> vec<N, T>
-@must_use @const fn countLeadingZeros<T: iu32>(T) -> T
-@must_use @const fn countLeadingZeros<N: num, T: iu32>(vec<N, T>) -> vec<N, T>
-@must_use @const fn countOneBits<T: iu32>(T) -> T
-@must_use @const fn countOneBits<N: num, T: iu32>(vec<N, T>) -> vec<N, T>
-@must_use @const fn countTrailingZeros<T: iu32>(T) -> T
-@must_use @const fn countTrailingZeros<N: num, T: iu32>(vec<N, T>) -> vec<N, T>
-@must_use @const fn cross<T: f32_f16>(vec3<T>, vec3<T>) -> vec3<T>
-@must_use @const fn degrees<T: f32_f16>(T) -> T
-@must_use @const fn degrees<N: num, T: f32_f16>(vec<N, T>) -> vec<N, T>
-@must_use @const fn determinant<N: num, T: f32_f16>(mat<N, N, T>) -> T
-@must_use @const fn distance<T: f32_f16>(T, T) -> T
-@must_use @const fn distance<N: num, T: f32_f16>(vec<N, T>, vec<N, T>) -> T
-@must_use @const fn dot<N: num, T: fiu32_f16>(vec<N, T>, vec<N, T>) -> T
+@must_use @const fn any[N: num](vec<N, bool>) -> bool
+@must_use fn arrayLength[T, A: access](ptr<storage, array<T>, A>) -> u32
+@must_use @const fn asin[T: f32_f16](@test_value(0.479425538604) T) -> T
+@must_use @const fn asin[N: num, T: f32_f16](@test_value(0.479425538604) vec<N, T>) -> vec<N, T>
+@must_use @const fn asinh[T: f32_f16](T) -> T
+@must_use @const fn asinh[N: num, T: f32_f16](vec<N, T>) -> vec<N, T>
+@must_use @const fn atan[T: f32_f16](T) -> T
+@must_use @const fn atan[N: num, T: f32_f16](vec<N, T>) -> vec<N, T>
+@must_use @const fn atan2[T: f32_f16](T, T) -> T
+@must_use @const fn atan2[T: f32_f16, N: num](vec<N, T>, vec<N, T>) -> vec<N, T>
+@must_use @const fn atanh[T: f32_f16](@test_value(0.5) T) -> T
+@must_use @const fn atanh[N: num, T: f32_f16](@test_value(0.5) vec<N, T>) -> vec<N, T>
+@must_use @const fn ceil[T: f32_f16](@test_value(1.5) T) -> T
+@must_use @const fn ceil[N: num, T: f32_f16](@test_value(1.5) vec<N, T>) -> vec<N, T>
+@must_use @const fn clamp[T: fiu32_f16](T, T, T) -> T
+@must_use @const fn clamp[T: fiu32_f16, N: num](vec<N, T>, vec<N, T>, vec<N, T>) -> vec<N, T>
+@must_use @const fn cos[T: f32_f16](@test_value(0) T) -> T
+@must_use @const fn cos[N: num, T: f32_f16](@test_value(0) vec<N, T>) -> vec<N, T>
+@must_use @const fn cosh[T: f32_f16](@test_value(0) T) -> T
+@must_use @const fn cosh[N: num, T: f32_f16](@test_value(0) vec<N, T>) -> vec<N, T>
+@must_use @const fn countLeadingZeros[T: iu32](T) -> T
+@must_use @const fn countLeadingZeros[N: num, T: iu32](vec<N, T>) -> vec<N, T>
+@must_use @const fn countOneBits[T: iu32](T) -> T
+@must_use @const fn countOneBits[N: num, T: iu32](vec<N, T>) -> vec<N, T>
+@must_use @const fn countTrailingZeros[T: iu32](T) -> T
+@must_use @const fn countTrailingZeros[N: num, T: iu32](vec<N, T>) -> vec<N, T>
+@must_use @const fn cross[T: f32_f16](vec3<T>, vec3<T>) -> vec3<T>
+@must_use @const fn degrees[T: f32_f16](T) -> T
+@must_use @const fn degrees[N: num, T: f32_f16](vec<N, T>) -> vec<N, T>
+@must_use @const fn determinant[N: num, T: f32_f16](mat<N, N, T>) -> T
+@must_use @const fn distance[T: f32_f16](T, T) -> T
+@must_use @const fn distance[N: num, T: f32_f16](vec<N, T>, vec<N, T>) -> T
+@must_use @const fn dot[N: num, T: fiu32_f16](vec<N, T>, vec<N, T>) -> T
@must_use fn dot4I8Packed(u32, u32) -> i32
@must_use fn dot4U8Packed(u32, u32) -> u32
@must_use @stage("fragment") fn dpdx(f32) -> f32
-@must_use @stage("fragment") fn dpdx<N: num>(vec<N, f32>) -> vec<N, f32>
+@must_use @stage("fragment") fn dpdx[N: num](vec<N, f32>) -> vec<N, f32>
@must_use @stage("fragment") fn dpdxCoarse(f32) -> f32
-@must_use @stage("fragment") fn dpdxCoarse<N: num>(vec<N, f32>) -> vec<N, f32>
+@must_use @stage("fragment") fn dpdxCoarse[N: num](vec<N, f32>) -> vec<N, f32>
@must_use @stage("fragment") fn dpdxFine(f32) -> f32
-@must_use @stage("fragment") fn dpdxFine<N: num>(vec<N, f32>) -> vec<N, f32>
+@must_use @stage("fragment") fn dpdxFine[N: num](vec<N, f32>) -> vec<N, f32>
@must_use @stage("fragment") fn dpdy(f32) -> f32
-@must_use @stage("fragment") fn dpdy<N: num>(vec<N, f32>) -> vec<N, f32>
+@must_use @stage("fragment") fn dpdy[N: num](vec<N, f32>) -> vec<N, f32>
@must_use @stage("fragment") fn dpdyCoarse(f32) -> f32
-@must_use @stage("fragment") fn dpdyCoarse<N: num>(vec<N, f32>) -> vec<N, f32>
+@must_use @stage("fragment") fn dpdyCoarse[N: num](vec<N, f32>) -> vec<N, f32>
@must_use @stage("fragment") fn dpdyFine(f32) -> f32
-@must_use @stage("fragment") fn dpdyFine<N: num>(vec<N, f32>) -> vec<N, f32>
-@must_use @const fn exp<T: f32_f16>(T) -> T
-@must_use @const fn exp<N: num, T: f32_f16>(vec<N, T>) -> vec<N, T>
-@must_use @const fn exp2<T: f32_f16>(T) -> T
-@must_use @const fn exp2<N: num, T: f32_f16>(vec<N, T>) -> vec<N, T>
-@must_use @const fn extractBits<T: iu32>(T, u32, u32) -> T
-@must_use @const fn extractBits<N: num, T: iu32>(vec<N, T>, u32, u32) -> vec<N, T>
-@must_use @const fn faceForward<N: num, T: f32_f16>(vec<N, T>, vec<N, T>, vec<N, T>) -> vec<N, T>
-@must_use @const fn firstLeadingBit<T: iu32>(T) -> T
-@must_use @const fn firstLeadingBit<N: num, T: iu32>(vec<N, T>) -> vec<N, T>
-@must_use @const fn firstTrailingBit<T: iu32>(T) -> T
-@must_use @const fn firstTrailingBit<N: num, T: iu32>(vec<N, T>) -> vec<N, T>
-@must_use @const fn floor<T: f32_f16>(@test_value(1.5) T) -> T
-@must_use @const fn floor<N: num, T: f32_f16>(@test_value(1.5) vec<N, T>) -> vec<N, T>
-@must_use @const fn fma<T: f32_f16>(T, T, T) -> T
-@must_use @const fn fma<N: num, T: f32_f16>(vec<N, T>, vec<N, T>, vec<N, T>) -> vec<N, T>
-@must_use @const fn fract<T: f32_f16>(@test_value(1.25) T) -> T
-@must_use @const fn fract<N: num, T: f32_f16>(@test_value(1.25) vec<N, T>) -> vec<N, T>
-@must_use @const fn frexp<T: f32_f16>(T) -> __frexp_result<T>
-@must_use @const fn frexp<N: num, T: f32_f16>(vec<N, T>) -> __frexp_result_vec<N, T>
+@must_use @stage("fragment") fn dpdyFine[N: num](vec<N, f32>) -> vec<N, f32>
+@must_use @const fn exp[T: f32_f16](T) -> T
+@must_use @const fn exp[N: num, T: f32_f16](vec<N, T>) -> vec<N, T>
+@must_use @const fn exp2[T: f32_f16](T) -> T
+@must_use @const fn exp2[N: num, T: f32_f16](vec<N, T>) -> vec<N, T>
+@must_use @const fn extractBits[T: iu32](T, u32, u32) -> T
+@must_use @const fn extractBits[N: num, T: iu32](vec<N, T>, u32, u32) -> vec<N, T>
+@must_use @const fn faceForward[N: num, T: f32_f16](vec<N, T>, vec<N, T>, vec<N, T>) -> vec<N, T>
+@must_use @const fn firstLeadingBit[T: iu32](T) -> T
+@must_use @const fn firstLeadingBit[N: num, T: iu32](vec<N, T>) -> vec<N, T>
+@must_use @const fn firstTrailingBit[T: iu32](T) -> T
+@must_use @const fn firstTrailingBit[N: num, T: iu32](vec<N, T>) -> vec<N, T>
+@must_use @const fn floor[T: f32_f16](@test_value(1.5) T) -> T
+@must_use @const fn floor[N: num, T: f32_f16](@test_value(1.5) vec<N, T>) -> vec<N, T>
+@must_use @const fn fma[T: f32_f16](T, T, T) -> T
+@must_use @const fn fma[N: num, T: f32_f16](vec<N, T>, vec<N, T>, vec<N, T>) -> vec<N, T>
+@must_use @const fn fract[T: f32_f16](@test_value(1.25) T) -> T
+@must_use @const fn fract[N: num, T: f32_f16](@test_value(1.25) vec<N, T>) -> vec<N, T>
+@must_use @const fn frexp[T: f32_f16](T) -> __frexp_result<T>
+@must_use @const fn frexp[N: num, T: f32_f16](vec<N, T>) -> __frexp_result_vec<N, T>
@must_use @stage("fragment") fn fwidth(f32) -> f32
-@must_use @stage("fragment") fn fwidth<N: num>(vec<N, f32>) -> vec<N, f32>
+@must_use @stage("fragment") fn fwidth[N: num](vec<N, f32>) -> vec<N, f32>
@must_use @stage("fragment") fn fwidthCoarse(f32) -> f32
-@must_use @stage("fragment") fn fwidthCoarse<N: num>(vec<N, f32>) -> vec<N, f32>
+@must_use @stage("fragment") fn fwidthCoarse[N: num](vec<N, f32>) -> vec<N, f32>
@must_use @stage("fragment") fn fwidthFine(f32) -> f32
-@must_use @stage("fragment") fn fwidthFine<N: num>(vec<N, f32>) -> vec<N, f32>
-@must_use @const fn insertBits<T: iu32>(T, T, u32, u32) -> T
-@must_use @const fn insertBits<N: num, T: iu32>(vec<N, T>, vec<N, T>, u32, u32) -> vec<N, T>
-@must_use @const fn inverseSqrt<T: f32_f16>(T) -> T
-@must_use @const fn inverseSqrt<N: num, T: f32_f16>(vec<N, T>) -> vec<N, T>
-@must_use @const fn ldexp<T: f32_f16, U: i32>(T, U) -> T
-@must_use @const fn ldexp<N: num, T: f32_f16, U: i32>(vec<N, T>, vec<N, U>) -> vec<N, T>
-@must_use @const fn length<T: f32_f16>(@test_value(0.0) T) -> T
-@must_use @const fn length<N: num, T: f32_f16>(@test_value(0.0) vec<N, T>) -> T
-@must_use @const fn log<T: f32_f16>(T) -> T
-@must_use @const fn log<N: num, T: f32_f16>(vec<N, T>) -> vec<N, T>
-@must_use @const fn log2<T: f32_f16>(T) -> T
-@must_use @const fn log2<N: num, T: f32_f16>(vec<N, T>) -> vec<N, T>
-@must_use @const fn max<T: fiu32_f16>(T, T) -> T
-@must_use @const fn max<N: num, T: fiu32_f16>(vec<N, T>, vec<N, T>) -> vec<N, T>
-@must_use @const fn min<T: fiu32_f16>(T, T) -> T
-@must_use @const fn min<N: num, T: fiu32_f16>(vec<N, T>, vec<N, T>) -> vec<N, T>
-@must_use @const fn mix<T: f32_f16>(T, T, T) -> T
-@must_use @const fn mix<N: num, T: f32_f16>(vec<N, T>, vec<N, T>, vec<N, T>) -> vec<N, T>
-@must_use @const fn mix<N: num, T: f32_f16>(vec<N, T>, vec<N, T>, T) -> vec<N, T>
-@must_use @const fn modf<T: f32_f16>(@test_value(-1.5) T) -> __modf_result<T>
-@must_use @const fn modf<N: num, T: f32_f16>(@test_value(-1.5) vec<N, T>) -> __modf_result_vec<N, T>
-@must_use @const fn normalize<N: num, T: f32_f16>(vec<N, T>) -> vec<N, T>
+@must_use @stage("fragment") fn fwidthFine[N: num](vec<N, f32>) -> vec<N, f32>
+@must_use @const fn insertBits[T: iu32](T, T, u32, u32) -> T
+@must_use @const fn insertBits[N: num, T: iu32](vec<N, T>, vec<N, T>, u32, u32) -> vec<N, T>
+@must_use @const fn inverseSqrt[T: f32_f16](T) -> T
+@must_use @const fn inverseSqrt[N: num, T: f32_f16](vec<N, T>) -> vec<N, T>
+@must_use @const fn ldexp[T: f32_f16, U: i32](T, U) -> T
+@must_use @const fn ldexp[N: num, T: f32_f16, U: i32](vec<N, T>, vec<N, U>) -> vec<N, T>
+@must_use @const fn length[T: f32_f16](@test_value(0.0) T) -> T
+@must_use @const fn length[N: num, T: f32_f16](@test_value(0.0) vec<N, T>) -> T
+@must_use @const fn log[T: f32_f16](T) -> T
+@must_use @const fn log[N: num, T: f32_f16](vec<N, T>) -> vec<N, T>
+@must_use @const fn log2[T: f32_f16](T) -> T
+@must_use @const fn log2[N: num, T: f32_f16](vec<N, T>) -> vec<N, T>
+@must_use @const fn max[T: fiu32_f16](T, T) -> T
+@must_use @const fn max[N: num, T: fiu32_f16](vec<N, T>, vec<N, T>) -> vec<N, T>
+@must_use @const fn min[T: fiu32_f16](T, T) -> T
+@must_use @const fn min[N: num, T: fiu32_f16](vec<N, T>, vec<N, T>) -> vec<N, T>
+@must_use @const fn mix[T: f32_f16](T, T, T) -> T
+@must_use @const fn mix[N: num, T: f32_f16](vec<N, T>, vec<N, T>, vec<N, T>) -> vec<N, T>
+@must_use @const fn mix[N: num, T: f32_f16](vec<N, T>, vec<N, T>, T) -> vec<N, T>
+@must_use @const fn modf[T: f32_f16](@test_value(-1.5) T) -> __modf_result<T>
+@must_use @const fn modf[N: num, T: f32_f16](@test_value(-1.5) vec<N, T>) -> __modf_result_vec<N, T>
+@must_use @const fn normalize[N: num, T: f32_f16](vec<N, T>) -> vec<N, T>
@must_use @const fn pack2x16float(vec2<f32>) -> u32
@must_use @const fn pack2x16snorm(vec2<f32>) -> u32
@must_use @const fn pack2x16unorm(vec2<f32>) -> u32
@@ -625,43 +625,43 @@
@must_use @const fn pack4xU8(vec4<u32>) -> u32
@must_use @const fn pack4xI8Clamp(vec4<i32>) -> u32
@must_use @const fn pack4xU8Clamp(vec4<u32>) -> u32
-@must_use @const fn pow<T: f32_f16>(T, T) -> T
-@must_use @const fn pow<N: num, T: f32_f16>(vec<N, T>, vec<N, T>) -> vec<N, T>
+@must_use @const fn pow[T: f32_f16](T, T) -> T
+@must_use @const fn pow[N: num, T: f32_f16](vec<N, T>, vec<N, T>) -> vec<N, T>
@must_use @const fn quantizeToF16(f32) -> f32
-@must_use @const fn quantizeToF16<N: num>(vec<N, f32>) -> vec<N, f32>
-@must_use @const fn radians<T: f32_f16>(T) -> T
-@must_use @const fn radians<N: num, T: f32_f16>(vec<N, T>) -> vec<N, T>
-@must_use @const fn reflect<N: num, T: f32_f16>(vec<N, T>, vec<N, T>) -> vec<N, T>
-@must_use @const fn refract<N: num, T: f32_f16>(vec<N, T>, vec<N, T>, T) -> vec<N, T>
-@must_use @const fn reverseBits<T: iu32>(T) -> T
-@must_use @const fn reverseBits<N: num, T: iu32>(vec<N, T>) -> vec<N, T>
-@must_use @const fn round<T: f32_f16>(@test_value(3.5) T) -> T
-@must_use @const fn round<N: num, T: f32_f16>(@test_value(3.5) vec<N, T>) -> vec<N, T>
-@must_use @const fn saturate<T: f32_f16>(@test_value(2) T) -> T
-@must_use @const fn saturate<T: f32_f16, N: num>(@test_value(2) vec<N, T>) -> vec<N, T>
-@must_use @const("select_bool") fn select<T: scalar>(T, T, bool) -> T
-@must_use @const("select_bool") fn select<T: scalar, N: num>(vec<N, T>, vec<N, T>, bool) -> vec<N, T>
-@must_use @const("select_boolvec") fn select<N: num, T: scalar>(vec<N, T>, vec<N, T>, vec<N, bool>) -> vec<N, T>
-@must_use @const fn sign<T: fi32_f16>(T) -> T
-@must_use @const fn sign<N: num, T: fi32_f16>(vec<N, T>) -> vec<N, T>
-@must_use @const fn sin<T: f32_f16>(@test_value(1.57079632679) T) -> T
-@must_use @const fn sin<N: num, T: f32_f16>(@test_value(1.57079632679) vec<N, T>) -> vec<N, T>
-@must_use @const fn sinh<T: f32_f16>(T) -> T
-@must_use @const fn sinh<N: num, T: f32_f16>(vec<N, T>) -> vec<N, T>
-@must_use @const fn smoothstep<T: f32_f16>(@test_value(2) T, @test_value(4) T, @test_value(3) T) -> T
-@must_use @const fn smoothstep<N: num, T: f32_f16>(@test_value(2) vec<N, T>, @test_value(4) vec<N, T>, @test_value(3) vec<N, T>) -> vec<N, T>
-@must_use @const fn sqrt<T: f32_f16>(T) -> T
-@must_use @const fn sqrt<N: num, T: f32_f16>(vec<N, T>) -> vec<N, T>
-@must_use @const fn step<T: f32_f16>(T, T) -> T
-@must_use @const fn step<N: num, T: f32_f16>(vec<N, T>, vec<N, T>) -> vec<N, T>
+@must_use @const fn quantizeToF16[N: num](vec<N, f32>) -> vec<N, f32>
+@must_use @const fn radians[T: f32_f16](T) -> T
+@must_use @const fn radians[N: num, T: f32_f16](vec<N, T>) -> vec<N, T>
+@must_use @const fn reflect[N: num, T: f32_f16](vec<N, T>, vec<N, T>) -> vec<N, T>
+@must_use @const fn refract[N: num, T: f32_f16](vec<N, T>, vec<N, T>, T) -> vec<N, T>
+@must_use @const fn reverseBits[T: iu32](T) -> T
+@must_use @const fn reverseBits[N: num, T: iu32](vec<N, T>) -> vec<N, T>
+@must_use @const fn round[T: f32_f16](@test_value(3.5) T) -> T
+@must_use @const fn round[N: num, T: f32_f16](@test_value(3.5) vec<N, T>) -> vec<N, T>
+@must_use @const fn saturate[T: f32_f16](@test_value(2) T) -> T
+@must_use @const fn saturate[T: f32_f16, N: num](@test_value(2) vec<N, T>) -> vec<N, T>
+@must_use @const("select_bool") fn select[T: scalar](T, T, bool) -> T
+@must_use @const("select_bool") fn select[T: scalar, N: num](vec<N, T>, vec<N, T>, bool) -> vec<N, T>
+@must_use @const("select_boolvec") fn select[N: num, T: scalar](vec<N, T>, vec<N, T>, vec<N, bool>) -> vec<N, T>
+@must_use @const fn sign[T: fi32_f16](T) -> T
+@must_use @const fn sign[N: num, T: fi32_f16](vec<N, T>) -> vec<N, T>
+@must_use @const fn sin[T: f32_f16](@test_value(1.57079632679) T) -> T
+@must_use @const fn sin[N: num, T: f32_f16](@test_value(1.57079632679) vec<N, T>) -> vec<N, T>
+@must_use @const fn sinh[T: f32_f16](T) -> T
+@must_use @const fn sinh[N: num, T: f32_f16](vec<N, T>) -> vec<N, T>
+@must_use @const fn smoothstep[T: f32_f16](@test_value(2) T, @test_value(4) T, @test_value(3) T) -> T
+@must_use @const fn smoothstep[N: num, T: f32_f16](@test_value(2) vec<N, T>, @test_value(4) vec<N, T>, @test_value(3) vec<N, T>) -> vec<N, T>
+@must_use @const fn sqrt[T: f32_f16](T) -> T
+@must_use @const fn sqrt[N: num, T: f32_f16](vec<N, T>) -> vec<N, T>
+@must_use @const fn step[T: f32_f16](T, T) -> T
+@must_use @const fn step[N: num, T: f32_f16](vec<N, T>, vec<N, T>) -> vec<N, T>
@stage("compute") fn storageBarrier()
-@must_use @const fn tan<T: f32_f16>(T) -> T
-@must_use @const fn tan<N: num, T: f32_f16>(vec<N, T>) -> vec<N, T>
-@must_use @const fn tanh<T: f32_f16>(T) -> T
-@must_use @const fn tanh<N: num, T: f32_f16>(vec<N, T>) -> vec<N, T>
-@must_use @const fn transpose<M: num, N: num, T: f32_f16>(mat<M, N, T>) -> mat<N, M, T>
-@must_use @const fn trunc<T: f32_f16>(@test_value(1.5) T) -> T
-@must_use @const fn trunc<N: num, T: f32_f16>(@test_value(1.5) vec<N, T>) -> vec<N, T>
+@must_use @const fn tan[T: f32_f16](T) -> T
+@must_use @const fn tan[N: num, T: f32_f16](vec<N, T>) -> vec<N, T>
+@must_use @const fn tanh[T: f32_f16](T) -> T
+@must_use @const fn tanh[N: num, T: f32_f16](vec<N, T>) -> vec<N, T>
+@must_use @const fn transpose[M: num, N: num, T: f32_f16](mat<M, N, T>) -> mat<N, M, T>
+@must_use @const fn trunc[T: f32_f16](@test_value(1.5) T) -> T
+@must_use @const fn trunc[N: num, T: f32_f16](@test_value(1.5) vec<N, T>) -> vec<N, T>
@must_use @const fn unpack2x16float(u32) -> vec2<f32>
@must_use @const fn unpack2x16snorm(u32) -> vec2<f32>
@must_use @const fn unpack2x16unorm(u32) -> vec2<f32>
@@ -672,176 +672,176 @@
@stage("compute") fn workgroupBarrier()
@stage("compute") fn textureBarrier()
-@must_use fn textureDimensions<T: fiu32>(texture: texture_1d<T>) -> u32
-@must_use fn textureDimensions<T: fiu32, L: iu32>(texture: texture_1d<T>, level: L) -> u32
-@must_use fn textureDimensions<T: fiu32>(texture: texture_2d<T>) -> vec2<u32>
-@must_use fn textureDimensions<T: fiu32, L: iu32>(texture: texture_2d<T>, level: L) -> vec2<u32>
-@must_use fn textureDimensions<T: fiu32>(texture: texture_2d_array<T>) -> vec2<u32>
-@must_use fn textureDimensions<T: fiu32, L: iu32>(texture: texture_2d_array<T>, level: L) -> vec2<u32>
-@must_use fn textureDimensions<T: fiu32>(texture: texture_3d<T>) -> vec3<u32>
-@must_use fn textureDimensions<T: fiu32, L: iu32>(texture: texture_3d<T>, level: L) -> vec3<u32>
-@must_use fn textureDimensions<T: fiu32>(texture: texture_cube<T>) -> vec2<u32>
-@must_use fn textureDimensions<T: fiu32, L: iu32>(texture: texture_cube<T>, level: L) -> vec2<u32>
-@must_use fn textureDimensions<T: fiu32>(texture: texture_cube_array<T>) -> vec2<u32>
-@must_use fn textureDimensions<T: fiu32, L: iu32>(texture: texture_cube_array<T>, level: L) -> vec2<u32>
-@must_use fn textureDimensions<T: fiu32>(texture: texture_multisampled_2d<T>) -> vec2<u32>
+@must_use fn textureDimensions[T: fiu32](texture: texture_1d<T>) -> u32
+@must_use fn textureDimensions[T: fiu32, L: iu32](texture: texture_1d<T>, level: L) -> u32
+@must_use fn textureDimensions[T: fiu32](texture: texture_2d<T>) -> vec2<u32>
+@must_use fn textureDimensions[T: fiu32, L: iu32](texture: texture_2d<T>, level: L) -> vec2<u32>
+@must_use fn textureDimensions[T: fiu32](texture: texture_2d_array<T>) -> vec2<u32>
+@must_use fn textureDimensions[T: fiu32, L: iu32](texture: texture_2d_array<T>, level: L) -> vec2<u32>
+@must_use fn textureDimensions[T: fiu32](texture: texture_3d<T>) -> vec3<u32>
+@must_use fn textureDimensions[T: fiu32, L: iu32](texture: texture_3d<T>, level: L) -> vec3<u32>
+@must_use fn textureDimensions[T: fiu32](texture: texture_cube<T>) -> vec2<u32>
+@must_use fn textureDimensions[T: fiu32, L: iu32](texture: texture_cube<T>, level: L) -> vec2<u32>
+@must_use fn textureDimensions[T: fiu32](texture: texture_cube_array<T>) -> vec2<u32>
+@must_use fn textureDimensions[T: fiu32, L: iu32](texture: texture_cube_array<T>, level: L) -> vec2<u32>
+@must_use fn textureDimensions[T: fiu32](texture: texture_multisampled_2d<T>) -> vec2<u32>
@must_use fn textureDimensions(texture: texture_depth_2d) -> vec2<u32>
-@must_use fn textureDimensions<L: iu32>(texture: texture_depth_2d, level: L) -> vec2<u32>
+@must_use fn textureDimensions[L: iu32](texture: texture_depth_2d, level: L) -> vec2<u32>
@must_use fn textureDimensions(texture: texture_depth_2d_array) -> vec2<u32>
-@must_use fn textureDimensions<L: iu32>(texture: texture_depth_2d_array, level: L) -> vec2<u32>
+@must_use fn textureDimensions[L: iu32](texture: texture_depth_2d_array, level: L) -> vec2<u32>
@must_use fn textureDimensions(texture: texture_depth_cube) -> vec2<u32>
-@must_use fn textureDimensions<L: iu32>(texture: texture_depth_cube, level: L) -> vec2<u32>
+@must_use fn textureDimensions[L: iu32](texture: texture_depth_cube, level: L) -> vec2<u32>
@must_use fn textureDimensions(texture: texture_depth_cube_array) -> vec2<u32>
-@must_use fn textureDimensions<L: iu32>(texture: texture_depth_cube_array, level: L) -> vec2<u32>
+@must_use fn textureDimensions[L: iu32](texture: texture_depth_cube_array, level: L) -> vec2<u32>
@must_use fn textureDimensions(texture: texture_depth_multisampled_2d) -> vec2<u32>
-@must_use fn textureDimensions<F: texel_format, A: access>(texture: texture_storage_1d<F, A>) -> u32
-@must_use fn textureDimensions<F: texel_format, A: access>(texture: texture_storage_2d<F, A>) -> vec2<u32>
-@must_use fn textureDimensions<F: texel_format, A: access>(texture: texture_storage_2d_array<F, A>) -> vec2<u32>
-@must_use fn textureDimensions<F: texel_format, A: access>(texture: texture_storage_3d<F, A>) -> vec3<u32>
+@must_use fn textureDimensions[F: texel_format, A: access](texture: texture_storage_1d<F, A>) -> u32
+@must_use fn textureDimensions[F: texel_format, A: access](texture: texture_storage_2d<F, A>) -> vec2<u32>
+@must_use fn textureDimensions[F: texel_format, A: access](texture: texture_storage_2d_array<F, A>) -> vec2<u32>
+@must_use fn textureDimensions[F: texel_format, A: access](texture: texture_storage_3d<F, A>) -> vec3<u32>
@must_use fn textureDimensions(texture: texture_external) -> vec2<u32>
-@must_use fn textureGather<T: fiu32, C: iu32>(@const component: C, texture: texture_2d<T>, sampler: sampler, coords: vec2<f32>) -> vec4<T>
-@must_use fn textureGather<T: fiu32, C: iu32>(@const component: C, texture: texture_2d<T>, sampler: sampler, coords: vec2<f32>, @const offset: vec2<i32>) -> vec4<T>
-@must_use fn textureGather<T: fiu32, C: iu32, A: iu32>(@const component: C, texture: texture_2d_array<T>, sampler: sampler, coords: vec2<f32>, array_index: A) -> vec4<T>
-@must_use fn textureGather<T: fiu32, C: iu32, A: iu32>(@const component: C, texture: texture_2d_array<T>, sampler: sampler, coords: vec2<f32>, array_index: A, @const offset: vec2<i32>) -> vec4<T>
-@must_use fn textureGather<T: fiu32, C: iu32>(@const component: C, texture: texture_cube<T>, sampler: sampler, coords: vec3<f32>) -> vec4<T>
-@must_use fn textureGather<T: fiu32, C: iu32, A: iu32>(@const component: C, texture: texture_cube_array<T>, sampler: sampler, coords: vec3<f32>, array_index: A) -> vec4<T>
+@must_use fn textureGather[T: fiu32, C: iu32](@const component: C, texture: texture_2d<T>, sampler: sampler, coords: vec2<f32>) -> vec4<T>
+@must_use fn textureGather[T: fiu32, C: iu32](@const component: C, texture: texture_2d<T>, sampler: sampler, coords: vec2<f32>, @const offset: vec2<i32>) -> vec4<T>
+@must_use fn textureGather[T: fiu32, C: iu32, A: iu32](@const component: C, texture: texture_2d_array<T>, sampler: sampler, coords: vec2<f32>, array_index: A) -> vec4<T>
+@must_use fn textureGather[T: fiu32, C: iu32, A: iu32](@const component: C, texture: texture_2d_array<T>, sampler: sampler, coords: vec2<f32>, array_index: A, @const offset: vec2<i32>) -> vec4<T>
+@must_use fn textureGather[T: fiu32, C: iu32](@const component: C, texture: texture_cube<T>, sampler: sampler, coords: vec3<f32>) -> vec4<T>
+@must_use fn textureGather[T: fiu32, C: iu32, A: iu32](@const component: C, texture: texture_cube_array<T>, sampler: sampler, coords: vec3<f32>, array_index: A) -> vec4<T>
@must_use fn textureGather(texture: texture_depth_2d, sampler: sampler, coords: vec2<f32>) -> vec4<f32>
@must_use fn textureGather(texture: texture_depth_2d, sampler: sampler, coords: vec2<f32>, @const offset: vec2<i32>) -> vec4<f32>
-@must_use fn textureGather<A: iu32>(texture: texture_depth_2d_array, sampler: sampler, coords: vec2<f32>, array_index: A) -> vec4<f32>
-@must_use fn textureGather<A: iu32>(texture: texture_depth_2d_array, sampler: sampler, coords: vec2<f32>, array_index: A, @const offset: vec2<i32>) -> vec4<f32>
+@must_use fn textureGather[A: iu32](texture: texture_depth_2d_array, sampler: sampler, coords: vec2<f32>, array_index: A) -> vec4<f32>
+@must_use fn textureGather[A: iu32](texture: texture_depth_2d_array, sampler: sampler, coords: vec2<f32>, array_index: A, @const offset: vec2<i32>) -> vec4<f32>
@must_use fn textureGather(texture: texture_depth_cube, sampler: sampler, coords: vec3<f32>) -> vec4<f32>
-@must_use fn textureGather<A: iu32>(texture: texture_depth_cube_array, sampler: sampler, coords: vec3<f32>, array_index: A) -> vec4<f32>
+@must_use fn textureGather[A: iu32](texture: texture_depth_cube_array, sampler: sampler, coords: vec3<f32>, array_index: A) -> vec4<f32>
@must_use fn textureGatherCompare(texture: texture_depth_2d, sampler: sampler_comparison, coords: vec2<f32>, depth_ref: f32) -> vec4<f32>
@must_use fn textureGatherCompare(texture: texture_depth_2d, sampler: sampler_comparison, coords: vec2<f32>, depth_ref: f32, @const offset: vec2<i32>) -> vec4<f32>
-@must_use fn textureGatherCompare<A: iu32>(texture: texture_depth_2d_array, sampler: sampler_comparison, coords: vec2<f32>, array_index: A, depth_ref: f32) -> vec4<f32>
-@must_use fn textureGatherCompare<A: iu32>(texture: texture_depth_2d_array, sampler: sampler_comparison, coords: vec2<f32>, array_index: A, depth_ref: f32, @const offset: vec2<i32>) -> vec4<f32>
+@must_use fn textureGatherCompare[A: iu32](texture: texture_depth_2d_array, sampler: sampler_comparison, coords: vec2<f32>, array_index: A, depth_ref: f32) -> vec4<f32>
+@must_use fn textureGatherCompare[A: iu32](texture: texture_depth_2d_array, sampler: sampler_comparison, coords: vec2<f32>, array_index: A, depth_ref: f32, @const offset: vec2<i32>) -> vec4<f32>
@must_use fn textureGatherCompare(texture: texture_depth_cube, sampler: sampler_comparison, coords: vec3<f32>, depth_ref: f32) -> vec4<f32>
-@must_use fn textureGatherCompare<A: iu32>(texture: texture_depth_cube_array, sampler: sampler_comparison, coords: vec3<f32>, array_index: A, depth_ref: f32) -> vec4<f32>
-@must_use fn textureNumLayers<T: fiu32>(texture: texture_2d_array<T>) -> u32
-@must_use fn textureNumLayers<T: fiu32>(texture: texture_cube_array<T>) -> u32
+@must_use fn textureGatherCompare[A: iu32](texture: texture_depth_cube_array, sampler: sampler_comparison, coords: vec3<f32>, array_index: A, depth_ref: f32) -> vec4<f32>
+@must_use fn textureNumLayers[T: fiu32](texture: texture_2d_array<T>) -> u32
+@must_use fn textureNumLayers[T: fiu32](texture: texture_cube_array<T>) -> u32
@must_use fn textureNumLayers(texture: texture_depth_2d_array) -> u32
@must_use fn textureNumLayers(texture: texture_depth_cube_array) -> u32
-@must_use fn textureNumLayers<F: texel_format, A: access>(texture: texture_storage_2d_array<F, A>) -> u32
-@must_use fn textureNumLevels<T: fiu32>(texture: texture_1d<T>) -> u32
-@must_use fn textureNumLevels<T: fiu32>(texture: texture_2d<T>) -> u32
-@must_use fn textureNumLevels<T: fiu32>(texture: texture_2d_array<T>) -> u32
-@must_use fn textureNumLevels<T: fiu32>(texture: texture_3d<T>) -> u32
-@must_use fn textureNumLevels<T: fiu32>(texture: texture_cube<T>) -> u32
-@must_use fn textureNumLevels<T: fiu32>(texture: texture_cube_array<T>) -> u32
+@must_use fn textureNumLayers[F: texel_format, A: access](texture: texture_storage_2d_array<F, A>) -> u32
+@must_use fn textureNumLevels[T: fiu32](texture: texture_1d<T>) -> u32
+@must_use fn textureNumLevels[T: fiu32](texture: texture_2d<T>) -> u32
+@must_use fn textureNumLevels[T: fiu32](texture: texture_2d_array<T>) -> u32
+@must_use fn textureNumLevels[T: fiu32](texture: texture_3d<T>) -> u32
+@must_use fn textureNumLevels[T: fiu32](texture: texture_cube<T>) -> u32
+@must_use fn textureNumLevels[T: fiu32](texture: texture_cube_array<T>) -> u32
@must_use fn textureNumLevels(texture: texture_depth_2d) -> u32
@must_use fn textureNumLevels(texture: texture_depth_2d_array) -> u32
@must_use fn textureNumLevels(texture: texture_depth_cube) -> u32
@must_use fn textureNumLevels(texture: texture_depth_cube_array) -> u32
-@must_use fn textureNumSamples<T: fiu32>(texture: texture_multisampled_2d<T>) -> u32
+@must_use fn textureNumSamples[T: fiu32](texture: texture_multisampled_2d<T>) -> u32
@must_use fn textureNumSamples(texture: texture_depth_multisampled_2d) -> u32
@must_use @stage("fragment") fn textureSample(texture: texture_1d<f32>, sampler: sampler, coords: f32) -> vec4<f32>
@must_use @stage("fragment") fn textureSample(texture: texture_2d<f32>, sampler: sampler, coords: vec2<f32>) -> vec4<f32>
@must_use @stage("fragment") fn textureSample(texture: texture_2d<f32>, sampler: sampler, coords: vec2<f32>, @const offset: vec2<i32>) -> vec4<f32>
-@must_use @stage("fragment") fn textureSample<A: iu32>(texture: texture_2d_array<f32>, sampler: sampler, coords: vec2<f32>, array_index: A) -> vec4<f32>
-@must_use @stage("fragment") fn textureSample<A: iu32>(texture: texture_2d_array<f32>, sampler: sampler, coords: vec2<f32>, array_index: A, @const offset: vec2<i32>) -> vec4<f32>
+@must_use @stage("fragment") fn textureSample[A: iu32](texture: texture_2d_array<f32>, sampler: sampler, coords: vec2<f32>, array_index: A) -> vec4<f32>
+@must_use @stage("fragment") fn textureSample[A: iu32](texture: texture_2d_array<f32>, sampler: sampler, coords: vec2<f32>, array_index: A, @const offset: vec2<i32>) -> vec4<f32>
@must_use @stage("fragment") fn textureSample(texture: texture_3d<f32>, sampler: sampler, coords: vec3<f32>) -> vec4<f32>
@must_use @stage("fragment") fn textureSample(texture: texture_3d<f32>, sampler: sampler, coords: vec3<f32>, @const offset: vec3<i32>) -> vec4<f32>
@must_use @stage("fragment") fn textureSample(texture: texture_cube<f32>, sampler: sampler, coords: vec3<f32>) -> vec4<f32>
-@must_use @stage("fragment") fn textureSample<A: iu32>(texture: texture_cube_array<f32>, sampler: sampler, coords: vec3<f32>, array_index: A) -> vec4<f32>
+@must_use @stage("fragment") fn textureSample[A: iu32](texture: texture_cube_array<f32>, sampler: sampler, coords: vec3<f32>, array_index: A) -> vec4<f32>
@must_use @stage("fragment") fn textureSample(texture: texture_depth_2d, sampler: sampler, coords: vec2<f32>) -> f32
@must_use @stage("fragment") fn textureSample(texture: texture_depth_2d, sampler: sampler, coords: vec2<f32>, @const offset: vec2<i32>) -> f32
-@must_use @stage("fragment") fn textureSample<A: iu32>(texture: texture_depth_2d_array, sampler: sampler, coords: vec2<f32>, array_index: A) -> f32
-@must_use @stage("fragment") fn textureSample<A: iu32>(texture: texture_depth_2d_array, sampler: sampler, coords: vec2<f32>, array_index: A, @const offset: vec2<i32>) -> f32
+@must_use @stage("fragment") fn textureSample[A: iu32](texture: texture_depth_2d_array, sampler: sampler, coords: vec2<f32>, array_index: A) -> f32
+@must_use @stage("fragment") fn textureSample[A: iu32](texture: texture_depth_2d_array, sampler: sampler, coords: vec2<f32>, array_index: A, @const offset: vec2<i32>) -> f32
@must_use @stage("fragment") fn textureSample(texture: texture_depth_cube, sampler: sampler, coords: vec3<f32>) -> f32
-@must_use @stage("fragment") fn textureSample<A: iu32>(texture: texture_depth_cube_array, sampler: sampler, coords: vec3<f32>, array_index: A) -> f32
+@must_use @stage("fragment") fn textureSample[A: iu32](texture: texture_depth_cube_array, sampler: sampler, coords: vec3<f32>, array_index: A) -> f32
@must_use @stage("fragment") fn textureSampleBias(texture: texture_2d<f32>, sampler: sampler, coords: vec2<f32>, bias: f32) -> vec4<f32>
@must_use @stage("fragment") fn textureSampleBias(texture: texture_2d<f32>, sampler: sampler, coords: vec2<f32>, bias: f32, @const offset: vec2<i32>) -> vec4<f32>
-@must_use @stage("fragment") fn textureSampleBias<A: iu32>(texture: texture_2d_array<f32>, sampler: sampler, coords: vec2<f32>, array_index: A, bias: f32) -> vec4<f32>
-@must_use @stage("fragment") fn textureSampleBias<A: iu32>(texture: texture_2d_array<f32>, sampler: sampler, coords: vec2<f32>, array_index: A, bias: f32, @const offset: vec2<i32>) -> vec4<f32>
+@must_use @stage("fragment") fn textureSampleBias[A: iu32](texture: texture_2d_array<f32>, sampler: sampler, coords: vec2<f32>, array_index: A, bias: f32) -> vec4<f32>
+@must_use @stage("fragment") fn textureSampleBias[A: iu32](texture: texture_2d_array<f32>, sampler: sampler, coords: vec2<f32>, array_index: A, bias: f32, @const offset: vec2<i32>) -> vec4<f32>
@must_use @stage("fragment") fn textureSampleBias(texture: texture_3d<f32>, sampler: sampler, coords: vec3<f32>, bias: f32) -> vec4<f32>
@must_use @stage("fragment") fn textureSampleBias(texture: texture_3d<f32>, sampler: sampler, coords: vec3<f32>, bias: f32, @const offset: vec3<i32>) -> vec4<f32>
@must_use @stage("fragment") fn textureSampleBias(texture: texture_cube<f32>, sampler: sampler, coords: vec3<f32>, bias: f32) -> vec4<f32>
-@must_use @stage("fragment") fn textureSampleBias<A: iu32>(texture: texture_cube_array<f32>, sampler: sampler, coords: vec3<f32>, array_index: A, bias: f32) -> vec4<f32>
+@must_use @stage("fragment") fn textureSampleBias[A: iu32](texture: texture_cube_array<f32>, sampler: sampler, coords: vec3<f32>, array_index: A, bias: f32) -> vec4<f32>
@must_use @stage("fragment") fn textureSampleCompare(texture: texture_depth_2d, sampler: sampler_comparison, coords: vec2<f32>, depth_ref: f32) -> f32
@must_use @stage("fragment") fn textureSampleCompare(texture: texture_depth_2d, sampler: sampler_comparison, coords: vec2<f32>, depth_ref: f32, @const offset: vec2<i32>) -> f32
-@must_use @stage("fragment") fn textureSampleCompare<A: iu32>(texture: texture_depth_2d_array, sampler: sampler_comparison, coords: vec2<f32>, array_index: A, depth_ref: f32) -> f32
-@must_use @stage("fragment") fn textureSampleCompare<A: iu32>(texture: texture_depth_2d_array, sampler: sampler_comparison, coords: vec2<f32>, array_index: A, depth_ref: f32, @const offset: vec2<i32>) -> f32
+@must_use @stage("fragment") fn textureSampleCompare[A: iu32](texture: texture_depth_2d_array, sampler: sampler_comparison, coords: vec2<f32>, array_index: A, depth_ref: f32) -> f32
+@must_use @stage("fragment") fn textureSampleCompare[A: iu32](texture: texture_depth_2d_array, sampler: sampler_comparison, coords: vec2<f32>, array_index: A, depth_ref: f32, @const offset: vec2<i32>) -> f32
@must_use @stage("fragment") fn textureSampleCompare(texture: texture_depth_cube, sampler: sampler_comparison, coords: vec3<f32>, depth_ref: f32) -> f32
-@must_use @stage("fragment") fn textureSampleCompare<A: iu32>(texture: texture_depth_cube_array, sampler: sampler_comparison, coords: vec3<f32>, array_index: A, depth_ref: f32) -> f32
+@must_use @stage("fragment") fn textureSampleCompare[A: iu32](texture: texture_depth_cube_array, sampler: sampler_comparison, coords: vec3<f32>, array_index: A, depth_ref: f32) -> f32
@must_use fn textureSampleCompareLevel(texture: texture_depth_2d, sampler: sampler_comparison, coords: vec2<f32>, depth_ref: f32) -> f32
@must_use fn textureSampleCompareLevel(texture: texture_depth_2d, sampler: sampler_comparison, coords: vec2<f32>, depth_ref: f32, @const offset: vec2<i32>) -> f32
-@must_use fn textureSampleCompareLevel<A: iu32>(texture: texture_depth_2d_array, sampler: sampler_comparison, coords: vec2<f32>, array_index: A, depth_ref: f32) -> f32
-@must_use fn textureSampleCompareLevel<A: iu32>(texture: texture_depth_2d_array, sampler: sampler_comparison, coords: vec2<f32>, array_index: A, depth_ref: f32, @const offset: vec2<i32>) -> f32
+@must_use fn textureSampleCompareLevel[A: iu32](texture: texture_depth_2d_array, sampler: sampler_comparison, coords: vec2<f32>, array_index: A, depth_ref: f32) -> f32
+@must_use fn textureSampleCompareLevel[A: iu32](texture: texture_depth_2d_array, sampler: sampler_comparison, coords: vec2<f32>, array_index: A, depth_ref: f32, @const offset: vec2<i32>) -> f32
@must_use fn textureSampleCompareLevel(texture: texture_depth_cube, sampler: sampler_comparison, coords: vec3<f32>, depth_ref: f32) -> f32
-@must_use fn textureSampleCompareLevel<A: iu32>(texture: texture_depth_cube_array, sampler: sampler_comparison, coords: vec3<f32>, array_index: A, depth_ref: f32) -> f32
+@must_use fn textureSampleCompareLevel[A: iu32](texture: texture_depth_cube_array, sampler: sampler_comparison, coords: vec3<f32>, array_index: A, depth_ref: f32) -> f32
@must_use fn textureSampleGrad(texture: texture_2d<f32>, sampler: sampler, coords: vec2<f32>, ddx: vec2<f32>, ddy: vec2<f32>) -> vec4<f32>
@must_use fn textureSampleGrad(texture: texture_2d<f32>, sampler: sampler, coords: vec2<f32>, ddx: vec2<f32>, ddy: vec2<f32>, @const offset: vec2<i32>) -> vec4<f32>
-@must_use fn textureSampleGrad<A: iu32>(texture: texture_2d_array<f32>, sampler: sampler, coords: vec2<f32>, array_index: A, ddx: vec2<f32>, ddy: vec2<f32>) -> vec4<f32>
-@must_use fn textureSampleGrad<A: iu32>(texture: texture_2d_array<f32>, sampler: sampler, coords: vec2<f32>, array_index: A, ddx: vec2<f32>, ddy: vec2<f32>, @const offset: vec2<i32>) -> vec4<f32>
+@must_use fn textureSampleGrad[A: iu32](texture: texture_2d_array<f32>, sampler: sampler, coords: vec2<f32>, array_index: A, ddx: vec2<f32>, ddy: vec2<f32>) -> vec4<f32>
+@must_use fn textureSampleGrad[A: iu32](texture: texture_2d_array<f32>, sampler: sampler, coords: vec2<f32>, array_index: A, ddx: vec2<f32>, ddy: vec2<f32>, @const offset: vec2<i32>) -> vec4<f32>
@must_use fn textureSampleGrad(texture: texture_3d<f32>, sampler: sampler, coords: vec3<f32>, ddx: vec3<f32>, ddy: vec3<f32>) -> vec4<f32>
@must_use fn textureSampleGrad(texture: texture_3d<f32>, sampler: sampler, coords: vec3<f32>, ddx: vec3<f32>, ddy: vec3<f32>, @const offset: vec3<i32>) -> vec4<f32>
@must_use fn textureSampleGrad(texture: texture_cube<f32>, sampler: sampler, coords: vec3<f32>, ddx: vec3<f32>, ddy: vec3<f32>) -> vec4<f32>
-@must_use fn textureSampleGrad<A: iu32>(texture: texture_cube_array<f32>, sampler: sampler, coords: vec3<f32>, array_index: A, ddx: vec3<f32>, ddy: vec3<f32>) -> vec4<f32>
+@must_use fn textureSampleGrad[A: iu32](texture: texture_cube_array<f32>, sampler: sampler, coords: vec3<f32>, array_index: A, ddx: vec3<f32>, ddy: vec3<f32>) -> vec4<f32>
@must_use fn textureSampleLevel(texture: texture_2d<f32>, sampler: sampler, coords: vec2<f32>, level: f32) -> vec4<f32>
@must_use fn textureSampleLevel(texture: texture_2d<f32>, sampler: sampler, coords: vec2<f32>, level: f32, @const offset: vec2<i32>) -> vec4<f32>
-@must_use fn textureSampleLevel<A: iu32>(texture: texture_2d_array<f32>, sampler: sampler, coords: vec2<f32>, array_index: A, level: f32) -> vec4<f32>
-@must_use fn textureSampleLevel<A: iu32>(texture: texture_2d_array<f32>, sampler: sampler, coords: vec2<f32>, array_index: A, level: f32, @const offset: vec2<i32>) -> vec4<f32>
+@must_use fn textureSampleLevel[A: iu32](texture: texture_2d_array<f32>, sampler: sampler, coords: vec2<f32>, array_index: A, level: f32) -> vec4<f32>
+@must_use fn textureSampleLevel[A: iu32](texture: texture_2d_array<f32>, sampler: sampler, coords: vec2<f32>, array_index: A, level: f32, @const offset: vec2<i32>) -> vec4<f32>
@must_use fn textureSampleLevel(texture: texture_3d<f32>, sampler: sampler, coords: vec3<f32>, level: f32) -> vec4<f32>
@must_use fn textureSampleLevel(texture: texture_3d<f32>, sampler: sampler, coords: vec3<f32>, level: f32, @const offset: vec3<i32>) -> vec4<f32>
@must_use fn textureSampleLevel(texture: texture_cube<f32>, sampler: sampler, coords: vec3<f32>, level: f32) -> vec4<f32>
-@must_use fn textureSampleLevel<A: iu32>(texture: texture_cube_array<f32>, sampler: sampler, coords: vec3<f32>, array_index: A, level: f32) -> vec4<f32>
-@must_use fn textureSampleLevel<L: iu32>(texture: texture_depth_2d, sampler: sampler, coords: vec2<f32>, level: L) -> f32
-@must_use fn textureSampleLevel<L: iu32>(texture: texture_depth_2d, sampler: sampler, coords: vec2<f32>, level: L, @const offset: vec2<i32>) -> f32
-@must_use fn textureSampleLevel<A: iu32, L: iu32>(texture: texture_depth_2d_array, sampler: sampler, coords: vec2<f32>, array_index: A, level: L) -> f32
-@must_use fn textureSampleLevel<A: iu32, L: iu32>(texture: texture_depth_2d_array, sampler: sampler, coords: vec2<f32>, array_index: A, level: L, @const offset: vec2<i32>) -> f32
-@must_use fn textureSampleLevel<L: iu32>(texture: texture_depth_cube, sampler: sampler, coords: vec3<f32>, level: L) -> f32
-@must_use fn textureSampleLevel<A: iu32, L: iu32>(texture: texture_depth_cube_array,sampler: sampler, coords: vec3<f32>, array_index: A, level: L) -> f32
+@must_use fn textureSampleLevel[A: iu32](texture: texture_cube_array<f32>, sampler: sampler, coords: vec3<f32>, array_index: A, level: f32) -> vec4<f32>
+@must_use fn textureSampleLevel[L: iu32](texture: texture_depth_2d, sampler: sampler, coords: vec2<f32>, level: L) -> f32
+@must_use fn textureSampleLevel[L: iu32](texture: texture_depth_2d, sampler: sampler, coords: vec2<f32>, level: L, @const offset: vec2<i32>) -> f32
+@must_use fn textureSampleLevel[A: iu32, L: iu32](texture: texture_depth_2d_array, sampler: sampler, coords: vec2<f32>, array_index: A, level: L) -> f32
+@must_use fn textureSampleLevel[A: iu32, L: iu32](texture: texture_depth_2d_array, sampler: sampler, coords: vec2<f32>, array_index: A, level: L, @const offset: vec2<i32>) -> f32
+@must_use fn textureSampleLevel[L: iu32](texture: texture_depth_cube, sampler: sampler, coords: vec3<f32>, level: L) -> f32
+@must_use fn textureSampleLevel[A: iu32, L: iu32](texture: texture_depth_cube_array,sampler: sampler, coords: vec3<f32>, array_index: A, level: L) -> f32
@must_use fn textureSampleBaseClampToEdge(texture: texture_2d<f32>, sampler: sampler, coords: vec2<f32>) -> vec4<f32>
@must_use fn textureSampleBaseClampToEdge(texture: texture_external, sampler: sampler, coords: vec2<f32>) -> vec4<f32>
-fn textureStore<C: iu32>(texture: texture_storage_1d<f32_texel_format, writable>, coords: C, value: vec4<f32>)
-fn textureStore<C: iu32>(texture: texture_storage_2d<f32_texel_format, writable>, coords: vec2<C>, value: vec4<f32>)
-fn textureStore<C: iu32, A: iu32>(texture: texture_storage_2d_array<f32_texel_format, writable>, coords: vec2<C>, array_index: A, value: vec4<f32>)
-fn textureStore<C: iu32>(texture: texture_storage_3d<f32_texel_format, writable>, coords: vec3<C>, value: vec4<f32>)
-fn textureStore<C: iu32>(texture: texture_storage_1d<i32_texel_format, writable>, coords: C, value: vec4<i32>)
-fn textureStore<C: iu32>(texture: texture_storage_2d<i32_texel_format, writable>, coords: vec2<C>, value: vec4<i32>)
-fn textureStore<C: iu32, A: iu32>(texture: texture_storage_2d_array<i32_texel_format, writable>, coords: vec2<C>, array_index: A, value: vec4<i32>)
-fn textureStore<C: iu32>(texture: texture_storage_3d<i32_texel_format, writable>, coords: vec3<C>, value: vec4<i32>)
-fn textureStore<C: iu32>(texture: texture_storage_1d<u32_texel_format, writable>, coords: C, value: vec4<u32>)
-fn textureStore<C: iu32>(texture: texture_storage_2d<u32_texel_format, writable>, coords: vec2<C>, value: vec4<u32>)
-fn textureStore<C: iu32, A: iu32>(texture: texture_storage_2d_array<u32_texel_format, writable>, coords: vec2<C>, array_index: A, value: vec4<u32>)
-fn textureStore<C: iu32>(texture: texture_storage_3d<u32_texel_format, writable>, coords: vec3<C>, value: vec4<u32>)
-@must_use fn textureLoad<T: fiu32, C: iu32, L: iu32>(texture: texture_1d<T>, coords: C, level: L) -> vec4<T>
-@must_use fn textureLoad<T: fiu32, C: iu32, L: iu32>(texture: texture_2d<T>, coords: vec2<C>, level: L) -> vec4<T>
-@must_use fn textureLoad<T: fiu32, C: iu32, A: iu32, L: iu32>(texture: texture_2d_array<T>, coords: vec2<C>, array_index: A, level: L) -> vec4<T>
-@must_use fn textureLoad<T: fiu32, C: iu32, L: iu32>(texture: texture_3d<T>, coords: vec3<C>, level: L) -> vec4<T>
-@must_use fn textureLoad<T: fiu32, C: iu32, S: iu32>(texture: texture_multisampled_2d<T>, coords: vec2<C>, sample_index: S) -> vec4<T>
-@must_use fn textureLoad<C: iu32, L: iu32>(texture: texture_depth_2d, coords: vec2<C>, level: L) -> f32
-@must_use fn textureLoad<C: iu32, A: iu32, L: iu32>(texture: texture_depth_2d_array, coords: vec2<C>, array_index: A, level: L) -> f32
-@must_use fn textureLoad<C: iu32, S: iu32>(texture: texture_depth_multisampled_2d, coords: vec2<C>, sample_index: S) -> f32
-@must_use fn textureLoad<C: iu32>(texture: texture_external, coords: vec2<C>) -> vec4<f32>
-@must_use fn textureLoad<C: iu32>(texture: texture_storage_1d<f32_texel_format, readable>, coords: C) -> vec4<f32>
-@must_use fn textureLoad<C: iu32>(texture: texture_storage_1d<i32_texel_format, readable>, coords: C) -> vec4<i32>
-@must_use fn textureLoad<C: iu32>(texture: texture_storage_1d<u32_texel_format, readable>, coords: C) -> vec4<u32>
-@must_use fn textureLoad<C: iu32>(texture: texture_storage_2d<f32_texel_format, readable>, coords: vec2<C>) -> vec4<f32>
-@must_use fn textureLoad<C: iu32>(texture: texture_storage_2d<i32_texel_format, readable>, coords: vec2<C>) -> vec4<i32>
-@must_use fn textureLoad<C: iu32>(texture: texture_storage_2d<u32_texel_format, readable>, coords: vec2<C>) -> vec4<u32>
-@must_use fn textureLoad<C: iu32, A: iu32>(texture: texture_storage_2d_array<f32_texel_format, readable>, coords: vec2<C>, array_index: A) -> vec4<f32>
-@must_use fn textureLoad<C: iu32, A: iu32>(texture: texture_storage_2d_array<i32_texel_format, readable>, coords: vec2<C>, array_index: A) -> vec4<i32>
-@must_use fn textureLoad<C: iu32, A: iu32>(texture: texture_storage_2d_array<u32_texel_format, readable>, coords: vec2<C>, array_index: A) -> vec4<u32>
-@must_use fn textureLoad<C: iu32>(texture: texture_storage_3d<f32_texel_format, readable>, coords: vec3<C>) -> vec4<f32>
-@must_use fn textureLoad<C: iu32>(texture: texture_storage_3d<i32_texel_format, readable>, coords: vec3<C>) -> vec4<i32>
-@must_use fn textureLoad<C: iu32>(texture: texture_storage_3d<u32_texel_format, readable>, coords: vec3<C>) -> vec4<u32>
+fn textureStore[C: iu32](texture: texture_storage_1d<f32_texel_format, writable>, coords: C, value: vec4<f32>)
+fn textureStore[C: iu32](texture: texture_storage_2d<f32_texel_format, writable>, coords: vec2<C>, value: vec4<f32>)
+fn textureStore[C: iu32, A: iu32](texture: texture_storage_2d_array<f32_texel_format, writable>, coords: vec2<C>, array_index: A, value: vec4<f32>)
+fn textureStore[C: iu32](texture: texture_storage_3d<f32_texel_format, writable>, coords: vec3<C>, value: vec4<f32>)
+fn textureStore[C: iu32](texture: texture_storage_1d<i32_texel_format, writable>, coords: C, value: vec4<i32>)
+fn textureStore[C: iu32](texture: texture_storage_2d<i32_texel_format, writable>, coords: vec2<C>, value: vec4<i32>)
+fn textureStore[C: iu32, A: iu32](texture: texture_storage_2d_array<i32_texel_format, writable>, coords: vec2<C>, array_index: A, value: vec4<i32>)
+fn textureStore[C: iu32](texture: texture_storage_3d<i32_texel_format, writable>, coords: vec3<C>, value: vec4<i32>)
+fn textureStore[C: iu32](texture: texture_storage_1d<u32_texel_format, writable>, coords: C, value: vec4<u32>)
+fn textureStore[C: iu32](texture: texture_storage_2d<u32_texel_format, writable>, coords: vec2<C>, value: vec4<u32>)
+fn textureStore[C: iu32, A: iu32](texture: texture_storage_2d_array<u32_texel_format, writable>, coords: vec2<C>, array_index: A, value: vec4<u32>)
+fn textureStore[C: iu32](texture: texture_storage_3d<u32_texel_format, writable>, coords: vec3<C>, value: vec4<u32>)
+@must_use fn textureLoad[T: fiu32, C: iu32, L: iu32](texture: texture_1d<T>, coords: C, level: L) -> vec4<T>
+@must_use fn textureLoad[T: fiu32, C: iu32, L: iu32](texture: texture_2d<T>, coords: vec2<C>, level: L) -> vec4<T>
+@must_use fn textureLoad[T: fiu32, C: iu32, A: iu32, L: iu32](texture: texture_2d_array<T>, coords: vec2<C>, array_index: A, level: L) -> vec4<T>
+@must_use fn textureLoad[T: fiu32, C: iu32, L: iu32](texture: texture_3d<T>, coords: vec3<C>, level: L) -> vec4<T>
+@must_use fn textureLoad[T: fiu32, C: iu32, S: iu32](texture: texture_multisampled_2d<T>, coords: vec2<C>, sample_index: S) -> vec4<T>
+@must_use fn textureLoad[C: iu32, L: iu32](texture: texture_depth_2d, coords: vec2<C>, level: L) -> f32
+@must_use fn textureLoad[C: iu32, A: iu32, L: iu32](texture: texture_depth_2d_array, coords: vec2<C>, array_index: A, level: L) -> f32
+@must_use fn textureLoad[C: iu32, S: iu32](texture: texture_depth_multisampled_2d, coords: vec2<C>, sample_index: S) -> f32
+@must_use fn textureLoad[C: iu32](texture: texture_external, coords: vec2<C>) -> vec4<f32>
+@must_use fn textureLoad[C: iu32](texture: texture_storage_1d<f32_texel_format, readable>, coords: C) -> vec4<f32>
+@must_use fn textureLoad[C: iu32](texture: texture_storage_1d<i32_texel_format, readable>, coords: C) -> vec4<i32>
+@must_use fn textureLoad[C: iu32](texture: texture_storage_1d<u32_texel_format, readable>, coords: C) -> vec4<u32>
+@must_use fn textureLoad[C: iu32](texture: texture_storage_2d<f32_texel_format, readable>, coords: vec2<C>) -> vec4<f32>
+@must_use fn textureLoad[C: iu32](texture: texture_storage_2d<i32_texel_format, readable>, coords: vec2<C>) -> vec4<i32>
+@must_use fn textureLoad[C: iu32](texture: texture_storage_2d<u32_texel_format, readable>, coords: vec2<C>) -> vec4<u32>
+@must_use fn textureLoad[C: iu32, A: iu32](texture: texture_storage_2d_array<f32_texel_format, readable>, coords: vec2<C>, array_index: A) -> vec4<f32>
+@must_use fn textureLoad[C: iu32, A: iu32](texture: texture_storage_2d_array<i32_texel_format, readable>, coords: vec2<C>, array_index: A) -> vec4<i32>
+@must_use fn textureLoad[C: iu32, A: iu32](texture: texture_storage_2d_array<u32_texel_format, readable>, coords: vec2<C>, array_index: A) -> vec4<u32>
+@must_use fn textureLoad[C: iu32](texture: texture_storage_3d<f32_texel_format, readable>, coords: vec3<C>) -> vec4<f32>
+@must_use fn textureLoad[C: iu32](texture: texture_storage_3d<i32_texel_format, readable>, coords: vec3<C>) -> vec4<i32>
+@must_use fn textureLoad[C: iu32](texture: texture_storage_3d<u32_texel_format, readable>, coords: vec3<C>) -> vec4<u32>
-@stage("fragment", "compute") fn atomicLoad<T: iu32, S: workgroup_or_storage>(ptr<S, atomic<T>, read_write>) -> T
-@stage("fragment", "compute") fn atomicStore<T: iu32, S: workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T)
-@stage("fragment", "compute") fn atomicAdd<T: iu32, S: workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T) -> T
-@stage("fragment", "compute") fn atomicSub<T: iu32, S: workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T) -> T
-@stage("fragment", "compute") fn atomicMax<T: iu32, S: workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T) -> T
-@stage("fragment", "compute") fn atomicMin<T: iu32, S: workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T) -> T
-@stage("fragment", "compute") fn atomicAnd<T: iu32, S: workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T) -> T
-@stage("fragment", "compute") fn atomicOr<T: iu32, S: workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T) -> T
-@stage("fragment", "compute") fn atomicXor<T: iu32, S: workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T) -> T
-@stage("fragment", "compute") fn atomicExchange<T: iu32, S: workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T) -> T
-@stage("fragment", "compute") fn atomicCompareExchangeWeak<T: iu32, S: workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T, T) -> __atomic_compare_exchange_result<T>
+@stage("fragment", "compute") fn atomicLoad[T: iu32, S: workgroup_or_storage](ptr<S, atomic<T>, read_write>) -> T
+@stage("fragment", "compute") fn atomicStore[T: iu32, S: workgroup_or_storage](ptr<S, atomic<T>, read_write>, T)
+@stage("fragment", "compute") fn atomicAdd[T: iu32, S: workgroup_or_storage](ptr<S, atomic<T>, read_write>, T) -> T
+@stage("fragment", "compute") fn atomicSub[T: iu32, S: workgroup_or_storage](ptr<S, atomic<T>, read_write>, T) -> T
+@stage("fragment", "compute") fn atomicMax[T: iu32, S: workgroup_or_storage](ptr<S, atomic<T>, read_write>, T) -> T
+@stage("fragment", "compute") fn atomicMin[T: iu32, S: workgroup_or_storage](ptr<S, atomic<T>, read_write>, T) -> T
+@stage("fragment", "compute") fn atomicAnd[T: iu32, S: workgroup_or_storage](ptr<S, atomic<T>, read_write>, T) -> T
+@stage("fragment", "compute") fn atomicOr[T: iu32, S: workgroup_or_storage](ptr<S, atomic<T>, read_write>, T) -> T
+@stage("fragment", "compute") fn atomicXor[T: iu32, S: workgroup_or_storage](ptr<S, atomic<T>, read_write>, T) -> T
+@stage("fragment", "compute") fn atomicExchange[T: iu32, S: workgroup_or_storage](ptr<S, atomic<T>, read_write>, T) -> T
+@stage("fragment", "compute") fn atomicCompareExchangeWeak[T: iu32, S: workgroup_or_storage](ptr<S, atomic<T>, read_write>, T, T) -> __atomic_compare_exchange_result<T>
@must_use @stage("compute") fn subgroupBallot() -> vec4<u32>
-@must_use @stage("compute") fn subgroupBroadcast<T: fiu32_f16>(value: T, @const sourceLaneIndex: u32) -> T
-@must_use @stage("compute") fn subgroupBroadcast<N: num, T: fiu32_f16>(value: vec<N, T>, @const sourceLaneIndex: u32) -> vec<N, T>
+@must_use @stage("compute") fn subgroupBroadcast[T: fiu32_f16](value: T, @const sourceLaneIndex: u32) -> T
+@must_use @stage("compute") fn subgroupBroadcast[N: num, T: fiu32_f16](value: vec<N, T>, @const sourceLaneIndex: u32) -> vec<N, T>
////////////////////////////////////////////////////////////////////////////////
// Value constructors //
@@ -853,18 +853,18 @@
@must_use @const("Zero") ctor f32() -> f32
@must_use @const("Zero") ctor f16() -> f16
@must_use @const("Zero") ctor bool() -> bool
-@must_use @const("Zero") ctor vec2<T: scalar>() -> vec2<T>
-@must_use @const("Zero") ctor vec3<T: scalar>() -> vec3<T>
-@must_use @const("Zero") ctor vec4<T: scalar>() -> vec4<T>
-@must_use @const("Zero") ctor mat2x2<T: f32_f16>() -> mat2x2<T>
-@must_use @const("Zero") ctor mat2x3<T: f32_f16>() -> mat2x3<T>
-@must_use @const("Zero") ctor mat2x4<T: f32_f16>() -> mat2x4<T>
-@must_use @const("Zero") ctor mat3x2<T: f32_f16>() -> mat3x2<T>
-@must_use @const("Zero") ctor mat3x3<T: f32_f16>() -> mat3x3<T>
-@must_use @const("Zero") ctor mat3x4<T: f32_f16>() -> mat3x4<T>
-@must_use @const("Zero") ctor mat4x2<T: f32_f16>() -> mat4x2<T>
-@must_use @const("Zero") ctor mat4x3<T: f32_f16>() -> mat4x3<T>
-@must_use @const("Zero") ctor mat4x4<T: f32_f16>() -> mat4x4<T>
+@must_use @const("Zero") ctor vec2[T: scalar]() -> vec2<T>
+@must_use @const("Zero") ctor vec3[T: scalar]() -> vec3<T>
+@must_use @const("Zero") ctor vec4[T: scalar]() -> vec4<T>
+@must_use @const("Zero") ctor mat2x2[T: f32_f16]() -> mat2x2<T>
+@must_use @const("Zero") ctor mat2x3[T: f32_f16]() -> mat2x3<T>
+@must_use @const("Zero") ctor mat2x4[T: f32_f16]() -> mat2x4<T>
+@must_use @const("Zero") ctor mat3x2[T: f32_f16]() -> mat3x2<T>
+@must_use @const("Zero") ctor mat3x3[T: f32_f16]() -> mat3x3<T>
+@must_use @const("Zero") ctor mat3x4[T: f32_f16]() -> mat3x4<T>
+@must_use @const("Zero") ctor mat4x2[T: f32_f16]() -> mat4x2<T>
+@must_use @const("Zero") ctor mat4x3[T: f32_f16]() -> mat4x3<T>
+@must_use @const("Zero") ctor mat4x4[T: f32_f16]() -> mat4x4<T>
// Identity constructors
@must_use @const("Identity") ctor i32(i32) -> i32
@@ -872,133 +872,133 @@
@must_use @const("Identity") ctor f32(f32) -> f32
@must_use @const("Identity") ctor f16(f16) -> f16
@must_use @const("Identity") ctor bool(bool) -> bool
-@must_use @const("Identity") ctor vec2<T: scalar>(vec2<T>) -> vec2<T>
-@must_use @const("Identity") ctor vec3<T: scalar>(vec3<T>) -> vec3<T>
-@must_use @const("Identity") ctor vec4<T: scalar>(vec4<T>) -> vec4<T>
-@must_use @const("Identity") ctor mat2x2<T: f32_f16>(mat2x2<T>) -> mat2x2<T>
-@must_use @const("Identity") ctor mat2x3<T: f32_f16>(mat2x3<T>) -> mat2x3<T>
-@must_use @const("Identity") ctor mat2x4<T: f32_f16>(mat2x4<T>) -> mat2x4<T>
-@must_use @const("Identity") ctor mat3x2<T: f32_f16>(mat3x2<T>) -> mat3x2<T>
-@must_use @const("Identity") ctor mat3x3<T: f32_f16>(mat3x3<T>) -> mat3x3<T>
-@must_use @const("Identity") ctor mat3x4<T: f32_f16>(mat3x4<T>) -> mat3x4<T>
-@must_use @const("Identity") ctor mat4x2<T: f32_f16>(mat4x2<T>) -> mat4x2<T>
-@must_use @const("Identity") ctor mat4x3<T: f32_f16>(mat4x3<T>) -> mat4x3<T>
-@must_use @const("Identity") ctor mat4x4<T: f32_f16>(mat4x4<T>) -> mat4x4<T>
+@must_use @const("Identity") ctor vec2[T: scalar](vec2<T>) -> vec2<T>
+@must_use @const("Identity") ctor vec3[T: scalar](vec3<T>) -> vec3<T>
+@must_use @const("Identity") ctor vec4[T: scalar](vec4<T>) -> vec4<T>
+@must_use @const("Identity") ctor mat2x2[T: f32_f16](mat2x2<T>) -> mat2x2<T>
+@must_use @const("Identity") ctor mat2x3[T: f32_f16](mat2x3<T>) -> mat2x3<T>
+@must_use @const("Identity") ctor mat2x4[T: f32_f16](mat2x4<T>) -> mat2x4<T>
+@must_use @const("Identity") ctor mat3x2[T: f32_f16](mat3x2<T>) -> mat3x2<T>
+@must_use @const("Identity") ctor mat3x3[T: f32_f16](mat3x3<T>) -> mat3x3<T>
+@must_use @const("Identity") ctor mat3x4[T: f32_f16](mat3x4<T>) -> mat3x4<T>
+@must_use @const("Identity") ctor mat4x2[T: f32_f16](mat4x2<T>) -> mat4x2<T>
+@must_use @const("Identity") ctor mat4x3[T: f32_f16](mat4x3<T>) -> mat4x3<T>
+@must_use @const("Identity") ctor mat4x4[T: f32_f16](mat4x4<T>) -> mat4x4<T>
// Vector constructors (splat)
-@must_use @const("VecSplat") ctor vec2<T: scalar>(T) -> vec2<T>
-@must_use @const("VecSplat") ctor vec3<T: scalar>(T) -> vec3<T>
-@must_use @const("VecSplat") ctor vec4<T: scalar>(T) -> vec4<T>
+@must_use @const("VecSplat") ctor vec2[T: scalar](T) -> vec2<T>
+@must_use @const("VecSplat") ctor vec3[T: scalar](T) -> vec3<T>
+@must_use @const("VecSplat") ctor vec4[T: scalar](T) -> vec4<T>
// Vector constructors (scalar)
-@must_use @const("VecInitS") ctor vec2<T: scalar>(x: T, y: T) -> vec2<T>
-@must_use @const("VecInitS") ctor vec3<T: scalar>(x: T, y: T, z: T) -> vec3<T>
-@must_use @const("VecInitS") ctor vec4<T: scalar>(x: T, y: T, z: T, w: T) -> vec4<T>
+@must_use @const("VecInitS") ctor vec2[T: scalar](x: T, y: T) -> vec2<T>
+@must_use @const("VecInitS") ctor vec3[T: scalar](x: T, y: T, z: T) -> vec3<T>
+@must_use @const("VecInitS") ctor vec4[T: scalar](x: T, y: T, z: T, w: T) -> vec4<T>
// Vector constructors (mixed)
-@must_use @const("VecInitM") ctor vec3<T: scalar>(xy: vec2<T>, z: T) -> vec3<T>
-@must_use @const("VecInitM") ctor vec3<T: scalar>(x: T, yz: vec2<T>) -> vec3<T>
-@must_use @const("VecInitM") ctor vec4<T: scalar>(xy: vec2<T>, z: T, w: T) -> vec4<T>
-@must_use @const("VecInitM") ctor vec4<T: scalar>(x: T, yz: vec2<T>, w: T) -> vec4<T>
-@must_use @const("VecInitM") ctor vec4<T: scalar>(x: T, y: T, zw: vec2<T>) -> vec4<T>
-@must_use @const("VecInitM") ctor vec4<T: scalar>(xy: vec2<T>, zw: vec2<T>) -> vec4<T>
-@must_use @const("VecInitM") ctor vec4<T: scalar>(xyz: vec3<T>, w: T) -> vec4<T>
-@must_use @const("VecInitM") ctor vec4<T: scalar>(x: T, zyw: vec3<T>) -> vec4<T>
+@must_use @const("VecInitM") ctor vec3[T: scalar](xy: vec2<T>, z: T) -> vec3<T>
+@must_use @const("VecInitM") ctor vec3[T: scalar](x: T, yz: vec2<T>) -> vec3<T>
+@must_use @const("VecInitM") ctor vec4[T: scalar](xy: vec2<T>, z: T, w: T) -> vec4<T>
+@must_use @const("VecInitM") ctor vec4[T: scalar](x: T, yz: vec2<T>, w: T) -> vec4<T>
+@must_use @const("VecInitM") ctor vec4[T: scalar](x: T, y: T, zw: vec2<T>) -> vec4<T>
+@must_use @const("VecInitM") ctor vec4[T: scalar](xy: vec2<T>, zw: vec2<T>) -> vec4<T>
+@must_use @const("VecInitM") ctor vec4[T: scalar](xyz: vec3<T>, w: T) -> vec4<T>
+@must_use @const("VecInitM") ctor vec4[T: scalar](x: T, zyw: vec3<T>) -> vec4<T>
// Matrix constructors (scalar)
@must_use @const("MatInitS")
-ctor mat2x2<T: f32_f16>(T, T,
+ctor mat2x2[T: f32_f16](T, T,
T, T) -> mat2x2<T>
@must_use @const("MatInitS")
-ctor mat2x3<T: f32_f16>(T, T, T,
+ctor mat2x3[T: f32_f16](T, T, T,
T, T, T) -> mat2x3<T>
@must_use @const("MatInitS")
-ctor mat2x4<T: f32_f16>(T, T, T, T,
+ctor mat2x4[T: f32_f16](T, T, T, T,
T, T, T, T) -> mat2x4<T>
@must_use @const("MatInitS")
-ctor mat3x2<T: f32_f16>(T, T,
+ctor mat3x2[T: f32_f16](T, T,
T, T,
T, T) -> mat3x2<T>
@must_use @const("MatInitS")
-ctor mat3x3<T: f32_f16>(T, T, T,
+ctor mat3x3[T: f32_f16](T, T, T,
T, T, T,
T, T, T) -> mat3x3<T>
@must_use @const("MatInitS")
-ctor mat3x4<T: f32_f16>(T, T, T, T,
+ctor mat3x4[T: f32_f16](T, T, T, T,
T, T, T, T,
T, T, T, T) -> mat3x4<T>
@must_use @const("MatInitS")
-ctor mat4x2<T: f32_f16>(T, T,
+ctor mat4x2[T: f32_f16](T, T,
T, T,
T, T,
T, T) -> mat4x2<T>
@must_use @const("MatInitS")
-ctor mat4x3<T: f32_f16>(T, T, T,
+ctor mat4x3[T: f32_f16](T, T, T,
T, T, T,
T, T, T,
T, T, T) -> mat4x3<T>
@must_use @const("MatInitS")
-ctor mat4x4<T: f32_f16>(T, T, T, T,
+ctor mat4x4[T: f32_f16](T, T, T, T,
T, T, T, T,
T, T, T, T,
T, T, T, T) -> mat4x4<T>
// Matrix constructors (column vectors)
-@must_use @const("MatInitV") ctor mat2x2<T: f32_f16>(vec2<T>, vec2<T>) -> mat2x2<T>
-@must_use @const("MatInitV") ctor mat2x3<T: f32_f16>(vec3<T>, vec3<T>) -> mat2x3<T>
-@must_use @const("MatInitV") ctor mat2x4<T: f32_f16>(vec4<T>, vec4<T>) -> mat2x4<T>
-@must_use @const("MatInitV") ctor mat3x2<T: f32_f16>(vec2<T>, vec2<T>, vec2<T>) -> mat3x2<T>
-@must_use @const("MatInitV") ctor mat3x3<T: f32_f16>(vec3<T>, vec3<T>, vec3<T>) -> mat3x3<T>
-@must_use @const("MatInitV") ctor mat3x4<T: f32_f16>(vec4<T>, vec4<T>, vec4<T>) -> mat3x4<T>
-@must_use @const("MatInitV") ctor mat4x2<T: f32_f16>(vec2<T>, vec2<T>, vec2<T>, vec2<T>) -> mat4x2<T>
-@must_use @const("MatInitV") ctor mat4x3<T: f32_f16>(vec3<T>, vec3<T>, vec3<T>, vec3<T>) -> mat4x3<T>
-@must_use @const("MatInitV") ctor mat4x4<T: f32_f16>(vec4<T>, vec4<T>, vec4<T>, vec4<T>) -> mat4x4<T>
+@must_use @const("MatInitV") ctor mat2x2[T: f32_f16](vec2<T>, vec2<T>) -> mat2x2<T>
+@must_use @const("MatInitV") ctor mat2x3[T: f32_f16](vec3<T>, vec3<T>) -> mat2x3<T>
+@must_use @const("MatInitV") ctor mat2x4[T: f32_f16](vec4<T>, vec4<T>) -> mat2x4<T>
+@must_use @const("MatInitV") ctor mat3x2[T: f32_f16](vec2<T>, vec2<T>, vec2<T>) -> mat3x2<T>
+@must_use @const("MatInitV") ctor mat3x3[T: f32_f16](vec3<T>, vec3<T>, vec3<T>) -> mat3x3<T>
+@must_use @const("MatInitV") ctor mat3x4[T: f32_f16](vec4<T>, vec4<T>, vec4<T>) -> mat3x4<T>
+@must_use @const("MatInitV") ctor mat4x2[T: f32_f16](vec2<T>, vec2<T>, vec2<T>, vec2<T>) -> mat4x2<T>
+@must_use @const("MatInitV") ctor mat4x3[T: f32_f16](vec3<T>, vec3<T>, vec3<T>, vec3<T>) -> mat4x3<T>
+@must_use @const("MatInitV") ctor mat4x4[T: f32_f16](vec4<T>, vec4<T>, vec4<T>, vec4<T>) -> mat4x4<T>
////////////////////////////////////////////////////////////////////////////////
// Value conversions //
////////////////////////////////////////////////////////////////////////////////
-@must_use @const conv f32<T: scalar_no_f32>(T) -> f32
-@must_use @const conv f16<T: scalar_no_f16>(T) -> f16
-@must_use @const conv i32<T: scalar_no_i32>(T) -> i32
-@must_use @const conv u32<T: scalar_no_u32>(T) -> u32
-@must_use @const conv bool<T: scalar_no_bool>(T) -> bool
+@must_use @const conv f32[T: scalar_no_f32](T) -> f32
+@must_use @const conv f16[T: scalar_no_f16](T) -> f16
+@must_use @const conv i32[T: scalar_no_i32](T) -> i32
+@must_use @const conv u32[T: scalar_no_u32](T) -> u32
+@must_use @const conv bool[T: scalar_no_bool](T) -> bool
-@must_use @const conv vec2<T: f32, U: scalar_no_f32>(vec2<U>) -> vec2<f32>
-@must_use @const conv vec2<T: f16, U: scalar_no_f16>(vec2<U>) -> vec2<f16>
-@must_use @const conv vec2<T: i32, U: scalar_no_i32>(vec2<U>) -> vec2<i32>
-@must_use @const conv vec2<T: u32, U: scalar_no_u32>(vec2<U>) -> vec2<u32>
-@must_use @const conv vec2<T: bool, U: scalar_no_bool>(vec2<U>) -> vec2<bool>
+@must_use @const conv vec2[T: f32, U: scalar_no_f32](vec2<U>) -> vec2<f32>
+@must_use @const conv vec2[T: f16, U: scalar_no_f16](vec2<U>) -> vec2<f16>
+@must_use @const conv vec2[T: i32, U: scalar_no_i32](vec2<U>) -> vec2<i32>
+@must_use @const conv vec2[T: u32, U: scalar_no_u32](vec2<U>) -> vec2<u32>
+@must_use @const conv vec2[T: bool, U: scalar_no_bool](vec2<U>) -> vec2<bool>
-@must_use @const conv vec3<T: f32, U: scalar_no_f32>(vec3<U>) -> vec3<f32>
-@must_use @const conv vec3<T: f16, U: scalar_no_f16>(vec3<U>) -> vec3<f16>
-@must_use @const conv vec3<T: i32, U: scalar_no_i32>(vec3<U>) -> vec3<i32>
-@must_use @const conv vec3<T: u32, U: scalar_no_u32>(vec3<U>) -> vec3<u32>
-@must_use @const conv vec3<T: bool, U: scalar_no_bool>(vec3<U>) -> vec3<bool>
+@must_use @const conv vec3[T: f32, U: scalar_no_f32](vec3<U>) -> vec3<f32>
+@must_use @const conv vec3[T: f16, U: scalar_no_f16](vec3<U>) -> vec3<f16>
+@must_use @const conv vec3[T: i32, U: scalar_no_i32](vec3<U>) -> vec3<i32>
+@must_use @const conv vec3[T: u32, U: scalar_no_u32](vec3<U>) -> vec3<u32>
+@must_use @const conv vec3[T: bool, U: scalar_no_bool](vec3<U>) -> vec3<bool>
-@must_use @const conv vec4<T: f32, U: scalar_no_f32>(vec4<U>) -> vec4<f32>
-@must_use @const conv vec4<T: f16, U: scalar_no_f16>(vec4<U>) -> vec4<f16>
-@must_use @const conv vec4<T: i32, U: scalar_no_i32>(vec4<U>) -> vec4<i32>
-@must_use @const conv vec4<T: u32, U: scalar_no_u32>(vec4<U>) -> vec4<u32>
-@must_use @const conv vec4<T: bool, U: scalar_no_bool>(vec4<U>) -> vec4<bool>
+@must_use @const conv vec4[T: f32, U: scalar_no_f32](vec4<U>) -> vec4<f32>
+@must_use @const conv vec4[T: f16, U: scalar_no_f16](vec4<U>) -> vec4<f16>
+@must_use @const conv vec4[T: i32, U: scalar_no_i32](vec4<U>) -> vec4<i32>
+@must_use @const conv vec4[T: u32, U: scalar_no_u32](vec4<U>) -> vec4<u32>
+@must_use @const conv vec4[T: bool, U: scalar_no_bool](vec4<U>) -> vec4<bool>
-@must_use @const conv mat2x2<T: f16>(mat2x2<f32>) -> mat2x2<f16>
-@must_use @const conv mat2x2<T: f32>(mat2x2<f16>) -> mat2x2<f32>
-@must_use @const conv mat2x3<T: f16>(mat2x3<f32>) -> mat2x3<f16>
-@must_use @const conv mat2x3<T: f32>(mat2x3<f16>) -> mat2x3<f32>
-@must_use @const conv mat2x4<T: f16>(mat2x4<f32>) -> mat2x4<f16>
-@must_use @const conv mat2x4<T: f32>(mat2x4<f16>) -> mat2x4<f32>
-@must_use @const conv mat3x2<T: f16>(mat3x2<f32>) -> mat3x2<f16>
-@must_use @const conv mat3x2<T: f32>(mat3x2<f16>) -> mat3x2<f32>
-@must_use @const conv mat3x3<T: f16>(mat3x3<f32>) -> mat3x3<f16>
-@must_use @const conv mat3x3<T: f32>(mat3x3<f16>) -> mat3x3<f32>
-@must_use @const conv mat3x4<T: f16>(mat3x4<f32>) -> mat3x4<f16>
-@must_use @const conv mat3x4<T: f32>(mat3x4<f16>) -> mat3x4<f32>
-@must_use @const conv mat4x2<T: f16>(mat4x2<f32>) -> mat4x2<f16>
-@must_use @const conv mat4x2<T: f32>(mat4x2<f16>) -> mat4x2<f32>
-@must_use @const conv mat4x3<T: f16>(mat4x3<f32>) -> mat4x3<f16>
-@must_use @const conv mat4x3<T: f32>(mat4x3<f16>) -> mat4x3<f32>
-@must_use @const conv mat4x4<T: f16>(mat4x4<f32>) -> mat4x4<f16>
-@must_use @const conv mat4x4<T: f32>(mat4x4<f16>) -> mat4x4<f32>
+@must_use @const conv mat2x2[T: f16](mat2x2<f32>) -> mat2x2<f16>
+@must_use @const conv mat2x2[T: f32](mat2x2<f16>) -> mat2x2<f32>
+@must_use @const conv mat2x3[T: f16](mat2x3<f32>) -> mat2x3<f16>
+@must_use @const conv mat2x3[T: f32](mat2x3<f16>) -> mat2x3<f32>
+@must_use @const conv mat2x4[T: f16](mat2x4<f32>) -> mat2x4<f16>
+@must_use @const conv mat2x4[T: f32](mat2x4<f16>) -> mat2x4<f32>
+@must_use @const conv mat3x2[T: f16](mat3x2<f32>) -> mat3x2<f16>
+@must_use @const conv mat3x2[T: f32](mat3x2<f16>) -> mat3x2<f32>
+@must_use @const conv mat3x3[T: f16](mat3x3<f32>) -> mat3x3<f16>
+@must_use @const conv mat3x3[T: f32](mat3x3<f16>) -> mat3x3<f32>
+@must_use @const conv mat3x4[T: f16](mat3x4<f32>) -> mat3x4<f16>
+@must_use @const conv mat3x4[T: f32](mat3x4<f16>) -> mat3x4<f32>
+@must_use @const conv mat4x2[T: f16](mat4x2<f32>) -> mat4x2<f16>
+@must_use @const conv mat4x2[T: f32](mat4x2<f16>) -> mat4x2<f32>
+@must_use @const conv mat4x3[T: f16](mat4x3<f32>) -> mat4x3<f16>
+@must_use @const conv mat4x3[T: f32](mat4x3<f16>) -> mat4x3<f32>
+@must_use @const conv mat4x4[T: f16](mat4x4<f32>) -> mat4x4<f16>
+@must_use @const conv mat4x4[T: f32](mat4x4<f16>) -> mat4x4<f32>
////////////////////////////////////////////////////////////////////////////////
// Operators //
@@ -1017,85 +1017,85 @@
// Unary Operators //
////////////////////////////////////////////////////////////////////////////////
@must_use @const op ! (bool) -> bool
-@must_use @const op ! <N: num> (vec<N, bool>) -> vec<N, bool>
+@must_use @const op ! [N: num](vec<N, bool>) -> vec<N, bool>
-@must_use @const op ~ <T: iu32>(T) -> T
-@must_use @const op ~ <T: iu32, N: num> (vec<N, T>) -> vec<N, T>
+@must_use @const op ~ [T: iu32](T) -> T
+@must_use @const op ~ [T: iu32, N: num](vec<N, T>) -> vec<N, T>
-@must_use @const("UnaryMinus") op - <T: fi32_f16>(T) -> T
-@must_use @const("UnaryMinus") op - <T: fi32_f16, N: num> (vec<N, T>) -> vec<N, T>
+@must_use @const("UnaryMinus") op - [T: fi32_f16](T) -> T
+@must_use @const("UnaryMinus") op - [T: fi32_f16, N: num](vec<N, T>) -> vec<N, T>
////////////////////////////////////////////////////////////////////////////////
// Binary Operators //
////////////////////////////////////////////////////////////////////////////////
-@must_use @const op + <T: fiu32_f16>(T, T) -> T
-@must_use @const op + <T: fiu32_f16, N: num> (vec<N, T>, vec<N, T>) -> vec<N, T>
-@must_use @const op + <T: fiu32_f16, N: num> (vec<N, T>, T) -> vec<N, T>
-@must_use @const op + <T: fiu32_f16, N: num> (T, vec<N, T>) -> vec<N, T>
-@must_use @const op + <T: f32_f16, N: num, M: num> (mat<N, M, T>, mat<N, M, T>) -> mat<N, M, T>
+@must_use @const op + [T: fiu32_f16](T, T) -> T
+@must_use @const op + [T: fiu32_f16, N: num](vec<N, T>, vec<N, T>) -> vec<N, T>
+@must_use @const op + [T: fiu32_f16, N: num](vec<N, T>, T) -> vec<N, T>
+@must_use @const op + [T: fiu32_f16, N: num](T, vec<N, T>) -> vec<N, T>
+@must_use @const op + [T: f32_f16, N: num, M: num](mat<N, M, T>, mat<N, M, T>) -> mat<N, M, T>
-@must_use @const op - <T: fiu32_f16>(T, T) -> T
-@must_use @const op - <T: fiu32_f16, N: num> (vec<N, T>, vec<N, T>) -> vec<N, T>
-@must_use @const op - <T: fiu32_f16, N: num> (vec<N, T>, T) -> vec<N, T>
-@must_use @const op - <T: fiu32_f16, N: num> (T, vec<N, T>) -> vec<N, T>
-@must_use @const op - <T: f32_f16, N: num, M: num> (mat<N, M, T>, mat<N, M, T>) -> mat<N, M, T>
+@must_use @const op - [T: fiu32_f16](T, T) -> T
+@must_use @const op - [T: fiu32_f16, N: num](vec<N, T>, vec<N, T>) -> vec<N, T>
+@must_use @const op - [T: fiu32_f16, N: num](vec<N, T>, T) -> vec<N, T>
+@must_use @const op - [T: fiu32_f16, N: num](T, vec<N, T>) -> vec<N, T>
+@must_use @const op - [T: f32_f16, N: num, M: num](mat<N, M, T>, mat<N, M, T>) -> mat<N, M, T>
-@must_use @const("Multiply") op * <T: fiu32_f16>(T, T) -> T
-@must_use @const("Multiply") op * <T: fiu32_f16, N: num> (vec<N, T>, vec<N, T>) -> vec<N, T>
-@must_use @const("Multiply") op * <T: fiu32_f16, N: num> (vec<N, T>, T) -> vec<N, T>
-@must_use @const("Multiply") op * <T: fiu32_f16, N: num> (T, vec<N, T>) -> vec<N, T>
-@must_use @const("Multiply") op * <T: f32_f16, N: num, M: num> (T, mat<N, M, T>) -> mat<N, M, T>
-@must_use @const("Multiply") op * <T: f32_f16, N: num, M: num> (mat<N, M, T>, T) -> mat<N, M, T>
-@must_use @const("MultiplyMatVec") op * <T: f32_f16, C: num, R: num> (mat<C, R, T>, vec<C, T>) -> vec<R, T>
-@must_use @const("MultiplyVecMat") op * <T: f32_f16, C: num, R: num> (vec<R, T>, mat<C, R, T>) -> vec<C, T>
-@must_use @const("MultiplyMatMat") op * <T: f32_f16, K: num, C: num, R: num> (mat<K, R, T>, mat<C, K, T>) -> mat<C, R, T>
+@must_use @const("Multiply") op * [T: fiu32_f16](T, T) -> T
+@must_use @const("Multiply") op * [T: fiu32_f16, N: num](vec<N, T>, vec<N, T>) -> vec<N, T>
+@must_use @const("Multiply") op * [T: fiu32_f16, N: num](vec<N, T>, T) -> vec<N, T>
+@must_use @const("Multiply") op * [T: fiu32_f16, N: num](T, vec<N, T>) -> vec<N, T>
+@must_use @const("Multiply") op * [T: f32_f16, N: num, M: num](T, mat<N, M, T>) -> mat<N, M, T>
+@must_use @const("Multiply") op * [T: f32_f16, N: num, M: num](mat<N, M, T>, T) -> mat<N, M, T>
+@must_use @const("MultiplyMatVec") op * [T: f32_f16, C: num, R: num](mat<C, R, T>, vec<C, T>) -> vec<R, T>
+@must_use @const("MultiplyVecMat") op * [T: f32_f16, C: num, R: num](vec<R, T>, mat<C, R, T>) -> vec<C, T>
+@must_use @const("MultiplyMatMat") op * [T: f32_f16, K: num, C: num, R: num](mat<K, R, T>, mat<C, K, T>) -> mat<C, R, T>
-@must_use @const op / <T: fiu32_f16>(T, T) -> T
-@must_use @const op / <T: fiu32_f16, N: num> (vec<N, T>, vec<N, T>) -> vec<N, T>
-@must_use @const op / <T: fiu32_f16, N: num> (vec<N, T>, T) -> vec<N, T>
-@must_use @const op / <T: fiu32_f16, N: num> (T, vec<N, T>) -> vec<N, T>
+@must_use @const op / [T: fiu32_f16](T, T) -> T
+@must_use @const op / [T: fiu32_f16, N: num](vec<N, T>, vec<N, T>) -> vec<N, T>
+@must_use @const op / [T: fiu32_f16, N: num](vec<N, T>, T) -> vec<N, T>
+@must_use @const op / [T: fiu32_f16, N: num](T, vec<N, T>) -> vec<N, T>
-@must_use @const op % <T: fiu32_f16>(T, T) -> T
-@must_use @const op % <T: fiu32_f16, N: num> (vec<N, T>, vec<N, T>) -> vec<N, T>
-@must_use @const op % <T: fiu32_f16, N: num> (vec<N, T>, T) -> vec<N, T>
-@must_use @const op % <T: fiu32_f16, N: num> (T, vec<N, T>) -> vec<N, T>
+@must_use @const op % [T: fiu32_f16](T, T) -> T
+@must_use @const op % [T: fiu32_f16, N: num](vec<N, T>, vec<N, T>) -> vec<N, T>
+@must_use @const op % [T: fiu32_f16, N: num](vec<N, T>, T) -> vec<N, T>
+@must_use @const op % [T: fiu32_f16, N: num](T, vec<N, T>) -> vec<N, T>
-@must_use @const op ^ <T: iu32>(T, T) -> T
-@must_use @const op ^ <T: iu32, N: num> (vec<N, T>, vec<N, T>) -> vec<N, T>
+@must_use @const op ^ [T: iu32](T, T) -> T
+@must_use @const op ^ [T: iu32, N: num](vec<N, T>, vec<N, T>) -> vec<N, T>
@must_use @const op & (bool, bool) -> bool
-@must_use @const op & <N: num> (vec<N, bool>, vec<N, bool>) -> vec<N, bool>
-@must_use @const op & <T: iu32>(T, T) -> T
-@must_use @const op & <T: iu32, N: num> (vec<N, T>, vec<N, T>) -> vec<N, T>
+@must_use @const op & [N: num](vec<N, bool>, vec<N, bool>) -> vec<N, bool>
+@must_use @const op & [T: iu32](T, T) -> T
+@must_use @const op & [T: iu32, N: num](vec<N, T>, vec<N, T>) -> vec<N, T>
@must_use @const op | (bool, bool) -> bool
-@must_use @const op | <N: num> (vec<N, bool>, vec<N, bool>) -> vec<N, bool>
-@must_use @const op | <T: iu32>(T, T) -> T
-@must_use @const op | <T: iu32, N: num> (vec<N, T>, vec<N, T>) -> vec<N, T>
+@must_use @const op | [N: num](vec<N, bool>, vec<N, bool>) -> vec<N, bool>
+@must_use @const op | [T: iu32](T, T) -> T
+@must_use @const op | [T: iu32, N: num](vec<N, T>, vec<N, T>) -> vec<N, T>
@must_use @const op && (bool, bool) -> bool
@must_use @const op || (bool, bool) -> bool
-@must_use @const op == <T: scalar>(T, T) -> bool
-@must_use @const op == <T: scalar, N: num> (vec<N, T>, vec<N, T>) -> vec<N, bool>
+@must_use @const op == [T: scalar](T, T) -> bool
+@must_use @const op == [T: scalar, N: num](vec<N, T>, vec<N, T>) -> vec<N, bool>
-@must_use @const op != <T: scalar>(T, T) -> bool
-@must_use @const op != <T: scalar, N: num> (vec<N, T>, vec<N, T>) -> vec<N, bool>
+@must_use @const op != [T: scalar](T, T) -> bool
+@must_use @const op != [T: scalar, N: num](vec<N, T>, vec<N, T>) -> vec<N, bool>
-@must_use @const op < <T: fiu32_f16>(T, T) -> bool
-@must_use @const op < <T: fiu32_f16, N: num> (vec<N, T>, vec<N, T>) -> vec<N, bool>
+@must_use @const op < [T: fiu32_f16](T, T) -> bool
+@must_use @const op < [T: fiu32_f16, N: num](vec<N, T>, vec<N, T>) -> vec<N, bool>
-@must_use @const op > <T: fiu32_f16>(T, T) -> bool
-@must_use @const op > <T: fiu32_f16, N: num> (vec<N, T>, vec<N, T>) -> vec<N, bool>
+@must_use @const op > [T: fiu32_f16](T, T) -> bool
+@must_use @const op > [T: fiu32_f16, N: num](vec<N, T>, vec<N, T>) -> vec<N, bool>
-@must_use @const op <= <T: fiu32_f16>(T, T) -> bool
-@must_use @const op <= <T: fiu32_f16, N: num> (vec<N, T>, vec<N, T>) -> vec<N, bool>
+@must_use @const op <= [T: fiu32_f16](T, T) -> bool
+@must_use @const op <= [T: fiu32_f16, N: num](vec<N, T>, vec<N, T>) -> vec<N, bool>
-@must_use @const op >= <T: fiu32_f16>(T, T) -> bool
-@must_use @const op >= <T: fiu32_f16, N: num> (vec<N, T>, vec<N, T>) -> vec<N, bool>
+@must_use @const op >= [T: fiu32_f16](T, T) -> bool
+@must_use @const op >= [T: fiu32_f16, N: num](vec<N, T>, vec<N, T>) -> vec<N, bool>
-@must_use @const op << <T: iu32>(T, u32) -> T
-@must_use @const op << <T: iu32, N: num> (vec<N, T>, vec<N, u32>) -> vec<N, T>
+@must_use @const op << [T: iu32](T, u32) -> T
+@must_use @const op << [T: iu32, N: num](vec<N, T>, vec<N, u32>) -> vec<N, T>
-@must_use @const op >> <T: iu32>(T, u32) -> T
-@must_use @const op >> <T: iu32, N: num> (vec<N, T>, vec<N, u32>) -> vec<N, T>
+@must_use @const op >> [T: iu32](T, u32) -> T
+@must_use @const op >> [T: iu32, N: num](vec<N, T>, vec<N, u32>) -> vec<N, T>
diff --git a/src/tint/lang/spirv/spirv.def b/src/tint/lang/spirv/spirv.def
index a5b3dcd..29d7e21 100644
--- a/src/tint/lang/spirv/spirv.def
+++ b/src/tint/lang/spirv/spirv.def
@@ -123,191 +123,191 @@
////////////////////////////////////////////////////////////////////////////////
// Builtin Functions //
////////////////////////////////////////////////////////////////////////////////
-fn array_length<I: u32, A: access>(ptr<storage, struct_with_runtime_array, A>, I) -> u32
+fn array_length[I: u32, A: access](ptr<storage, struct_with_runtime_array, A>, I) -> u32
-@stage("fragment", "compute") fn atomic_and<T: iu32, U: u32, S: workgroup_or_storage>(ptr<S, atomic<T>, read_write>, U, U, T) -> T
-@stage("fragment", "compute") fn atomic_compare_exchange<T: iu32, U: u32, S: workgroup_or_storage>(ptr<S, atomic<T>, read_write>, U, U, U, T, T) -> T
-@stage("fragment", "compute") fn atomic_exchange<T: iu32, U: u32, S: workgroup_or_storage>(ptr<S, atomic<T>, read_write>, U, U, T) -> T
-@stage("fragment", "compute") fn atomic_iadd<T: iu32, U: u32, S: workgroup_or_storage>(ptr<S, atomic<T>, read_write>, U, U, T) -> T
-@stage("fragment", "compute") fn atomic_isub<T: iu32, U: u32, S: workgroup_or_storage>(ptr<S, atomic<T>, read_write>, U, U, T) -> T
-@stage("fragment", "compute") fn atomic_load<T: iu32, U: u32, S: workgroup_or_storage>(ptr<S, atomic<T>, read_write>, U, U) -> T
-@stage("fragment", "compute") fn atomic_or<T: iu32, U: u32, S: workgroup_or_storage>(ptr<S, atomic<T>, read_write>, U, U, T) -> T
-@stage("fragment", "compute") fn atomic_smax<T: iu32, U: u32, S: workgroup_or_storage>(ptr<S, atomic<T>, read_write>, U, U, T) -> T
-@stage("fragment", "compute") fn atomic_smin<T: iu32, U: u32, S: workgroup_or_storage>(ptr<S, atomic<T>, read_write>, U, U, T) -> T
-@stage("fragment", "compute") fn atomic_store<T: iu32, U: u32, S: workgroup_or_storage>(ptr<S, atomic<T>, read_write>, U, U, T)
-@stage("fragment", "compute") fn atomic_umax<T: iu32, U: u32, S: workgroup_or_storage>(ptr<S, atomic<T>, read_write>, U, U, T) -> T
-@stage("fragment", "compute") fn atomic_umin<T: iu32, U: u32, S: workgroup_or_storage>(ptr<S, atomic<T>, read_write>, U, U, T) -> T
-@stage("fragment", "compute") fn atomic_xor<T: iu32, U: u32, S: workgroup_or_storage>(ptr<S, atomic<T>, read_write>, U, U, T) -> T
+@stage("fragment", "compute") fn atomic_and[T: iu32, U: u32, S: workgroup_or_storage](ptr<S, atomic<T>, read_write>, U, U, T) -> T
+@stage("fragment", "compute") fn atomic_compare_exchange[T: iu32, U: u32, S: workgroup_or_storage](ptr<S, atomic<T>, read_write>, U, U, U, T, T) -> T
+@stage("fragment", "compute") fn atomic_exchange[T: iu32, U: u32, S: workgroup_or_storage](ptr<S, atomic<T>, read_write>, U, U, T) -> T
+@stage("fragment", "compute") fn atomic_iadd[T: iu32, U: u32, S: workgroup_or_storage](ptr<S, atomic<T>, read_write>, U, U, T) -> T
+@stage("fragment", "compute") fn atomic_isub[T: iu32, U: u32, S: workgroup_or_storage](ptr<S, atomic<T>, read_write>, U, U, T) -> T
+@stage("fragment", "compute") fn atomic_load[T: iu32, U: u32, S: workgroup_or_storage](ptr<S, atomic<T>, read_write>, U, U) -> T
+@stage("fragment", "compute") fn atomic_or[T: iu32, U: u32, S: workgroup_or_storage](ptr<S, atomic<T>, read_write>, U, U, T) -> T
+@stage("fragment", "compute") fn atomic_smax[T: iu32, U: u32, S: workgroup_or_storage](ptr<S, atomic<T>, read_write>, U, U, T) -> T
+@stage("fragment", "compute") fn atomic_smin[T: iu32, U: u32, S: workgroup_or_storage](ptr<S, atomic<T>, read_write>, U, U, T) -> T
+@stage("fragment", "compute") fn atomic_store[T: iu32, U: u32, S: workgroup_or_storage](ptr<S, atomic<T>, read_write>, U, U, T)
+@stage("fragment", "compute") fn atomic_umax[T: iu32, U: u32, S: workgroup_or_storage](ptr<S, atomic<T>, read_write>, U, U, T) -> T
+@stage("fragment", "compute") fn atomic_umin[T: iu32, U: u32, S: workgroup_or_storage](ptr<S, atomic<T>, read_write>, U, U, T) -> T
+@stage("fragment", "compute") fn atomic_xor[T: iu32, U: u32, S: workgroup_or_storage](ptr<S, atomic<T>, read_write>, U, U, T) -> T
-fn dot<N: num, T: f32_f16>(vec<N, T>, vec<N, T>) -> T
+fn dot[N: num, T: f32_f16](vec<N, T>, vec<N, T>) -> T
-fn image_dref_gather<A: f32, B: iu32>(sampled_image<texture_depth_2d>, vec2<f32>, A, B) -> vec4<f32>
-fn image_dref_gather<A: f32, B: iu32, C: iu32>(sampled_image<texture_depth_2d>, vec2<f32>, A, B, vec2<C>) -> vec4<f32>
-fn image_dref_gather<A: f32, B: iu32>(sampled_image<texture_depth_2d_array>, vec3<f32>, A, B) -> vec4<f32>
-fn image_dref_gather<A: f32, B: iu32, C: iu32>(sampled_image<texture_depth_2d_array>, vec3<f32>, A, B, vec2<C>) -> vec4<f32>
-fn image_dref_gather<A: f32, B: iu32>(sampled_image<texture_depth_cube>, vec3<f32>, A, B) -> vec4<f32>
-fn image_dref_gather<A: f32, B: iu32>(sampled_image<texture_depth_cube_array>, vec4<f32>, A, B) -> vec4<f32>
+fn image_dref_gather[A: f32, B: iu32](sampled_image<texture_depth_2d>, vec2<f32>, A, B) -> vec4<f32>
+fn image_dref_gather[A: f32, B: iu32, C: iu32](sampled_image<texture_depth_2d>, vec2<f32>, A, B, vec2<C>) -> vec4<f32>
+fn image_dref_gather[A: f32, B: iu32](sampled_image<texture_depth_2d_array>, vec3<f32>, A, B) -> vec4<f32>
+fn image_dref_gather[A: f32, B: iu32, C: iu32](sampled_image<texture_depth_2d_array>, vec3<f32>, A, B, vec2<C>) -> vec4<f32>
+fn image_dref_gather[A: f32, B: iu32](sampled_image<texture_depth_cube>, vec3<f32>, A, B) -> vec4<f32>
+fn image_dref_gather[A: f32, B: iu32](sampled_image<texture_depth_cube_array>, vec4<f32>, A, B) -> vec4<f32>
-fn image_fetch<T: fiu32, C: iu32, I: iu32, S: iu32>(texture_1d<T>, C, I, S) -> vec4<T>
-fn image_fetch<T: fiu32, C: iu32, I: iu32, S: iu32>(texture_2d<T>, vec2<C>, I, S) -> vec4<T>
-fn image_fetch<T: fiu32, C: iu32, I: iu32, S: iu32>(texture_2d_array<T>, vec3<C>, I, S) -> vec4<T>
-fn image_fetch<T: fiu32, C: iu32, I: iu32, S: iu32>(texture_3d<T>, vec3<C>, I, S) -> vec4<T>
-fn image_fetch<T: fiu32, C: iu32, I: iu32, S: iu32>(texture_multisampled_2d<T>, vec2<C>, I, S) -> vec4<T>
-fn image_fetch<I: iu32, C: iu32, S: iu32>(texture_depth_2d, vec2<C>, I, S) -> vec4<f32>
-fn image_fetch<I: iu32, C: iu32, S: iu32>(texture_depth_2d_array, vec3<C>, I, S) -> vec4<f32>
-fn image_fetch<I: iu32, C: iu32, S: iu32>(texture_depth_multisampled_2d, vec2<C>, I, S) -> vec4<f32>
+fn image_fetch[T: fiu32, C: iu32, I: iu32, S: iu32](texture_1d<T>, C, I, S) -> vec4<T>
+fn image_fetch[T: fiu32, C: iu32, I: iu32, S: iu32](texture_2d<T>, vec2<C>, I, S) -> vec4<T>
+fn image_fetch[T: fiu32, C: iu32, I: iu32, S: iu32](texture_2d_array<T>, vec3<C>, I, S) -> vec4<T>
+fn image_fetch[T: fiu32, C: iu32, I: iu32, S: iu32](texture_3d<T>, vec3<C>, I, S) -> vec4<T>
+fn image_fetch[T: fiu32, C: iu32, I: iu32, S: iu32](texture_multisampled_2d<T>, vec2<C>, I, S) -> vec4<T>
+fn image_fetch[I: iu32, C: iu32, S: iu32](texture_depth_2d, vec2<C>, I, S) -> vec4<f32>
+fn image_fetch[I: iu32, C: iu32, S: iu32](texture_depth_2d_array, vec3<C>, I, S) -> vec4<f32>
+fn image_fetch[I: iu32, C: iu32, S: iu32](texture_depth_multisampled_2d, vec2<C>, I, S) -> vec4<f32>
-fn image_gather<T: fiu32, A: iu32, B: iu32>(sampled_image<texture_1d<T> >, vec2<f32>, A, B) -> vec4<T>
-fn image_gather<T: fiu32, A: iu32, B: iu32>(sampled_image<texture_2d<T> >, vec2<f32>, A, B) -> vec4<T>
-fn image_gather<T: fiu32, A: iu32, B: iu32>(sampled_image<texture_2d<T> >, vec2<f32>, A, B, vec2<i32>) -> vec4<T>
-fn image_gather<T: fiu32, A: iu32, B: iu32>(sampled_image<texture_2d_array<T> >, vec3<f32>, A, B) -> vec4<T>
-fn image_gather<T: fiu32, A: iu32, B: iu32, C: iu32>(sampled_image<texture_2d_array<T> >, vec3<f32>, A, B, vec2<C>) -> vec4<T>
-fn image_gather<T: fiu32, A: iu32, B: iu32>(sampled_image<texture_3d<T> >, vec2<f32>, A, B) -> vec4<T>
-fn image_gather<T: fiu32, A: iu32, B: iu32>(sampled_image<texture_cube<T> >, vec3<f32>, A, B) -> vec4<T>
-fn image_gather<T: fiu32, A: iu32, B: iu32>(sampled_image<texture_cube_array<T> >, vec4<f32>, A, B) -> vec4<T>
-fn image_gather<A: iu32, B: iu32>(sampled_image<texture_depth_2d>, vec2<f32>, A, B) -> vec4<f32>
-fn image_gather<A: iu32, B: iu32, C: iu32>(sampled_image<texture_depth_2d>, vec2<f32>, A, B, vec2<C>) -> vec4<f32>
-fn image_gather<A: iu32, B: iu32>(sampled_image<texture_depth_2d_array>, vec3<f32>, A, B) -> vec4<f32>
-fn image_gather<A: iu32, B: iu32, C: iu32>(sampled_image<texture_depth_2d_array>, vec3<f32>, A, B, vec2<C>) -> vec4<f32>
-fn image_gather<A: iu32, B: iu32>(sampled_image<texture_depth_cube>, vec3<f32>, A, B) -> vec4<f32>
-fn image_gather<A: iu32, B: iu32>(sampled_image<texture_depth_cube_array>, vec4<f32>, A, B) -> vec4<f32>
+fn image_gather[T: fiu32, A: iu32, B: iu32](sampled_image<texture_1d<T> >, vec2<f32>, A, B) -> vec4<T>
+fn image_gather[T: fiu32, A: iu32, B: iu32](sampled_image<texture_2d<T> >, vec2<f32>, A, B) -> vec4<T>
+fn image_gather[T: fiu32, A: iu32, B: iu32](sampled_image<texture_2d<T> >, vec2<f32>, A, B, vec2<i32>) -> vec4<T>
+fn image_gather[T: fiu32, A: iu32, B: iu32](sampled_image<texture_2d_array<T> >, vec3<f32>, A, B) -> vec4<T>
+fn image_gather[T: fiu32, A: iu32, B: iu32, C: iu32](sampled_image<texture_2d_array<T> >, vec3<f32>, A, B, vec2<C>) -> vec4<T>
+fn image_gather[T: fiu32, A: iu32, B: iu32](sampled_image<texture_3d<T> >, vec2<f32>, A, B) -> vec4<T>
+fn image_gather[T: fiu32, A: iu32, B: iu32](sampled_image<texture_cube<T> >, vec3<f32>, A, B) -> vec4<T>
+fn image_gather[T: fiu32, A: iu32, B: iu32](sampled_image<texture_cube_array<T> >, vec4<f32>, A, B) -> vec4<T>
+fn image_gather[A: iu32, B: iu32](sampled_image<texture_depth_2d>, vec2<f32>, A, B) -> vec4<f32>
+fn image_gather[A: iu32, B: iu32, C: iu32](sampled_image<texture_depth_2d>, vec2<f32>, A, B, vec2<C>) -> vec4<f32>
+fn image_gather[A: iu32, B: iu32](sampled_image<texture_depth_2d_array>, vec3<f32>, A, B) -> vec4<f32>
+fn image_gather[A: iu32, B: iu32, C: iu32](sampled_image<texture_depth_2d_array>, vec3<f32>, A, B, vec2<C>) -> vec4<f32>
+fn image_gather[A: iu32, B: iu32](sampled_image<texture_depth_cube>, vec3<f32>, A, B) -> vec4<f32>
+fn image_gather[A: iu32, B: iu32](sampled_image<texture_depth_cube_array>, vec4<f32>, A, B) -> vec4<f32>
-fn image_query_size<T: fiu32>(texture_1d<T>) -> u32
-fn image_query_size<T: fiu32>(texture_2d<T>) -> vec2<u32>
-fn image_query_size<T: fiu32>(texture_2d_array<T>) -> vec3<u32>
-fn image_query_size<T: fiu32>(texture_3d<T>) -> vec3<u32>
-fn image_query_size<T: fiu32>(texture_cube<T>) -> vec2<u32>
-fn image_query_size<T: fiu32>(texture_cube_array<T>) -> vec3<u32>
-fn image_query_size<T: fiu32>(texture_multisampled_2d<T>) -> vec2<u32>
+fn image_query_size[T: fiu32](texture_1d<T>) -> u32
+fn image_query_size[T: fiu32](texture_2d<T>) -> vec2<u32>
+fn image_query_size[T: fiu32](texture_2d_array<T>) -> vec3<u32>
+fn image_query_size[T: fiu32](texture_3d<T>) -> vec3<u32>
+fn image_query_size[T: fiu32](texture_cube<T>) -> vec2<u32>
+fn image_query_size[T: fiu32](texture_cube_array<T>) -> vec3<u32>
+fn image_query_size[T: fiu32](texture_multisampled_2d<T>) -> vec2<u32>
fn image_query_size(texture_depth_2d) -> vec2<u32>
fn image_query_size(texture_depth_2d_array) -> vec3<u32>
fn image_query_size(texture_depth_cube) -> vec2<u32>
fn image_query_size(texture_depth_cube_array) -> vec3<u32>
fn image_query_size(texture_depth_multisampled_2d) -> vec2<u32>
-fn image_query_size<F: texel_format, A: access>(texture_storage_1d<F, A>) -> u32
-fn image_query_size<F: texel_format, A: access>(texture_storage_2d<F, A>) -> vec2<u32>
-fn image_query_size<F: texel_format, A: access>(texture_storage_2d_array<F, A>) -> vec3<u32>
-fn image_query_size<F: texel_format, A: access>(texture_storage_3d<F, A>) -> vec3<u32>
+fn image_query_size[F: texel_format, A: access](texture_storage_1d<F, A>) -> u32
+fn image_query_size[F: texel_format, A: access](texture_storage_2d<F, A>) -> vec2<u32>
+fn image_query_size[F: texel_format, A: access](texture_storage_2d_array<F, A>) -> vec3<u32>
+fn image_query_size[F: texel_format, A: access](texture_storage_3d<F, A>) -> vec3<u32>
-fn image_query_size_lod<T: fiu32, A: iu32>(texture_1d<T>, A) -> u32
-fn image_query_size_lod<T: fiu32, A: iu32>(texture_2d<T>, A) -> vec2<u32>
-fn image_query_size_lod<T: fiu32, A: iu32>(texture_2d_array<T>, A) -> vec3<u32>
-fn image_query_size_lod<T: fiu32, A: iu32>(texture_3d<T>, A) -> vec3<u32>
-fn image_query_size_lod<T: fiu32, A: iu32>(texture_cube<T>, A) -> vec2<u32>
-fn image_query_size_lod<T: fiu32, A: iu32>(texture_cube_array<T>, A) -> vec3<u32>
-fn image_query_size_lod<A: iu32>(texture_depth_2d, A) -> vec2<u32>
-fn image_query_size_lod<A: iu32>(texture_depth_2d_array, A) -> vec3<u32>
-fn image_query_size_lod<A: iu32>(texture_depth_cube, A) -> vec2<u32>
-fn image_query_size_lod<A: iu32>(texture_depth_cube_array, A) -> vec3<u32>
+fn image_query_size_lod[T: fiu32, A: iu32](texture_1d<T>, A) -> u32
+fn image_query_size_lod[T: fiu32, A: iu32](texture_2d<T>, A) -> vec2<u32>
+fn image_query_size_lod[T: fiu32, A: iu32](texture_2d_array<T>, A) -> vec3<u32>
+fn image_query_size_lod[T: fiu32, A: iu32](texture_3d<T>, A) -> vec3<u32>
+fn image_query_size_lod[T: fiu32, A: iu32](texture_cube<T>, A) -> vec2<u32>
+fn image_query_size_lod[T: fiu32, A: iu32](texture_cube_array<T>, A) -> vec3<u32>
+fn image_query_size_lod[A: iu32](texture_depth_2d, A) -> vec2<u32>
+fn image_query_size_lod[A: iu32](texture_depth_2d_array, A) -> vec3<u32>
+fn image_query_size_lod[A: iu32](texture_depth_cube, A) -> vec2<u32>
+fn image_query_size_lod[A: iu32](texture_depth_cube_array, A) -> vec3<u32>
-fn image_read<F: f32_texel_format, A: readable, C: iu32, S: iu32>(texture_storage_1d<F, A>, C, S) -> vec4<f32>
-fn image_read<F: i32_texel_format, A: readable, C: iu32, S: iu32>(texture_storage_1d<F, A>, C, S) -> vec4<i32>
-fn image_read<F: u32_texel_format, A: readable, C: iu32, S: iu32>(texture_storage_1d<F, A>, C, S) -> vec4<u32>
-fn image_read<F: f32_texel_format, A: readable, C: iu32, S: iu32>(texture_storage_2d<F, A>, vec2<C>, S) -> vec4<f32>
-fn image_read<F: i32_texel_format, A: readable, C: iu32, S: iu32>(texture_storage_2d<F, A>, vec2<C>, S) -> vec4<i32>
-fn image_read<F: u32_texel_format, A: readable, C: iu32, S: iu32>(texture_storage_2d<F, A>, vec2<C>, S) -> vec4<u32>
-fn image_read<F: f32_texel_format, A: readable, C: iu32, S: iu32>(texture_storage_2d_array<F, A>, vec3<C>, S) -> vec4<f32>
-fn image_read<F: i32_texel_format, A: readable, C: iu32, S: iu32>(texture_storage_2d_array<F, A>, vec3<C>, S) -> vec4<i32>
-fn image_read<F: u32_texel_format, A: readable, C: iu32, S: iu32>(texture_storage_2d_array<F, A>, vec3<C>, S) -> vec4<u32>
-fn image_read<F: f32_texel_format, A: readable, C: iu32, S: iu32>(texture_storage_3d<F, A>, vec3<C>, S) -> vec4<f32>
-fn image_read<F: i32_texel_format, A: readable, C: iu32, S: iu32>(texture_storage_3d<F, A>, vec3<C>, S) -> vec4<i32>
-fn image_read<F: u32_texel_format, A: readable, C: iu32, S: iu32>(texture_storage_3d<F, A>, vec3<C>, S) -> vec4<u32>
+fn image_read[F: f32_texel_format, A: readable, C: iu32, S: iu32](texture_storage_1d<F, A>, C, S) -> vec4<f32>
+fn image_read[F: i32_texel_format, A: readable, C: iu32, S: iu32](texture_storage_1d<F, A>, C, S) -> vec4<i32>
+fn image_read[F: u32_texel_format, A: readable, C: iu32, S: iu32](texture_storage_1d<F, A>, C, S) -> vec4<u32>
+fn image_read[F: f32_texel_format, A: readable, C: iu32, S: iu32](texture_storage_2d<F, A>, vec2<C>, S) -> vec4<f32>
+fn image_read[F: i32_texel_format, A: readable, C: iu32, S: iu32](texture_storage_2d<F, A>, vec2<C>, S) -> vec4<i32>
+fn image_read[F: u32_texel_format, A: readable, C: iu32, S: iu32](texture_storage_2d<F, A>, vec2<C>, S) -> vec4<u32>
+fn image_read[F: f32_texel_format, A: readable, C: iu32, S: iu32](texture_storage_2d_array<F, A>, vec3<C>, S) -> vec4<f32>
+fn image_read[F: i32_texel_format, A: readable, C: iu32, S: iu32](texture_storage_2d_array<F, A>, vec3<C>, S) -> vec4<i32>
+fn image_read[F: u32_texel_format, A: readable, C: iu32, S: iu32](texture_storage_2d_array<F, A>, vec3<C>, S) -> vec4<u32>
+fn image_read[F: f32_texel_format, A: readable, C: iu32, S: iu32](texture_storage_3d<F, A>, vec3<C>, S) -> vec4<f32>
+fn image_read[F: i32_texel_format, A: readable, C: iu32, S: iu32](texture_storage_3d<F, A>, vec3<C>, S) -> vec4<i32>
+fn image_read[F: u32_texel_format, A: readable, C: iu32, S: iu32](texture_storage_3d<F, A>, vec3<C>, S) -> vec4<u32>
-fn image_sample_implicit_lod<T: fiu32, C: iu32>(sampled_image<texture_1d<T> >, f32, C) -> vec4<f32>
-fn image_sample_implicit_lod<T: fiu32, C: iu32>(sampled_image<texture_2d<T> >, vec2<f32>, C) -> vec4<f32>
-fn image_sample_implicit_lod<T: fiu32, C: iu32>(sampled_image<texture_2d<T> >, vec2<f32>, C, f32) -> vec4<f32>
-fn image_sample_implicit_lod<T: fiu32, C: iu32, D: iu32>(sampled_image<texture_2d<T> >, vec2<f32>, C, f32, vec2<D>) -> vec4<f32>
-fn image_sample_implicit_lod<T: fiu32, C: iu32, D: iu32>(sampled_image<texture_2d<T> >, vec2<f32>, C, vec2<D>) -> vec4<f32>
-fn image_sample_implicit_lod<T: fiu32, C: iu32>(sampled_image<texture_2d_array<T> >, vec3<f32>, C) -> vec4<f32>
-fn image_sample_implicit_lod<T: fiu32, C: iu32>(sampled_image<texture_2d_array<T> >, vec3<f32>, C, f32) -> vec4<f32>
-fn image_sample_implicit_lod<T: fiu32, C: iu32, D: iu32>(sampled_image<texture_2d_array<T> >, vec3<f32>, C, vec2<D>) -> vec4<f32>
-fn image_sample_implicit_lod<T: fiu32, C: iu32, D: iu32>(sampled_image<texture_2d_array<T> >, vec3<f32>, C, f32, vec2<D>) -> vec4<f32>
-fn image_sample_implicit_lod<T: fiu32, C: iu32>(sampled_image<texture_3d<T> >, vec3<f32>, C) -> vec4<f32>
-fn image_sample_implicit_lod<T: fiu32, C: iu32>(sampled_image<texture_3d<T> >, vec3<f32>, C, f32) -> vec4<f32>
-fn image_sample_implicit_lod<T: fiu32, C: iu32, D: iu32>(sampled_image<texture_3d<T> >, vec3<f32>, C, f32, vec3<D>) -> vec4<f32>
-fn image_sample_implicit_lod<T: fiu32, C: iu32, D: iu32>(sampled_image<texture_3d<T> >, vec3<f32>, C, vec3<D>) -> vec4<f32>
-fn image_sample_implicit_lod<T: fiu32, C: iu32>(sampled_image<texture_cube<T> >, vec3<f32>, C) -> vec4<f32>
-fn image_sample_implicit_lod<T: fiu32, C: iu32>(sampled_image<texture_cube<T> >, vec3<f32>, C, f32) -> vec4<f32>
-fn image_sample_implicit_lod<T: fiu32, C: iu32>(sampled_image<texture_cube_array<T> >, vec4<f32>, C) -> vec4<f32>
-fn image_sample_implicit_lod<T: fiu32, C: iu32>(sampled_image<texture_cube_array<T> >, vec4<f32>, C, f32) -> vec4<f32>
-fn image_sample_implicit_lod<C: iu32>(sampled_image<texture_depth_2d>, vec2<f32>, C) -> vec4<f32>
-fn image_sample_implicit_lod<C: iu32, D: iu32>(sampled_image<texture_depth_2d>, vec2<f32>, C, vec2<D>) -> vec4<f32>
-fn image_sample_implicit_lod<C: iu32>(sampled_image<texture_depth_cube>, vec3<f32>, C) -> vec4<f32>
-fn image_sample_implicit_lod<C: iu32>(sampled_image<texture_depth_2d_array>, vec3<f32>, C) -> vec4<f32>
-fn image_sample_implicit_lod<C: iu32, D: iu32>(sampled_image<texture_depth_2d_array>, vec3<f32>, C, vec2<D>) -> vec4<f32>
-fn image_sample_implicit_lod<C: iu32>(sampled_image<texture_depth_cube_array>, vec4<f32>, C) -> vec4<f32>
+fn image_sample_implicit_lod[T: fiu32, C: iu32](sampled_image<texture_1d<T> >, f32, C) -> vec4<f32>
+fn image_sample_implicit_lod[T: fiu32, C: iu32](sampled_image<texture_2d<T> >, vec2<f32>, C) -> vec4<f32>
+fn image_sample_implicit_lod[T: fiu32, C: iu32](sampled_image<texture_2d<T> >, vec2<f32>, C, f32) -> vec4<f32>
+fn image_sample_implicit_lod[T: fiu32, C: iu32, D: iu32](sampled_image<texture_2d<T> >, vec2<f32>, C, f32, vec2<D>) -> vec4<f32>
+fn image_sample_implicit_lod[T: fiu32, C: iu32, D: iu32](sampled_image<texture_2d<T> >, vec2<f32>, C, vec2<D>) -> vec4<f32>
+fn image_sample_implicit_lod[T: fiu32, C: iu32](sampled_image<texture_2d_array<T> >, vec3<f32>, C) -> vec4<f32>
+fn image_sample_implicit_lod[T: fiu32, C: iu32](sampled_image<texture_2d_array<T> >, vec3<f32>, C, f32) -> vec4<f32>
+fn image_sample_implicit_lod[T: fiu32, C: iu32, D: iu32](sampled_image<texture_2d_array<T> >, vec3<f32>, C, vec2<D>) -> vec4<f32>
+fn image_sample_implicit_lod[T: fiu32, C: iu32, D: iu32](sampled_image<texture_2d_array<T> >, vec3<f32>, C, f32, vec2<D>) -> vec4<f32>
+fn image_sample_implicit_lod[T: fiu32, C: iu32](sampled_image<texture_3d<T> >, vec3<f32>, C) -> vec4<f32>
+fn image_sample_implicit_lod[T: fiu32, C: iu32](sampled_image<texture_3d<T> >, vec3<f32>, C, f32) -> vec4<f32>
+fn image_sample_implicit_lod[T: fiu32, C: iu32, D: iu32](sampled_image<texture_3d<T> >, vec3<f32>, C, f32, vec3<D>) -> vec4<f32>
+fn image_sample_implicit_lod[T: fiu32, C: iu32, D: iu32](sampled_image<texture_3d<T> >, vec3<f32>, C, vec3<D>) -> vec4<f32>
+fn image_sample_implicit_lod[T: fiu32, C: iu32](sampled_image<texture_cube<T> >, vec3<f32>, C) -> vec4<f32>
+fn image_sample_implicit_lod[T: fiu32, C: iu32](sampled_image<texture_cube<T> >, vec3<f32>, C, f32) -> vec4<f32>
+fn image_sample_implicit_lod[T: fiu32, C: iu32](sampled_image<texture_cube_array<T> >, vec4<f32>, C) -> vec4<f32>
+fn image_sample_implicit_lod[T: fiu32, C: iu32](sampled_image<texture_cube_array<T> >, vec4<f32>, C, f32) -> vec4<f32>
+fn image_sample_implicit_lod[C: iu32](sampled_image<texture_depth_2d>, vec2<f32>, C) -> vec4<f32>
+fn image_sample_implicit_lod[C: iu32, D: iu32](sampled_image<texture_depth_2d>, vec2<f32>, C, vec2<D>) -> vec4<f32>
+fn image_sample_implicit_lod[C: iu32](sampled_image<texture_depth_cube>, vec3<f32>, C) -> vec4<f32>
+fn image_sample_implicit_lod[C: iu32](sampled_image<texture_depth_2d_array>, vec3<f32>, C) -> vec4<f32>
+fn image_sample_implicit_lod[C: iu32, D: iu32](sampled_image<texture_depth_2d_array>, vec3<f32>, C, vec2<D>) -> vec4<f32>
+fn image_sample_implicit_lod[C: iu32](sampled_image<texture_depth_cube_array>, vec4<f32>, C) -> vec4<f32>
-fn image_sample_explicit_lod<T: fiu32, C: iu32>(sampled_image<texture_2d<T> >, vec2<f32>, C, f32) -> vec4<f32>
-fn image_sample_explicit_lod<T: fiu32, C: iu32>(sampled_image<texture_2d<T> >, vec2<f32>, C, vec2<f32>, vec2<f32>) -> vec4<f32>
-fn image_sample_explicit_lod<T: fiu32, C: iu32, D: iu32>(sampled_image<texture_2d<T> >, vec2<f32>, C, f32, vec2<D>) -> vec4<f32>
-fn image_sample_explicit_lod<T: fiu32, C: iu32, D: iu32>(sampled_image<texture_2d<T> >, vec2<f32>, C, vec2<f32>, vec2<D>) -> vec4<f32>
-fn image_sample_explicit_lod<T: fiu32, C: iu32, D: iu32>(sampled_image<texture_2d<T> >, vec2<f32>, C, vec2<f32>, vec2<f32>, vec2<D>) -> vec4<f32>
-fn image_sample_explicit_lod<T: fiu32, C: iu32>(sampled_image<texture_2d_array<T> >, vec3<f32>, C, f32) -> vec4<f32>
-fn image_sample_explicit_lod<T: fiu32, C: iu32>(sampled_image<texture_2d_array<T> >, vec3<f32>, C, vec2<f32>, vec2<f32>) -> vec4<f32>
-fn image_sample_explicit_lod<T: fiu32, C: iu32, D: iu32>(sampled_image<texture_2d_array<T> >, vec3<f32>, C, f32, vec2<D>) -> vec4<f32>
-fn image_sample_explicit_lod<T: fiu32, C: iu32, D: iu32>(sampled_image<texture_2d_array<T> >, vec3<f32>, C, vec2<f32>, vec2<f32>, vec2<D>) -> vec4<f32>
-fn image_sample_explicit_lod<T: fiu32, C: iu32>(sampled_image<texture_3d<T> >, vec3<f32>, C, f32) -> vec4<f32>
-fn image_sample_explicit_lod<T: fiu32, C: iu32>(sampled_image<texture_3d<T> >, vec3<f32>, C, vec3<f32>, vec3<f32>) -> vec4<f32>
-fn image_sample_explicit_lod<T: fiu32, C: iu32, D: iu32>(sampled_image<texture_3d<T> >, vec3<f32>, C, f32, vec3<D>) -> vec4<f32>
-fn image_sample_explicit_lod<T: fiu32, C: iu32, D: iu32>(sampled_image<texture_3d<T> >, vec3<f32>, C, vec3<f32>, vec3<f32>, vec3<D>) -> vec4<f32>
-fn image_sample_explicit_lod<T: fiu32, C: iu32>(sampled_image<texture_cube<T> >, vec3<f32>, C, f32) -> vec4<f32>
-fn image_sample_explicit_lod<T: fiu32, C: iu32>(sampled_image<texture_cube<T> >, vec3<f32>, C, vec3<f32>, vec3<f32>) -> vec4<f32>
-fn image_sample_explicit_lod<T: fiu32, C: iu32>(sampled_image<texture_cube_array<T> >, vec4<f32>, C, f32) -> vec4<f32>
-fn image_sample_explicit_lod<T: fiu32, C: iu32>(sampled_image<texture_cube_array<T> >, vec4<f32>, C, vec3<f32>, vec3<f32>) -> vec4<f32>
-fn image_sample_explicit_lod<C: iu32>(sampled_image<texture_depth_2d>, vec2<f32>, C, f32) -> vec4<f32>
-fn image_sample_explicit_lod<C: iu32, D: iu32>(sampled_image<texture_depth_2d>, vec2<f32>, C, f32, vec2<D>) -> vec4<f32>
-fn image_sample_explicit_lod<C: iu32>(sampled_image<texture_depth_2d_array>, vec3<f32>, C, f32) -> vec4<f32>
-fn image_sample_explicit_lod<C: iu32, D: iu32>(sampled_image<texture_depth_2d_array>, vec3<f32>, C, f32, vec2<D>) -> vec4<f32>
-fn image_sample_explicit_lod<C: iu32>(sampled_image<texture_depth_cube>, vec3<f32>, C, f32) -> vec4<f32>
-fn image_sample_explicit_lod<C: iu32>(sampled_image<texture_depth_cube_array>, vec4<f32>, C, f32) -> vec4<f32>
+fn image_sample_explicit_lod[T: fiu32, C: iu32](sampled_image<texture_2d<T> >, vec2<f32>, C, f32) -> vec4<f32>
+fn image_sample_explicit_lod[T: fiu32, C: iu32](sampled_image<texture_2d<T> >, vec2<f32>, C, vec2<f32>, vec2<f32>) -> vec4<f32>
+fn image_sample_explicit_lod[T: fiu32, C: iu32, D: iu32](sampled_image<texture_2d<T> >, vec2<f32>, C, f32, vec2<D>) -> vec4<f32>
+fn image_sample_explicit_lod[T: fiu32, C: iu32, D: iu32](sampled_image<texture_2d<T> >, vec2<f32>, C, vec2<f32>, vec2<D>) -> vec4<f32>
+fn image_sample_explicit_lod[T: fiu32, C: iu32, D: iu32](sampled_image<texture_2d<T> >, vec2<f32>, C, vec2<f32>, vec2<f32>, vec2<D>) -> vec4<f32>
+fn image_sample_explicit_lod[T: fiu32, C: iu32](sampled_image<texture_2d_array<T> >, vec3<f32>, C, f32) -> vec4<f32>
+fn image_sample_explicit_lod[T: fiu32, C: iu32](sampled_image<texture_2d_array<T> >, vec3<f32>, C, vec2<f32>, vec2<f32>) -> vec4<f32>
+fn image_sample_explicit_lod[T: fiu32, C: iu32, D: iu32](sampled_image<texture_2d_array<T> >, vec3<f32>, C, f32, vec2<D>) -> vec4<f32>
+fn image_sample_explicit_lod[T: fiu32, C: iu32, D: iu32](sampled_image<texture_2d_array<T> >, vec3<f32>, C, vec2<f32>, vec2<f32>, vec2<D>) -> vec4<f32>
+fn image_sample_explicit_lod[T: fiu32, C: iu32](sampled_image<texture_3d<T> >, vec3<f32>, C, f32) -> vec4<f32>
+fn image_sample_explicit_lod[T: fiu32, C: iu32](sampled_image<texture_3d<T> >, vec3<f32>, C, vec3<f32>, vec3<f32>) -> vec4<f32>
+fn image_sample_explicit_lod[T: fiu32, C: iu32, D: iu32](sampled_image<texture_3d<T> >, vec3<f32>, C, f32, vec3<D>) -> vec4<f32>
+fn image_sample_explicit_lod[T: fiu32, C: iu32, D: iu32](sampled_image<texture_3d<T> >, vec3<f32>, C, vec3<f32>, vec3<f32>, vec3<D>) -> vec4<f32>
+fn image_sample_explicit_lod[T: fiu32, C: iu32](sampled_image<texture_cube<T> >, vec3<f32>, C, f32) -> vec4<f32>
+fn image_sample_explicit_lod[T: fiu32, C: iu32](sampled_image<texture_cube<T> >, vec3<f32>, C, vec3<f32>, vec3<f32>) -> vec4<f32>
+fn image_sample_explicit_lod[T: fiu32, C: iu32](sampled_image<texture_cube_array<T> >, vec4<f32>, C, f32) -> vec4<f32>
+fn image_sample_explicit_lod[T: fiu32, C: iu32](sampled_image<texture_cube_array<T> >, vec4<f32>, C, vec3<f32>, vec3<f32>) -> vec4<f32>
+fn image_sample_explicit_lod[C: iu32](sampled_image<texture_depth_2d>, vec2<f32>, C, f32) -> vec4<f32>
+fn image_sample_explicit_lod[C: iu32, D: iu32](sampled_image<texture_depth_2d>, vec2<f32>, C, f32, vec2<D>) -> vec4<f32>
+fn image_sample_explicit_lod[C: iu32](sampled_image<texture_depth_2d_array>, vec3<f32>, C, f32) -> vec4<f32>
+fn image_sample_explicit_lod[C: iu32, D: iu32](sampled_image<texture_depth_2d_array>, vec3<f32>, C, f32, vec2<D>) -> vec4<f32>
+fn image_sample_explicit_lod[C: iu32](sampled_image<texture_depth_cube>, vec3<f32>, C, f32) -> vec4<f32>
+fn image_sample_explicit_lod[C: iu32](sampled_image<texture_depth_cube_array>, vec4<f32>, C, f32) -> vec4<f32>
-fn image_sample_dref_implicit_lod<C: iu32>(sampled_image<texture_depth_2d>, vec2<f32>, f32, C) -> f32
-fn image_sample_dref_implicit_lod<C: iu32, D: iu32>(sampled_image<texture_depth_2d>, vec2<f32>, f32, C, vec2<D>) -> f32
-fn image_sample_dref_implicit_lod<C: iu32>(sampled_image<texture_depth_2d_array>, vec3<f32>, f32, C) -> f32
-fn image_sample_dref_implicit_lod<C: iu32, D: iu32>(sampled_image<texture_depth_2d_array>, vec3<f32>, f32, C, vec2<D>) -> f32
-fn image_sample_dref_implicit_lod<C: iu32>(sampled_image<texture_depth_cube>, vec3<f32>, f32, C) -> f32
-fn image_sample_dref_implicit_lod<C: iu32>(sampled_image<texture_depth_cube_array>, vec4<f32>, f32, C) -> f32
+fn image_sample_dref_implicit_lod[C: iu32](sampled_image<texture_depth_2d>, vec2<f32>, f32, C) -> f32
+fn image_sample_dref_implicit_lod[C: iu32, D: iu32](sampled_image<texture_depth_2d>, vec2<f32>, f32, C, vec2<D>) -> f32
+fn image_sample_dref_implicit_lod[C: iu32](sampled_image<texture_depth_2d_array>, vec3<f32>, f32, C) -> f32
+fn image_sample_dref_implicit_lod[C: iu32, D: iu32](sampled_image<texture_depth_2d_array>, vec3<f32>, f32, C, vec2<D>) -> f32
+fn image_sample_dref_implicit_lod[C: iu32](sampled_image<texture_depth_cube>, vec3<f32>, f32, C) -> f32
+fn image_sample_dref_implicit_lod[C: iu32](sampled_image<texture_depth_cube_array>, vec4<f32>, f32, C) -> f32
-fn image_sample_dref_explicit_lod<C: iu32>(sampled_image<texture_depth_2d>, vec2<f32>, f32, C, f32) -> f32
-fn image_sample_dref_explicit_lod<C: iu32, D: iu32>(sampled_image<texture_depth_2d>, vec2<f32>, f32, C, f32, vec2<D>) -> f32
-fn image_sample_dref_explicit_lod<C: iu32>(sampled_image<texture_depth_2d_array>, vec3<f32>, f32, C, f32) -> f32
-fn image_sample_dref_explicit_lod<C: iu32, D: iu32>(sampled_image<texture_depth_2d_array>, vec3<f32>, f32, C, f32, vec2<D>) -> f32
-fn image_sample_dref_explicit_lod<C: iu32>(sampled_image<texture_depth_cube>, vec3<f32>, f32, C, f32) -> f32
-fn image_sample_dref_explicit_lod<C: iu32>(sampled_image<texture_depth_cube_array>, vec4<f32>, f32, C, f32) -> f32
+fn image_sample_dref_explicit_lod[C: iu32](sampled_image<texture_depth_2d>, vec2<f32>, f32, C, f32) -> f32
+fn image_sample_dref_explicit_lod[C: iu32, D: iu32](sampled_image<texture_depth_2d>, vec2<f32>, f32, C, f32, vec2<D>) -> f32
+fn image_sample_dref_explicit_lod[C: iu32](sampled_image<texture_depth_2d_array>, vec3<f32>, f32, C, f32) -> f32
+fn image_sample_dref_explicit_lod[C: iu32, D: iu32](sampled_image<texture_depth_2d_array>, vec3<f32>, f32, C, f32, vec2<D>) -> f32
+fn image_sample_dref_explicit_lod[C: iu32](sampled_image<texture_depth_cube>, vec3<f32>, f32, C, f32) -> f32
+fn image_sample_dref_explicit_lod[C: iu32](sampled_image<texture_depth_cube_array>, vec4<f32>, f32, C, f32) -> f32
-fn image_write<C: iu32, D: iu32>(texture_storage_1d<f32_texel_format, writable>, C, vec4<f32>, D)
-fn image_write<C: iu32, D: iu32>(texture_storage_1d<i32_texel_format, writable>, C, vec4<i32>, D)
-fn image_write<C: iu32, D: iu32>(texture_storage_1d<u32_texel_format, writable>, C, vec4<u32>, D)
-fn image_write<C: iu32, D: iu32>(texture_storage_2d<f32_texel_format, writable>, vec2<C>, vec4<f32>, D)
-fn image_write<C: iu32, D: iu32>(texture_storage_2d<i32_texel_format, writable>, vec2<C>, vec4<i32>, D)
-fn image_write<C: iu32, D: iu32>(texture_storage_2d<u32_texel_format, writable>, vec2<C>, vec4<u32>, D)
-fn image_write<C: iu32, D: iu32>(texture_storage_2d_array<f32_texel_format, writable>, vec3<C>, vec4<f32>, D)
-fn image_write<C: iu32, D: iu32>(texture_storage_2d_array<i32_texel_format, writable>, vec3<C>, vec4<i32>, D)
-fn image_write<C: iu32, D: iu32>(texture_storage_2d_array<u32_texel_format, writable>, vec3<C>, vec4<u32>, D)
-fn image_write<C: iu32, D: iu32>(texture_storage_3d<f32_texel_format, writable>, vec3<C>, vec4<f32>, D)
-fn image_write<C: iu32, D: iu32>(texture_storage_3d<i32_texel_format, writable>, vec3<C>, vec4<i32>, D)
-fn image_write<C: iu32, D: iu32>(texture_storage_3d<u32_texel_format, writable>, vec3<C>, vec4<u32>, D)
+fn image_write[C: iu32, D: iu32](texture_storage_1d<f32_texel_format, writable>, C, vec4<f32>, D)
+fn image_write[C: iu32, D: iu32](texture_storage_1d<i32_texel_format, writable>, C, vec4<i32>, D)
+fn image_write[C: iu32, D: iu32](texture_storage_1d<u32_texel_format, writable>, C, vec4<u32>, D)
+fn image_write[C: iu32, D: iu32](texture_storage_2d<f32_texel_format, writable>, vec2<C>, vec4<f32>, D)
+fn image_write[C: iu32, D: iu32](texture_storage_2d<i32_texel_format, writable>, vec2<C>, vec4<i32>, D)
+fn image_write[C: iu32, D: iu32](texture_storage_2d<u32_texel_format, writable>, vec2<C>, vec4<u32>, D)
+fn image_write[C: iu32, D: iu32](texture_storage_2d_array<f32_texel_format, writable>, vec3<C>, vec4<f32>, D)
+fn image_write[C: iu32, D: iu32](texture_storage_2d_array<i32_texel_format, writable>, vec3<C>, vec4<i32>, D)
+fn image_write[C: iu32, D: iu32](texture_storage_2d_array<u32_texel_format, writable>, vec3<C>, vec4<u32>, D)
+fn image_write[C: iu32, D: iu32](texture_storage_3d<f32_texel_format, writable>, vec3<C>, vec4<f32>, D)
+fn image_write[C: iu32, D: iu32](texture_storage_3d<i32_texel_format, writable>, vec3<C>, vec4<i32>, D)
+fn image_write[C: iu32, D: iu32](texture_storage_3d<u32_texel_format, writable>, vec3<C>, vec4<u32>, D)
-fn matrix_times_matrix<T: f32_f16, K: num, C: num, R: num>(mat<K, R, T>, mat<C, K, T>) -> mat<C, R, T>
-fn matrix_times_scalar<T: f32_f16, N: num, M: num>(mat<N, M, T>, T) -> mat<N, M, T>
-fn matrix_times_vector<T: f32_f16, N: num, M: num>(mat<N, M, T>, vec<N, T>) -> vec<M, T>
+fn matrix_times_matrix[T: f32_f16, K: num, C: num, R: num](mat<K, R, T>, mat<C, K, T>) -> mat<C, R, T>
+fn matrix_times_scalar[T: f32_f16, N: num, M: num](mat<N, M, T>, T) -> mat<N, M, T>
+fn matrix_times_vector[T: f32_f16, N: num, M: num](mat<N, M, T>, vec<N, T>) -> vec<M, T>
-fn sampled_image<T: fiu32, S: samplers>(texture_1d<T>, S) -> sampled_image<texture_1d<T> >
-fn sampled_image<T: fiu32, S: samplers>(texture_2d<T>, S) -> sampled_image<texture_2d<T> >
-fn sampled_image<T: fiu32, S: samplers>(texture_2d_array<T>, S) -> sampled_image<texture_2d_array<T> >
-fn sampled_image<T: fiu32, S: samplers>(texture_3d<T>, S) -> sampled_image<texture_3d<T> >
-fn sampled_image<T: fiu32, S: samplers>(texture_cube<T>, S) -> sampled_image<texture_cube<T> >
-fn sampled_image<T: fiu32, S: samplers>(texture_cube_array<T>, S) -> sampled_image<texture_cube_array<T> >
-fn sampled_image<S: samplers>(texture_depth_2d, S) -> sampled_image<texture_depth_2d>
-fn sampled_image<S: samplers>(texture_depth_2d_array, S) -> sampled_image<texture_depth_2d_array>
-fn sampled_image<S: samplers>(texture_depth_cube, S) -> sampled_image<texture_depth_cube>
-fn sampled_image<S: samplers>(texture_depth_cube_array, S) -> sampled_image<texture_depth_cube_array>
+fn sampled_image[T: fiu32, S: samplers](texture_1d<T>, S) -> sampled_image<texture_1d<T> >
+fn sampled_image[T: fiu32, S: samplers](texture_2d<T>, S) -> sampled_image<texture_2d<T> >
+fn sampled_image[T: fiu32, S: samplers](texture_2d_array<T>, S) -> sampled_image<texture_2d_array<T> >
+fn sampled_image[T: fiu32, S: samplers](texture_3d<T>, S) -> sampled_image<texture_3d<T> >
+fn sampled_image[T: fiu32, S: samplers](texture_cube<T>, S) -> sampled_image<texture_cube<T> >
+fn sampled_image[T: fiu32, S: samplers](texture_cube_array<T>, S) -> sampled_image<texture_cube_array<T> >
+fn sampled_image[S: samplers](texture_depth_2d, S) -> sampled_image<texture_depth_2d>
+fn sampled_image[S: samplers](texture_depth_2d_array, S) -> sampled_image<texture_depth_2d_array>
+fn sampled_image[S: samplers](texture_depth_cube, S) -> sampled_image<texture_depth_cube>
+fn sampled_image[S: samplers](texture_depth_cube_array, S) -> sampled_image<texture_depth_cube_array>
-fn select<T: scalar>(bool, T, T) -> T
-fn select<N: num, T: scalar>(vec<N, bool>, vec<N, T>, vec<N, T>) -> vec<N, T>
+fn select[T: scalar](bool, T, T) -> T
+fn select[N: num, T: scalar](vec<N, bool>, vec<N, T>, vec<N, T>) -> vec<N, T>
-fn vector_times_matrix<T: f32_f16, N: num, M: num>(vec<N, T>, mat<M, N, T>) -> vec<M, T>
-fn vector_times_scalar<T: f32_f16, N: num>(vec<N, T>, T) -> vec<N, T>
+fn vector_times_matrix[T: f32_f16, N: num, M: num](vec<N, T>, mat<M, N, T>) -> vec<M, T>
+fn vector_times_scalar[T: f32_f16, N: num](vec<N, T>, T) -> vec<N, T>
////////////////////////////////////////////////////////////////////////////////
// SPV_KHR_integer_dot_product instructions
diff --git a/src/tint/lang/wgsl/wgsl.def b/src/tint/lang/wgsl/wgsl.def
index 33f2038..f3ef635 100644
--- a/src/tint/lang/wgsl/wgsl.def
+++ b/src/tint/lang/wgsl/wgsl.def
@@ -261,7 +261,7 @@
// //
// * Template type example without constraint: //
// //
-// fn arrayLength<T>(array<T>) -> u32 //
+// fn arrayLength[T](array<T>) -> u32 //
// //
// Declares an overload of the function 'arrayLength' that accepts a //
// single argument of an array type with no constraints on the array //
@@ -270,7 +270,7 @@
// //
// * Template type example with constraint: //
// //
-// fn abs<T: fiu32>(T) -> T //
+// fn abs[T: fiu32](T) -> T //
// //
// Declares an overload of the function 'abs' that accepts a single //
// argument of type 'f32', 'i32' or 'u32', which returns a value of the //
@@ -281,7 +281,7 @@
// //
// * Template number example: //
// //
-// fn dpdx<N: num>(vec<N, f32>) -> vec<N, f32> //
+// fn dpdx[N: num](vec<N, f32>) -> vec<N, f32> //
// //
// Declares an overload of the function 'dpdx' that accepts a single //
// argument of a variable-sized vector of 'f32', which returns a value of //
@@ -315,7 +315,7 @@
// To better understand, let's consider the following hypothetical overload //
// declaration: //
// //
-// fn foo<T: scalar>(T, T); //
+// fn foo[T: scalar](T, T); //
// //
// T - is the template type name //
// scalar - is a matcher for the types 'f32', 'i32', 'u32' or 'bool' //
@@ -386,21 +386,21 @@
// Note: Parameter names are used by Tint to infer parameter order for //
// some builtin functions //
// //
-// fn F<T>(T) //
+// fn F[T](T) //
// - Single parameter of unconstrained template type T (any type) //
// //
-// fn F<T: scalar>(T) //
+// fn F[T: scalar](T) //
// - Single parameter of constrained template type T (must be a scalar) //
// //
-// fn F<T: fiu32>(T) -> T //
+// fn F[T: fiu32](T) -> T //
// - Single parameter of constrained template type T (must be a one of //
// fiu32) Return type matches parameter type //
// //
-// fn F<T, N: num>(vec<N, T>) //
+// fn F[T, N: num](vec<N, T>) //
// - Single parameter of vector type with template number size N and //
// element template type T //
// //
-// fn F<A: access>(texture_storage_1d<f32_texel_format, A>) //
+// fn F[A: access](texture_storage_1d<f32_texel_format, A>) //
// - Single parameter of texture_storage_1d type with template number //
// access-control C, and of a texel format that is listed in //
// f32_texel_format //
@@ -408,109 +408,109 @@
////////////////////////////////////////////////////////////////////////////////
// https://gpuweb.github.io/gpuweb/wgsl/#builtin-functions
-@must_use @const fn abs<T: fia_fiu32_f16>(T) -> T
-@must_use @const fn abs<N: num, T: fia_fiu32_f16>(vec<N, T>) -> vec<N, T>
-@must_use @const fn acos<T: fa_f32_f16>(@test_value(0.96891242171) T) -> T
-@must_use @const fn acos<N: num, T: fa_f32_f16>(@test_value(0.96891242171) vec<N, T>) -> vec<N, T>
-@must_use @const fn acosh<T: fa_f32_f16>(@test_value(1.5430806348) T) -> T
-@must_use @const fn acosh<N: num, T: fa_f32_f16>(@test_value(1.5430806348) vec<N, T>) -> vec<N, T>
+@must_use @const fn abs[T: fia_fiu32_f16](T) -> T
+@must_use @const fn abs[N: num, T: fia_fiu32_f16](vec<N, T>) -> vec<N, T>
+@must_use @const fn acos[T: fa_f32_f16](@test_value(0.96891242171) T) -> T
+@must_use @const fn acos[N: num, T: fa_f32_f16](@test_value(0.96891242171) vec<N, T>) -> vec<N, T>
+@must_use @const fn acosh[T: fa_f32_f16](@test_value(1.5430806348) T) -> T
+@must_use @const fn acosh[N: num, T: fa_f32_f16](@test_value(1.5430806348) vec<N, T>) -> vec<N, T>
@must_use @const fn all(bool) -> bool
-@must_use @const fn all<N: num>(vec<N, bool>) -> bool
+@must_use @const fn all[N: num](vec<N, bool>) -> bool
@must_use @const fn any(bool) -> bool
-@must_use @const fn any<N: num>(vec<N, bool>) -> bool
-@must_use fn arrayLength<T, A: access>(ptr<storage, array<T>, A>) -> u32
-@must_use @const fn asin<T: fa_f32_f16>(@test_value(0.479425538604) T) -> T
-@must_use @const fn asin<N: num, T: fa_f32_f16>(@test_value(0.479425538604) vec<N, T>) -> vec<N, T>
-@must_use @const fn asinh<T: fa_f32_f16>(T) -> T
-@must_use @const fn asinh<N: num, T: fa_f32_f16>(vec<N, T>) -> vec<N, T>
-@must_use @const fn atan<T: fa_f32_f16>(T) -> T
-@must_use @const fn atan<N: num, T: fa_f32_f16>(vec<N, T>) -> vec<N, T>
-@must_use @const fn atan2<T: fa_f32_f16>(T, T) -> T
-@must_use @const fn atan2<T: fa_f32_f16, N: num>(vec<N, T>, vec<N, T>) -> vec<N, T>
-@must_use @const fn atanh<T: fa_f32_f16>(@test_value(0.5) T) -> T
-@must_use @const fn atanh<N: num, T: fa_f32_f16>(@test_value(0.5) vec<N, T>) -> vec<N, T>
-@must_use @const fn ceil<T: fa_f32_f16>(@test_value(1.5) T) -> T
-@must_use @const fn ceil<N: num, T: fa_f32_f16>(@test_value(1.5) vec<N, T>) -> vec<N, T>
-@must_use @const fn clamp<T: fia_fiu32_f16>(T, T, T) -> T
-@must_use @const fn clamp<T: fia_fiu32_f16, N: num>(vec<N, T>, vec<N, T>, vec<N, T>) -> vec<N, T>
-@must_use @const fn cos<T: fa_f32_f16>(@test_value(0) T) -> T
-@must_use @const fn cos<N: num, T: fa_f32_f16>(@test_value(0) vec<N, T>) -> vec<N, T>
-@must_use @const fn cosh<T: fa_f32_f16>(@test_value(0) T) -> T
-@must_use @const fn cosh<N: num, T: fa_f32_f16>(@test_value(0) vec<N, T>) -> vec<N, T>
-@must_use @const fn countLeadingZeros<T: iu32>(T) -> T
-@must_use @const fn countLeadingZeros<N: num, T: iu32>(vec<N, T>) -> vec<N, T>
-@must_use @const fn countOneBits<T: iu32>(T) -> T
-@must_use @const fn countOneBits<N: num, T: iu32>(vec<N, T>) -> vec<N, T>
-@must_use @const fn countTrailingZeros<T: iu32>(T) -> T
-@must_use @const fn countTrailingZeros<N: num, T: iu32>(vec<N, T>) -> vec<N, T>
-@must_use @const fn cross<T: fa_f32_f16>(vec3<T>, vec3<T>) -> vec3<T>
-@must_use @const fn degrees<T: fa_f32_f16>(T) -> T
-@must_use @const fn degrees<N: num, T: fa_f32_f16>(vec<N, T>) -> vec<N, T>
-@must_use @const fn determinant<N: num, T: fa_f32_f16>(mat<N, N, T>) -> T
-@must_use @const fn distance<T: fa_f32_f16>(T, T) -> T
-@must_use @const fn distance<N: num, T: fa_f32_f16>(vec<N, T>, vec<N, T>) -> T
-@must_use @const fn dot<N: num, T: fia_fiu32_f16>(vec<N, T>, vec<N, T>) -> T
+@must_use @const fn any[N: num](vec<N, bool>) -> bool
+@must_use fn arrayLength[T, A: access](ptr<storage, array<T>, A>) -> u32
+@must_use @const fn asin[T: fa_f32_f16](@test_value(0.479425538604) T) -> T
+@must_use @const fn asin[N: num, T: fa_f32_f16](@test_value(0.479425538604) vec<N, T>) -> vec<N, T>
+@must_use @const fn asinh[T: fa_f32_f16](T) -> T
+@must_use @const fn asinh[N: num, T: fa_f32_f16](vec<N, T>) -> vec<N, T>
+@must_use @const fn atan[T: fa_f32_f16](T) -> T
+@must_use @const fn atan[N: num, T: fa_f32_f16](vec<N, T>) -> vec<N, T>
+@must_use @const fn atan2[T: fa_f32_f16](T, T) -> T
+@must_use @const fn atan2[T: fa_f32_f16, N: num](vec<N, T>, vec<N, T>) -> vec<N, T>
+@must_use @const fn atanh[T: fa_f32_f16](@test_value(0.5) T) -> T
+@must_use @const fn atanh[N: num, T: fa_f32_f16](@test_value(0.5) vec<N, T>) -> vec<N, T>
+@must_use @const fn ceil[T: fa_f32_f16](@test_value(1.5) T) -> T
+@must_use @const fn ceil[N: num, T: fa_f32_f16](@test_value(1.5) vec<N, T>) -> vec<N, T>
+@must_use @const fn clamp[T: fia_fiu32_f16](T, T, T) -> T
+@must_use @const fn clamp[T: fia_fiu32_f16, N: num](vec<N, T>, vec<N, T>, vec<N, T>) -> vec<N, T>
+@must_use @const fn cos[T: fa_f32_f16](@test_value(0) T) -> T
+@must_use @const fn cos[N: num, T: fa_f32_f16](@test_value(0) vec<N, T>) -> vec<N, T>
+@must_use @const fn cosh[T: fa_f32_f16](@test_value(0) T) -> T
+@must_use @const fn cosh[N: num, T: fa_f32_f16](@test_value(0) vec<N, T>) -> vec<N, T>
+@must_use @const fn countLeadingZeros[T: iu32](T) -> T
+@must_use @const fn countLeadingZeros[N: num, T: iu32](vec<N, T>) -> vec<N, T>
+@must_use @const fn countOneBits[T: iu32](T) -> T
+@must_use @const fn countOneBits[N: num, T: iu32](vec<N, T>) -> vec<N, T>
+@must_use @const fn countTrailingZeros[T: iu32](T) -> T
+@must_use @const fn countTrailingZeros[N: num, T: iu32](vec<N, T>) -> vec<N, T>
+@must_use @const fn cross[T: fa_f32_f16](vec3<T>, vec3<T>) -> vec3<T>
+@must_use @const fn degrees[T: fa_f32_f16](T) -> T
+@must_use @const fn degrees[N: num, T: fa_f32_f16](vec<N, T>) -> vec<N, T>
+@must_use @const fn determinant[N: num, T: fa_f32_f16](mat<N, N, T>) -> T
+@must_use @const fn distance[T: fa_f32_f16](T, T) -> T
+@must_use @const fn distance[N: num, T: fa_f32_f16](vec<N, T>, vec<N, T>) -> T
+@must_use @const fn dot[N: num, T: fia_fiu32_f16](vec<N, T>, vec<N, T>) -> T
@must_use @const fn dot4I8Packed(u32, u32) -> i32
@must_use @const fn dot4U8Packed(u32, u32) -> u32
@must_use @stage("fragment") fn dpdx(f32) -> f32
-@must_use @stage("fragment") fn dpdx<N: num>(vec<N, f32>) -> vec<N, f32>
+@must_use @stage("fragment") fn dpdx[N: num](vec<N, f32>) -> vec<N, f32>
@must_use @stage("fragment") fn dpdxCoarse(f32) -> f32
-@must_use @stage("fragment") fn dpdxCoarse<N: num>(vec<N, f32>) -> vec<N, f32>
+@must_use @stage("fragment") fn dpdxCoarse[N: num](vec<N, f32>) -> vec<N, f32>
@must_use @stage("fragment") fn dpdxFine(f32) -> f32
-@must_use @stage("fragment") fn dpdxFine<N: num>(vec<N, f32>) -> vec<N, f32>
+@must_use @stage("fragment") fn dpdxFine[N: num](vec<N, f32>) -> vec<N, f32>
@must_use @stage("fragment") fn dpdy(f32) -> f32
-@must_use @stage("fragment") fn dpdy<N: num>(vec<N, f32>) -> vec<N, f32>
+@must_use @stage("fragment") fn dpdy[N: num](vec<N, f32>) -> vec<N, f32>
@must_use @stage("fragment") fn dpdyCoarse(f32) -> f32
-@must_use @stage("fragment") fn dpdyCoarse<N: num>(vec<N, f32>) -> vec<N, f32>
+@must_use @stage("fragment") fn dpdyCoarse[N: num](vec<N, f32>) -> vec<N, f32>
@must_use @stage("fragment") fn dpdyFine(f32) -> f32
-@must_use @stage("fragment") fn dpdyFine<N: num>(vec<N, f32>) -> vec<N, f32>
-@must_use @const fn exp<T: fa_f32_f16>(T) -> T
-@must_use @const fn exp<N: num, T: fa_f32_f16>(vec<N, T>) -> vec<N, T>
-@must_use @const fn exp2<T: fa_f32_f16>(T) -> T
-@must_use @const fn exp2<N: num, T: fa_f32_f16>(vec<N, T>) -> vec<N, T>
-@must_use @const fn extractBits<T: iu32>(T, u32, u32) -> T
-@must_use @const fn extractBits<N: num, T: iu32>(vec<N, T>, u32, u32) -> vec<N, T>
-@must_use @const fn faceForward<N: num, T: fa_f32_f16>(vec<N, T>, vec<N, T>, vec<N, T>) -> vec<N, T>
-@must_use @const fn firstLeadingBit<T: iu32>(T) -> T
-@must_use @const fn firstLeadingBit<N: num, T: iu32>(vec<N, T>) -> vec<N, T>
-@must_use @const fn firstTrailingBit<T: iu32>(T) -> T
-@must_use @const fn firstTrailingBit<N: num, T: iu32>(vec<N, T>) -> vec<N, T>
-@must_use @const fn floor<T: fa_f32_f16>(@test_value(1.5) T) -> T
-@must_use @const fn floor<N: num, T: fa_f32_f16>(@test_value(1.5) vec<N, T>) -> vec<N, T>
-@must_use @const fn fma<T: fa_f32_f16>(T, T, T) -> T
-@must_use @const fn fma<N: num, T: fa_f32_f16>(vec<N, T>, vec<N, T>, vec<N, T>) -> vec<N, T>
-@must_use @const fn fract<T: fa_f32_f16>(@test_value(1.25) T) -> T
-@must_use @const fn fract<N: num, T: fa_f32_f16>(@test_value(1.25) vec<N, T>) -> vec<N, T>
-@must_use @const fn frexp<T: fa_f32_f16>(T) -> __frexp_result<T>
-@must_use @const fn frexp<N: num, T: fa_f32_f16>(vec<N, T>) -> __frexp_result_vec<N, T>
+@must_use @stage("fragment") fn dpdyFine[N: num](vec<N, f32>) -> vec<N, f32>
+@must_use @const fn exp[T: fa_f32_f16](T) -> T
+@must_use @const fn exp[N: num, T: fa_f32_f16](vec<N, T>) -> vec<N, T>
+@must_use @const fn exp2[T: fa_f32_f16](T) -> T
+@must_use @const fn exp2[N: num, T: fa_f32_f16](vec<N, T>) -> vec<N, T>
+@must_use @const fn extractBits[T: iu32](T, u32, u32) -> T
+@must_use @const fn extractBits[N: num, T: iu32](vec<N, T>, u32, u32) -> vec<N, T>
+@must_use @const fn faceForward[N: num, T: fa_f32_f16](vec<N, T>, vec<N, T>, vec<N, T>) -> vec<N, T>
+@must_use @const fn firstLeadingBit[T: iu32](T) -> T
+@must_use @const fn firstLeadingBit[N: num, T: iu32](vec<N, T>) -> vec<N, T>
+@must_use @const fn firstTrailingBit[T: iu32](T) -> T
+@must_use @const fn firstTrailingBit[N: num, T: iu32](vec<N, T>) -> vec<N, T>
+@must_use @const fn floor[T: fa_f32_f16](@test_value(1.5) T) -> T
+@must_use @const fn floor[N: num, T: fa_f32_f16](@test_value(1.5) vec<N, T>) -> vec<N, T>
+@must_use @const fn fma[T: fa_f32_f16](T, T, T) -> T
+@must_use @const fn fma[N: num, T: fa_f32_f16](vec<N, T>, vec<N, T>, vec<N, T>) -> vec<N, T>
+@must_use @const fn fract[T: fa_f32_f16](@test_value(1.25) T) -> T
+@must_use @const fn fract[N: num, T: fa_f32_f16](@test_value(1.25) vec<N, T>) -> vec<N, T>
+@must_use @const fn frexp[T: fa_f32_f16](T) -> __frexp_result<T>
+@must_use @const fn frexp[N: num, T: fa_f32_f16](vec<N, T>) -> __frexp_result_vec<N, T>
@must_use @stage("fragment") fn fwidth(f32) -> f32
-@must_use @stage("fragment") fn fwidth<N: num>(vec<N, f32>) -> vec<N, f32>
+@must_use @stage("fragment") fn fwidth[N: num](vec<N, f32>) -> vec<N, f32>
@must_use @stage("fragment") fn fwidthCoarse(f32) -> f32
-@must_use @stage("fragment") fn fwidthCoarse<N: num>(vec<N, f32>) -> vec<N, f32>
+@must_use @stage("fragment") fn fwidthCoarse[N: num](vec<N, f32>) -> vec<N, f32>
@must_use @stage("fragment") fn fwidthFine(f32) -> f32
-@must_use @stage("fragment") fn fwidthFine<N: num>(vec<N, f32>) -> vec<N, f32>
-@must_use @const fn insertBits<T: iu32>(T, T, u32, u32) -> T
-@must_use @const fn insertBits<N: num, T: iu32>(vec<N, T>, vec<N, T>, u32, u32) -> vec<N, T>
-@must_use @const fn inverseSqrt<T: fa_f32_f16>(T) -> T
-@must_use @const fn inverseSqrt<N: num, T: fa_f32_f16>(vec<N, T>) -> vec<N, T>
-@must_use @const fn ldexp<T: fa_f32_f16, U: ia_i32>(T, U) -> T
-@must_use @const fn ldexp<N: num, T: fa_f32_f16, U: ia_i32>(vec<N, T>, vec<N, U>) -> vec<N, T>
-@must_use @const fn length<T: fa_f32_f16>(@test_value(0.0) T) -> T
-@must_use @const fn length<N: num, T: fa_f32_f16>(@test_value(0.0) vec<N, T>) -> T
-@must_use @const fn log<T: fa_f32_f16>(T) -> T
-@must_use @const fn log<N: num, T: fa_f32_f16>(vec<N, T>) -> vec<N, T>
-@must_use @const fn log2<T: fa_f32_f16>(T) -> T
-@must_use @const fn log2<N: num, T: fa_f32_f16>(vec<N, T>) -> vec<N, T>
-@must_use @const fn max<T: fia_fiu32_f16>(T, T) -> T
-@must_use @const fn max<N: num, T: fia_fiu32_f16>(vec<N, T>, vec<N, T>) -> vec<N, T>
-@must_use @const fn min<T: fia_fiu32_f16>(T, T) -> T
-@must_use @const fn min<N: num, T: fia_fiu32_f16>(vec<N, T>, vec<N, T>) -> vec<N, T>
-@must_use @const fn mix<T: fa_f32_f16>(T, T, T) -> T
-@must_use @const fn mix<N: num, T: fa_f32_f16>(vec<N, T>, vec<N, T>, vec<N, T>) -> vec<N, T>
-@must_use @const fn mix<N: num, T: fa_f32_f16>(vec<N, T>, vec<N, T>, T) -> vec<N, T>
-@must_use @const fn modf<T: fa_f32_f16>(@test_value(-1.5) T) -> __modf_result<T>
-@must_use @const fn modf<N: num, T: fa_f32_f16>(@test_value(-1.5) vec<N, T>) -> __modf_result_vec<N, T>
-@must_use @const fn normalize<N: num, T: fa_f32_f16>(vec<N, T>) -> vec<N, T>
+@must_use @stage("fragment") fn fwidthFine[N: num](vec<N, f32>) -> vec<N, f32>
+@must_use @const fn insertBits[T: iu32](T, T, u32, u32) -> T
+@must_use @const fn insertBits[N: num, T: iu32](vec<N, T>, vec<N, T>, u32, u32) -> vec<N, T>
+@must_use @const fn inverseSqrt[T: fa_f32_f16](T) -> T
+@must_use @const fn inverseSqrt[N: num, T: fa_f32_f16](vec<N, T>) -> vec<N, T>
+@must_use @const fn ldexp[T: fa_f32_f16, U: ia_i32](T, U) -> T
+@must_use @const fn ldexp[N: num, T: fa_f32_f16, U: ia_i32](vec<N, T>, vec<N, U>) -> vec<N, T>
+@must_use @const fn length[T: fa_f32_f16](@test_value(0.0) T) -> T
+@must_use @const fn length[N: num, T: fa_f32_f16](@test_value(0.0) vec<N, T>) -> T
+@must_use @const fn log[T: fa_f32_f16](T) -> T
+@must_use @const fn log[N: num, T: fa_f32_f16](vec<N, T>) -> vec<N, T>
+@must_use @const fn log2[T: fa_f32_f16](T) -> T
+@must_use @const fn log2[N: num, T: fa_f32_f16](vec<N, T>) -> vec<N, T>
+@must_use @const fn max[T: fia_fiu32_f16](T, T) -> T
+@must_use @const fn max[N: num, T: fia_fiu32_f16](vec<N, T>, vec<N, T>) -> vec<N, T>
+@must_use @const fn min[T: fia_fiu32_f16](T, T) -> T
+@must_use @const fn min[N: num, T: fia_fiu32_f16](vec<N, T>, vec<N, T>) -> vec<N, T>
+@must_use @const fn mix[T: fa_f32_f16](T, T, T) -> T
+@must_use @const fn mix[N: num, T: fa_f32_f16](vec<N, T>, vec<N, T>, vec<N, T>) -> vec<N, T>
+@must_use @const fn mix[N: num, T: fa_f32_f16](vec<N, T>, vec<N, T>, T) -> vec<N, T>
+@must_use @const fn modf[T: fa_f32_f16](@test_value(-1.5) T) -> __modf_result<T>
+@must_use @const fn modf[N: num, T: fa_f32_f16](@test_value(-1.5) vec<N, T>) -> __modf_result_vec<N, T>
+@must_use @const fn normalize[N: num, T: fa_f32_f16](vec<N, T>) -> vec<N, T>
@must_use @const fn pack2x16float(vec2<f32>) -> u32
@must_use @const fn pack2x16snorm(vec2<f32>) -> u32
@must_use @const fn pack2x16unorm(vec2<f32>) -> u32
@@ -520,43 +520,43 @@
@must_use @const fn pack4xU8(vec4<u32>) -> u32
@must_use @const fn pack4xI8Clamp(vec4<i32>) -> u32
@must_use @const fn pack4xU8Clamp(vec4<u32>) -> u32
-@must_use @const fn pow<T: fa_f32_f16>(T, T) -> T
-@must_use @const fn pow<N: num, T: fa_f32_f16>(vec<N, T>, vec<N, T>) -> vec<N, T>
+@must_use @const fn pow[T: fa_f32_f16](T, T) -> T
+@must_use @const fn pow[N: num, T: fa_f32_f16](vec<N, T>, vec<N, T>) -> vec<N, T>
@must_use @const fn quantizeToF16(f32) -> f32
-@must_use @const fn quantizeToF16<N: num>(vec<N, f32>) -> vec<N, f32>
-@must_use @const fn radians<T: fa_f32_f16>(T) -> T
-@must_use @const fn radians<N: num, T: fa_f32_f16>(vec<N, T>) -> vec<N, T>
-@must_use @const fn reflect<N: num, T: fa_f32_f16>(vec<N, T>, vec<N, T>) -> vec<N, T>
-@must_use @const fn refract<N: num, T: fa_f32_f16>(vec<N, T>, vec<N, T>, T) -> vec<N, T>
-@must_use @const fn reverseBits<T: iu32>(T) -> T
-@must_use @const fn reverseBits<N: num, T: iu32>(vec<N, T>) -> vec<N, T>
-@must_use @const fn round<T: fa_f32_f16>(@test_value(3.5) T) -> T
-@must_use @const fn round<N: num, T: fa_f32_f16>(@test_value(3.5) vec<N, T>) -> vec<N, T>
-@must_use @const fn saturate<T: fa_f32_f16>(@test_value(2) T) -> T
-@must_use @const fn saturate<T: fa_f32_f16, N: num>(@test_value(2) vec<N, T>) -> vec<N, T>
-@must_use @const("select_bool") fn select<T: scalar>(T, T, bool) -> T
-@must_use @const("select_bool") fn select<T: scalar, N: num>(vec<N, T>, vec<N, T>, bool) -> vec<N, T>
-@must_use @const("select_boolvec") fn select<N: num, T: scalar>(vec<N, T>, vec<N, T>, vec<N, bool>) -> vec<N, T>
-@must_use @const fn sign<T: fia_fi32_f16>(T) -> T
-@must_use @const fn sign<N: num, T: fia_fi32_f16>(vec<N, T>) -> vec<N, T>
-@must_use @const fn sin<T: fa_f32_f16>(@test_value(1.57079632679) T) -> T
-@must_use @const fn sin<N: num, T: fa_f32_f16>(@test_value(1.57079632679) vec<N, T>) -> vec<N, T>
-@must_use @const fn sinh<T: fa_f32_f16>(T) -> T
-@must_use @const fn sinh<N: num, T: fa_f32_f16>(vec<N, T>) -> vec<N, T>
-@must_use @const fn smoothstep<T: fa_f32_f16>(@test_value(2) T, @test_value(4) T, @test_value(3) T) -> T
-@must_use @const fn smoothstep<N: num, T: fa_f32_f16>(@test_value(2) vec<N, T>, @test_value(4) vec<N, T>, @test_value(3) vec<N, T>) -> vec<N, T>
-@must_use @const fn sqrt<T: fa_f32_f16>(T) -> T
-@must_use @const fn sqrt<N: num, T: fa_f32_f16>(vec<N, T>) -> vec<N, T>
-@must_use @const fn step<T: fa_f32_f16>(T, T) -> T
-@must_use @const fn step<N: num, T: fa_f32_f16>(vec<N, T>, vec<N, T>) -> vec<N, T>
+@must_use @const fn quantizeToF16[N: num](vec<N, f32>) -> vec<N, f32>
+@must_use @const fn radians[T: fa_f32_f16](T) -> T
+@must_use @const fn radians[N: num, T: fa_f32_f16](vec<N, T>) -> vec<N, T>
+@must_use @const fn reflect[N: num, T: fa_f32_f16](vec<N, T>, vec<N, T>) -> vec<N, T>
+@must_use @const fn refract[N: num, T: fa_f32_f16](vec<N, T>, vec<N, T>, T) -> vec<N, T>
+@must_use @const fn reverseBits[T: iu32](T) -> T
+@must_use @const fn reverseBits[N: num, T: iu32](vec<N, T>) -> vec<N, T>
+@must_use @const fn round[T: fa_f32_f16](@test_value(3.5) T) -> T
+@must_use @const fn round[N: num, T: fa_f32_f16](@test_value(3.5) vec<N, T>) -> vec<N, T>
+@must_use @const fn saturate[T: fa_f32_f16](@test_value(2) T) -> T
+@must_use @const fn saturate[T: fa_f32_f16, N: num](@test_value(2) vec<N, T>) -> vec<N, T>
+@must_use @const("select_bool") fn select[T: scalar](T, T, bool) -> T
+@must_use @const("select_bool") fn select[T: scalar, N: num](vec<N, T>, vec<N, T>, bool) -> vec<N, T>
+@must_use @const("select_boolvec") fn select[N: num, T: scalar](vec<N, T>, vec<N, T>, vec<N, bool>) -> vec<N, T>
+@must_use @const fn sign[T: fia_fi32_f16](T) -> T
+@must_use @const fn sign[N: num, T: fia_fi32_f16](vec<N, T>) -> vec<N, T>
+@must_use @const fn sin[T: fa_f32_f16](@test_value(1.57079632679) T) -> T
+@must_use @const fn sin[N: num, T: fa_f32_f16](@test_value(1.57079632679) vec<N, T>) -> vec<N, T>
+@must_use @const fn sinh[T: fa_f32_f16](T) -> T
+@must_use @const fn sinh[N: num, T: fa_f32_f16](vec<N, T>) -> vec<N, T>
+@must_use @const fn smoothstep[T: fa_f32_f16](@test_value(2) T, @test_value(4) T, @test_value(3) T) -> T
+@must_use @const fn smoothstep[N: num, T: fa_f32_f16](@test_value(2) vec<N, T>, @test_value(4) vec<N, T>, @test_value(3) vec<N, T>) -> vec<N, T>
+@must_use @const fn sqrt[T: fa_f32_f16](T) -> T
+@must_use @const fn sqrt[N: num, T: fa_f32_f16](vec<N, T>) -> vec<N, T>
+@must_use @const fn step[T: fa_f32_f16](T, T) -> T
+@must_use @const fn step[N: num, T: fa_f32_f16](vec<N, T>, vec<N, T>) -> vec<N, T>
@stage("compute") fn storageBarrier()
-@must_use @const fn tan<T: fa_f32_f16>(T) -> T
-@must_use @const fn tan<N: num, T: fa_f32_f16>(vec<N, T>) -> vec<N, T>
-@must_use @const fn tanh<T: fa_f32_f16>(T) -> T
-@must_use @const fn tanh<N: num, T: fa_f32_f16>(vec<N, T>) -> vec<N, T>
-@must_use @const fn transpose<M: num, N: num, T: fa_f32_f16>(mat<M, N, T>) -> mat<N, M, T>
-@must_use @const fn trunc<T: fa_f32_f16>(@test_value(1.5) T) -> T
-@must_use @const fn trunc<N: num, T: fa_f32_f16>(@test_value(1.5) vec<N, T>) -> vec<N, T>
+@must_use @const fn tan[T: fa_f32_f16](T) -> T
+@must_use @const fn tan[N: num, T: fa_f32_f16](vec<N, T>) -> vec<N, T>
+@must_use @const fn tanh[T: fa_f32_f16](T) -> T
+@must_use @const fn tanh[N: num, T: fa_f32_f16](vec<N, T>) -> vec<N, T>
+@must_use @const fn transpose[M: num, N: num, T: fa_f32_f16](mat<M, N, T>) -> mat<N, M, T>
+@must_use @const fn trunc[T: fa_f32_f16](@test_value(1.5) T) -> T
+@must_use @const fn trunc[N: num, T: fa_f32_f16](@test_value(1.5) vec<N, T>) -> vec<N, T>
@must_use @const fn unpack2x16float(u32) -> vec2<f32>
@must_use @const fn unpack2x16snorm(u32) -> vec2<f32>
@must_use @const fn unpack2x16unorm(u32) -> vec2<f32>
@@ -565,179 +565,179 @@
@must_use @const fn unpack4xI8(u32) -> vec4<i32>
@must_use @const fn unpack4xU8(u32) -> vec4<u32>
@stage("compute") fn workgroupBarrier()
-@must_use @stage("compute") fn workgroupUniformLoad<T>(ptr<workgroup, T, read_write>) -> T
+@must_use @stage("compute") fn workgroupUniformLoad[T](ptr<workgroup, T, read_write>) -> T
@stage("compute") fn textureBarrier()
-@must_use fn textureDimensions<T: fiu32>(texture: texture_1d<T>) -> u32
-@must_use fn textureDimensions<T: fiu32, L: iu32>(texture: texture_1d<T>, level: L) -> u32
-@must_use fn textureDimensions<T: fiu32>(texture: texture_2d<T>) -> vec2<u32>
-@must_use fn textureDimensions<T: fiu32, L: iu32>(texture: texture_2d<T>, level: L) -> vec2<u32>
-@must_use fn textureDimensions<T: fiu32>(texture: texture_2d_array<T>) -> vec2<u32>
-@must_use fn textureDimensions<T: fiu32, L: iu32>(texture: texture_2d_array<T>, level: L) -> vec2<u32>
-@must_use fn textureDimensions<T: fiu32>(texture: texture_3d<T>) -> vec3<u32>
-@must_use fn textureDimensions<T: fiu32, L: iu32>(texture: texture_3d<T>, level: L) -> vec3<u32>
-@must_use fn textureDimensions<T: fiu32>(texture: texture_cube<T>) -> vec2<u32>
-@must_use fn textureDimensions<T: fiu32, L: iu32>(texture: texture_cube<T>, level: L) -> vec2<u32>
-@must_use fn textureDimensions<T: fiu32>(texture: texture_cube_array<T>) -> vec2<u32>
-@must_use fn textureDimensions<T: fiu32, L: iu32>(texture: texture_cube_array<T>, level: L) -> vec2<u32>
-@must_use fn textureDimensions<T: fiu32>(texture: texture_multisampled_2d<T>) -> vec2<u32>
+@must_use fn textureDimensions[T: fiu32](texture: texture_1d<T>) -> u32
+@must_use fn textureDimensions[T: fiu32, L: iu32](texture: texture_1d<T>, level: L) -> u32
+@must_use fn textureDimensions[T: fiu32](texture: texture_2d<T>) -> vec2<u32>
+@must_use fn textureDimensions[T: fiu32, L: iu32](texture: texture_2d<T>, level: L) -> vec2<u32>
+@must_use fn textureDimensions[T: fiu32](texture: texture_2d_array<T>) -> vec2<u32>
+@must_use fn textureDimensions[T: fiu32, L: iu32](texture: texture_2d_array<T>, level: L) -> vec2<u32>
+@must_use fn textureDimensions[T: fiu32](texture: texture_3d<T>) -> vec3<u32>
+@must_use fn textureDimensions[T: fiu32, L: iu32](texture: texture_3d<T>, level: L) -> vec3<u32>
+@must_use fn textureDimensions[T: fiu32](texture: texture_cube<T>) -> vec2<u32>
+@must_use fn textureDimensions[T: fiu32, L: iu32](texture: texture_cube<T>, level: L) -> vec2<u32>
+@must_use fn textureDimensions[T: fiu32](texture: texture_cube_array<T>) -> vec2<u32>
+@must_use fn textureDimensions[T: fiu32, L: iu32](texture: texture_cube_array<T>, level: L) -> vec2<u32>
+@must_use fn textureDimensions[T: fiu32](texture: texture_multisampled_2d<T>) -> vec2<u32>
@must_use fn textureDimensions(texture: texture_depth_2d) -> vec2<u32>
-@must_use fn textureDimensions<L: iu32>(texture: texture_depth_2d, level: L) -> vec2<u32>
+@must_use fn textureDimensions[L: iu32](texture: texture_depth_2d, level: L) -> vec2<u32>
@must_use fn textureDimensions(texture: texture_depth_2d_array) -> vec2<u32>
-@must_use fn textureDimensions<L: iu32>(texture: texture_depth_2d_array, level: L) -> vec2<u32>
+@must_use fn textureDimensions[L: iu32](texture: texture_depth_2d_array, level: L) -> vec2<u32>
@must_use fn textureDimensions(texture: texture_depth_cube) -> vec2<u32>
-@must_use fn textureDimensions<L: iu32>(texture: texture_depth_cube, level: L) -> vec2<u32>
+@must_use fn textureDimensions[L: iu32](texture: texture_depth_cube, level: L) -> vec2<u32>
@must_use fn textureDimensions(texture: texture_depth_cube_array) -> vec2<u32>
-@must_use fn textureDimensions<L: iu32>(texture: texture_depth_cube_array, level: L) -> vec2<u32>
+@must_use fn textureDimensions[L: iu32](texture: texture_depth_cube_array, level: L) -> vec2<u32>
@must_use fn textureDimensions(texture: texture_depth_multisampled_2d) -> vec2<u32>
-@must_use fn textureDimensions<F: texel_format, A: access>(texture: texture_storage_1d<F, A>) -> u32
-@must_use fn textureDimensions<F: texel_format, A: access>(texture: texture_storage_2d<F, A>) -> vec2<u32>
-@must_use fn textureDimensions<F: texel_format, A: access>(texture: texture_storage_2d_array<F, A>) -> vec2<u32>
-@must_use fn textureDimensions<F: texel_format, A: access>(texture: texture_storage_3d<F, A>) -> vec3<u32>
+@must_use fn textureDimensions[F: texel_format, A: access](texture: texture_storage_1d<F, A>) -> u32
+@must_use fn textureDimensions[F: texel_format, A: access](texture: texture_storage_2d<F, A>) -> vec2<u32>
+@must_use fn textureDimensions[F: texel_format, A: access](texture: texture_storage_2d_array<F, A>) -> vec2<u32>
+@must_use fn textureDimensions[F: texel_format, A: access](texture: texture_storage_3d<F, A>) -> vec3<u32>
@must_use fn textureDimensions(texture: texture_external) -> vec2<u32>
-@must_use fn textureGather<T: fiu32, C: iu32>(@const component: C, texture: texture_2d<T>, sampler: sampler, coords: vec2<f32>) -> vec4<T>
-@must_use fn textureGather<T: fiu32, C: iu32>(@const component: C, texture: texture_2d<T>, sampler: sampler, coords: vec2<f32>, @const offset: vec2<i32>) -> vec4<T>
-@must_use fn textureGather<T: fiu32, C: iu32, A: iu32>(@const component: C, texture: texture_2d_array<T>, sampler: sampler, coords: vec2<f32>, array_index: A) -> vec4<T>
-@must_use fn textureGather<T: fiu32, C: iu32, A: iu32>(@const component: C, texture: texture_2d_array<T>, sampler: sampler, coords: vec2<f32>, array_index: A, @const offset: vec2<i32>) -> vec4<T>
-@must_use fn textureGather<T: fiu32, C: iu32>(@const component: C, texture: texture_cube<T>, sampler: sampler, coords: vec3<f32>) -> vec4<T>
-@must_use fn textureGather<T: fiu32, C: iu32, A: iu32>(@const component: C, texture: texture_cube_array<T>, sampler: sampler, coords: vec3<f32>, array_index: A) -> vec4<T>
+@must_use fn textureGather[T: fiu32, C: iu32](@const component: C, texture: texture_2d<T>, sampler: sampler, coords: vec2<f32>) -> vec4<T>
+@must_use fn textureGather[T: fiu32, C: iu32](@const component: C, texture: texture_2d<T>, sampler: sampler, coords: vec2<f32>, @const offset: vec2<i32>) -> vec4<T>
+@must_use fn textureGather[T: fiu32, C: iu32, A: iu32](@const component: C, texture: texture_2d_array<T>, sampler: sampler, coords: vec2<f32>, array_index: A) -> vec4<T>
+@must_use fn textureGather[T: fiu32, C: iu32, A: iu32](@const component: C, texture: texture_2d_array<T>, sampler: sampler, coords: vec2<f32>, array_index: A, @const offset: vec2<i32>) -> vec4<T>
+@must_use fn textureGather[T: fiu32, C: iu32](@const component: C, texture: texture_cube<T>, sampler: sampler, coords: vec3<f32>) -> vec4<T>
+@must_use fn textureGather[T: fiu32, C: iu32, A: iu32](@const component: C, texture: texture_cube_array<T>, sampler: sampler, coords: vec3<f32>, array_index: A) -> vec4<T>
@must_use fn textureGather(texture: texture_depth_2d, sampler: sampler, coords: vec2<f32>) -> vec4<f32>
@must_use fn textureGather(texture: texture_depth_2d, sampler: sampler, coords: vec2<f32>, @const offset: vec2<i32>) -> vec4<f32>
-@must_use fn textureGather<A: iu32>(texture: texture_depth_2d_array, sampler: sampler, coords: vec2<f32>, array_index: A) -> vec4<f32>
-@must_use fn textureGather<A: iu32>(texture: texture_depth_2d_array, sampler: sampler, coords: vec2<f32>, array_index: A, @const offset: vec2<i32>) -> vec4<f32>
+@must_use fn textureGather[A: iu32](texture: texture_depth_2d_array, sampler: sampler, coords: vec2<f32>, array_index: A) -> vec4<f32>
+@must_use fn textureGather[A: iu32](texture: texture_depth_2d_array, sampler: sampler, coords: vec2<f32>, array_index: A, @const offset: vec2<i32>) -> vec4<f32>
@must_use fn textureGather(texture: texture_depth_cube, sampler: sampler, coords: vec3<f32>) -> vec4<f32>
-@must_use fn textureGather<A: iu32>(texture: texture_depth_cube_array, sampler: sampler, coords: vec3<f32>, array_index: A) -> vec4<f32>
+@must_use fn textureGather[A: iu32](texture: texture_depth_cube_array, sampler: sampler, coords: vec3<f32>, array_index: A) -> vec4<f32>
@must_use fn textureGatherCompare(texture: texture_depth_2d, sampler: sampler_comparison, coords: vec2<f32>, depth_ref: f32) -> vec4<f32>
@must_use fn textureGatherCompare(texture: texture_depth_2d, sampler: sampler_comparison, coords: vec2<f32>, depth_ref: f32, @const offset: vec2<i32>) -> vec4<f32>
-@must_use fn textureGatherCompare<A: iu32>(texture: texture_depth_2d_array, sampler: sampler_comparison, coords: vec2<f32>, array_index: A, depth_ref: f32) -> vec4<f32>
-@must_use fn textureGatherCompare<A: iu32>(texture: texture_depth_2d_array, sampler: sampler_comparison, coords: vec2<f32>, array_index: A, depth_ref: f32, @const offset: vec2<i32>) -> vec4<f32>
+@must_use fn textureGatherCompare[A: iu32](texture: texture_depth_2d_array, sampler: sampler_comparison, coords: vec2<f32>, array_index: A, depth_ref: f32) -> vec4<f32>
+@must_use fn textureGatherCompare[A: iu32](texture: texture_depth_2d_array, sampler: sampler_comparison, coords: vec2<f32>, array_index: A, depth_ref: f32, @const offset: vec2<i32>) -> vec4<f32>
@must_use fn textureGatherCompare(texture: texture_depth_cube, sampler: sampler_comparison, coords: vec3<f32>, depth_ref: f32) -> vec4<f32>
-@must_use fn textureGatherCompare<A: iu32>(texture: texture_depth_cube_array, sampler: sampler_comparison, coords: vec3<f32>, array_index: A, depth_ref: f32) -> vec4<f32>
-@must_use fn textureNumLayers<T: fiu32>(texture: texture_2d_array<T>) -> u32
-@must_use fn textureNumLayers<T: fiu32>(texture: texture_cube_array<T>) -> u32
+@must_use fn textureGatherCompare[A: iu32](texture: texture_depth_cube_array, sampler: sampler_comparison, coords: vec3<f32>, array_index: A, depth_ref: f32) -> vec4<f32>
+@must_use fn textureNumLayers[T: fiu32](texture: texture_2d_array<T>) -> u32
+@must_use fn textureNumLayers[T: fiu32](texture: texture_cube_array<T>) -> u32
@must_use fn textureNumLayers(texture: texture_depth_2d_array) -> u32
@must_use fn textureNumLayers(texture: texture_depth_cube_array) -> u32
-@must_use fn textureNumLayers<F: texel_format, A: access>(texture: texture_storage_2d_array<F, A>) -> u32
-@must_use fn textureNumLevels<T: fiu32>(texture: texture_1d<T>) -> u32
-@must_use fn textureNumLevels<T: fiu32>(texture: texture_2d<T>) -> u32
-@must_use fn textureNumLevels<T: fiu32>(texture: texture_2d_array<T>) -> u32
-@must_use fn textureNumLevels<T: fiu32>(texture: texture_3d<T>) -> u32
-@must_use fn textureNumLevels<T: fiu32>(texture: texture_cube<T>) -> u32
-@must_use fn textureNumLevels<T: fiu32>(texture: texture_cube_array<T>) -> u32
+@must_use fn textureNumLayers[F: texel_format, A: access](texture: texture_storage_2d_array<F, A>) -> u32
+@must_use fn textureNumLevels[T: fiu32](texture: texture_1d<T>) -> u32
+@must_use fn textureNumLevels[T: fiu32](texture: texture_2d<T>) -> u32
+@must_use fn textureNumLevels[T: fiu32](texture: texture_2d_array<T>) -> u32
+@must_use fn textureNumLevels[T: fiu32](texture: texture_3d<T>) -> u32
+@must_use fn textureNumLevels[T: fiu32](texture: texture_cube<T>) -> u32
+@must_use fn textureNumLevels[T: fiu32](texture: texture_cube_array<T>) -> u32
@must_use fn textureNumLevels(texture: texture_depth_2d) -> u32
@must_use fn textureNumLevels(texture: texture_depth_2d_array) -> u32
@must_use fn textureNumLevels(texture: texture_depth_cube) -> u32
@must_use fn textureNumLevels(texture: texture_depth_cube_array) -> u32
-@must_use fn textureNumSamples<T: fiu32>(texture: texture_multisampled_2d<T>) -> u32
+@must_use fn textureNumSamples[T: fiu32](texture: texture_multisampled_2d<T>) -> u32
@must_use fn textureNumSamples(texture: texture_depth_multisampled_2d) -> u32
@must_use @stage("fragment") fn textureSample(texture: texture_1d<f32>, sampler: sampler, coords: f32) -> vec4<f32>
@must_use @stage("fragment") fn textureSample(texture: texture_2d<f32>, sampler: sampler, coords: vec2<f32>) -> vec4<f32>
@must_use @stage("fragment") fn textureSample(texture: texture_2d<f32>, sampler: sampler, coords: vec2<f32>, @const offset: vec2<i32>) -> vec4<f32>
-@must_use @stage("fragment") fn textureSample<A: iu32>(texture: texture_2d_array<f32>, sampler: sampler, coords: vec2<f32>, array_index: A) -> vec4<f32>
-@must_use @stage("fragment") fn textureSample<A: iu32>(texture: texture_2d_array<f32>, sampler: sampler, coords: vec2<f32>, array_index: A, @const offset: vec2<i32>) -> vec4<f32>
+@must_use @stage("fragment") fn textureSample[A: iu32](texture: texture_2d_array<f32>, sampler: sampler, coords: vec2<f32>, array_index: A) -> vec4<f32>
+@must_use @stage("fragment") fn textureSample[A: iu32](texture: texture_2d_array<f32>, sampler: sampler, coords: vec2<f32>, array_index: A, @const offset: vec2<i32>) -> vec4<f32>
@must_use @stage("fragment") fn textureSample(texture: texture_3d<f32>, sampler: sampler, coords: vec3<f32>) -> vec4<f32>
@must_use @stage("fragment") fn textureSample(texture: texture_3d<f32>, sampler: sampler, coords: vec3<f32>, @const offset: vec3<i32>) -> vec4<f32>
@must_use @stage("fragment") fn textureSample(texture: texture_cube<f32>, sampler: sampler, coords: vec3<f32>) -> vec4<f32>
-@must_use @stage("fragment") fn textureSample<A: iu32>(texture: texture_cube_array<f32>, sampler: sampler, coords: vec3<f32>, array_index: A) -> vec4<f32>
+@must_use @stage("fragment") fn textureSample[A: iu32](texture: texture_cube_array<f32>, sampler: sampler, coords: vec3<f32>, array_index: A) -> vec4<f32>
@must_use @stage("fragment") fn textureSample(texture: texture_depth_2d, sampler: sampler, coords: vec2<f32>) -> f32
@must_use @stage("fragment") fn textureSample(texture: texture_depth_2d, sampler: sampler, coords: vec2<f32>, @const offset: vec2<i32>) -> f32
-@must_use @stage("fragment") fn textureSample<A: iu32>(texture: texture_depth_2d_array, sampler: sampler, coords: vec2<f32>, array_index: A) -> f32
-@must_use @stage("fragment") fn textureSample<A: iu32>(texture: texture_depth_2d_array, sampler: sampler, coords: vec2<f32>, array_index: A, @const offset: vec2<i32>) -> f32
+@must_use @stage("fragment") fn textureSample[A: iu32](texture: texture_depth_2d_array, sampler: sampler, coords: vec2<f32>, array_index: A) -> f32
+@must_use @stage("fragment") fn textureSample[A: iu32](texture: texture_depth_2d_array, sampler: sampler, coords: vec2<f32>, array_index: A, @const offset: vec2<i32>) -> f32
@must_use @stage("fragment") fn textureSample(texture: texture_depth_cube, sampler: sampler, coords: vec3<f32>) -> f32
-@must_use @stage("fragment") fn textureSample<A: iu32>(texture: texture_depth_cube_array, sampler: sampler, coords: vec3<f32>, array_index: A) -> f32
+@must_use @stage("fragment") fn textureSample[A: iu32](texture: texture_depth_cube_array, sampler: sampler, coords: vec3<f32>, array_index: A) -> f32
@must_use @stage("fragment") fn textureSampleBias(texture: texture_2d<f32>, sampler: sampler, coords: vec2<f32>, bias: f32) -> vec4<f32>
@must_use @stage("fragment") fn textureSampleBias(texture: texture_2d<f32>, sampler: sampler, coords: vec2<f32>, bias: f32, @const offset: vec2<i32>) -> vec4<f32>
-@must_use @stage("fragment") fn textureSampleBias<A: iu32>(texture: texture_2d_array<f32>, sampler: sampler, coords: vec2<f32>, array_index: A, bias: f32) -> vec4<f32>
-@must_use @stage("fragment") fn textureSampleBias<A: iu32>(texture: texture_2d_array<f32>, sampler: sampler, coords: vec2<f32>, array_index: A, bias: f32, @const offset: vec2<i32>) -> vec4<f32>
+@must_use @stage("fragment") fn textureSampleBias[A: iu32](texture: texture_2d_array<f32>, sampler: sampler, coords: vec2<f32>, array_index: A, bias: f32) -> vec4<f32>
+@must_use @stage("fragment") fn textureSampleBias[A: iu32](texture: texture_2d_array<f32>, sampler: sampler, coords: vec2<f32>, array_index: A, bias: f32, @const offset: vec2<i32>) -> vec4<f32>
@must_use @stage("fragment") fn textureSampleBias(texture: texture_3d<f32>, sampler: sampler, coords: vec3<f32>, bias: f32) -> vec4<f32>
@must_use @stage("fragment") fn textureSampleBias(texture: texture_3d<f32>, sampler: sampler, coords: vec3<f32>, bias: f32, @const offset: vec3<i32>) -> vec4<f32>
@must_use @stage("fragment") fn textureSampleBias(texture: texture_cube<f32>, sampler: sampler, coords: vec3<f32>, bias: f32) -> vec4<f32>
-@must_use @stage("fragment") fn textureSampleBias<A: iu32>(texture: texture_cube_array<f32>, sampler: sampler, coords: vec3<f32>, array_index: A, bias: f32) -> vec4<f32>
+@must_use @stage("fragment") fn textureSampleBias[A: iu32](texture: texture_cube_array<f32>, sampler: sampler, coords: vec3<f32>, array_index: A, bias: f32) -> vec4<f32>
@must_use @stage("fragment") fn textureSampleCompare(texture: texture_depth_2d, sampler: sampler_comparison, coords: vec2<f32>, depth_ref: f32) -> f32
@must_use @stage("fragment") fn textureSampleCompare(texture: texture_depth_2d, sampler: sampler_comparison, coords: vec2<f32>, depth_ref: f32, @const offset: vec2<i32>) -> f32
-@must_use @stage("fragment") fn textureSampleCompare<A: iu32>(texture: texture_depth_2d_array, sampler: sampler_comparison, coords: vec2<f32>, array_index: A, depth_ref: f32) -> f32
-@must_use @stage("fragment") fn textureSampleCompare<A: iu32>(texture: texture_depth_2d_array, sampler: sampler_comparison, coords: vec2<f32>, array_index: A, depth_ref: f32, @const offset: vec2<i32>) -> f32
+@must_use @stage("fragment") fn textureSampleCompare[A: iu32](texture: texture_depth_2d_array, sampler: sampler_comparison, coords: vec2<f32>, array_index: A, depth_ref: f32) -> f32
+@must_use @stage("fragment") fn textureSampleCompare[A: iu32](texture: texture_depth_2d_array, sampler: sampler_comparison, coords: vec2<f32>, array_index: A, depth_ref: f32, @const offset: vec2<i32>) -> f32
@must_use @stage("fragment") fn textureSampleCompare(texture: texture_depth_cube, sampler: sampler_comparison, coords: vec3<f32>, depth_ref: f32) -> f32
-@must_use @stage("fragment") fn textureSampleCompare<A: iu32>(texture: texture_depth_cube_array, sampler: sampler_comparison, coords: vec3<f32>, array_index: A, depth_ref: f32) -> f32
+@must_use @stage("fragment") fn textureSampleCompare[A: iu32](texture: texture_depth_cube_array, sampler: sampler_comparison, coords: vec3<f32>, array_index: A, depth_ref: f32) -> f32
@must_use fn textureSampleCompareLevel(texture: texture_depth_2d, sampler: sampler_comparison, coords: vec2<f32>, depth_ref: f32) -> f32
@must_use fn textureSampleCompareLevel(texture: texture_depth_2d, sampler: sampler_comparison, coords: vec2<f32>, depth_ref: f32, @const offset: vec2<i32>) -> f32
-@must_use fn textureSampleCompareLevel<A: iu32>(texture: texture_depth_2d_array, sampler: sampler_comparison, coords: vec2<f32>, array_index: A, depth_ref: f32) -> f32
-@must_use fn textureSampleCompareLevel<A: iu32>(texture: texture_depth_2d_array, sampler: sampler_comparison, coords: vec2<f32>, array_index: A, depth_ref: f32, @const offset: vec2<i32>) -> f32
+@must_use fn textureSampleCompareLevel[A: iu32](texture: texture_depth_2d_array, sampler: sampler_comparison, coords: vec2<f32>, array_index: A, depth_ref: f32) -> f32
+@must_use fn textureSampleCompareLevel[A: iu32](texture: texture_depth_2d_array, sampler: sampler_comparison, coords: vec2<f32>, array_index: A, depth_ref: f32, @const offset: vec2<i32>) -> f32
@must_use fn textureSampleCompareLevel(texture: texture_depth_cube, sampler: sampler_comparison, coords: vec3<f32>, depth_ref: f32) -> f32
-@must_use fn textureSampleCompareLevel<A: iu32>(texture: texture_depth_cube_array, sampler: sampler_comparison, coords: vec3<f32>, array_index: A, depth_ref: f32) -> f32
+@must_use fn textureSampleCompareLevel[A: iu32](texture: texture_depth_cube_array, sampler: sampler_comparison, coords: vec3<f32>, array_index: A, depth_ref: f32) -> f32
@must_use fn textureSampleGrad(texture: texture_2d<f32>, sampler: sampler, coords: vec2<f32>, ddx: vec2<f32>, ddy: vec2<f32>) -> vec4<f32>
@must_use fn textureSampleGrad(texture: texture_2d<f32>, sampler: sampler, coords: vec2<f32>, ddx: vec2<f32>, ddy: vec2<f32>, @const offset: vec2<i32>) -> vec4<f32>
-@must_use fn textureSampleGrad<A: iu32>(texture: texture_2d_array<f32>, sampler: sampler, coords: vec2<f32>, array_index: A, ddx: vec2<f32>, ddy: vec2<f32>) -> vec4<f32>
-@must_use fn textureSampleGrad<A: iu32>(texture: texture_2d_array<f32>, sampler: sampler, coords: vec2<f32>, array_index: A, ddx: vec2<f32>, ddy: vec2<f32>, @const offset: vec2<i32>) -> vec4<f32>
+@must_use fn textureSampleGrad[A: iu32](texture: texture_2d_array<f32>, sampler: sampler, coords: vec2<f32>, array_index: A, ddx: vec2<f32>, ddy: vec2<f32>) -> vec4<f32>
+@must_use fn textureSampleGrad[A: iu32](texture: texture_2d_array<f32>, sampler: sampler, coords: vec2<f32>, array_index: A, ddx: vec2<f32>, ddy: vec2<f32>, @const offset: vec2<i32>) -> vec4<f32>
@must_use fn textureSampleGrad(texture: texture_3d<f32>, sampler: sampler, coords: vec3<f32>, ddx: vec3<f32>, ddy: vec3<f32>) -> vec4<f32>
@must_use fn textureSampleGrad(texture: texture_3d<f32>, sampler: sampler, coords: vec3<f32>, ddx: vec3<f32>, ddy: vec3<f32>, @const offset: vec3<i32>) -> vec4<f32>
@must_use fn textureSampleGrad(texture: texture_cube<f32>, sampler: sampler, coords: vec3<f32>, ddx: vec3<f32>, ddy: vec3<f32>) -> vec4<f32>
-@must_use fn textureSampleGrad<A: iu32>(texture: texture_cube_array<f32>, sampler: sampler, coords: vec3<f32>, array_index: A, ddx: vec3<f32>, ddy: vec3<f32>) -> vec4<f32>
+@must_use fn textureSampleGrad[A: iu32](texture: texture_cube_array<f32>, sampler: sampler, coords: vec3<f32>, array_index: A, ddx: vec3<f32>, ddy: vec3<f32>) -> vec4<f32>
@must_use fn textureSampleLevel(texture: texture_2d<f32>, sampler: sampler, coords: vec2<f32>, level: f32) -> vec4<f32>
@must_use fn textureSampleLevel(texture: texture_2d<f32>, sampler: sampler, coords: vec2<f32>, level: f32, @const offset: vec2<i32>) -> vec4<f32>
-@must_use fn textureSampleLevel<A: iu32>(texture: texture_2d_array<f32>, sampler: sampler, coords: vec2<f32>, array_index: A, level: f32) -> vec4<f32>
-@must_use fn textureSampleLevel<A: iu32>(texture: texture_2d_array<f32>, sampler: sampler, coords: vec2<f32>, array_index: A, level: f32, @const offset: vec2<i32>) -> vec4<f32>
+@must_use fn textureSampleLevel[A: iu32](texture: texture_2d_array<f32>, sampler: sampler, coords: vec2<f32>, array_index: A, level: f32) -> vec4<f32>
+@must_use fn textureSampleLevel[A: iu32](texture: texture_2d_array<f32>, sampler: sampler, coords: vec2<f32>, array_index: A, level: f32, @const offset: vec2<i32>) -> vec4<f32>
@must_use fn textureSampleLevel(texture: texture_3d<f32>, sampler: sampler, coords: vec3<f32>, level: f32) -> vec4<f32>
@must_use fn textureSampleLevel(texture: texture_3d<f32>, sampler: sampler, coords: vec3<f32>, level: f32, @const offset: vec3<i32>) -> vec4<f32>
@must_use fn textureSampleLevel(texture: texture_cube<f32>, sampler: sampler, coords: vec3<f32>, level: f32) -> vec4<f32>
-@must_use fn textureSampleLevel<A: iu32>(texture: texture_cube_array<f32>, sampler: sampler, coords: vec3<f32>, array_index: A, level: f32) -> vec4<f32>
-@must_use fn textureSampleLevel<L: iu32>(texture: texture_depth_2d, sampler: sampler, coords: vec2<f32>, level: L) -> f32
-@must_use fn textureSampleLevel<L: iu32>(texture: texture_depth_2d, sampler: sampler, coords: vec2<f32>, level: L, @const offset: vec2<i32>) -> f32
-@must_use fn textureSampleLevel<A: iu32, L: iu32>(texture: texture_depth_2d_array, sampler: sampler, coords: vec2<f32>, array_index: A, level: L) -> f32
-@must_use fn textureSampleLevel<A: iu32, L: iu32>(texture: texture_depth_2d_array, sampler: sampler, coords: vec2<f32>, array_index: A, level: L, @const offset: vec2<i32>) -> f32
-@must_use fn textureSampleLevel<L: iu32>(texture: texture_depth_cube, sampler: sampler, coords: vec3<f32>, level: L) -> f32
-@must_use fn textureSampleLevel<A: iu32, L: iu32>(texture: texture_depth_cube_array,sampler: sampler, coords: vec3<f32>, array_index: A, level: L) -> f32
+@must_use fn textureSampleLevel[A: iu32](texture: texture_cube_array<f32>, sampler: sampler, coords: vec3<f32>, array_index: A, level: f32) -> vec4<f32>
+@must_use fn textureSampleLevel[L: iu32](texture: texture_depth_2d, sampler: sampler, coords: vec2<f32>, level: L) -> f32
+@must_use fn textureSampleLevel[L: iu32](texture: texture_depth_2d, sampler: sampler, coords: vec2<f32>, level: L, @const offset: vec2<i32>) -> f32
+@must_use fn textureSampleLevel[A: iu32, L: iu32](texture: texture_depth_2d_array, sampler: sampler, coords: vec2<f32>, array_index: A, level: L) -> f32
+@must_use fn textureSampleLevel[A: iu32, L: iu32](texture: texture_depth_2d_array, sampler: sampler, coords: vec2<f32>, array_index: A, level: L, @const offset: vec2<i32>) -> f32
+@must_use fn textureSampleLevel[L: iu32](texture: texture_depth_cube, sampler: sampler, coords: vec3<f32>, level: L) -> f32
+@must_use fn textureSampleLevel[A: iu32, L: iu32](texture: texture_depth_cube_array,sampler: sampler, coords: vec3<f32>, array_index: A, level: L) -> f32
@must_use fn textureSampleBaseClampToEdge(texture: texture_2d<f32>, sampler: sampler, coords: vec2<f32>) -> vec4<f32>
@must_use fn textureSampleBaseClampToEdge(texture: texture_external, sampler: sampler, coords: vec2<f32>) -> vec4<f32>
-fn textureStore<C: iu32>(texture: texture_storage_1d<f32_texel_format, writable>, coords: C, value: vec4<f32>)
-fn textureStore<C: iu32>(texture: texture_storage_2d<f32_texel_format, writable>, coords: vec2<C>, value: vec4<f32>)
-fn textureStore<C: iu32, A: iu32>(texture: texture_storage_2d_array<f32_texel_format, writable>, coords: vec2<C>, array_index: A, value: vec4<f32>)
-fn textureStore<C: iu32>(texture: texture_storage_3d<f32_texel_format, writable>, coords: vec3<C>, value: vec4<f32>)
-fn textureStore<C: iu32>(texture: texture_storage_1d<i32_texel_format, writable>, coords: C, value: vec4<i32>)
-fn textureStore<C: iu32>(texture: texture_storage_2d<i32_texel_format, writable>, coords: vec2<C>, value: vec4<i32>)
-fn textureStore<C: iu32, A: iu32>(texture: texture_storage_2d_array<i32_texel_format, writable>, coords: vec2<C>, array_index: A, value: vec4<i32>)
-fn textureStore<C: iu32>(texture: texture_storage_3d<i32_texel_format, writable>, coords: vec3<C>, value: vec4<i32>)
-fn textureStore<C: iu32>(texture: texture_storage_1d<u32_texel_format, writable>, coords: C, value: vec4<u32>)
-fn textureStore<C: iu32>(texture: texture_storage_2d<u32_texel_format, writable>, coords: vec2<C>, value: vec4<u32>)
-fn textureStore<C: iu32, A: iu32>(texture: texture_storage_2d_array<u32_texel_format, writable>, coords: vec2<C>, array_index: A, value: vec4<u32>)
-fn textureStore<C: iu32>(texture: texture_storage_3d<u32_texel_format, writable>, coords: vec3<C>, value: vec4<u32>)
-@must_use fn textureLoad<T: fiu32, C: iu32, L: iu32>(texture: texture_1d<T>, coords: C, level: L) -> vec4<T>
-@must_use fn textureLoad<T: fiu32, C: iu32, L: iu32>(texture: texture_2d<T>, coords: vec2<C>, level: L) -> vec4<T>
-@must_use fn textureLoad<T: fiu32, C: iu32, A: iu32, L: iu32>(texture: texture_2d_array<T>, coords: vec2<C>, array_index: A, level: L) -> vec4<T>
-@must_use fn textureLoad<T: fiu32, C: iu32, L: iu32>(texture: texture_3d<T>, coords: vec3<C>, level: L) -> vec4<T>
-@must_use fn textureLoad<T: fiu32, C: iu32, S: iu32>(texture: texture_multisampled_2d<T>, coords: vec2<C>, sample_index: S) -> vec4<T>
-@must_use fn textureLoad<C: iu32, L: iu32>(texture: texture_depth_2d, coords: vec2<C>, level: L) -> f32
-@must_use fn textureLoad<C: iu32, A: iu32, L: iu32>(texture: texture_depth_2d_array, coords: vec2<C>, array_index: A, level: L) -> f32
-@must_use fn textureLoad<C: iu32, S: iu32>(texture: texture_depth_multisampled_2d, coords: vec2<C>, sample_index: S) -> f32
-@must_use fn textureLoad<C: iu32>(texture: texture_external, coords: vec2<C>) -> vec4<f32>
-@must_use fn textureLoad<C: iu32>(texture: texture_storage_1d<f32_texel_format, readable>, coords: C) -> vec4<f32>
-@must_use fn textureLoad<C: iu32>(texture: texture_storage_1d<i32_texel_format, readable>, coords: C) -> vec4<i32>
-@must_use fn textureLoad<C: iu32>(texture: texture_storage_1d<u32_texel_format, readable>, coords: C) -> vec4<u32>
-@must_use fn textureLoad<C: iu32>(texture: texture_storage_2d<f32_texel_format, readable>, coords: vec2<C>) -> vec4<f32>
-@must_use fn textureLoad<C: iu32>(texture: texture_storage_2d<i32_texel_format, readable>, coords: vec2<C>) -> vec4<i32>
-@must_use fn textureLoad<C: iu32>(texture: texture_storage_2d<u32_texel_format, readable>, coords: vec2<C>) -> vec4<u32>
-@must_use fn textureLoad<C: iu32, A: iu32>(texture: texture_storage_2d_array<f32_texel_format, readable>, coords: vec2<C>, array_index: A) -> vec4<f32>
-@must_use fn textureLoad<C: iu32, A: iu32>(texture: texture_storage_2d_array<i32_texel_format, readable>, coords: vec2<C>, array_index: A) -> vec4<i32>
-@must_use fn textureLoad<C: iu32, A: iu32>(texture: texture_storage_2d_array<u32_texel_format, readable>, coords: vec2<C>, array_index: A) -> vec4<u32>
-@must_use fn textureLoad<C: iu32>(texture: texture_storage_3d<f32_texel_format, readable>, coords: vec3<C>) -> vec4<f32>
-@must_use fn textureLoad<C: iu32>(texture: texture_storage_3d<i32_texel_format, readable>, coords: vec3<C>) -> vec4<i32>
-@must_use fn textureLoad<C: iu32>(texture: texture_storage_3d<u32_texel_format, readable>, coords: vec3<C>) -> vec4<u32>
+fn textureStore[C: iu32](texture: texture_storage_1d<f32_texel_format, writable>, coords: C, value: vec4<f32>)
+fn textureStore[C: iu32](texture: texture_storage_2d<f32_texel_format, writable>, coords: vec2<C>, value: vec4<f32>)
+fn textureStore[C: iu32, A: iu32](texture: texture_storage_2d_array<f32_texel_format, writable>, coords: vec2<C>, array_index: A, value: vec4<f32>)
+fn textureStore[C: iu32](texture: texture_storage_3d<f32_texel_format, writable>, coords: vec3<C>, value: vec4<f32>)
+fn textureStore[C: iu32](texture: texture_storage_1d<i32_texel_format, writable>, coords: C, value: vec4<i32>)
+fn textureStore[C: iu32](texture: texture_storage_2d<i32_texel_format, writable>, coords: vec2<C>, value: vec4<i32>)
+fn textureStore[C: iu32, A: iu32](texture: texture_storage_2d_array<i32_texel_format, writable>, coords: vec2<C>, array_index: A, value: vec4<i32>)
+fn textureStore[C: iu32](texture: texture_storage_3d<i32_texel_format, writable>, coords: vec3<C>, value: vec4<i32>)
+fn textureStore[C: iu32](texture: texture_storage_1d<u32_texel_format, writable>, coords: C, value: vec4<u32>)
+fn textureStore[C: iu32](texture: texture_storage_2d<u32_texel_format, writable>, coords: vec2<C>, value: vec4<u32>)
+fn textureStore[C: iu32, A: iu32](texture: texture_storage_2d_array<u32_texel_format, writable>, coords: vec2<C>, array_index: A, value: vec4<u32>)
+fn textureStore[C: iu32](texture: texture_storage_3d<u32_texel_format, writable>, coords: vec3<C>, value: vec4<u32>)
+@must_use fn textureLoad[T: fiu32, C: iu32, L: iu32](texture: texture_1d<T>, coords: C, level: L) -> vec4<T>
+@must_use fn textureLoad[T: fiu32, C: iu32, L: iu32](texture: texture_2d<T>, coords: vec2<C>, level: L) -> vec4<T>
+@must_use fn textureLoad[T: fiu32, C: iu32, A: iu32, L: iu32](texture: texture_2d_array<T>, coords: vec2<C>, array_index: A, level: L) -> vec4<T>
+@must_use fn textureLoad[T: fiu32, C: iu32, L: iu32](texture: texture_3d<T>, coords: vec3<C>, level: L) -> vec4<T>
+@must_use fn textureLoad[T: fiu32, C: iu32, S: iu32](texture: texture_multisampled_2d<T>, coords: vec2<C>, sample_index: S) -> vec4<T>
+@must_use fn textureLoad[C: iu32, L: iu32](texture: texture_depth_2d, coords: vec2<C>, level: L) -> f32
+@must_use fn textureLoad[C: iu32, A: iu32, L: iu32](texture: texture_depth_2d_array, coords: vec2<C>, array_index: A, level: L) -> f32
+@must_use fn textureLoad[C: iu32, S: iu32](texture: texture_depth_multisampled_2d, coords: vec2<C>, sample_index: S) -> f32
+@must_use fn textureLoad[C: iu32](texture: texture_external, coords: vec2<C>) -> vec4<f32>
+@must_use fn textureLoad[C: iu32](texture: texture_storage_1d<f32_texel_format, readable>, coords: C) -> vec4<f32>
+@must_use fn textureLoad[C: iu32](texture: texture_storage_1d<i32_texel_format, readable>, coords: C) -> vec4<i32>
+@must_use fn textureLoad[C: iu32](texture: texture_storage_1d<u32_texel_format, readable>, coords: C) -> vec4<u32>
+@must_use fn textureLoad[C: iu32](texture: texture_storage_2d<f32_texel_format, readable>, coords: vec2<C>) -> vec4<f32>
+@must_use fn textureLoad[C: iu32](texture: texture_storage_2d<i32_texel_format, readable>, coords: vec2<C>) -> vec4<i32>
+@must_use fn textureLoad[C: iu32](texture: texture_storage_2d<u32_texel_format, readable>, coords: vec2<C>) -> vec4<u32>
+@must_use fn textureLoad[C: iu32, A: iu32](texture: texture_storage_2d_array<f32_texel_format, readable>, coords: vec2<C>, array_index: A) -> vec4<f32>
+@must_use fn textureLoad[C: iu32, A: iu32](texture: texture_storage_2d_array<i32_texel_format, readable>, coords: vec2<C>, array_index: A) -> vec4<i32>
+@must_use fn textureLoad[C: iu32, A: iu32](texture: texture_storage_2d_array<u32_texel_format, readable>, coords: vec2<C>, array_index: A) -> vec4<u32>
+@must_use fn textureLoad[C: iu32](texture: texture_storage_3d<f32_texel_format, readable>, coords: vec3<C>) -> vec4<f32>
+@must_use fn textureLoad[C: iu32](texture: texture_storage_3d<i32_texel_format, readable>, coords: vec3<C>) -> vec4<i32>
+@must_use fn textureLoad[C: iu32](texture: texture_storage_3d<u32_texel_format, readable>, coords: vec3<C>) -> vec4<u32>
-@stage("fragment", "compute") fn atomicLoad<T: iu32, S: workgroup_or_storage>(ptr<S, atomic<T>, read_write>) -> T
-@stage("fragment", "compute") fn atomicStore<T: iu32, S: workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T)
-@stage("fragment", "compute") fn atomicAdd<T: iu32, S: workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T) -> T
-@stage("fragment", "compute") fn atomicSub<T: iu32, S: workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T) -> T
-@stage("fragment", "compute") fn atomicMax<T: iu32, S: workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T) -> T
-@stage("fragment", "compute") fn atomicMin<T: iu32, S: workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T) -> T
-@stage("fragment", "compute") fn atomicAnd<T: iu32, S: workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T) -> T
-@stage("fragment", "compute") fn atomicOr<T: iu32, S: workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T) -> T
-@stage("fragment", "compute") fn atomicXor<T: iu32, S: workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T) -> T
-@stage("fragment", "compute") fn atomicExchange<T: iu32, S: workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T) -> T
-@stage("fragment", "compute") fn atomicCompareExchangeWeak<T: iu32, S: workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T, T) -> __atomic_compare_exchange_result<T>
+@stage("fragment", "compute") fn atomicLoad[T: iu32, S: workgroup_or_storage](ptr<S, atomic<T>, read_write>) -> T
+@stage("fragment", "compute") fn atomicStore[T: iu32, S: workgroup_or_storage](ptr<S, atomic<T>, read_write>, T)
+@stage("fragment", "compute") fn atomicAdd[T: iu32, S: workgroup_or_storage](ptr<S, atomic<T>, read_write>, T) -> T
+@stage("fragment", "compute") fn atomicSub[T: iu32, S: workgroup_or_storage](ptr<S, atomic<T>, read_write>, T) -> T
+@stage("fragment", "compute") fn atomicMax[T: iu32, S: workgroup_or_storage](ptr<S, atomic<T>, read_write>, T) -> T
+@stage("fragment", "compute") fn atomicMin[T: iu32, S: workgroup_or_storage](ptr<S, atomic<T>, read_write>, T) -> T
+@stage("fragment", "compute") fn atomicAnd[T: iu32, S: workgroup_or_storage](ptr<S, atomic<T>, read_write>, T) -> T
+@stage("fragment", "compute") fn atomicOr[T: iu32, S: workgroup_or_storage](ptr<S, atomic<T>, read_write>, T) -> T
+@stage("fragment", "compute") fn atomicXor[T: iu32, S: workgroup_or_storage](ptr<S, atomic<T>, read_write>, T) -> T
+@stage("fragment", "compute") fn atomicExchange[T: iu32, S: workgroup_or_storage](ptr<S, atomic<T>, read_write>, T) -> T
+@stage("fragment", "compute") fn atomicCompareExchangeWeak[T: iu32, S: workgroup_or_storage](ptr<S, atomic<T>, read_write>, T, T) -> __atomic_compare_exchange_result<T>
@must_use @stage("compute") fn subgroupBallot() -> vec4<u32>
-@must_use @stage("compute") fn subgroupBroadcast<T: fiu32_f16>(value: T, @const sourceLaneIndex: u32) -> T
-@must_use @stage("compute") fn subgroupBroadcast<N: num, T: fiu32_f16>(value: vec<N, T>, @const sourceLaneIndex: u32) -> vec<N, T>
+@must_use @stage("compute") fn subgroupBroadcast[T: fiu32_f16](value: T, @const sourceLaneIndex: u32) -> T
+@must_use @stage("compute") fn subgroupBroadcast[N: num, T: fiu32_f16](value: vec<N, T>, @const sourceLaneIndex: u32) -> vec<N, T>
////////////////////////////////////////////////////////////////////////////////
// Value constructors //
@@ -752,18 +752,18 @@
@must_use @const("Zero") ctor vec2() -> vec2<ia>
@must_use @const("Zero") ctor vec3() -> vec3<ia>
@must_use @const("Zero") ctor vec4() -> vec4<ia>
-@must_use @const("Zero") ctor vec2<T: concrete_scalar>() -> vec2<T>
-@must_use @const("Zero") ctor vec3<T: concrete_scalar>() -> vec3<T>
-@must_use @const("Zero") ctor vec4<T: concrete_scalar>() -> vec4<T>
-@must_use @const("Zero") ctor mat2x2<T: f32_f16>() -> mat2x2<T>
-@must_use @const("Zero") ctor mat2x3<T: f32_f16>() -> mat2x3<T>
-@must_use @const("Zero") ctor mat2x4<T: f32_f16>() -> mat2x4<T>
-@must_use @const("Zero") ctor mat3x2<T: f32_f16>() -> mat3x2<T>
-@must_use @const("Zero") ctor mat3x3<T: f32_f16>() -> mat3x3<T>
-@must_use @const("Zero") ctor mat3x4<T: f32_f16>() -> mat3x4<T>
-@must_use @const("Zero") ctor mat4x2<T: f32_f16>() -> mat4x2<T>
-@must_use @const("Zero") ctor mat4x3<T: f32_f16>() -> mat4x3<T>
-@must_use @const("Zero") ctor mat4x4<T: f32_f16>() -> mat4x4<T>
+@must_use @const("Zero") ctor vec2[T: concrete_scalar]() -> vec2<T>
+@must_use @const("Zero") ctor vec3[T: concrete_scalar]() -> vec3<T>
+@must_use @const("Zero") ctor vec4[T: concrete_scalar]() -> vec4<T>
+@must_use @const("Zero") ctor mat2x2[T: f32_f16]() -> mat2x2<T>
+@must_use @const("Zero") ctor mat2x3[T: f32_f16]() -> mat2x3<T>
+@must_use @const("Zero") ctor mat2x4[T: f32_f16]() -> mat2x4<T>
+@must_use @const("Zero") ctor mat3x2[T: f32_f16]() -> mat3x2<T>
+@must_use @const("Zero") ctor mat3x3[T: f32_f16]() -> mat3x3<T>
+@must_use @const("Zero") ctor mat3x4[T: f32_f16]() -> mat3x4<T>
+@must_use @const("Zero") ctor mat4x2[T: f32_f16]() -> mat4x2<T>
+@must_use @const("Zero") ctor mat4x3[T: f32_f16]() -> mat4x3<T>
+@must_use @const("Zero") ctor mat4x4[T: f32_f16]() -> mat4x4<T>
// Identity constructors
@must_use @const("Identity") ctor i32(i32) -> i32
@@ -771,136 +771,136 @@
@must_use @const("Identity") ctor f32(f32) -> f32
@must_use @const("Identity") ctor f16(f16) -> f16
@must_use @const("Identity") ctor bool(bool) -> bool
-@must_use @const("Identity") ctor vec2<T: scalar>(vec2<T>) -> vec2<T>
-@must_use @const("Identity") ctor vec3<T: scalar>(vec3<T>) -> vec3<T>
-@must_use @const("Identity") ctor vec4<T: scalar>(vec4<T>) -> vec4<T>
-@must_use @const("Identity") ctor mat2x2<T: f32_f16>(mat2x2<T>) -> mat2x2<T>
-@must_use @const("Identity") ctor mat2x3<T: f32_f16>(mat2x3<T>) -> mat2x3<T>
-@must_use @const("Identity") ctor mat2x4<T: f32_f16>(mat2x4<T>) -> mat2x4<T>
-@must_use @const("Identity") ctor mat3x2<T: f32_f16>(mat3x2<T>) -> mat3x2<T>
-@must_use @const("Identity") ctor mat3x3<T: f32_f16>(mat3x3<T>) -> mat3x3<T>
-@must_use @const("Identity") ctor mat3x4<T: f32_f16>(mat3x4<T>) -> mat3x4<T>
-@must_use @const("Identity") ctor mat4x2<T: f32_f16>(mat4x2<T>) -> mat4x2<T>
-@must_use @const("Identity") ctor mat4x3<T: f32_f16>(mat4x3<T>) -> mat4x3<T>
-@must_use @const("Identity") ctor mat4x4<T: f32_f16>(mat4x4<T>) -> mat4x4<T>
+@must_use @const("Identity") ctor vec2[T: scalar](vec2<T>) -> vec2<T>
+@must_use @const("Identity") ctor vec3[T: scalar](vec3<T>) -> vec3<T>
+@must_use @const("Identity") ctor vec4[T: scalar](vec4<T>) -> vec4<T>
+@must_use @const("Identity") ctor mat2x2[T: f32_f16](mat2x2<T>) -> mat2x2<T>
+@must_use @const("Identity") ctor mat2x3[T: f32_f16](mat2x3<T>) -> mat2x3<T>
+@must_use @const("Identity") ctor mat2x4[T: f32_f16](mat2x4<T>) -> mat2x4<T>
+@must_use @const("Identity") ctor mat3x2[T: f32_f16](mat3x2<T>) -> mat3x2<T>
+@must_use @const("Identity") ctor mat3x3[T: f32_f16](mat3x3<T>) -> mat3x3<T>
+@must_use @const("Identity") ctor mat3x4[T: f32_f16](mat3x4<T>) -> mat3x4<T>
+@must_use @const("Identity") ctor mat4x2[T: f32_f16](mat4x2<T>) -> mat4x2<T>
+@must_use @const("Identity") ctor mat4x3[T: f32_f16](mat4x3<T>) -> mat4x3<T>
+@must_use @const("Identity") ctor mat4x4[T: f32_f16](mat4x4<T>) -> mat4x4<T>
// Vector constructors (splat)
-@must_use @const("VecSplat") ctor vec2<T: scalar>(T) -> vec2<T>
-@must_use @const("VecSplat") ctor vec3<T: scalar>(T) -> vec3<T>
-@must_use @const("VecSplat") ctor vec4<T: scalar>(T) -> vec4<T>
+@must_use @const("VecSplat") ctor vec2[T: scalar](T) -> vec2<T>
+@must_use @const("VecSplat") ctor vec3[T: scalar](T) -> vec3<T>
+@must_use @const("VecSplat") ctor vec4[T: scalar](T) -> vec4<T>
// Vector constructors (scalar)
-@must_use @const("VecInitS") ctor vec2<T: scalar>(x: T, y: T) -> vec2<T>
-@must_use @const("VecInitS") ctor vec3<T: scalar>(x: T, y: T, z: T) -> vec3<T>
-@must_use @const("VecInitS") ctor vec4<T: scalar>(x: T, y: T, z: T, w: T) -> vec4<T>
+@must_use @const("VecInitS") ctor vec2[T: scalar](x: T, y: T) -> vec2<T>
+@must_use @const("VecInitS") ctor vec3[T: scalar](x: T, y: T, z: T) -> vec3<T>
+@must_use @const("VecInitS") ctor vec4[T: scalar](x: T, y: T, z: T, w: T) -> vec4<T>
// Vector constructors (mixed)
-@must_use @const("VecInitM") ctor vec3<T: scalar>(xy: vec2<T>, z: T) -> vec3<T>
-@must_use @const("VecInitM") ctor vec3<T: scalar>(x: T, yz: vec2<T>) -> vec3<T>
-@must_use @const("VecInitM") ctor vec4<T: scalar>(xy: vec2<T>, z: T, w: T) -> vec4<T>
-@must_use @const("VecInitM") ctor vec4<T: scalar>(x: T, yz: vec2<T>, w: T) -> vec4<T>
-@must_use @const("VecInitM") ctor vec4<T: scalar>(x: T, y: T, zw: vec2<T>) -> vec4<T>
-@must_use @const("VecInitM") ctor vec4<T: scalar>(xy: vec2<T>, zw: vec2<T>) -> vec4<T>
-@must_use @const("VecInitM") ctor vec4<T: scalar>(xyz: vec3<T>, w: T) -> vec4<T>
-@must_use @const("VecInitM") ctor vec4<T: scalar>(x: T, zyw: vec3<T>) -> vec4<T>
+@must_use @const("VecInitM") ctor vec3[T: scalar](xy: vec2<T>, z: T) -> vec3<T>
+@must_use @const("VecInitM") ctor vec3[T: scalar](x: T, yz: vec2<T>) -> vec3<T>
+@must_use @const("VecInitM") ctor vec4[T: scalar](xy: vec2<T>, z: T, w: T) -> vec4<T>
+@must_use @const("VecInitM") ctor vec4[T: scalar](x: T, yz: vec2<T>, w: T) -> vec4<T>
+@must_use @const("VecInitM") ctor vec4[T: scalar](x: T, y: T, zw: vec2<T>) -> vec4<T>
+@must_use @const("VecInitM") ctor vec4[T: scalar](xy: vec2<T>, zw: vec2<T>) -> vec4<T>
+@must_use @const("VecInitM") ctor vec4[T: scalar](xyz: vec3<T>, w: T) -> vec4<T>
+@must_use @const("VecInitM") ctor vec4[T: scalar](x: T, zyw: vec3<T>) -> vec4<T>
// Matrix constructors (scalar)
@must_use @const("MatInitS")
-ctor mat2x2<T: fa_f32_f16>(T, T,
+ctor mat2x2[T: fa_f32_f16](T, T,
T, T) -> mat2x2<T>
@must_use @const("MatInitS")
-ctor mat2x3<T: fa_f32_f16>(T, T, T,
+ctor mat2x3[T: fa_f32_f16](T, T, T,
T, T, T) -> mat2x3<T>
@must_use @const("MatInitS")
-ctor mat2x4<T: fa_f32_f16>(T, T, T, T,
+ctor mat2x4[T: fa_f32_f16](T, T, T, T,
T, T, T, T) -> mat2x4<T>
@must_use @const("MatInitS")
-ctor mat3x2<T: fa_f32_f16>(T, T,
+ctor mat3x2[T: fa_f32_f16](T, T,
T, T,
T, T) -> mat3x2<T>
@must_use @const("MatInitS")
-ctor mat3x3<T: fa_f32_f16>(T, T, T,
+ctor mat3x3[T: fa_f32_f16](T, T, T,
T, T, T,
T, T, T) -> mat3x3<T>
@must_use @const("MatInitS")
-ctor mat3x4<T: fa_f32_f16>(T, T, T, T,
+ctor mat3x4[T: fa_f32_f16](T, T, T, T,
T, T, T, T,
T, T, T, T) -> mat3x4<T>
@must_use @const("MatInitS")
-ctor mat4x2<T: fa_f32_f16>(T, T,
+ctor mat4x2[T: fa_f32_f16](T, T,
T, T,
T, T,
T, T) -> mat4x2<T>
@must_use @const("MatInitS")
-ctor mat4x3<T: fa_f32_f16>(T, T, T,
+ctor mat4x3[T: fa_f32_f16](T, T, T,
T, T, T,
T, T, T,
T, T, T) -> mat4x3<T>
@must_use @const("MatInitS")
-ctor mat4x4<T: fa_f32_f16>(T, T, T, T,
+ctor mat4x4[T: fa_f32_f16](T, T, T, T,
T, T, T, T,
T, T, T, T,
T, T, T, T) -> mat4x4<T>
// Matrix constructors (column vectors)
-@must_use @const("MatInitV") ctor mat2x2<T: fa_f32_f16>(vec2<T>, vec2<T>) -> mat2x2<T>
-@must_use @const("MatInitV") ctor mat2x3<T: fa_f32_f16>(vec3<T>, vec3<T>) -> mat2x3<T>
-@must_use @const("MatInitV") ctor mat2x4<T: fa_f32_f16>(vec4<T>, vec4<T>) -> mat2x4<T>
-@must_use @const("MatInitV") ctor mat3x2<T: fa_f32_f16>(vec2<T>, vec2<T>, vec2<T>) -> mat3x2<T>
-@must_use @const("MatInitV") ctor mat3x3<T: fa_f32_f16>(vec3<T>, vec3<T>, vec3<T>) -> mat3x3<T>
-@must_use @const("MatInitV") ctor mat3x4<T: fa_f32_f16>(vec4<T>, vec4<T>, vec4<T>) -> mat3x4<T>
-@must_use @const("MatInitV") ctor mat4x2<T: fa_f32_f16>(vec2<T>, vec2<T>, vec2<T>, vec2<T>) -> mat4x2<T>
-@must_use @const("MatInitV") ctor mat4x3<T: fa_f32_f16>(vec3<T>, vec3<T>, vec3<T>, vec3<T>) -> mat4x3<T>
-@must_use @const("MatInitV") ctor mat4x4<T: fa_f32_f16>(vec4<T>, vec4<T>, vec4<T>, vec4<T>) -> mat4x4<T>
+@must_use @const("MatInitV") ctor mat2x2[T: fa_f32_f16](vec2<T>, vec2<T>) -> mat2x2<T>
+@must_use @const("MatInitV") ctor mat2x3[T: fa_f32_f16](vec3<T>, vec3<T>) -> mat2x3<T>
+@must_use @const("MatInitV") ctor mat2x4[T: fa_f32_f16](vec4<T>, vec4<T>) -> mat2x4<T>
+@must_use @const("MatInitV") ctor mat3x2[T: fa_f32_f16](vec2<T>, vec2<T>, vec2<T>) -> mat3x2<T>
+@must_use @const("MatInitV") ctor mat3x3[T: fa_f32_f16](vec3<T>, vec3<T>, vec3<T>) -> mat3x3<T>
+@must_use @const("MatInitV") ctor mat3x4[T: fa_f32_f16](vec4<T>, vec4<T>, vec4<T>) -> mat3x4<T>
+@must_use @const("MatInitV") ctor mat4x2[T: fa_f32_f16](vec2<T>, vec2<T>, vec2<T>, vec2<T>) -> mat4x2<T>
+@must_use @const("MatInitV") ctor mat4x3[T: fa_f32_f16](vec3<T>, vec3<T>, vec3<T>, vec3<T>) -> mat4x3<T>
+@must_use @const("MatInitV") ctor mat4x4[T: fa_f32_f16](vec4<T>, vec4<T>, vec4<T>, vec4<T>) -> mat4x4<T>
////////////////////////////////////////////////////////////////////////////////
// Value conversions //
////////////////////////////////////////////////////////////////////////////////
-@must_use @const conv f32<T: scalar_no_f32>(T) -> f32
-@must_use @const conv f16<T: scalar_no_f16>(T) -> f16
-@must_use @const conv i32<T: scalar_no_i32>(T) -> i32
-@must_use @const conv u32<T: scalar_no_u32>(T) -> u32
-@must_use @const conv bool<T: scalar_no_bool>(T) -> bool
+@must_use @const conv f32[T: scalar_no_f32](T) -> f32
+@must_use @const conv f16[T: scalar_no_f16](T) -> f16
+@must_use @const conv i32[T: scalar_no_i32](T) -> i32
+@must_use @const conv u32[T: scalar_no_u32](T) -> u32
+@must_use @const conv bool[T: scalar_no_bool](T) -> bool
-@must_use @const conv vec2<T: f32, U: scalar_no_f32>(vec2<U>) -> vec2<f32>
-@must_use @const conv vec2<T: f16, U: scalar_no_f16>(vec2<U>) -> vec2<f16>
-@must_use @const conv vec2<T: i32, U: scalar_no_i32>(vec2<U>) -> vec2<i32>
-@must_use @const conv vec2<T: u32, U: scalar_no_u32>(vec2<U>) -> vec2<u32>
-@must_use @const conv vec2<T: bool, U: scalar_no_bool>(vec2<U>) -> vec2<bool>
+@must_use @const conv vec2[T: f32, U: scalar_no_f32](vec2<U>) -> vec2<f32>
+@must_use @const conv vec2[T: f16, U: scalar_no_f16](vec2<U>) -> vec2<f16>
+@must_use @const conv vec2[T: i32, U: scalar_no_i32](vec2<U>) -> vec2<i32>
+@must_use @const conv vec2[T: u32, U: scalar_no_u32](vec2<U>) -> vec2<u32>
+@must_use @const conv vec2[T: bool, U: scalar_no_bool](vec2<U>) -> vec2<bool>
-@must_use @const conv vec3<T: f32, U: scalar_no_f32>(vec3<U>) -> vec3<f32>
-@must_use @const conv vec3<T: f16, U: scalar_no_f16>(vec3<U>) -> vec3<f16>
-@must_use @const conv vec3<T: i32, U: scalar_no_i32>(vec3<U>) -> vec3<i32>
-@must_use @const conv vec3<T: u32, U: scalar_no_u32>(vec3<U>) -> vec3<u32>
-@must_use @const conv vec3<T: bool, U: scalar_no_bool>(vec3<U>) -> vec3<bool>
+@must_use @const conv vec3[T: f32, U: scalar_no_f32](vec3<U>) -> vec3<f32>
+@must_use @const conv vec3[T: f16, U: scalar_no_f16](vec3<U>) -> vec3<f16>
+@must_use @const conv vec3[T: i32, U: scalar_no_i32](vec3<U>) -> vec3<i32>
+@must_use @const conv vec3[T: u32, U: scalar_no_u32](vec3<U>) -> vec3<u32>
+@must_use @const conv vec3[T: bool, U: scalar_no_bool](vec3<U>) -> vec3<bool>
-@must_use @const conv vec4<T: f32, U: scalar_no_f32>(vec4<U>) -> vec4<f32>
-@must_use @const conv vec4<T: f16, U: scalar_no_f16>(vec4<U>) -> vec4<f16>
-@must_use @const conv vec4<T: i32, U: scalar_no_i32>(vec4<U>) -> vec4<i32>
-@must_use @const conv vec4<T: u32, U: scalar_no_u32>(vec4<U>) -> vec4<u32>
-@must_use @const conv vec4<T: bool, U: scalar_no_bool>(vec4<U>) -> vec4<bool>
+@must_use @const conv vec4[T: f32, U: scalar_no_f32](vec4<U>) -> vec4<f32>
+@must_use @const conv vec4[T: f16, U: scalar_no_f16](vec4<U>) -> vec4<f16>
+@must_use @const conv vec4[T: i32, U: scalar_no_i32](vec4<U>) -> vec4<i32>
+@must_use @const conv vec4[T: u32, U: scalar_no_u32](vec4<U>) -> vec4<u32>
+@must_use @const conv vec4[T: bool, U: scalar_no_bool](vec4<U>) -> vec4<bool>
-@must_use @const conv mat2x2<T: f16>(mat2x2<f32>) -> mat2x2<f16>
-@must_use @const conv mat2x2<T: f32>(mat2x2<f16>) -> mat2x2<f32>
-@must_use @const conv mat2x3<T: f16>(mat2x3<f32>) -> mat2x3<f16>
-@must_use @const conv mat2x3<T: f32>(mat2x3<f16>) -> mat2x3<f32>
-@must_use @const conv mat2x4<T: f16>(mat2x4<f32>) -> mat2x4<f16>
-@must_use @const conv mat2x4<T: f32>(mat2x4<f16>) -> mat2x4<f32>
-@must_use @const conv mat3x2<T: f16>(mat3x2<f32>) -> mat3x2<f16>
-@must_use @const conv mat3x2<T: f32>(mat3x2<f16>) -> mat3x2<f32>
-@must_use @const conv mat3x3<T: f16>(mat3x3<f32>) -> mat3x3<f16>
-@must_use @const conv mat3x3<T: f32>(mat3x3<f16>) -> mat3x3<f32>
-@must_use @const conv mat3x4<T: f16>(mat3x4<f32>) -> mat3x4<f16>
-@must_use @const conv mat3x4<T: f32>(mat3x4<f16>) -> mat3x4<f32>
-@must_use @const conv mat4x2<T: f16>(mat4x2<f32>) -> mat4x2<f16>
-@must_use @const conv mat4x2<T: f32>(mat4x2<f16>) -> mat4x2<f32>
-@must_use @const conv mat4x3<T: f16>(mat4x3<f32>) -> mat4x3<f16>
-@must_use @const conv mat4x3<T: f32>(mat4x3<f16>) -> mat4x3<f32>
-@must_use @const conv mat4x4<T: f16>(mat4x4<f32>) -> mat4x4<f16>
-@must_use @const conv mat4x4<T: f32>(mat4x4<f16>) -> mat4x4<f32>
+@must_use @const conv mat2x2[T: f16](mat2x2<f32>) -> mat2x2<f16>
+@must_use @const conv mat2x2[T: f32](mat2x2<f16>) -> mat2x2<f32>
+@must_use @const conv mat2x3[T: f16](mat2x3<f32>) -> mat2x3<f16>
+@must_use @const conv mat2x3[T: f32](mat2x3<f16>) -> mat2x3<f32>
+@must_use @const conv mat2x4[T: f16](mat2x4<f32>) -> mat2x4<f16>
+@must_use @const conv mat2x4[T: f32](mat2x4<f16>) -> mat2x4<f32>
+@must_use @const conv mat3x2[T: f16](mat3x2<f32>) -> mat3x2<f16>
+@must_use @const conv mat3x2[T: f32](mat3x2<f16>) -> mat3x2<f32>
+@must_use @const conv mat3x3[T: f16](mat3x3<f32>) -> mat3x3<f16>
+@must_use @const conv mat3x3[T: f32](mat3x3<f16>) -> mat3x3<f32>
+@must_use @const conv mat3x4[T: f16](mat3x4<f32>) -> mat3x4<f16>
+@must_use @const conv mat3x4[T: f32](mat3x4<f16>) -> mat3x4<f32>
+@must_use @const conv mat4x2[T: f16](mat4x2<f32>) -> mat4x2<f16>
+@must_use @const conv mat4x2[T: f32](mat4x2<f16>) -> mat4x2<f32>
+@must_use @const conv mat4x3[T: f16](mat4x3<f32>) -> mat4x3<f16>
+@must_use @const conv mat4x3[T: f32](mat4x3<f16>) -> mat4x3<f32>
+@must_use @const conv mat4x4[T: f16](mat4x4<f32>) -> mat4x4<f16>
+@must_use @const conv mat4x4[T: f32](mat4x4<f16>) -> mat4x4<f32>
// Conversion from vec3 to internal __packed_vec3 type.
-@must_use @const conv packedVec3<T: concrete_scalar>(vec3<T>) -> packedVec3<T>
+@must_use @const conv packedVec3[T: concrete_scalar](vec3<T>) -> packedVec3<T>
////////////////////////////////////////////////////////////////////////////////
// Operators //
@@ -919,90 +919,90 @@
// Unary Operators //
////////////////////////////////////////////////////////////////////////////////
@must_use @const op ! (bool) -> bool
-@must_use @const op ! <N: num> (vec<N, bool>) -> vec<N, bool>
+@must_use @const op ! [N: num](vec<N, bool>) -> vec<N, bool>
-@must_use @const op ~ <T: ia_iu32>(T) -> T
-@must_use @const op ~ <T: ia_iu32, N: num> (vec<N, T>) -> vec<N, T>
+@must_use @const op ~ [T: ia_iu32](T) -> T
+@must_use @const op ~ [T: ia_iu32, N: num](vec<N, T>) -> vec<N, T>
-@must_use @const("UnaryMinus") op - <T: fia_fi32_f16>(T) -> T
-@must_use @const("UnaryMinus") op - <T: fia_fi32_f16, N: num> (vec<N, T>) -> vec<N, T>
+@must_use @const("UnaryMinus") op - [T: fia_fi32_f16](T) -> T
+@must_use @const("UnaryMinus") op - [T: fia_fi32_f16, N: num](vec<N, T>) -> vec<N, T>
////////////////////////////////////////////////////////////////////////////////
// Binary Operators //
////////////////////////////////////////////////////////////////////////////////
-@must_use @const op + <T: fia_fiu32_f16>(T, T) -> T
-@must_use @const op + <T: fia_fiu32_f16, N: num> (vec<N, T>, vec<N, T>) -> vec<N, T>
-@must_use @const op + <T: fia_fiu32_f16, N: num> (vec<N, T>, T) -> vec<N, T>
-@must_use @const op + <T: fia_fiu32_f16, N: num> (T, vec<N, T>) -> vec<N, T>
-@must_use @const op + <T: fa_f32_f16, N: num, M: num> (mat<N, M, T>, mat<N, M, T>) -> mat<N, M, T>
+@must_use @const op + [T: fia_fiu32_f16](T, T) -> T
+@must_use @const op + [T: fia_fiu32_f16, N: num](vec<N, T>, vec<N, T>) -> vec<N, T>
+@must_use @const op + [T: fia_fiu32_f16, N: num](vec<N, T>, T) -> vec<N, T>
+@must_use @const op + [T: fia_fiu32_f16, N: num](T, vec<N, T>) -> vec<N, T>
+@must_use @const op + [T: fa_f32_f16, N: num, M: num](mat<N, M, T>, mat<N, M, T>) -> mat<N, M, T>
-@must_use @const op - <T: fia_fiu32_f16>(T, T) -> T
-@must_use @const op - <T: fia_fiu32_f16, N: num> (vec<N, T>, vec<N, T>) -> vec<N, T>
-@must_use @const op - <T: fia_fiu32_f16, N: num> (vec<N, T>, T) -> vec<N, T>
-@must_use @const op - <T: fia_fiu32_f16, N: num> (T, vec<N, T>) -> vec<N, T>
-@must_use @const op - <T: fa_f32_f16, N: num, M: num> (mat<N, M, T>, mat<N, M, T>) -> mat<N, M, T>
+@must_use @const op - [T: fia_fiu32_f16](T, T) -> T
+@must_use @const op - [T: fia_fiu32_f16, N: num](vec<N, T>, vec<N, T>) -> vec<N, T>
+@must_use @const op - [T: fia_fiu32_f16, N: num](vec<N, T>, T) -> vec<N, T>
+@must_use @const op - [T: fia_fiu32_f16, N: num](T, vec<N, T>) -> vec<N, T>
+@must_use @const op - [T: fa_f32_f16, N: num, M: num](mat<N, M, T>, mat<N, M, T>) -> mat<N, M, T>
-@must_use @const("Multiply") op * <T: fia_fiu32_f16>(T, T) -> T
-@must_use @const("Multiply") op * <T: fia_fiu32_f16, N: num> (vec<N, T>, vec<N, T>) -> vec<N, T>
-@must_use @const("Multiply") op * <T: fia_fiu32_f16, N: num> (vec<N, T>, T) -> vec<N, T>
-@must_use @const("Multiply") op * <T: fia_fiu32_f16, N: num> (T, vec<N, T>) -> vec<N, T>
-@must_use @const("Multiply") op * <T: fa_f32_f16, N: num, M: num> (T, mat<N, M, T>) -> mat<N, M, T>
-@must_use @const("Multiply") op * <T: fa_f32_f16, N: num, M: num> (mat<N, M, T>, T) -> mat<N, M, T>
-@must_use @const("MultiplyMatVec") op * <T: fa_f32_f16, C: num, R: num> (mat<C, R, T>, vec<C, T>) -> vec<R, T>
-@must_use @const("MultiplyVecMat") op * <T: fa_f32_f16, C: num, R: num> (vec<R, T>, mat<C, R, T>) -> vec<C, T>
-@must_use @const("MultiplyMatMat") op * <T: fa_f32_f16, K: num, C: num, R: num> (mat<K, R, T>, mat<C, K, T>) -> mat<C, R, T>
+@must_use @const("Multiply") op * [T: fia_fiu32_f16](T, T) -> T
+@must_use @const("Multiply") op * [T: fia_fiu32_f16, N: num](vec<N, T>, vec<N, T>) -> vec<N, T>
+@must_use @const("Multiply") op * [T: fia_fiu32_f16, N: num](vec<N, T>, T) -> vec<N, T>
+@must_use @const("Multiply") op * [T: fia_fiu32_f16, N: num](T, vec<N, T>) -> vec<N, T>
+@must_use @const("Multiply") op * [T: fa_f32_f16, N: num, M: num](T, mat<N, M, T>) -> mat<N, M, T>
+@must_use @const("Multiply") op * [T: fa_f32_f16, N: num, M: num](mat<N, M, T>, T) -> mat<N, M, T>
+@must_use @const("MultiplyMatVec") op * [T: fa_f32_f16, C: num, R: num](mat<C, R, T>, vec<C, T>) -> vec<R, T>
+@must_use @const("MultiplyVecMat") op * [T: fa_f32_f16, C: num, R: num](vec<R, T>, mat<C, R, T>) -> vec<C, T>
+@must_use @const("MultiplyMatMat") op * [T: fa_f32_f16, K: num, C: num, R: num](mat<K, R, T>, mat<C, K, T>) -> mat<C, R, T>
-@must_use @const op / <T: fia_fiu32_f16>(T, T) -> T
-@must_use @const op / <T: fia_fiu32_f16, N: num> (vec<N, T>, vec<N, T>) -> vec<N, T>
-@must_use @const op / <T: fia_fiu32_f16, N: num> (vec<N, T>, T) -> vec<N, T>
-@must_use @const op / <T: fia_fiu32_f16, N: num> (T, vec<N, T>) -> vec<N, T>
+@must_use @const op / [T: fia_fiu32_f16](T, T) -> T
+@must_use @const op / [T: fia_fiu32_f16, N: num](vec<N, T>, vec<N, T>) -> vec<N, T>
+@must_use @const op / [T: fia_fiu32_f16, N: num](vec<N, T>, T) -> vec<N, T>
+@must_use @const op / [T: fia_fiu32_f16, N: num](T, vec<N, T>) -> vec<N, T>
-@must_use @const op % <T: fia_fiu32_f16>(T, T) -> T
-@must_use @const op % <T: fia_fiu32_f16, N: num> (vec<N, T>, vec<N, T>) -> vec<N, T>
-@must_use @const op % <T: fia_fiu32_f16, N: num> (vec<N, T>, T) -> vec<N, T>
-@must_use @const op % <T: fia_fiu32_f16, N: num> (T, vec<N, T>) -> vec<N, T>
+@must_use @const op % [T: fia_fiu32_f16](T, T) -> T
+@must_use @const op % [T: fia_fiu32_f16, N: num](vec<N, T>, vec<N, T>) -> vec<N, T>
+@must_use @const op % [T: fia_fiu32_f16, N: num](vec<N, T>, T) -> vec<N, T>
+@must_use @const op % [T: fia_fiu32_f16, N: num](T, vec<N, T>) -> vec<N, T>
-@must_use @const op ^ <T: ia_iu32>(T, T) -> T
-@must_use @const op ^ <T: ia_iu32, N: num> (vec<N, T>, vec<N, T>) -> vec<N, T>
+@must_use @const op ^ [T: ia_iu32](T, T) -> T
+@must_use @const op ^ [T: ia_iu32, N: num](vec<N, T>, vec<N, T>) -> vec<N, T>
@must_use @const op & (bool, bool) -> bool
-@must_use @const op & <N: num> (vec<N, bool>, vec<N, bool>) -> vec<N, bool>
-@must_use @const op & <T: ia_iu32>(T, T) -> T
-@must_use @const op & <T: ia_iu32, N: num> (vec<N, T>, vec<N, T>) -> vec<N, T>
+@must_use @const op & [N: num](vec<N, bool>, vec<N, bool>) -> vec<N, bool>
+@must_use @const op & [T: ia_iu32](T, T) -> T
+@must_use @const op & [T: ia_iu32, N: num](vec<N, T>, vec<N, T>) -> vec<N, T>
@must_use @const op | (bool, bool) -> bool
-@must_use @const op | <N: num> (vec<N, bool>, vec<N, bool>) -> vec<N, bool>
-@must_use @const op | <T: ia_iu32>(T, T) -> T
-@must_use @const op | <T: ia_iu32, N: num> (vec<N, T>, vec<N, T>) -> vec<N, T>
+@must_use @const op | [N: num](vec<N, bool>, vec<N, bool>) -> vec<N, bool>
+@must_use @const op | [T: ia_iu32](T, T) -> T
+@must_use @const op | [T: ia_iu32, N: num](vec<N, T>, vec<N, T>) -> vec<N, T>
@must_use @const op && (bool, bool) -> bool
@must_use @const op || (bool, bool) -> bool
-@must_use @const op == <T: scalar>(T, T) -> bool
-@must_use @const op == <T: scalar, N: num> (vec<N, T>, vec<N, T>) -> vec<N, bool>
+@must_use @const op == [T: scalar](T, T) -> bool
+@must_use @const op == [T: scalar, N: num](vec<N, T>, vec<N, T>) -> vec<N, bool>
-@must_use @const op != <T: scalar>(T, T) -> bool
-@must_use @const op != <T: scalar, N: num> (vec<N, T>, vec<N, T>) -> vec<N, bool>
+@must_use @const op != [T: scalar](T, T) -> bool
+@must_use @const op != [T: scalar, N: num](vec<N, T>, vec<N, T>) -> vec<N, bool>
-@must_use @const op < <T: fia_fiu32_f16>(T, T) -> bool
-@must_use @const op < <T: fia_fiu32_f16, N: num> (vec<N, T>, vec<N, T>) -> vec<N, bool>
+@must_use @const op < [T: fia_fiu32_f16](T, T) -> bool
+@must_use @const op < [T: fia_fiu32_f16, N: num](vec<N, T>, vec<N, T>) -> vec<N, bool>
-@must_use @const op > <T: fia_fiu32_f16>(T, T) -> bool
-@must_use @const op > <T: fia_fiu32_f16, N: num> (vec<N, T>, vec<N, T>) -> vec<N, bool>
+@must_use @const op > [T: fia_fiu32_f16](T, T) -> bool
+@must_use @const op > [T: fia_fiu32_f16, N: num](vec<N, T>, vec<N, T>) -> vec<N, bool>
-@must_use @const op <= <T: fia_fiu32_f16>(T, T) -> bool
-@must_use @const op <= <T: fia_fiu32_f16, N: num> (vec<N, T>, vec<N, T>) -> vec<N, bool>
+@must_use @const op <= [T: fia_fiu32_f16](T, T) -> bool
+@must_use @const op <= [T: fia_fiu32_f16, N: num](vec<N, T>, vec<N, T>) -> vec<N, bool>
-@must_use @const op >= <T: fia_fiu32_f16>(T, T) -> bool
-@must_use @const op >= <T: fia_fiu32_f16, N: num> (vec<N, T>, vec<N, T>) -> vec<N, bool>
+@must_use @const op >= [T: fia_fiu32_f16](T, T) -> bool
+@must_use @const op >= [T: fia_fiu32_f16, N: num](vec<N, T>, vec<N, T>) -> vec<N, bool>
-@must_use @const op << <T: ia_iu32>(T, u32) -> T
-@must_use @const op << <T: ia_iu32, N: num> (vec<N, T>, vec<N, u32>) -> vec<N, T>
+@must_use @const op << [T: ia_iu32](T, u32) -> T
+@must_use @const op << [T: ia_iu32, N: num](vec<N, T>, vec<N, u32>) -> vec<N, T>
-@must_use @const op >> <T: ia_iu32>(T, u32) -> T
-@must_use @const op >> <T: ia_iu32, N: num> (vec<N, T>, vec<N, u32>) -> vec<N, T>
+@must_use @const op >> [T: ia_iu32](T, u32) -> T
+@must_use @const op >> [T: ia_iu32, N: num](vec<N, T>, vec<N, u32>) -> vec<N, T>
////////////////////////////////////////////////////////////////////////////////
// Tint internal builtins //
////////////////////////////////////////////////////////////////////////////////
-@const("Identity") fn _tint_materialize<T>(T) -> T
+@const("Identity") fn _tint_materialize[T](T) -> T
diff --git a/tools/src/tint/intrinsic/lexer/lexer.go b/tools/src/tint/intrinsic/lexer/lexer.go
index 480a9e1..7aefb2e 100644
--- a/tools/src/tint/intrinsic/lexer/lexer.go
+++ b/tools/src/tint/intrinsic/lexer/lexer.go
@@ -172,6 +172,8 @@
case l.match(">=", tok.Ge):
case l.match(">>", tok.Shr):
case l.match(">", tok.Gt):
+ case l.match("[", tok.Lbracket):
+ case l.match("]", tok.Rbracket):
default:
return fmt.Errorf("%v: unexpected '%v'", l.loc, string(l.runes[0]))
}
diff --git a/tools/src/tint/intrinsic/parser/parser.go b/tools/src/tint/intrinsic/parser/parser.go
index 86379d4..bd2f055 100644
--- a/tools/src/tint/intrinsic/parser/parser.go
+++ b/tools/src/tint/intrinsic/parser/parser.go
@@ -175,9 +175,8 @@
Attributes: decos,
Name: string(name.Runes),
}
- if p.peekIs(0, tok.Lt) {
- m.TemplateParams = p.templateParams()
- }
+ m.TemplateParams = p.typeTemplateParams()
+
return m
}
@@ -229,9 +228,7 @@
Attributes: decos,
Name: string(name.Runes),
}
- if p.peekIs(0, tok.Lt) {
- f.TemplateParams = p.templateParams()
- }
+ f.TemplateParams = p.intrinsicTemplateParams()
f.Parameters = p.parameters()
if p.match(tok.Arrow) != nil {
ret := p.templatedName()
@@ -249,9 +246,7 @@
Attributes: decos,
Name: string(name.Runes),
}
- if p.peekIs(0, tok.Lt) {
- f.TemplateParams = p.templateParams()
- }
+ f.TemplateParams = p.intrinsicTemplateParams()
f.Parameters = p.parameters()
if p.match(tok.Arrow) != nil {
ret := p.templatedName()
@@ -269,9 +264,7 @@
Attributes: decos,
Name: string(name.Runes),
}
- if p.peekIs(0, tok.Lt) {
- f.TemplateParams = p.templateParams()
- }
+ f.TemplateParams = p.intrinsicTemplateParams()
f.Parameters = p.parameters()
if p.match(tok.Arrow) != nil {
ret := p.templatedName()
@@ -289,9 +282,7 @@
Attributes: decos,
Name: string(name.Runes),
}
- if p.peekIs(0, tok.Lt) {
- f.TemplateParams = p.templateParams()
- }
+ f.TemplateParams = p.intrinsicTemplateParams()
f.Parameters = p.parameters()
if p.match(tok.Arrow) != nil {
ret := p.templatedName()
@@ -368,16 +359,30 @@
return m
}
-func (p *parser) templateParams() []ast.TemplateParam {
+func (p *parser) typeTemplateParams() []ast.TemplateParam {
+ if p.match(tok.Lt) == nil {
+ return nil
+ }
t := []ast.TemplateParam{}
- p.expect(tok.Lt, "template parameter list")
for p.err == nil && p.peekIs(0, tok.Identifier) {
t = append(t, p.templateParam())
}
- p.expect(tok.Gt, "template parameter list")
+ p.expect(tok.Gt, "type template parameter list")
return t
}
+func (p *parser) intrinsicTemplateParams() []ast.TemplateParam {
+ if p.match(tok.Lbracket) == nil {
+ return nil
+ }
+ out := []ast.TemplateParam{}
+ for p.err == nil && p.peekIs(0, tok.Identifier) {
+ out = append(out, p.templateParam())
+ }
+ p.expect(tok.Rbracket, "intrinsic template parameter list")
+ return out
+}
+
func (p *parser) templateParam() ast.TemplateParam {
name := p.match(tok.Identifier)
t := ast.TemplateParam{
diff --git a/tools/src/tint/intrinsic/parser/parser_test.go b/tools/src/tint/intrinsic/parser/parser_test.go
index 76ed5cd..9dec76b 100644
--- a/tools/src/tint/intrinsic/parser/parser_test.go
+++ b/tools/src/tint/intrinsic/parser/parser_test.go
@@ -251,7 +251,7 @@
},
}, { ///////////////////////////////////////////////////////////////////
fileutils.ThisLine(),
- "fn F<A : B<C> >()",
+ "fn F[A : B<C> ]()",
ast.AST{
Builtins: []ast.IntrinsicDecl{{
Kind: ast.Builtin,
@@ -271,7 +271,7 @@
},
}, { ///////////////////////////////////////////////////////////////////
fileutils.ThisLine(),
- "fn F<T>(a: X, b: Y<T>)",
+ "fn F[T](a: X, b: Y<T>)",
ast.AST{
Builtins: []ast.IntrinsicDecl{{
Kind: ast.Builtin,
@@ -389,7 +389,7 @@
},
}, { ///////////////////////////////////////////////////////////////////
fileutils.ThisLine(),
- "op F<A : B<C> >()",
+ "op F[A : B<C> ]()",
ast.AST{
Operators: []ast.IntrinsicDecl{{
Kind: ast.Operator,
@@ -409,7 +409,7 @@
},
}, { ///////////////////////////////////////////////////////////////////
fileutils.ThisLine(),
- "op F<T>(a: X, b: Y<T>)",
+ "op F[T](a: X, b: Y<T>)",
ast.AST{
Operators: []ast.IntrinsicDecl{{
Kind: ast.Operator,
@@ -513,7 +513,7 @@
},
}, { ///////////////////////////////////////////////////////////////////
fileutils.ThisLine(),
- "ctor F<A : B<C> >()",
+ "ctor F[A : B<C> ]()",
ast.AST{
Constructors: []ast.IntrinsicDecl{{
Kind: ast.Constructor,
@@ -533,7 +533,7 @@
},
}, { ///////////////////////////////////////////////////////////////////
fileutils.ThisLine(),
- "ctor F<T>(a: X, b: Y<T>)",
+ "ctor F[T](a: X, b: Y<T>)",
ast.AST{
Constructors: []ast.IntrinsicDecl{{
Kind: ast.Constructor,
@@ -637,7 +637,7 @@
},
}, { ///////////////////////////////////////////////////////////////////
fileutils.ThisLine(),
- "conv F<A : B<C> >()",
+ "conv F[A : B<C> ]()",
ast.AST{
Converters: []ast.IntrinsicDecl{{
Kind: ast.Converter,
@@ -657,7 +657,7 @@
},
}, { ///////////////////////////////////////////////////////////////////
fileutils.ThisLine(),
- "conv F<T>(a: X, b: Y<T>)",
+ "conv F[T](a: X, b: Y<T>)",
ast.AST{
Converters: []ast.IntrinsicDecl{{
Kind: ast.Converter,
diff --git a/tools/src/tint/intrinsic/resolver/resolver_test.go b/tools/src/tint/intrinsic/resolver/resolver_test.go
index 294691a..c73fd4b 100644
--- a/tools/src/tint/intrinsic/resolver/resolver_test.go
+++ b/tools/src/tint/intrinsic/resolver/resolver_test.go
@@ -73,29 +73,29 @@
`fn f()`,
success,
}, {
- `fn f<T>()`,
+ `fn f[T]()`,
success,
}, {
`
type f32
-fn f<N: num>()`,
+fn f[N: num]()`,
success,
}, {
`
enum e { a b c }
-fn f<N: e>()`,
+fn f[N: e]()`,
success,
}, {
`
type f32
-fn f<T>(T) -> f32`,
+fn f[T](T) -> f32`,
success,
}, {
`
type f32
type P<T>
match m: f32
-fn f<T: m>(P<T>) -> T`,
+fn f[T: m](P<T>) -> T`,
success,
}, {
`
@@ -108,7 +108,7 @@
enum e { a b }
type T<E: e>
match m: e.a
-fn f<E: m>(T<E>)`,
+fn f[E: m](T<E>)`,
success,
}, {
`
@@ -134,21 +134,21 @@
}, {
`
type T<E: num>
-fn f<E: num>(T<E>)`,
+fn f[E: num](T<E>)`,
success,
}, {
- `fn f<T>(T)`,
+ `fn f[T](T)`,
success,
}, {
`
enum e { a b }
-fn f<E: e>()`,
+fn f[E: e]()`,
success,
}, {
`
enum e { a b }
match m: e.a | e.b
-fn f<E: m>()`,
+fn f[E: m]()`,
success,
}, {
`
@@ -300,7 +300,7 @@
`fn f() -> u`,
`file.txt:1:11 cannot resolve 'u'`,
}, {
- `fn f<T: u>()`,
+ `fn f[T: u]()`,
`file.txt:1:9 cannot resolve 'u'`,
}, {
`
@@ -315,7 +315,7 @@
}, {
`
type x
-fn f<T>(T<x>)`,
+fn f[T](T<x>)`,
`file.txt:2:9 'T' template parameters do not accept template arguments`,
}, {
`
@@ -348,7 +348,7 @@
type P<N: num>
enum E { a b }
match m: E.a | E.b
-fn f<M: m>(P<M>)`,
+fn f[M: m](P<M>)`,
`file.txt:4:14 cannot use template enum 'E' as template number`,
}, {
`
@@ -373,7 +373,7 @@
}, {
`
type x
-op << <T>(T<x>)`,
+op << [T](T<x>)`,
`file.txt:2:11 'T' template parameters do not accept template arguments`,
}, {
`
@@ -413,7 +413,7 @@
type P<N: num>
enum E { a b }
match m: E.a | E.b
-op << <M: m>(P<M>)`,
+op << [M: m](P<M>)`,
`file.txt:4:16 cannot use template enum 'E' as template number`,
}, {
`
@@ -429,7 +429,7 @@
}, {
`
type x
-ctor F<T>(T<x>)`,
+ctor F[T](T<x>)`,
`file.txt:2:11 'T' template parameters do not accept template arguments`,
}, {
`
@@ -469,7 +469,7 @@
type P<N: num>
enum E { a b }
match m: E.a | E.b
-ctor F<M: m>(P<M>)`,
+ctor F[M: m](P<M>)`,
`file.txt:4:16 cannot use template enum 'E' as template number`,
}, {
`
@@ -494,7 +494,7 @@
}, {
`
type x
-conv F<T>(T<x>)`,
+conv F[T](T<x>)`,
`file.txt:2:11 'T' template parameters do not accept template arguments`,
}, {
`
@@ -534,7 +534,7 @@
type P<N: num>
enum E { a b }
match m: E.a | E.b
-conv F<M: m>(P<M>)`,
+conv F[M: m](P<M>)`,
`file.txt:4:16 cannot use template enum 'E' as template number`,
}, {
`
diff --git a/tools/src/tint/intrinsic/tok/tok.go b/tools/src/tint/intrinsic/tok/tok.go
index ad06175..d9711fc 100644
--- a/tools/src/tint/intrinsic/tok/tok.go
+++ b/tools/src/tint/intrinsic/tok/tok.go
@@ -79,6 +79,8 @@
Shr Kind = ">>"
Star Kind = "*"
Xor Kind = "^"
+ Lbracket Kind = "["
+ Rbracket Kind = "]"
)
// Invalid represents an invalid token
