Internal change

PiperOrigin-RevId: 952911533

Author: runzw

rust/upb/BUILD

@@ -17,6 +17,7 @@ rust_library(
         "lib.rs",
         "message.rs",
         "owned_arena_box.rs",
+        "reflection.rs",
         "text.rs",
         "wire.rs",
     ],

rust/upb/lib.rs

@@ -13,6 +13,9 @@ pub use arena::Arena;
 mod associated_mini_table;
 pub use associated_mini_table::{AssociatedMiniTable, AssociatedMiniTableEnum};
 
+mod reflection;
+pub use reflection::{DefPool, MessageDef};
+
 mod text;
 pub use text::debug_string;
 

rust/upb/reflection.rs

@@ -0,0 +1,69 @@
+use std::marker::PhantomData;
+use std::ptr::NonNull;
+
+pub use super::sys::reflection::def_pool::upb_DefPool;
+use super::sys::reflection::def_pool::{upb_DefPool_Free, upb_DefPool_New};
+pub use super::sys::reflection::message_def::upb_MessageDef;
+
+/// A wrapper over a `upb_DefPool`.
+///
+/// This is an owning type and will automatically free the pool when
+/// dropped.
+pub struct DefPool {
+    raw: NonNull<upb_DefPool>,
+}
+
+impl Default for DefPool {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl DefPool {
+    /// Allocates a fresh pool.
+    #[inline]
+    pub fn new() -> Self {
+        // SAFETY: upb_DefPool_New is guaranteed to return a valid pointer or crash.
+        let ptr = unsafe { upb_DefPool_New() };
+        Self { raw: NonNull::new(ptr).unwrap() }
+    }
+
+    /// Returns the raw, UPB-managed pointer to the pool.
+    #[inline]
+    #[doc(hidden)]
+    pub fn as_mut_ptr(&self) -> *mut upb_DefPool {
+        self.raw.as_ptr()
+    }
+}
+
+impl Drop for DefPool {
+    fn drop(&mut self) {
+        // SAFETY: The pointer was generated by upb_DefPool_New and hasn't been freed.
+        unsafe { upb_DefPool_Free(self.raw.as_ptr()) }
+    }
+}
+
+/// A borrowed message descriptor tied to the lifetime of a DefPool. No drop implementation is
+/// provided because this is not an owning type and cannot be individually freed.
+pub struct MessageDef<'pool> {
+    raw: NonNull<upb_MessageDef>,
+    _marker: PhantomData<&'pool DefPool>,
+}
+
+impl<'pool> MessageDef<'pool> {
+    /// # Safety
+    /// The caller must guarantee `ptr` was allocated by the pool providing the `'pool` lifetime.
+    pub unsafe fn from_raw(ptr: *const upb_MessageDef) -> Self {
+        Self {
+            raw: NonNull::new(ptr as *mut _).expect("Descriptor ptr cannot be null"),
+            _marker: PhantomData,
+        }
+    }
+
+    /// Returns the raw, UPB-managed pointer to the descriptor.
+    #[inline]
+    #[doc(hidden)]
+    pub fn as_ptr(&self) -> *const upb_MessageDef {
+        self.raw.as_ptr()
+    }
+}

rust/upb/sys/BUILD

