diff --git a/rust/BUILD b/rust/BUILD
index 4feba32..53c824b 100644
--- a/rust/BUILD
+++ b/rust/BUILD
@@ -52,6 +52,7 @@
     name = "protobuf_upb",
     srcs = [
         "internal.rs",
+        "macros.rs",
         "optional.rs",
         "proxied.rs",
         "shared.rs",
@@ -89,6 +90,7 @@
     srcs = [
         "cpp.rs",
         "internal.rs",
+        "macros.rs",
         "optional.rs",
         "proxied.rs",
         "shared.rs",
diff --git a/rust/internal.rs b/rust/internal.rs
index c1d8dca..e919746 100644
--- a/rust/internal.rs
+++ b/rust/internal.rs
@@ -32,6 +32,7 @@
 //! exposed to through the `protobuf` path but must be public for use by
 //! generated code.
 
+use crate::macros::define_opaque_nonnulls;
 pub use crate::vtable::{
     new_vtable_field_entry, BytesMutVTable, BytesOptionalMutVTable, RawVTableMutator,
 };
@@ -40,46 +41,6 @@
 /// Used to protect internal-only items from being used accidentally.
 pub struct Private;
 
-/// Defines a set of opaque pointers and a unique non-accessible pointees.
-///
-/// This provides a type safety benefit over using `NonNull<u8>` everywhere.
-/// The [Rustonomicon][nomicon] currently recommends a zero-sized struct,
-/// though this should use [`extern type`] when that is stabilized.
-///
-/// Because this defines a new private module, it can only be called once per
-/// module.
-///
-/// [nomicon]: https://doc.rust-lang.org/nomicon/ffi.html#representing-opaque-structs
-/// [`extern type`]: https://github.com/rust-lang/rust/issues/43467
-macro_rules! define_opaque_nonnulls {
-    ($($(#[$meta:meta])* $vis:vis type $name:ident = NonNull<$raw_name:ident>;)*) => {
-        mod _opaque_pointees {
-            $(
-                #[doc = concat!("Opaque pointee for [`", stringify!($name), "`][pointer]")]
-                ///
-                /// This type is not meant to be dereferenced in Rust code.
-                /// It is only meant to provide type safety for raw pointers
-                /// which are manipulated behind FFI.
-                #[doc = concat!("[pointer]: super::", stringify!($name))]
-                #[repr(C)]
-                pub struct $raw_name {
-                    _data: [u8; 0],
-                    _marker: ::std::marker::PhantomData<(*mut u8, ::std::marker::PhantomPinned)>,
-                }
-            )*
-        }
-        $(
-            $(#[$meta])*
-            ///
-            /// This is an opaque pointer used for FFI:
-            /// do not dereference this type in Rust code.
-            $vis type $name = ::std::ptr::NonNull<_opaque_pointees::$raw_name>;
-        )*
-    };
-}
-
-pub(crate) use define_opaque_nonnulls;
-
 define_opaque_nonnulls!(
     /// A raw pointer to the underlying arena for this runtime.
     pub type RawArena = NonNull<RawArenaData>;
diff --git a/rust/macros.rs b/rust/macros.rs
new file mode 100644
index 0000000..c25ddfc
--- /dev/null
+++ b/rust/macros.rs
@@ -0,0 +1,109 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2023 Google LLC.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google LLC. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+//! Runtime-internal macros
+
+/// Defines a set of opaque pointers and a unique non-accessible pointees.
+///
+/// This provides a type safety benefit over using `NonNull<u8>` everywhere.
+/// The [Rustonomicon][nomicon] currently recommends a zero-sized struct,
+/// though this should use [`extern type`] when that is stabilized.
+///
+/// Because this defines a new private module, it can only be called once per
+/// module.
+///
+/// [nomicon]: https://doc.rust-lang.org/nomicon/ffi.html#representing-opaque-structs
+/// [`extern type`]: https://github.com/rust-lang/rust/issues/43467
+macro_rules! define_opaque_nonnulls {
+    ($($(#[$meta:meta])* $vis:vis type $name:ident = NonNull<$raw_name:ident>;)*) => {
+        mod _opaque_pointees {
+            $(
+                #[doc = concat!("Opaque pointee for [`", stringify!($name), "`][pointer]")]
+                ///
+                /// This type is not meant to be dereferenced in Rust code.
+                /// It is only meant to provide type safety for raw pointers
+                /// which are manipulated behind FFI.
+                #[doc = concat!("[pointer]: super::", stringify!($name))]
+                #[repr(C)]
+                pub struct $raw_name {
+                    _data: [u8; 0],
+                    _marker: ::std::marker::PhantomData<(*mut u8, ::std::marker::PhantomPinned)>,
+                }
+            )*
+        }
+        $(
+            $(#[$meta])*
+            ///
+            /// This is an opaque pointer used for FFI:
+            /// do not dereference this type in Rust code.
+            $vis type $name = ::std::ptr::NonNull<_opaque_pointees::$raw_name>;
+        )*
+    };
+}
+pub(crate) use define_opaque_nonnulls;
+
+/// Defines a `impl SettableValue<$proxied> for SomeType` body that forwards to
+/// another implementation.
+///
+/// # Example
+/// ```ignore
+/// impl<'a, const N: usize> SettableValue<[u8]> for &'a [u8; N] {
+///     // Use the `SettableValue<[u8]>` implementation for `&[u8]`:
+///     impl_forwarding_settable_value!([u8], self => &self[..]);
+/// }
+/// ```
+macro_rules! impl_forwarding_settable_value {
+    ($proxied:ty, $self:ident => $self_forwarding_expr:expr) => {
+        fn set_on(
+            $self,
+            _private: $crate::__internal::Private,
+            mutator: $crate::Mut<'_, $proxied>,
+        ) {
+            ($self_forwarding_expr).set_on(Private, mutator)
+        }
+
+        fn set_on_absent(
+            $self,
+            _private: $crate::__internal::Private,
+            absent_mutator: <$proxied as $crate::ProxiedWithPresence>::AbsentMutData<'_>,
+        ) -> <$proxied as $crate::ProxiedWithPresence>::PresentMutData<'_> {
+            ($self_forwarding_expr).set_on_absent($crate::__internal::Private, absent_mutator)
+        }
+
+        fn set_on_present(
+            $self,
+            _private: $crate::__internal::Private,
+            present_mutator: <$proxied as $crate::ProxiedWithPresence>::PresentMutData<'_>,
+        ) {
+            ($self_forwarding_expr).set_on_present($crate::__internal::Private, present_mutator)
+        }
+    };
+}
+pub(crate) use impl_forwarding_settable_value;
diff --git a/rust/shared.rs b/rust/shared.rs
index 5abd8be..b6f8805 100644
--- a/rust/shared.rs
+++ b/rust/shared.rs
@@ -64,6 +64,7 @@
 #[path = "upb.rs"]
 pub mod __runtime;
 
+mod macros;
 mod optional;
 mod proxied;
 mod string;
diff --git a/rust/string.rs b/rust/string.rs
index fe78871..523a508 100644
--- a/rust/string.rs
+++ b/rust/string.rs
@@ -34,6 +34,7 @@
 
 use crate::__internal::{Private, PtrAndLen, RawMessage};
 use crate::__runtime::{BytesAbsentMutData, BytesPresentMutData, InnerBytesMut};
+use crate::macros::impl_forwarding_settable_value;
 use crate::{Mut, MutProxy, Proxied, ProxiedWithPresence, SettableValue, View, ViewProxy};
 use std::borrow::Cow;
 use std::cmp::{Eq, Ord, Ordering, PartialEq, PartialOrd};
@@ -230,30 +231,6 @@
     }
 }
 
-macro_rules! impl_forwarding_settable_value {
-    ($proxied:ty, $self:ident => $self_forwarding_expr:expr) => {
-        fn set_on($self, _private: Private, mutator: BytesMut<'_>) {
-            ($self_forwarding_expr).set_on(Private, mutator)
-        }
-
-        fn set_on_absent(
-            $self,
-            _private: Private,
-            absent_mutator: <$proxied as ProxiedWithPresence>::AbsentMutData<'_>,
-        ) -> <$proxied as ProxiedWithPresence>::PresentMutData<'_> {
-            ($self_forwarding_expr).set_on_absent(Private, absent_mutator)
-        }
-
-        fn set_on_present(
-            $self,
-            _private: Private,
-            present_mutator: <$proxied as ProxiedWithPresence>::PresentMutData<'_>,
-        ) {
-            ($self_forwarding_expr).set_on_present(Private, present_mutator)
-        }
-    };
-}
-
 impl<'a, const N: usize> SettableValue<[u8]> for &'a [u8; N] {
     // forward to `self[..]`
     impl_forwarding_settable_value!([u8], self => &self[..]);