diff --git a/naga/src/back/glsl/mod.rs b/naga/src/back/glsl/mod.rs
index c669f032c7..4c672c11b7 100644
--- a/naga/src/back/glsl/mod.rs
+++ b/naga/src/back/glsl/mod.rs
@@ -63,6 +63,7 @@ use thiserror::Error;
 
 use crate::{
     back::{self, Baked},
+    common,
     proc::{self, ExpressionKindTracker, NameKey},
     valid, Handle, ShaderStage, TypeInner,
 };
@@ -3446,7 +3447,7 @@ impl<'a, W: Write> Writer<'a, W> {
                             TypeInner::Vector { size, .. } => write!(
                                 self.out,
                                 ", vec{}(0.0), vec{0}(1.0)",
-                                back::vector_size_str(size)
+                                common::vector_size_str(size)
                             )?,
                             _ => write!(self.out, ", 0.0, 1.0")?,
                         }
@@ -3593,7 +3594,7 @@ impl<'a, W: Write> Writer<'a, W> {
                     Mf::CountTrailingZeros => {
                         match *ctx.resolve_type(arg, &self.module.types) {
                             TypeInner::Vector { size, scalar, .. } => {
-                                let s = back::vector_size_str(size);
+                                let s = common::vector_size_str(size);
                                 if let crate::ScalarKind::Uint = scalar.kind {
                                     write!(self.out, "min(uvec{s}(findLSB(")?;
                                     self.write_expr(arg, ctx)?;
@@ -3623,7 +3624,7 @@ impl<'a, W: Write> Writer<'a, W> {
                         if self.options.version.supports_integer_functions() {
                             match *ctx.resolve_type(arg, &self.module.types) {
                                 TypeInner::Vector { size, scalar } => {
-                                    let s = back::vector_size_str(size);
+                                    let s = common::vector_size_str(size);
 
                                     if let crate::ScalarKind::Uint = scalar.kind {
                                         write!(self.out, "uvec{s}(ivec{s}(31) - findMSB(")?;
@@ -3654,7 +3655,7 @@ impl<'a, W: Write> Writer<'a, W> {
                         } else {
                             match *ctx.resolve_type(arg, &self.module.types) {
                                 TypeInner::Vector { size, scalar } => {
-                                    let s = back::vector_size_str(size);
+                                    let s = common::vector_size_str(size);
 
                                     if let crate::ScalarKind::Uint = scalar.kind {
                                         write!(self.out, "uvec{s}(")?;
diff --git a/naga/src/back/hlsl/conv.rs b/naga/src/back/hlsl/conv.rs
index 11a9e83548..6553745ac2 100644
--- a/naga/src/back/hlsl/conv.rs
+++ b/naga/src/back/hlsl/conv.rs
@@ -1,3 +1,5 @@
+use crate::common;
+
 use alloc::{borrow::Cow, format, string::String};
 
 use super::Error;
@@ -88,7 +90,7 @@ impl crate::TypeInner {
             crate::TypeInner::Vector { size, scalar } => Cow::Owned(format!(
                 "{}{}",
                 scalar.to_hlsl_str()?,
-                crate::back::vector_size_str(size)
+                common::vector_size_str(size)
             )),
             crate::TypeInner::Matrix {
                 columns,
@@ -97,8 +99,8 @@ impl crate::TypeInner {
             } => Cow::Owned(format!(
                 "{}{}x{}",
                 scalar.to_hlsl_str()?,
-                crate::back::vector_size_str(columns),
-                crate::back::vector_size_str(rows),
+                common::vector_size_str(columns),
+                common::vector_size_str(rows),
             )),
             crate::TypeInner::Array {
                 base,
diff --git a/naga/src/back/hlsl/writer.rs b/naga/src/back/hlsl/writer.rs
index 953def189f..02b8e9aaf3 100644
--- a/naga/src/back/hlsl/writer.rs
+++ b/naga/src/back/hlsl/writer.rs
@@ -16,6 +16,7 @@ use super::{
 };
 use crate::{
     back::{self, Baked},
+    common,
     proc::{self, index, ExpressionKindTracker, NameKey},
     valid, Handle, Module, RayQueryFunction, Scalar, ScalarKind, ShaderStage, TypeInner,
 };
@@ -1321,7 +1322,7 @@ impl<'a, W: fmt::Write> super::Writer<'a, W> {
                     self.out,
                     "{}{}",
                     scalar.to_hlsl_str()?,
-                    back::vector_size_str(size)
+                    common::vector_size_str(size)
                 )?;
             }
             TypeInner::Matrix {
@@ -1337,8 +1338,8 @@ impl<'a, W: fmt::Write> super::Writer<'a, W> {
                     self.out,
                     "{}{}x{}",
                     scalar.to_hlsl_str()?,
-                    back::vector_size_str(columns),
-                    back::vector_size_str(rows),
+                    common::vector_size_str(columns),
+                    common::vector_size_str(rows),
                 )?;
             }
             TypeInner::Image {
@@ -3340,7 +3341,7 @@ impl<'a, W: fmt::Write> super::Writer<'a, W> {
                                     self.out,
                                     "{}{}(",
                                     scalar.to_hlsl_str()?,
-                                    back::vector_size_str(size)
+                                    common::vector_size_str(size)
                                 )?;
                             }
                             TypeInner::Scalar(_) => {
@@ -3351,8 +3352,8 @@ impl<'a, W: fmt::Write> super::Writer<'a, W> {
                                     self.out,
                                     "{}{}x{}(",
                                     scalar.to_hlsl_str()?,
-                                    back::vector_size_str(columns),
-                                    back::vector_size_str(rows)
+                                    common::vector_size_str(columns),
+                                    common::vector_size_str(rows)
                                 )?;
                             }
                             _ => {
diff --git a/naga/src/back/mod.rs b/naga/src/back/mod.rs
index 2acb18626a..0f293ba925 100644
--- a/naga/src/back/mod.rs
+++ b/naga/src/back/mod.rs
@@ -250,15 +250,6 @@ pub const fn binary_operation_str(op: crate::BinaryOperator) -> &'static str {
     }
 }
 
-/// Helper function that returns the string corresponding to the [`VectorSize`](crate::VectorSize)
-const fn vector_size_str(size: crate::VectorSize) -> &'static str {
-    match size {
-        crate::VectorSize::Bi => "2",
-        crate::VectorSize::Tri => "3",
-        crate::VectorSize::Quad => "4",
-    }
-}
-
 impl crate::TypeInner {
     /// Returns true if this is a handle to a type rather than the type directly.
     pub const fn is_handle(&self) -> bool {
diff --git a/naga/src/back/msl/writer.rs b/naga/src/back/msl/writer.rs
index 3b1e28f67a..bd90b96b6b 100644
--- a/naga/src/back/msl/writer.rs
+++ b/naga/src/back/msl/writer.rs
@@ -13,6 +13,7 @@ use super::{sampler as sm, Error, LocationMode, Options, PipelineOptions, Transl
 use crate::{
     arena::{Handle, HandleSet},
     back::{self, Baked},
+    common,
     proc::{self, index, ExpressionKindTracker, NameKey, TypeResolution},
     valid, FastHashMap, FastHashSet,
 };
@@ -80,7 +81,7 @@ fn put_numeric_type(
                 "{}::{}{}",
                 NAMESPACE,
                 scalar.to_msl_name(),
-                back::vector_size_str(rows)
+                common::vector_size_str(rows)
             )
         }
         (scalar, &[rows, columns]) => {
@@ -89,8 +90,8 @@ fn put_numeric_type(
                 "{}::{}{}x{}",
                 NAMESPACE,
                 scalar.to_msl_name(),
-                back::vector_size_str(columns),
-                back::vector_size_str(rows)
+                common::vector_size_str(columns),
+                common::vector_size_str(rows)
             )
         }
         (_, _) => Ok(()), // not meaningful
@@ -1408,7 +1409,7 @@ impl<W: Write> Writer<W> {
             .to_msl_name();
         match context.resolve_type(arg) {
             &crate::TypeInner::Vector { size, .. } => {
-                let size = back::vector_size_str(size);
+                let size = common::vector_size_str(size);
                 write!(self.out, "{scalar}{size}(-1), {scalar}{size}(1)")?;
             }
             _ => {
@@ -2133,7 +2134,7 @@ impl<W: Write> Writer<W> {
                         // or metal will complain that select is ambiguous
                         match *inner {
                             crate::TypeInner::Vector { size, scalar } => {
-                                let size = back::vector_size_str(size);
+                                let size = common::vector_size_str(size);
                                 let name = scalar.to_msl_name();
                                 write!(self.out, "{name}{size}")?;
                             }
@@ -2261,7 +2262,7 @@ impl<W: Write> Writer<W> {
                             crate::TypeInner::Vector { size, .. } => write!(
                                 self.out,
                                 "{NAMESPACE}::float{size}({NAMESPACE}::half{size}(",
-                                size = back::vector_size_str(size),
+                                size = common::vector_size_str(size),
                             )?,
                             _ => unreachable!(
                                 "Correct TypeInner for QuantizeToF16 should be already validated"
diff --git a/naga/src/back/wgsl/writer.rs b/naga/src/back/wgsl/writer.rs
index 7c6b3bf242..c56fcb5572 100644
--- a/naga/src/back/wgsl/writer.rs
+++ b/naga/src/back/wgsl/writer.rs
@@ -11,7 +11,10 @@ use super::ToWgslIfImplemented as _;
 use crate::back::wgsl::polyfill::InversePolyfill;
 use crate::{
     back::{self, Baked},
-    common::wgsl::{ToWgsl, TryToWgsl},
+    common::{
+        self,
+        wgsl::{ToWgsl, TryToWgsl},
+    },
     proc::{self, ExpressionKindTracker, NameKey},
     valid, Handle, Module, ShaderStage, TypeInner,
 };
@@ -419,7 +422,7 @@ impl<W: Write> Writer<W> {
             TypeInner::Vector { size, scalar } => write!(
                 self.out,
                 "vec{}<{}>",
-                back::vector_size_str(size),
+                common::vector_size_str(size),
                 scalar_kind_str(scalar),
             )?,
             TypeInner::Sampler { comparison: false } => {
@@ -528,8 +531,8 @@ impl<W: Write> Writer<W> {
                 write!(
                     self.out,
                     "mat{}x{}<{}>",
-                    back::vector_size_str(columns),
-                    back::vector_size_str(rows),
+                    common::vector_size_str(columns),
+                    common::vector_size_str(rows),
                     scalar_kind_str(scalar)
                 )?;
             }
@@ -578,7 +581,7 @@ impl<W: Write> Writer<W> {
                         self.out,
                         "ptr<{}, vec{}<{}>",
                         space,
-                        back::vector_size_str(size),
+                        common::vector_size_str(size),
                         scalar_kind_str(scalar)
                     )?;
                     if let Some(access) = maybe_access {
@@ -1295,7 +1298,7 @@ impl<W: Write> Writer<W> {
                 write!(self.out, ")")?
             }
             Expression::Splat { size, value } => {
-                let size = back::vector_size_str(size);
+                let size = common::vector_size_str(size);
                 write!(self.out, "vec{size}(")?;
                 write_expression(self, value)?;
                 write!(self.out, ")")?;
@@ -1591,8 +1594,8 @@ impl<W: Write> Writer<W> {
                         write!(
                             self.out,
                             "mat{}x{}<{}>",
-                            back::vector_size_str(columns),
-                            back::vector_size_str(rows),
+                            common::vector_size_str(columns),
+                            common::vector_size_str(rows),
                             scalar_kind_str
                         )?;
                     }
@@ -1604,7 +1607,7 @@ impl<W: Write> Writer<W> {
                             kind,
                             width: convert.unwrap_or(width),
                         };
-                        let vector_size_str = back::vector_size_str(size);
+                        let vector_size_str = common::vector_size_str(size);
                         let scalar_kind_str = scalar_kind_str(scalar);
                         if convert.is_some() {
                             write!(self.out, "vec{vector_size_str}<{scalar_kind_str}>")?;
diff --git a/naga/src/common/mod.rs b/naga/src/common/mod.rs
index b603904ee0..8ed0396952 100644
--- a/naga/src/common/mod.rs
+++ b/naga/src/common/mod.rs
@@ -1,3 +1,12 @@
 //! Code common to the front and backends for specific languages.
 
 pub mod wgsl;
+
+/// Helper function that returns the string corresponding to the [`VectorSize`](crate::VectorSize)
+pub const fn vector_size_str(size: crate::VectorSize) -> &'static str {
+    match size {
+        crate::VectorSize::Bi => "2",
+        crate::VectorSize::Tri => "3",
+        crate::VectorSize::Quad => "4",
+    }
+}