@@ -28,6 +28,9 @@ rust_library(
         "mini_table/mini_table.rs",
         "mini_table/mod.rs",
         "opaque_pointee.rs",
+        "reflection/def_pool.rs",
+        "reflection/message_def.rs",
+        "reflection/mod.rs",
         "test_helpers.rs",
         "text/mod.rs",
         "text/text.rs",
@@ -59,6 +62,8 @@ cc_library(
         "//upb/message:copy",
         "//upb/mini_descriptor",
         "//upb/mini_table",
+        "//upb/reflection",
+        "//upb/text",
         "//upb/text:debug",
         "//upb/wire:byte_size",
     ],

rust/upb/sys/lib.rs

@@ -3,6 +3,7 @@ pub mod mem;
 pub mod message;
 pub mod mini_table;
 pub mod opaque_pointee;
+pub mod reflection;
 pub mod text;
 pub mod wire;
 

rust/upb/sys/reflection/def_pool.rs

@@ -0,0 +1,31 @@
+use super::super::opaque_pointee::opaque_pointee;
+
+opaque_pointee!(upb_DefPool);
+
+unsafe extern "C" {
+    /// Creates a new upb_DefPool.
+    ///
+    /// The caller takes ownership of the returned pointer and is responsible for calling
+    /// `upb_DefPool_Free` on it, or leaking memory.
+    pub fn upb_DefPool_New() -> *mut upb_DefPool;
+
+    /// Frees a upb_DefPool and all message definitions allocated within it.
+    ///
+    /// # Safety
+    /// - `s` must be a valid pointer to a `upb_DefPool` created by `upb_DefPool_New`. This fn is
+    ///   only called during Drop so it is safe to assume that the pointer is not null. It is
+    ///   technically identical to taking a NonNull pointer.
+    pub fn upb_DefPool_Free(s: *mut upb_DefPool);
+}
+
+#[cfg(test)]
+mod tests {
+    use googletest::gtest;
+
+    #[gtest]
+    fn assert_def_pool_linked() {
+        use crate::assert_linked;
+        assert_linked!(super::upb_DefPool_New);
+        assert_linked!(super::upb_DefPool_Free);
+    }
+}

rust/upb/sys/reflection/message_def.rs

@@ -0,0 +1,3 @@
+use super::super::opaque_pointee::opaque_pointee;
+
+opaque_pointee!(upb_MessageDef);

rust/upb/sys/reflection/mod.rs

@@ -0,0 +1,2 @@
+pub mod def_pool;
+pub mod message_def;

rust/upb/sys/text/text.rs

@@ -11,6 +11,8 @@ mod sys {
 
 use sys::message::message::RawMessage;
 use sys::mini_table::mini_table::RawMiniTable;
+use sys::reflection::def_pool::upb_DefPool;
+use sys::reflection::message_def::upb_MessageDef;
 
 unsafe extern "C" {
     /// Returns the minimum needed length (excluding NULL) that `buf` has to be
@@ -28,6 +30,27 @@ unsafe extern "C" {
         buf: *mut u8,
         size: usize,
     ) -> usize;
+
+    /// Encodes a message to text format.
+    ///
+    /// Returns the exact number of bytes required to store the resulting text (excluding
+    /// the null terminator). If `size` is greater than 0, the text is written into `buf`
+    /// up to `size - 1` bytes and null-terminated.
+    ///
+    /// # Safety
+    /// - `msg` must point to a valid `upb_Message` whose shape perfectly aligns with the
+    ///   supplied descriptor `m`.
+    /// - `m` must point to a legally allocated `upb_MessageDef`.
+    /// - `ext_pool` may be null, but if provided, it must point to a valid `upb_DefPool`.
+    /// - `buf` must be legally writable for at least `size` bytes (or may be null if `size` is 0).
+    pub fn upb_TextEncode(
+        msg: RawMessage,
+        m: *const upb_MessageDef,
+        ext_pool: *const upb_DefPool,
+        options: i32, // bitmask of `text_encode_options` values
+        buf: *mut u8,
+        size: usize,
+    ) -> usize;
 }
 
 /// Encoding options.
@@ -52,5 +75,6 @@ mod tests {
     fn assert_text_linked() {
         use crate::assert_linked;
         assert_linked!(upb_DebugString);
+        assert_linked!(upb_TextEncode);
     }
 }

rust/upb/text.rs

@@ -5,7 +5,7 @@
 // license that can be found in the LICENSE file or at
 // https://developers.google.com/open-source/licenses/bsd
 
-use super::sys::text::text::upb_DebugString;
+use super::sys::text::text::{upb_DebugString, upb_TextEncode};
 use super::{AssociatedMiniTable, MessagePtr};
 
 /// Returns a string of field number to value entries of a message.
@@ -34,3 +34,34 @@ pub unsafe fn debug_string<T: AssociatedMiniTable>(msg: MessagePtr<T>) -> String
     assert_eq!(len, written_len);
     String::from_utf8_lossy(buf.as_slice()).to_string()
 }
+
+/// Encodes a message as text format.
+///
+/// # Safety
+/// - `msg` must be legally dereferenceable.
+pub unsafe fn text_encode<'pool, T>(
+    msg: super::MessagePtr<T>,
+    def: &super::MessageDef<'pool>,
+    _pool: &'pool super::DefPool,
+) -> String {
+    let msg = msg.raw();
+
+    // SAFETY: buf is legally writable if size > 0 (size is 0 here)
+    let len = unsafe {
+        upb_TextEncode(msg, def.as_ptr(), core::ptr::null(), 0, core::ptr::null_mut(), 0)
+    };
+
+    let mut buf = vec![0u8; len + 1];
+
+    // SAFETY: buf is writable for its len
+    let written_len = unsafe {
+        upb_TextEncode(msg, def.as_ptr(), core::ptr::null(), 0, buf.as_mut_ptr(), buf.len())
+    };
+
+    // upb_TextEncode returns the length excluding NULL, same as len
+    assert_eq!(len, written_len);
+
+    // Truncate to written length (ignoring NULL)
+    buf.truncate(len);
+    String::from_utf8_lossy(buf.as_slice()).to_string()
+}