refactor(naga): extract Validator::validate_func_call_with_overloads

Author: ErichDonGubler

naga/src/valid/expression.rs

@@ -1,11 +1,14 @@
-use alloc::{format, string::String};
+use alloc::{
+    format,
+    string::{String, ToString},
+};
 
 use super::{compose::validate_compose, FunctionInfo, ModuleInfo, ShaderStages, TypeFlags};
 use crate::arena::UniqueArena;
 use crate::{
     arena::Handle,
     proc,
-    proc::OverloadSet as _,
+    proc::OverloadSet,
     proc::{IndexableLengthError, ResolveError},
 };
 
@@ -237,6 +240,61 @@ impl super::Validator {
         Ok(())
     }
 
+    pub(super) fn validate_func_call_with_overloads<'a, F, O, A>(
+        &self,
+        module: &crate::Module,
+        fun: F,
+        overloads: O,
+        actuals: A,
+    ) -> Result<(), ExpressionError>
+    where
+        F: core::fmt::Display + Copy,
+        O: OverloadSet,
+        A: Iterator<Item = (Handle<crate::Expression>, &'a crate::TypeInner)> + ExactSizeIterator,
+    {
+        // Start with the set of all overloads available for `fun`.
+        let mut overloads = overloads;
+        log::debug!(
+            "initial overloads for {}: {:#?}",
+            fun,
+            overloads.for_debug(&module.types)
+        );
+
+        // If any argument is not a constant expression, then no
+        // overloads that accept abstract values should be considered.
+        // `OverloadSet::concrete_only` is supposed to help impose this
+        // restriction. However, no `MathFunction` accepts a mix of
+        // abstract and concrete arguments, so we don't need to worry
+        // about that here.
+
+        let actuals_len = actuals.len();
+
+        for (i, (expr, ty)) in actuals.into_iter().enumerate() {
+            // Remove overloads that cannot accept an `i`'th
+            // argument arguments of type `ty`.
+            overloads = overloads.arg(i, ty, &module.types);
+            log::debug!(
+                "overloads after arg {i}: {:#?}",
+                overloads.for_debug(&module.types)
+            );
+
+            if overloads.is_empty() {
+                log::debug!("all overloads eliminated");
+                return Err(ExpressionError::InvalidArgumentType(
+                    fun.to_string(),
+                    i as u32,
+                    expr,
+                ));
+            }
+        }
+
+        if actuals_len < overloads.min_arguments() {
+            return Err(ExpressionError::WrongArgumentCount(fun.to_string()));
+        }
+
+        Ok(())
+    }
+
     #[allow(clippy::too_many_arguments)]
     pub(super) fn validate_expression(
         &self,
@@ -1027,43 +1085,15 @@ impl super::Validator {
                     _ => unreachable!(),
                 };
 
-                // Start with the set of all overloads available for `fun`.
-                let mut overloads = fun.overloads();
-                log::debug!(
-                    "initial overloads for {:?}: {:#?}",
-                    fun,
-                    overloads.for_debug(&module.types)
-                );
-
-                // If any argument is not a constant expression, then no
-                // overloads that accept abstract values should be considered.
-                // `OverloadSet::concrete_only` is supposed to help impose this
-                // restriction. However, no `MathFunction` accepts a mix of
-                // abstract and concrete arguments, so we don't need to worry
-                // about that here.
-
-                for (i, (&expr, &ty)) in actuals.iter().zip(actual_types).enumerate() {
-                    // Remove overloads that cannot accept an `i`'th
-                    // argument arguments of type `ty`.
-                    overloads = overloads.arg(i, ty, &module.types);
-                    log::debug!(
-                        "overloads after arg {i}: {:#?}",
-                        overloads.for_debug(&module.types)
-                    );
-
-                    if overloads.is_empty() {
-                        log::debug!("all overloads eliminated");
-                        return Err(ExpressionError::InvalidArgumentType(
-                            format!("{fun:?}"),
-                            i as u32,
-                            expr,
-                        ));
-                    }
-                }
-
-                if actuals.len() < overloads.min_arguments() {
-                    return Err(ExpressionError::WrongArgumentCount(format!("{fun:?}")));
-                }
+                self.validate_func_call_with_overloads(
+                    module,
+                    format_args!("{fun:?}"),
+                    fun.overloads(),
+                    actuals
+                        .iter()
+                        .zip(actual_types.iter())
+                        .map(|(&val, &ty)| (val, ty)),
+                )?;
 
                 ShaderStages::all()
             }