Add AsView + AsMut as supertraits of Proxied and MutProxied.

PiperOrigin-RevId: 655660782

rust/codegen_traits.rs

@@ -7,7 +7,7 @@
 
 //! Traits that are implemeted by codegen types.
 
-use crate::{AsMut, AsView, MutProxied, MutProxy, ViewProxy};
+use crate::{MutProxied, MutProxy, ViewProxy};
 use create::Parse;
 use read::Serialize;
 use std::fmt::Debug;
@@ -16,12 +16,12 @@ use write::ClearAndParse;
 /// A trait that all generated owned message types implement.
 pub trait Message: MutProxied
   // Create traits:
-  + create::Parse + Default
+  + Parse + Default
   // Read traits:
-  + Debug + Serialize + AsView
+  + Debug + Serialize
   // Write traits:
   // TODO: Msg should impl Clear.
-  + ClearAndParse + AsMut
+  + ClearAndParse
   // Thread safety:
   + Send + Sync
   // Copy/Clone:
@@ -31,23 +31,22 @@ pub trait Message: MutProxied
 /// A trait that all generated message views implement.
 pub trait MessageView<'msg>: ViewProxy<'msg, Proxied = Self::Message>
     // Read traits:
-    + Debug + Serialize + AsView
+    + Debug + Serialize
     // Thread safety:
     + Send + Sync
     // Copy/Clone:
     + Copy + Clone
-    {
-      #[doc(hidden)]
-      type Message: Message;
-    }
+{
+    #[doc(hidden)]
+    type Message: Message;
+}
 
 /// A trait that all generated message muts implement.
 pub trait MessageMut<'msg>:
     MutProxy<'msg, MutProxied = Self::Message>
     // Read traits:
-    + Debug + Serialize + AsView
+    + Debug + Serialize
     // Write traits:
-    + AsMut
     // TODO: MsgMut should impl Clear and ClearAndParse.
     // Thread safety:
     + Sync
