Use concrete_int_scalars and vector_sizes helpers. Avoid Box::leak.

Author: andyleiserson

naga/src/back/msl/keywords.rs

@@ -1,15 +1,13 @@
-use crate::common;
-use crate::proc::KeywordSet;
+use crate::proc::{concrete_int_scalars, vector_size_str, vector_sizes, KeywordSet};
 use crate::racy_lock::RacyLock;
-use alloc::vec::Vec;
-use alloc::{boxed::Box, format};
+use alloc::{format, string::String, vec::Vec};
 
 // MSLS - Metal Shading Language Specification:
 // https://developer.apple.com/metal/Metal-Shading-Language-Specification.pdf
 //
 // C++ - Standard for Programming Language C++ (N4431)
 // https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4431.pdf
-pub const RESERVED: &[&str] = &[
+const RESERVED: &[&str] = &[
     // Undocumented
     "assert", // found in https://github.com/gfx-rs/wgpu/issues/5347
     // Standard for Programming Language C++ (N4431): 2.5 Alternative tokens
@@ -363,65 +361,31 @@ pub const RESERVED: &[&str] = &[
     super::writer::EXTERNAL_TEXTURE_WRAPPER_STRUCT,
 ];
 
-const CONCRETE_INTEGER_SCALARS: [crate::Scalar; 4] = [
-    crate::Scalar::I32,
-    crate::Scalar::U32,
-    crate::Scalar::I64,
-    crate::Scalar::U64,
-];
-
-const CONCRETE_VECTOR_SIZES: [crate::VectorSize; 3] = [
-    crate::VectorSize::Bi,
-    crate::VectorSize::Tri,
-    crate::VectorSize::Quad,
-];
-
-/// The above set of reserved keywords, turned into a cached HashSet. This saves
-/// significant time during [`Namer::reset`](crate::proc::Namer::reset).
-///
-/// See <https://github.com/gfx-rs/wgpu/pull/7338> for benchmarks.
-pub static RESERVED_SET: RacyLock<KeywordSet> = RacyLock::new(|| {
-    let mut set = KeywordSet::from_iter(RESERVED);
-    // Add all concrete integer dot product function variants.
-    // These are generated to match the names produced by
-    // `Writer::get_dot_wrapper_function_helper_name`, ensuring they stay in sync.
-    let mut dot_function_names: Vec<&'static str> = Vec::new();
-    for scalar in CONCRETE_INTEGER_SCALARS {
-        // Map scalar to MSL type name (matching the logic in Scalar::to_msl_name)
-        let type_name = match scalar {
-            crate::Scalar {
-                kind: crate::ScalarKind::Sint,
-                width: 4,
-            } => "int",
-            crate::Scalar {
-                kind: crate::ScalarKind::Uint,
-                width: 4,
-            } => "uint",
-            crate::Scalar {
-                kind: crate::ScalarKind::Sint,
-                width: 8,
-            } => "long",
-            crate::Scalar {
-                kind: crate::ScalarKind::Uint,
-                width: 8,
-            } => "ulong",
-            _ => continue, // Skip non-integer or unsupported types
-        };
-
-        for size in CONCRETE_VECTOR_SIZES {
-            let size_suffix = common::vector_size_str(size);
+// The set of concrete integer dot product function variants.
+// This must match the set of names that could be produced by
+// `Writer::get_dot_wrapper_function_helper_name`.
+static DOT_FUNCTION_NAMES: RacyLock<Vec<String>> = RacyLock::new(|| {
+    let mut names = Vec::new();
+    for scalar in concrete_int_scalars().map(crate::Scalar::to_msl_name) {
+        for size_suffix in vector_sizes().map(vector_size_str) {
             let fun_name = format!(
                 "{}_{}{}",
                 super::writer::DOT_FUNCTION_PREFIX,
-                type_name,
+                scalar,
                 size_suffix
             );
-            // Convert to &'static str by leaking the String
-            // (In theory) This is safe because these are generated once and cached
-            let leaked = Box::leak(fun_name.into_boxed_str());
-            dot_function_names.push(leaked);
+            names.push(fun_name);
         }
     }
-    set.extend(dot_function_names);
+    names
+});
+
+/// The above set of reserved keywords, turned into a cached HashSet. This saves
+/// significant time during [`Namer::reset`](crate::proc::Namer::reset).
+///
+/// See <https://github.com/gfx-rs/wgpu/pull/7338> for benchmarks.
+pub static RESERVED_SET: RacyLock<KeywordSet> = RacyLock::new(|| {
+    let mut set = KeywordSet::from_iter(RESERVED);
+    set.extend(DOT_FUNCTION_NAMES.iter().map(String::as_str));
     set
 });

naga/src/back/msl/writer.rs

@@ -19,7 +19,7 @@ use crate::{
     back::{self, get_entry_points, Baked},
     common,
     proc::{
-        self,
+        self, concrete_int_scalars,
         index::{self, BoundsCheck},
         ExternalTextureNameKey, NameKey, TypeResolution,
     },
@@ -489,7 +489,7 @@ pub struct Writer<W> {
 }
 
 impl crate::Scalar {
-    fn to_msl_name(self) -> &'static str {
+    pub(super) fn to_msl_name(self) -> &'static str {
         use crate::ScalarKind as Sk;
         match self {
             Self {
@@ -5796,12 +5796,18 @@ template <typename A>
     }
 
     /// Build the mangled helper name for integer vector dot products.
+    ///
+    /// `scalar` must be a concrete integer scalar type.
+    ///
     /// Result format: `{DOT_FUNCTION_PREFIX}_{type}{N}` (e.g., `naga_dot_int3`).
     fn get_dot_wrapper_function_helper_name(
         &self,
         scalar: crate::Scalar,
         size: crate::VectorSize,
     ) -> String {
+        // Check for consistency with [`super::keywords::RESERVED_SET`]
+        debug_assert!(concrete_int_scalars().any(|s| s == scalar));
+
         let type_name = scalar.to_msl_name();
         let size_suffix = common::vector_size_str(size);
         format!("{DOT_FUNCTION_PREFIX}_{type_name}{size_suffix}")