From c50f8c32eafa910bf5e43bf87434d8fb532ed844 Mon Sep 17 00:00:00 2001
From: Jim Blandy <jimb@red-bean.com>
Date: Wed, 2 Apr 2025 14:20:24 -0700
Subject: [PATCH] [naga wgsl-in] In Lowerer, check arity with
 `unconverted_arguments`.

In `naga::front::wgsl::lower::Lowerer::call`, when building `Math`
expressions, use `unconverted_arguments` to check the number of
arguments to the call. This means that `arguments` is never used in
this branch once we have built `unconverted_arguments`.

This is a minor refactor that prepares for later cleanups.
---
 naga/src/front/wgsl/lower/mod.rs | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/naga/src/front/wgsl/lower/mod.rs b/naga/src/front/wgsl/lower/mod.rs
index 80c7c18fe7..31c243548f 100644
--- a/naga/src/front/wgsl/lower/mod.rs
+++ b/naga/src/front/wgsl/lower/mod.rs
@@ -2454,22 +2454,29 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
                 } else if let Some(fun) = conv::map_standard_fun(function.name) {
                     use crate::proc::OverloadSet as _;
 
+                    let mut unconverted_arguments = Vec::with_capacity(arguments.len());
+                    for &arg in arguments {
+                        let lowered = self.expression_for_abstract(arg, ctx)?;
+                        ctx.grow_types(lowered)?;
+                        unconverted_arguments.push(lowered);
+                    }
+
                     let fun_overloads = fun.overloads();
                     let mut remaining_overloads = fun_overloads.clone();
                     let min_arguments = remaining_overloads.min_arguments();
                     let max_arguments = remaining_overloads.max_arguments();
-                    if arguments.len() < min_arguments {
+                    if unconverted_arguments.len() < min_arguments {
                         return Err(Box::new(Error::WrongArgumentCount {
                             span,
                             expected: min_arguments as u32..max_arguments as u32,
-                            found: arguments.len() as u32,
+                            found: unconverted_arguments.len() as u32,
                         }));
                     }
-                    if arguments.len() > max_arguments {
+                    if unconverted_arguments.len() > max_arguments {
                         return Err(Box::new(Error::TooManyArguments {
                             function: fun.to_wgsl_for_diagnostics(),
                             call_span: span,
-                            arg_span: ctx.ast_expressions.get_span(arguments[max_arguments]),
+                            arg_span: ctx.get_expression_span(unconverted_arguments[max_arguments]),
                             max_arguments: max_arguments as _,
                         }));
                     }
@@ -2479,13 +2486,6 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
                         remaining_overloads.for_debug(&ctx.module.types)
                     );
 
-                    let mut unconverted_arguments = Vec::with_capacity(arguments.len());
-                    for &arg in arguments {
-                        let lowered = self.expression_for_abstract(arg, ctx)?;
-                        ctx.grow_types(lowered)?;
-                        unconverted_arguments.push(lowered);
-                    }
-
                     for (arg_index, &arg) in unconverted_arguments.iter().enumerate() {
                         let ty = ctx.typifier()[arg].inner_with(&ctx.module.types);
                         log::debug!(