@@ -60,7 +59,6 @@ pub trait MessageMut<'msg>:
 /// Operations related to constructing a message. Only owned messages implement
 /// these traits.
 pub(crate) mod create {
-
     pub trait Parse: Sized {
         fn parse(serialized: &[u8]) -> Result<Self, crate::ParseError>;
     }

rust/cord.rs

@@ -18,7 +18,7 @@ macro_rules! impl_cord_types {
     ($($t:ty, $vt:ty);*) => {
         paste! { $(
           #[derive(Debug)]
-          pub struct [< $t Cord>];
+          pub struct [< $t Cord>](Private);
 
           #[derive(Debug)]
           pub enum [< $t Cow>]<'a> {
@@ -30,6 +30,13 @@ macro_rules! impl_cord_types {
             type View<'msg> = [< $t Cow>]<'msg>;
           }
 
+          impl AsView for [< $t Cord>] {
+            type Proxied = Self;
+            fn as_view(&self) -> [< $t Cow>]<'_> {
+              unimplemented!("Proto Cord should never be constructed");
+            }
+          }
+
           impl<'msg> Proxy<'msg> for [< $t Cow>]<'msg> {}
 
           impl<'msg> ViewProxy<'msg> for [< $t Cow>]<'msg> {}

rust/internal.rs

@@ -21,4 +21,5 @@ pub use crate::ProtoStr;
 pub use crate::__runtime::{PtrAndLen, RawMap, RawMessage, RawRepeatedField};
 
 /// Used to protect internal-only items from being used accidentally.
+#[derive(Debug)]
 pub struct Private;

rust/map.rs

@@ -109,10 +109,26 @@ impl<K: Proxied, V: ProxiedInMapValue<K>> Proxied for Map<K, V> {
     type View<'msg> = MapView<'msg, K, V> where K: 'msg, V: 'msg;
 }
 
+impl<K: Proxied, V: ProxiedInMapValue<K>> AsView for Map<K, V> {
+    type Proxied = Self;
+
+    fn as_view(&self) -> MapView<'_, K, V> {
+        self.as_view()
+    }
+}
+
 impl<K: Proxied, V: ProxiedInMapValue<K>> MutProxied for Map<K, V> {
     type Mut<'msg> = MapMut<'msg, K, V> where K: 'msg, V: 'msg;
 }
 
+impl<K: Proxied, V: ProxiedInMapValue<K>> AsMut for Map<K, V> {
+    type MutProxied = Self;
+
+    fn as_mut(&mut self) -> MapMut<'_, K, V> {
+        self.as_mut()
+    }
+}
+
 impl<'msg, K: Proxied, V: ProxiedInMapValue<K>> Proxy<'msg> for MapView<'msg, K, V> {}
 
 impl<'msg, K: Proxied, V: ProxiedInMapValue<K>> AsView for MapView<'msg, K, V> {

rust/proxied.rs

@@ -52,7 +52,7 @@ use std::fmt::Debug;
 /// An instance of a `Proxied` can be accessed immutably via `Proxied::View`.
 ///
 /// All Protobuf field types implement `Proxied`.
-pub trait Proxied: Sized {
+pub trait Proxied: AsView<Proxied = Self> + Sized {
     /// The proxy type that provides shared access to a `T`, like a `&'msg T`.
     ///
     /// Most code should use the type alias [`View`].
@@ -67,7 +67,7 @@ pub trait Proxied: Sized {
 /// and immutably via `MutProxied::View`.
 ///
 /// `MutProxied` is implemented by message, map and repeated field types.
-pub trait MutProxied: Proxied {
+pub trait MutProxied: Proxied + AsMut<MutProxied = Self> {
     /// The proxy type that provides exclusive mutable access to a `T`, like a
     /// `&'msg mut T`.
     ///
@@ -263,10 +263,24 @@ mod tests {
         type View<'msg> = MyProxiedView<'msg>;
     }
 
+    impl AsView for MyProxied {
+        type Proxied = Self;
+        fn as_view(&self) -> MyProxiedView<'_> {
+            self.as_view()
+        }
+    }
+
     impl MutProxied for MyProxied {
         type Mut<'msg> = MyProxiedMut<'msg>;
     }
 
+    impl AsMut for MyProxied {
+        type MutProxied = Self;
+        fn as_mut(&mut self) -> MyProxiedMut<'_> {
+            self.as_mut()
+        }
+    }
+
     #[derive(Debug, Clone, Copy)]
     struct MyProxiedView<'msg> {
         my_proxied_ref: &'msg MyProxied,

rust/repeated.rs

@@ -391,13 +391,35 @@ where
     type View<'msg> = RepeatedView<'msg, T> where Repeated<T>: 'msg;
 }
 
+impl<T> AsView for Repeated<T>
+where
+    T: ProxiedInRepeated,
+{
+    type Proxied = Self;
+
+    fn as_view(&self) -> RepeatedView<'_, T> {
+        self.as_view()
+    }
+}
+
 impl<T> MutProxied for Repeated<T>
 where
     T: ProxiedInRepeated,
 {
     type Mut<'msg> = RepeatedMut<'msg, T> where Repeated<T>: 'msg;
 }
 
+impl<T> AsMut for Repeated<T>
+where
+    T: ProxiedInRepeated,
+{
+    type MutProxied = Self;
+
+    fn as_mut(&mut self) -> RepeatedMut<'_, T> {
+        self.as_mut()
+    }
+}
+
 impl<'msg, T> Proxy<'msg> for RepeatedView<'msg, T> where T: ProxiedInRepeated + 'msg {}
 
 impl<'msg, T> AsView for RepeatedView<'msg, T>

rust/string.rs

@@ -72,6 +72,14 @@ impl Proxied for ProtoBytes {
     type View<'msg> = &'msg [u8];
 }
 
+impl AsView for ProtoBytes {
+    type Proxied = Self;
+
+    fn as_view(&self) -> &[u8] {
+        self.as_view()
+    }
+}
+
 impl IntoProxied<ProtoBytes> for ProtoBytes {
     fn into_proxied(self, _private: Private) -> ProtoBytes {
         self
@@ -512,6 +520,14 @@ impl Proxied for ProtoString {
     type View<'msg> = &'msg ProtoStr;
 }
 
+impl AsView for ProtoString {
+    type Proxied = Self;
+
+    fn as_view(&self) -> &ProtoStr {
+        self.as_view()
+    }
+}
+
 impl<'msg> Proxy<'msg> for &'msg ProtoStr {}
 
 impl AsView for &ProtoStr {