[naga] Move TypeInner::automatically_converts_to into proc.

Make the associated function `TypeInner::automatically_converts_to`
available outside the WGSL front end by moving it into the
`proc::type_methods` module.

Author: jimblandy

naga/src/front/wgsl/lower/conversion.rs

@@ -338,96 +338,6 @@ impl<'source> super::ExpressionContext<'source, '_, '_> {
 }
 
 impl crate::TypeInner {
-    /// Determine whether `self` automatically converts to `goal`.
-    ///
-    /// If WGSL's automatic conversions (excluding the Load Rule) will
-    /// convert `self` to `goal`, then return a pair `(from, to)`,
-    /// where `from` and `to` are the scalar types of the leaf values
-    /// of `self` and `goal`.
-    ///
-    /// This function assumes that `self` and `goal` are different
-    /// types. Callers should first check whether any conversion is
-    /// needed at all.
-    ///
-    /// If the automatic conversions cannot convert `self` to `goal`,
-    /// return `None`.
-    fn automatically_converts_to(
-        &self,
-        goal: &Self,
-        types: &crate::UniqueArena<crate::Type>,
-    ) -> Option<(crate::Scalar, crate::Scalar)> {
-        use crate::ScalarKind as Sk;
-        use crate::TypeInner as Ti;
-
-        // Automatic conversions only change the scalar type of a value's leaves
-        // (e.g., `vec4<AbstractFloat>` to `vec4<f32>`), never the type
-        // constructors applied to those scalar types (e.g., never scalar to
-        // `vec4`, or `vec2` to `vec3`). So first we check that the type
-        // constructors match, extracting the leaf scalar types in the process.
-        let expr_scalar;
-        let goal_scalar;
-        match (self, goal) {
-            (&Ti::Scalar(expr), &Ti::Scalar(goal)) => {
-                expr_scalar = expr;
-                goal_scalar = goal;
-            }
-            (
-                &Ti::Vector {
-                    size: expr_size,
-                    scalar: expr,
-                },
-                &Ti::Vector {
-                    size: goal_size,
-                    scalar: goal,
-                },
-            ) if expr_size == goal_size => {
-                expr_scalar = expr;
-                goal_scalar = goal;
-            }
-            (
-                &Ti::Matrix {
-                    rows: expr_rows,
-                    columns: expr_columns,
-                    scalar: expr,
-                },
-                &Ti::Matrix {
-                    rows: goal_rows,
-                    columns: goal_columns,
-                    scalar: goal,
-                },
-            ) if expr_rows == goal_rows && expr_columns == goal_columns => {
-                expr_scalar = expr;
-                goal_scalar = goal;
-            }
-            (
-                &Ti::Array {
-                    base: expr_base,
-                    size: expr_size,
-                    stride: _,
-                },
-                &Ti::Array {
-                    base: goal_base,
-                    size: goal_size,
-                    stride: _,
-                },
-            ) if expr_size == goal_size => {
-                return types[expr_base]
-                    .inner
-                    .automatically_converts_to(&types[goal_base].inner, types);
-            }
-            _ => return None,
-        }
-
-        match (expr_scalar.kind, goal_scalar.kind) {
-            (Sk::AbstractFloat, Sk::Float) => {}
-            (Sk::AbstractInt, Sk::Sint | Sk::Uint | Sk::AbstractFloat | Sk::Float) => {}
-            _ => return None,
-        }
-
-        log::trace!("      okay: expr {expr_scalar:?}, goal {goal_scalar:?}");
-        Some((expr_scalar, goal_scalar))
-    }
-
     fn automatically_convertible_scalar(
         &self,
         types: &crate::UniqueArena<crate::Type>,

naga/src/proc/type_methods.rs

@@ -303,4 +303,109 @@ impl crate::TypeInner {
             | crate::TypeInner::BindingArray { .. } => false,
         }
     }
+
+    /// Determine whether `self` automatically converts to `goal`.
+    ///
+    /// If Naga IR's automatic conversions will convert `self` to
+    /// `goal`, then return a pair `(from, to)`, where `from` and `to`
+    /// are the scalar types of the leaf values of `self` and `goal`.
+    ///
+    /// If `self` and `goal` are the same type, this will simply return
+    /// a pair `(S, S)`.
+    ///
+    /// If the automatic conversions cannot convert `self` to `goal`,
+    /// return `None`.
+    ///
+    /// Naga IR's automatic conversions will convert:
+    ///
+    /// - [`AbstractInt`] scalars to [`AbstractFloat`] or any numeric scalar type
+    ///
+    /// - [`AbstractFloat`] scalars to any floating-point scalar type
+    ///
+    /// - A [`Vector`] `{ size, scalar: S }` to `{ size, scalar: T }`
+    ///   if they would convert `S` to `T`
+    ///
+    /// - An [`Array`] `{ base: S, size, stride }` to `{ base: T, size, stride }`
+    ///   if they would convert `S` to `T`
+    ///
+    /// [`AbstractInt`]: crate::ScalarKind::AbstractInt
+    /// [`AbstractFloat`]: crate::ScalarKind::AbstractFloat
+    /// [`Vector`]: crate::TypeInner::Vector
+    /// [`Array`]: crate::TypeInner::Array
+    pub fn automatically_converts_to(
+        &self,
+        goal: &Self,
+        types: &crate::UniqueArena<crate::Type>,
+    ) -> Option<(crate::Scalar, crate::Scalar)> {
+        use crate::ScalarKind as Sk;
+        use crate::TypeInner as Ti;
+
+        // Automatic conversions only change the scalar type of a value's leaves
+        // (e.g., `vec4<AbstractFloat>` to `vec4<f32>`), never the type
+        // constructors applied to those scalar types (e.g., never scalar to
+        // `vec4`, or `vec2` to `vec3`). So first we check that the type
+        // constructors match, extracting the leaf scalar types in the process.
+        let expr_scalar;
+        let goal_scalar;
+        match (self, goal) {
+            (&Ti::Scalar(expr), &Ti::Scalar(goal)) => {
+                expr_scalar = expr;
+                goal_scalar = goal;
+            }
+            (
+                &Ti::Vector {
+                    size: expr_size,
+                    scalar: expr,
+                },
+                &Ti::Vector {
+                    size: goal_size,
+                    scalar: goal,
+                },
+            ) if expr_size == goal_size => {
+                expr_scalar = expr;
+                goal_scalar = goal;
+            }
+            (
+                &Ti::Matrix {
+                    rows: expr_rows,
+                    columns: expr_columns,
+                    scalar: expr,
+                },
+                &Ti::Matrix {
+                    rows: goal_rows,
+                    columns: goal_columns,
+                    scalar: goal,
+                },
+            ) if expr_rows == goal_rows && expr_columns == goal_columns => {
+                expr_scalar = expr;
+                goal_scalar = goal;
+            }
+            (
+                &Ti::Array {
+                    base: expr_base,
+                    size: expr_size,
+                    stride: _,
+                },
+                &Ti::Array {
+                    base: goal_base,
+                    size: goal_size,
+                    stride: _,
+                },
+            ) if expr_size == goal_size => {
+                return types[expr_base]
+                    .inner
+                    .automatically_converts_to(&types[goal_base].inner, types);
+            }
+            _ => return None,
+        }
+
+        match (expr_scalar.kind, goal_scalar.kind) {
+            (Sk::AbstractFloat, Sk::Float) => {}
+            (Sk::AbstractInt, Sk::Sint | Sk::Uint | Sk::AbstractFloat | Sk::Float) => {}
+            _ => return None,
+        }
+
+        log::trace!("      okay: expr {expr_scalar:?}, goal {goal_scalar:?}");
+        Some((expr_scalar, goal_scalar))
+    }
 }