naga: Enforce @must_use for built-in functions (#8713)

---------

Co-authored-by: Jim Blandy <jimb@red-bean.com>
This commit is contained in:
Andy LeisersonandJim Blandy authored and GitHub committed 2026-01-29 15:03:29 -08:00
1 parent f7ce2a0052
commit 70a7f83ea8
5 files changed
+236 -162

No files matched your search

+1
View File
@@ -90,6 +90,7 @@ Bottom level categories:
- Fix some cases where f16 constants were not working. By @andyleiserson in [#8816](https://github.com/gfx-rs/wgpu/pull/8816).
- Use wrapping arithmetic when evaluating constant expressions involving `u32`. By @andyleiserson in [#8912](https://github.com/gfx-rs/wgpu/pull/8912).
- Fix missing side effects from sequence expressions in GLSL. By @Vipitis in [#8787](https://github.com/gfx-rs/wgpu/pull/8787).
- Naga now enforces the `@must_use` attribute on WGSL built-in functions, when applicable. You can waive the error with a phony assignment, e.g., `_ = subgroupElect()`. By @andyleiserson in [#8713](https://github.com/gfx-rs/wgpu/pull/8713).
- Reject zero-value construction of a runtime-sized array with a validation error. Previously it would crash in the HLSL backend. By @mooori in [#8741](https://github.com/gfx-rs/wgpu/pull/8741).
- Reject splat vector construction if the argument type does not match the type of the vector's scalar. Previously it would succeed. By @mooori in [#8829](https://github.com/gfx-rs/wgpu/pull/8829).
- Fixed `workgroupUniformLoad` incorrectly returning an atomic when called on an atomic, it now returns the inner `T` as per the spec. By @cryvosh in [#8791](https://github.com/gfx-rs/wgpu/pull/8791).
+19 -10
View File
@@ -222,9 +222,26 @@ webgpu:shader,validation,expression,binary,short_circuiting_and_or:array_overrid
webgpu:shader,validation,expression,binary,short_circuiting_and_or:invalid_types:*
webgpu:shader,validation,expression,binary,short_circuiting_and_or:scalar_vector:op="%26%26";lhs="bool";rhs="bool"
webgpu:shader,validation,expression,call,builtin,all:arguments:test="ptr_deref"
webgpu:shader,validation,expression,call,builtin,arrayLength:*
webgpu:shader,validation,expression,call,builtin,barriers:*
webgpu:shader,validation,expression,call,builtin,cos:*
webgpu:shader,validation,expression,call,builtin,distance:values:stage="constant";type="f32"
webgpu:shader,validation,expression,call,builtin,floor:*
webgpu:shader,validation,expression,call,builtin,fract:*
webgpu:shader,validation,expression,call,builtin,length:scalar:stage="constant";type="f32"
webgpu:shader,validation,expression,call,builtin,max:values:*
webgpu:shader,validation,expression,call,builtin,max:*
webgpu:shader,validation,expression,call,builtin,min:*
webgpu:shader,validation,expression,call,builtin,radians:*
webgpu:shader,validation,expression,call,builtin,sign:*
webgpu:shader,validation,expression,call,builtin,sin:*
webgpu:shader,validation,expression,call,builtin,step:*
webgpu:shader,validation,expression,call,builtin,tan:*
webgpu:shader,validation,expression,call,builtin,tanh:*
webgpu:shader,validation,expression,call,builtin,textureNumLayers:*
webgpu:shader,validation,expression,call,builtin,textureNumLevels:*
webgpu:shader,validation,expression,call,builtin,textureNumSamples:*
webgpu:shader,validation,expression,call,builtin,textureStore:*
webgpu:shader,validation,expression,call,builtin,trunc:*
// FAIL: others in `value_constructor` due to https://github.com/gfx-rs/wgpu/issues/4720, possibly more
webgpu:shader,validation,expression,call,builtin,value_constructor:array_value:*
webgpu:shader,validation,expression,call,builtin,value_constructor:matrix_zero_value:*
@@ -233,15 +250,7 @@ webgpu:shader,validation,expression,call,builtin,value_constructor:scalar_zero_v
webgpu:shader,validation,expression,call,builtin,value_constructor:struct_value:*
webgpu:shader,validation,expression,call,builtin,value_constructor:vector_splat:*
webgpu:shader,validation,expression,call,builtin,value_constructor:vector_zero_value:*
// NOTE: This is supposed to be an exhaustive listing underneath
// `webgpu:shader,validation,expression,call,builtin,workgroupUniformLoad:*`, so exceptions can be
// worked around.
//FAIL: https://github.com/gfx-rs/wgpu/pull/8713
// webgpu:shader,validation,expression,call,builtin,workgroupUniformLoad:must_use:use=false
webgpu:shader,validation,expression,call,builtin,workgroupUniformLoad:must_use:use=true
webgpu:shader,validation,expression,call,builtin,workgroupUniformLoad:no_atomics:*
webgpu:shader,validation,expression,call,builtin,workgroupUniformLoad:only_in_compute:*
webgpu:shader,validation,expression,call,builtin,workgroupUniformLoad:param_constructible_only:*
webgpu:shader,validation,expression,call,builtin,workgroupUniformLoad:*
webgpu:shader,validation,extension,dual_source_blending:blend_src_syntax_validation:*
webgpu:shader,validation,extension,pointer_composite_access:*
webgpu:shader,validation,parse,requires:*
+185 -121
View File
@@ -1237,6 +1237,23 @@ enum AbstractRule {
Allow,
}
/// Whether `@must_use` applies to a call expression.
#[derive(Debug, Copy, Clone)]
enum MustUse {
Yes,
No,
}
impl From<bool> for MustUse {
fn from(value: bool) -> Self {
if value {
MustUse::Yes
} else {
MustUse::No
}
}
}
pub struct Lowerer<'source, 'temp> {
index: &'temp Index<'source>,
}
@@ -2934,8 +2951,8 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
call_span: Span,
ctx: &mut ExpressionContext<'source, '_, '_>,
is_statement: bool,
) -> Result<'source, Option<Handle<ir::Expression>>> {
let expr = if let Some(fun) = conv::map_relational_fun(function_name) {
) -> Result<'source, Option<(Handle<ir::Expression>, MustUse)>> {
let (expr, must_use) = if let Some(fun) = conv::map_relational_fun(function_name) {
let mut args = ctx.prepare_args(arguments, 1, function_span);
let argument = self.expression(args.next()?, ctx)?;
args.finish()?;
@@ -2955,37 +2972,43 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
};
if argument_unmodified {
return Ok(Some(argument));
return Ok(Some((argument, MustUse::Yes)));
} else {
ir::Expression::Relational { fun, argument }
(ir::Expression::Relational { fun, argument }, MustUse::Yes)
}
} else if let Some((axis, ctrl)) = conv::map_derivative(function_name) {
let mut args = ctx.prepare_args(arguments, 1, function_span);
let expr = self.expression(args.next()?, ctx)?;
args.finish()?;
ir::Expression::Derivative { axis, ctrl, expr }
(
ir::Expression::Derivative { axis, ctrl, expr },
MustUse::Yes,
)
} else if let Some(fun) = conv::map_standard_fun(function_name) {
self.math_function_helper(function_span, fun, arguments, ctx)?
(
self.math_function_helper(function_span, fun, arguments, ctx)?,
MustUse::Yes,
)
} else if let Some(fun) = Texture::map(function_name) {
self.texture_sample_helper(fun, arguments, function_span, ctx)?
(
self.texture_sample_helper(fun, arguments, function_span, ctx)?,
MustUse::Yes,
)
} else if let Some((op, cop)) = conv::map_subgroup_operation(function_name) {
return Ok(Some(self.subgroup_operation_helper(
function_span,
op,
cop,
arguments,
ctx,
)?));
return Ok(Some((
self.subgroup_operation_helper(function_span, op, cop, arguments, ctx)?,
MustUse::Yes,
)));
} else if let Some(mode) = SubgroupGather::map(function_name) {
return Ok(Some(self.subgroup_gather_helper(
function_span,
mode,
arguments,
ctx,
)?));
return Ok(Some((
self.subgroup_gather_helper(function_span, mode, arguments, ctx)?,
MustUse::Yes,
)));
} else if let Some(fun) = ir::AtomicFunction::map(function_name) {
return self.atomic_helper(function_span, fun, arguments, is_statement, ctx);
return Ok(self
.atomic_helper(function_span, fun, arguments, is_statement, ctx)?
.map(|result| (result, MustUse::No)));
} else {
match function_name {
"bitcast" => {
@@ -3008,11 +3031,14 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
}
};
ir::Expression::As {
expr,
kind: element_scalar.kind,
convert: None,
}
(
ir::Expression::As {
expr,
kind: element_scalar.kind,
convert: None,
},
MustUse::Yes,
)
}
"coopLoad" | "coopLoadT" => {
let row_major = function_name.ends_with("T");
@@ -3045,16 +3071,19 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
};
args.finish()?;
crate::Expression::CooperativeLoad {
columns,
rows,
role,
data: crate::CooperativeData {
pointer,
stride,
row_major,
(
crate::Expression::CooperativeLoad {
columns,
rows,
role,
data: crate::CooperativeData {
pointer,
stride,
row_major,
},
},
}
MustUse::Yes,
)
}
"select" => {
let mut args = ctx.prepare_args(arguments, 3, function_span);
@@ -3119,25 +3148,28 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
let [reject, accept] = values;
ir::Expression::Select {
reject,
accept,
condition,
}
(
ir::Expression::Select {
reject,
accept,
condition,
},
MustUse::Yes,
)
}
"arrayLength" => {
let mut args = ctx.prepare_args(arguments, 1, function_span);
let expr = self.expression(args.next()?, ctx)?;
args.finish()?;
ir::Expression::ArrayLength(expr)
(ir::Expression::ArrayLength(expr), MustUse::Yes)
}
"atomicLoad" => {
let mut args = ctx.prepare_args(arguments, 1, function_span);
let (pointer, _scalar) = self.atomic_pointer(args.next()?, ctx)?;
args.finish()?;
ir::Expression::Load { pointer }
(ir::Expression::Load { pointer }, MustUse::No)
}
"atomicStore" => {
let mut args = ctx.prepare_args(arguments, 2, function_span);
@@ -3189,7 +3221,7 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
},
function_span,
);
return Ok(Some(result));
return Ok(Some((result, MustUse::No)));
}
"textureAtomicMin" | "textureAtomicMax" | "textureAtomicAdd"
| "textureAtomicAnd" | "textureAtomicOr" | "textureAtomicXor" => {
@@ -3326,7 +3358,7 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
function_span,
);
return Ok(Some(result));
return Ok(Some((result, MustUse::Yes)));
}
"textureStore" => {
let mut args = ctx.prepare_args(arguments, 3, function_span);
@@ -3399,13 +3431,16 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
args.finish()?;
ir::Expression::ImageLoad {
image,
coordinate,
array_index,
level,
sample,
}
(
ir::Expression::ImageLoad {
image,
coordinate,
array_index,
level,
sample,
},
MustUse::Yes,
)
}
"textureDimensions" => {
let mut args = ctx.prepare_args(arguments, 1, function_span);
@@ -3417,40 +3452,52 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
.transpose()?;
args.finish()?;
ir::Expression::ImageQuery {
image,
query: ir::ImageQuery::Size { level },
}
(
ir::Expression::ImageQuery {
image,
query: ir::ImageQuery::Size { level },
},
MustUse::Yes,
)
}
"textureNumLevels" => {
let mut args = ctx.prepare_args(arguments, 1, function_span);
let image = self.expression(args.next()?, ctx)?;
args.finish()?;
ir::Expression::ImageQuery {
image,
query: ir::ImageQuery::NumLevels,
}
(
ir::Expression::ImageQuery {
image,
query: ir::ImageQuery::NumLevels,
},
MustUse::Yes,
)
}
"textureNumLayers" => {
let mut args = ctx.prepare_args(arguments, 1, function_span);
let image = self.expression(args.next()?, ctx)?;
args.finish()?;
ir::Expression::ImageQuery {
image,
query: ir::ImageQuery::NumLayers,
}
(
ir::Expression::ImageQuery {
image,
query: ir::ImageQuery::NumLayers,
},
MustUse::Yes,
)
}
"textureNumSamples" => {
let mut args = ctx.prepare_args(arguments, 1, function_span);
let image = self.expression(args.next()?, ctx)?;
args.finish()?;
ir::Expression::ImageQuery {
image,
query: ir::ImageQuery::NumSamples,
}
(
ir::Expression::ImageQuery {
image,
query: ir::ImageQuery::NumSamples,
},
MustUse::Yes,
)
}
"rayQueryInitialize" => {
let mut args = ctx.prepare_args(arguments, 3, function_span);
@@ -3480,10 +3527,13 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
let _ = ctx.module.generate_vertex_return_type();
ir::Expression::RayQueryVertexPositions {
query,
committed: true,
}
(
ir::Expression::RayQueryVertexPositions {
query,
committed: true,
},
MustUse::No,
)
}
"getCandidateHitVertexPositions" => {
let mut args = ctx.prepare_args(arguments, 1, function_span);
@@ -3492,10 +3542,13 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
let _ = ctx.module.generate_vertex_return_type();
ir::Expression::RayQueryVertexPositions {
query,
committed: false,
}
(
ir::Expression::RayQueryVertexPositions {
query,
committed: false,
},
MustUse::No,
)
}
"rayQueryProceed" => {
let mut args = ctx.prepare_args(arguments, 1, function_span);
@@ -3508,7 +3561,7 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
let rctx = ctx.runtime_expression_ctx(function_span)?;
rctx.block
.push(ir::Statement::RayQuery { query, fun }, function_span);
return Ok(Some(result));
return Ok(Some((result, MustUse::No)));
}
"rayQueryGenerateIntersection" => {
let mut args = ctx.prepare_args(arguments, 2, function_span);
@@ -3550,10 +3603,13 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
args.finish()?;
let _ = ctx.module.generate_ray_intersection_type();
ir::Expression::RayQueryGetIntersection {
query,
committed: true,
}
(
ir::Expression::RayQueryGetIntersection {
query,
committed: true,
},
MustUse::No,
)
}
"rayQueryGetCandidateIntersection" => {
let mut args = ctx.prepare_args(arguments, 1, function_span);
@@ -3561,10 +3617,13 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
args.finish()?;
let _ = ctx.module.generate_ray_intersection_type();
ir::Expression::RayQueryGetIntersection {
query,
committed: false,
}
(
ir::Expression::RayQueryGetIntersection {
query,
committed: false,
},
MustUse::No,
)
}
"subgroupBallot" => {
let mut args = ctx.prepare_args(arguments, 0, function_span);
@@ -3582,7 +3641,7 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
ir::Statement::SubgroupBallot { result, predicate },
function_span,
);
return Ok(Some(result));
return Ok(Some((result, MustUse::Yes)));
}
"quadSwapX" => {
let mut args = ctx.prepare_args(arguments, 1, function_span);
@@ -3605,7 +3664,7 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
},
function_span,
);
return Ok(Some(result));
return Ok(Some((result, MustUse::Yes)));
}
"quadSwapY" => {
let mut args = ctx.prepare_args(arguments, 1, function_span);
@@ -3628,7 +3687,7 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
},
function_span,
);
return Ok(Some(result));
return Ok(Some((result, MustUse::Yes)));
}
"quadSwapDiagonal" => {
let mut args = ctx.prepare_args(arguments, 1, function_span);
@@ -3651,7 +3710,7 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
},
function_span,
);
return Ok(Some(result));
return Ok(Some((result, MustUse::Yes)));
}
"coopStore" | "coopStoreT" => {
let row_major = function_name.ends_with("T");
@@ -3701,7 +3760,10 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
let c = self.expression(args.next()?, ctx)?;
args.finish()?;
ir::Expression::CooperativeMultiplyAdd { a, b, c }
(
ir::Expression::CooperativeMultiplyAdd { a, b, c },
MustUse::Yes,
)
}
"traceRay" => {
let mut args = ctx.prepare_args(arguments, 3, function_span);
@@ -3730,7 +3792,7 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
};
let expr = ctx.append_expression(expr, function_span)?;
Ok(Some(expr))
Ok(Some((expr, must_use)))
}
/// Generate Naga IR for call expressions and statements, and type
@@ -3772,25 +3834,27 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
let mut tl = TemplateListIter::new(function_span, &call_phrase.function.template_list);
match ctx.globals.get(function_name) {
let result = match ctx.globals.get(function_name) {
Some(&LoweredGlobalDecl::Type(ty)) => {
// user-declared types can't make use of template lists
tl.finish(ctx)?;
let handle =
self.construct(span, Constructor::Type(ty), function_span, arguments, ctx)?;
Ok(Some(handle))
Some((handle, MustUse::Yes))
}
Some(
&LoweredGlobalDecl::Const(_)
| &LoweredGlobalDecl::Override(_)
| &LoweredGlobalDecl::Var(_),
) => Err(Box::new(Error::Unexpected(
function_span,
ExpectedToken::Function,
))),
) => {
return Err(Box::new(Error::Unexpected(
function_span,
ExpectedToken::Function,
)))
}
Some(&LoweredGlobalDecl::EntryPoint(_)) => {
Err(Box::new(Error::CalledEntryPoint(function_span)))
return Err(Box::new(Error::CalledEntryPoint(function_span)));
}
Some(&LoweredGlobalDecl::Function {
handle: function,
@@ -3824,10 +3888,6 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
let has_result = ctx.module.functions[function].result.is_some();
if must_use && is_statement {
return Err(Box::new(Error::FunctionMustUseUnused(function_span)));
}
let rctx = ctx.runtime_expression_ctx(span)?;
// we need to always do this before a fn call since all arguments need to be emitted before the fn call
rctx.block
@@ -3839,19 +3899,19 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
.append(ir::Expression::CallResult(function), span);
rctx.local_expression_kind_tracker
.insert(result, proc::ExpressionKind::Runtime);
result
(result, must_use.into())
});
rctx.emitter.start(&rctx.function.expressions);
rctx.block.push(
ir::Statement::Call {
function,
arguments,
result,
result: result.map(|(expr, _)| expr),
},
span,
);
Ok(result)
result
}
None => {
// If the name refers to a predeclared type, this is a construction expression.
@@ -3885,25 +3945,29 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
tl.finish(ctx)?;
let handle =
self.construct(span, constructor_ty, function_span, arguments, ctx)?;
return Ok(Some(handle));
};
// Otherwise, it must be a call to a builtin function.
let expr = self.call_builtin(
function_name,
function_span,
arguments,
&mut tl,
span,
ctx,
is_statement,
)?;
tl.finish(ctx)?;
Ok(expr)
Some((handle, MustUse::Yes))
} else {
// Otherwise, it must be a call to a builtin function.
let result = self.call_builtin(
function_name,
function_span,
arguments,
&mut tl,
span,
ctx,
is_statement,
)?;
tl.finish(ctx)?;
result
}
}
};
let result_used = !is_statement;
if matches!(result, Some((_, MustUse::Yes))) && !result_used {
return Err(Box::new(Error::FunctionMustUseUnused(function_span)));
}
Ok(result.map(|(expr, _)| expr))
}
/// Generate a Naga IR [`Math`] expression.
+25 -25
View File
@@ -11,32 +11,32 @@ fn main(
) {
subgroupBarrier();
subgroupBallot((subgroup_invocation_id & 1u) == 1u);
subgroupBallot();
_ = subgroupBallot((subgroup_invocation_id & 1u) == 1u);
_ = subgroupBallot();
subgroupAll(subgroup_invocation_id != 0u);
subgroupAny(subgroup_invocation_id == 0u);
subgroupAdd(subgroup_invocation_id);
subgroupMul(subgroup_invocation_id);
subgroupMin(subgroup_invocation_id);
subgroupMax(subgroup_invocation_id);
subgroupAnd(subgroup_invocation_id);
subgroupOr(subgroup_invocation_id);
subgroupXor(subgroup_invocation_id);
subgroupExclusiveAdd(subgroup_invocation_id);
subgroupExclusiveMul(subgroup_invocation_id);
subgroupInclusiveAdd(subgroup_invocation_id);
subgroupInclusiveMul(subgroup_invocation_id);
_ = subgroupAll(subgroup_invocation_id != 0u);
_ = subgroupAny(subgroup_invocation_id == 0u);
_ = subgroupAdd(subgroup_invocation_id);
_ = subgroupMul(subgroup_invocation_id);
_ = subgroupMin(subgroup_invocation_id);
_ = subgroupMax(subgroup_invocation_id);
_ = subgroupAnd(subgroup_invocation_id);
_ = subgroupOr(subgroup_invocation_id);
_ = subgroupXor(subgroup_invocation_id);
_ = subgroupExclusiveAdd(subgroup_invocation_id);
_ = subgroupExclusiveMul(subgroup_invocation_id);
_ = subgroupInclusiveAdd(subgroup_invocation_id);
_ = subgroupInclusiveMul(subgroup_invocation_id);
subgroupBroadcastFirst(subgroup_invocation_id);
subgroupBroadcast(subgroup_invocation_id, 4u);
subgroupShuffle(subgroup_invocation_id, sizes.subgroup_size - 1u - subgroup_invocation_id);
subgroupShuffleDown(subgroup_invocation_id, 1u);
subgroupShuffleUp(subgroup_invocation_id, 1u);
subgroupShuffleXor(subgroup_invocation_id, sizes.subgroup_size - 1u);
_ = subgroupBroadcastFirst(subgroup_invocation_id);
_ = subgroupBroadcast(subgroup_invocation_id, 4u);
_ = subgroupShuffle(subgroup_invocation_id, sizes.subgroup_size - 1u - subgroup_invocation_id);
_ = subgroupShuffleDown(subgroup_invocation_id, 1u);
_ = subgroupShuffleUp(subgroup_invocation_id, 1u);
_ = subgroupShuffleXor(subgroup_invocation_id, sizes.subgroup_size - 1u);
quadBroadcast(subgroup_invocation_id, 4u);
quadSwapX(subgroup_invocation_id);
quadSwapY(subgroup_invocation_id);
quadSwapDiagonal(subgroup_invocation_id);
_ = quadBroadcast(subgroup_invocation_id, 4u);
_ = quadSwapX(subgroup_invocation_id);
_ = quadSwapY(subgroup_invocation_id);
_ = quadSwapDiagonal(subgroup_invocation_id);
}
+6 -6
View File
@@ -3934,7 +3934,7 @@ fn subgroup_capability() {
&format!("
{stage_attr}
fn main() {{
subgroupBallot();
_ = subgroupBallot();
}}
"),
Err(naga::valid::ValidationError::EntryPoint {
@@ -3959,7 +3959,7 @@ fn subgroup_capability() {
"
{stage_attr}
fn main() {{
subgroupBallot();
_ = subgroupBallot();
}}
"
),
@@ -3976,7 +3976,7 @@ fn subgroup_capability() {
"
@vertex
fn main() -> @builtin(position) vec4<f32> {{
subgroupBallot();
_ = subgroupBallot();
return vec4();
}}
":
@@ -3988,7 +3988,7 @@ fn subgroup_capability() {
"
@vertex
fn main() -> @builtin(position) vec4<f32> {{
subgroupBallot();
_ = subgroupBallot();
return vec4();
}}
",
@@ -4085,7 +4085,7 @@ fn subgroup_invalid_broadcast() {
check_validation! {
r#"
fn main(id: u32) {
subgroupBroadcast(123, id);
_ = subgroupBroadcast(123, id);
}
"#:
Err(naga::valid::ValidationError::Function {
@@ -4099,7 +4099,7 @@ fn subgroup_invalid_broadcast() {
check_validation! {
r#"
fn main(id: u32) {
quadBroadcast(123, id);
_ = quadBroadcast(123, id);
}
"#:
Err(naga::valid::ValidationError::Function {