Implement rust repeated scalars for cpp and upb

PiperOrigin-RevId: 574261929

Author: protobuf-github-bot

Cargo.bazel.lock

@@ -1,5 +1,5 @@
 {
-  "checksum": "8bc2d235f612e77f4dca1b6886cc8bd14df348168fea27a687805ed9518a8f1a",
+  "checksum": "641f887b045ff0fc19f64df79b53d96d77d1c03c96069036d84bd1104ddc0000",
   "crates": {
     "aho-corasick 1.1.2": {
       "name": "aho-corasick",
@@ -108,6 +108,15 @@
           "selects": {}
         },
         "edition": "2018",
+        "proc_macro_deps": {
+          "common": [
+            {
+              "id": "paste 1.0.14",
+              "target": "paste"
+            }
+          ],
+          "selects": {}
+        },
         "version": "0.0.1"
       },
       "license": null
@@ -318,6 +327,59 @@
       },
       "license": "MIT OR Apache-2.0"
     },
+    "paste 1.0.14": {
+      "name": "paste",
+      "version": "1.0.14",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/paste/1.0.14/download",
+          "sha256": "de3145af08024dea9fa9914f381a17b8fc6034dfb00f3a84013f7ff43f29ed4c"
+        }
+      },
+      "targets": [
+        {
+          "ProcMacro": {
+            "crate_name": "paste",
+            "crate_root": "src/lib.rs",
+            "srcs": [
+              "**/*.rs"
+            ]
+          }
+        },
+        {
+          "BuildScript": {
+            "crate_name": "build_script_build",
+            "crate_root": "build.rs",
+            "srcs": [
+              "**/*.rs"
+            ]
+          }
+        }
+      ],
+      "library_target_name": "paste",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "paste 1.0.14",
+              "target": "build_script_build"
+            }
+          ],
+          "selects": {}
+        },
+        "edition": "2018",
+        "version": "1.0.14"
+      },
+      "build_script_attrs": {
+        "data_glob": [
+          "**"
+        ]
+      },
+      "license": "MIT OR Apache-2.0"
+    },
     "proc-macro2 1.0.69": {
       "name": "proc-macro2",
       "version": "1.0.69",
@@ -769,4 +831,3 @@
   },
   "conditions": {}
 }
-

Cargo.lock

@@ -193,6 +193,9 @@ crates_repository(
         "googletest": crate.spec(
             version = ">0.0.0",
         ),
+        "paste": crate.spec(
+          version = ">=1",
+        ),
     },
 )
 

WORKSPACE

@@ -52,6 +52,7 @@ PROTOBUF_SHARED = [
     "optional.rs",
     "primitive.rs",
     "proxied.rs",
+    "repeated.rs",
     "shared.rs",
     "string.rs",
     "vtable.rs",
@@ -92,8 +93,14 @@ rust_library(
     name = "protobuf_cpp",
     srcs = PROTOBUF_SHARED + ["cpp.rs"],
     crate_root = "shared.rs",
+    proc_macro_deps = [
+        "@crate_index//:paste",
+    ],
     rustc_flags = ["--cfg=cpp_kernel"],
-    deps = [":utf8"],
+    deps = [
+        ":utf8",
+        "//rust/cpp_kernel:cpp_api",
+    ],
 )
 
 rust_test(

rust/BUILD

@@ -7,7 +7,8 @@
 
 // Rust Protobuf runtime using the C++ kernel.
 
-use crate::__internal::{Private, RawArena, RawMessage};
+use crate::__internal::{Private, RawArena, RawMessage, RawRepeatedField};
+use paste::paste;
 use std::alloc::Layout;
 use std::cell::UnsafeCell;
 use std::fmt;
@@ -35,6 +36,7 @@ pub struct Arena {
 impl Arena {
     /// Allocates a fresh arena.
     #[inline]
+    #[allow(clippy::new_without_default)]
     pub fn new() -> Self {
         Self { ptr: NonNull::dangling(), _not_sync: PhantomData }
     }
@@ -182,6 +184,116 @@ pub fn copy_bytes_in_arena_if_needed_by_runtime<'a>(
     val
 }
 
+/// RepeatedField impls delegate out to `extern "C"` functions exposed by
+/// `cpp_api.h` and store either a RepeatedField* or a RepeatedPtrField*
+/// depending on the type.
+///
+/// Note: even though this type is `Copy`, it should only be copied by
+/// protobuf internals that can maintain mutation invariants:
+///
+/// - No concurrent mutation for any two fields in a message: this means
+///   mutators cannot be `Send` but are `Sync`.
+/// - If there are multiple accessible `Mut` to a single message at a time, they
+///   must be different fields, and not be in the same oneof. As such, a `Mut`
+///   cannot be `Clone` but *can* reborrow itself with `.as_mut()`, which
+///   converts `&'b mut Mut<'a, T>` to `Mut<'b, T>`.
+#[derive(Clone, Copy)]
+pub struct RepeatedField<'msg, T: ?Sized> {
+    inner: RepeatedFieldInner<'msg>,
+    _phantom: PhantomData<&'msg mut T>,
+}
+
+/// CPP runtime-specific arguments for initializing a RepeatedField.
+/// See RepeatedField comment about mutation invariants for when this type can
+/// be copied.
+#[derive(Clone, Copy)]
+pub struct RepeatedFieldInner<'msg> {
+    pub raw: RawRepeatedField,
+    pub _phantom: PhantomData<&'msg ()>,
+}
+
+impl<'msg, T: ?Sized> RepeatedField<'msg, T> {
+    pub fn from_inner(_private: Private, inner: RepeatedFieldInner<'msg>) -> Self {
+        RepeatedField { inner, _phantom: PhantomData }
+    }
+}
+impl<'msg> RepeatedField<'msg, i32> {}
+
+pub trait RepeatedScalarOps {
+    fn new_repeated_field() -> RawRepeatedField;
+    fn push(f: RawRepeatedField, v: Self);
+    fn len(f: RawRepeatedField) -> usize;
+    fn get(f: RawRepeatedField, i: usize) -> Self;
+    fn set(f: RawRepeatedField, i: usize, v: Self);
+}
+
+macro_rules! impl_repeated_scalar_ops {
+    ($($t: ty),*) => {
+        paste! { $(
+            extern "C" {
+                fn [< __pb_rust_RepeatedField_ $t _new >]() -> RawRepeatedField;
+                fn [< __pb_rust_RepeatedField_ $t _add >](f: RawRepeatedField, v: $t);
+                fn [< __pb_rust_RepeatedField_ $t _size >](f: RawRepeatedField) -> usize;
+                fn [< __pb_rust_RepeatedField_ $t _get >](f: RawRepeatedField, i: usize) -> $t;
+                fn [< __pb_rust_RepeatedField_ $t _set >](f: RawRepeatedField, i: usize, v: $t);
+            }
+            impl RepeatedScalarOps for $t {
+                fn new_repeated_field() -> RawRepeatedField {
+                    unsafe { [< __pb_rust_RepeatedField_ $t _new >]() }
+                }
+                fn push(f: RawRepeatedField, v: Self) {
+                    unsafe { [< __pb_rust_RepeatedField_ $t _add >](f, v) }
+                }
+                fn len(f: RawRepeatedField) -> usize {
+                    unsafe { [< __pb_rust_RepeatedField_ $t _size >](f) }
+                }
+                fn get(f: RawRepeatedField, i: usize) -> Self {
+                    unsafe { [< __pb_rust_RepeatedField_ $t _get >](f, i) }
+                }
+                fn set(f: RawRepeatedField, i: usize, v: Self) {
+                    unsafe { [< __pb_rust_RepeatedField_ $t _set >](f, i, v) }
+                }
+            }
+        )* }
+    };
+}
+
+impl_repeated_scalar_ops!(i32, u32, i64, u64, f32, f64, bool);
+
+impl<'msg, T: RepeatedScalarOps> RepeatedField<'msg, T> {
+    #[allow(clippy::new_without_default, dead_code)]
+    /// new() is not currently used in our normal pathways, it is only used
+    /// for testing. Existing `RepeatedField<>`s are owned by, and retrieved
+    /// from, the containing `Message`.
+    pub fn new() -> Self {
+        Self::from_inner(
+            Private,
+            RepeatedFieldInner::<'msg> { raw: T::new_repeated_field(), _phantom: PhantomData },
+        )
+    }
+    pub fn push(&mut self, val: T) {
+        T::push(self.inner.raw, val)
+    }
+    pub fn len(&self) -> usize {
+        T::len(self.inner.raw)
+    }
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+    pub fn get(&self, index: usize) -> Option<T> {
+        if index >= self.len() {
+            return None;
+        }
+        Some(T::get(self.inner.raw, index))
+    }
+    pub fn set(&mut self, index: usize, val: T) {
+        if index >= self.len() {
+            return;
+        }
+        T::set(self.inner.raw, index, val)
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -201,4 +313,27 @@ mod tests {
         let serialized_data = SerializedData { data: NonNull::new(ptr).unwrap(), len: len };
         assert_eq!(&*serialized_data, b"Hello world");
     }
+
+    #[test]
+    fn repeated_field() {
+        let mut r = RepeatedField::<i32>::new();
+        assert_eq!(r.len(), 0);
+        r.push(32);
+        assert_eq!(r.get(0), Some(32));
+
+        let mut r = RepeatedField::<u32>::new();
+        assert_eq!(r.len(), 0);
+        r.push(32);
+        assert_eq!(r.get(0), Some(32));
+
+        let mut r = RepeatedField::<f64>::new();
+        assert_eq!(r.len(), 0);
+        r.push(0.1234f64);
+        assert_eq!(r.get(0), Some(0.1234));
+
+        let mut r = RepeatedField::<bool>::new();
+        assert_eq!(r.len(), 0);
+        r.push(true);
+        assert_eq!(r.get(0), Some(true));
+    }
 }

rust/cpp.rs

@@ -4,13 +4,14 @@ load("@rules_rust//rust:defs.bzl", "rust_library")
 
 cc_library(
     name = "cpp_api",
+    srcs = ["cpp_api.cc"],
     hdrs = ["cpp_api.h"],
     visibility = [
         "//src/google/protobuf:__subpackages__",
         "//rust:__subpackages__",
     ],
     deps = [
-        ":rust_alloc_for_cpp_api",
+        ":rust_alloc_for_cpp_api",  # buildcleaner: keep
         "//:protobuf_nowkt",
     ],
 )

rust/cpp_kernel/BUILD

@@ -0,0 +1,35 @@
+#include "google/protobuf/repeated_field.h"
+
+extern "C" {
+
+#define expose_repeated_field_methods(ty, rust_ty)                           \
+  google::protobuf::RepeatedField<ty>* __pb_rust_RepeatedField_##rust_ty##_new() {     \
+    return new google::protobuf::RepeatedField<ty>();                                  \
+  }                                                                          \
+  void __pb_rust_RepeatedField_##rust_ty##_add(google::protobuf::RepeatedField<ty>* r, \
+                                               ty val) {                     \
+    r->Add(val);                                                             \
+  }                                                                          \
+  size_t __pb_rust_RepeatedField_##rust_ty##_size(                           \
+      google::protobuf::RepeatedField<ty>* r) {                                        \
+    return r->size();                                                        \
+  }                                                                          \
+  ty __pb_rust_RepeatedField_##rust_ty##_get(google::protobuf::RepeatedField<ty>* r,   \
+                                             size_t index) {                 \
+    return r->Get(index);                                                    \
+  }                                                                          \
+  void __pb_rust_RepeatedField_##rust_ty##_set(google::protobuf::RepeatedField<ty>* r, \
+                                               size_t index, ty val) {       \
+    return r->Set(index, val);                                               \
+  }
+
+expose_repeated_field_methods(int32_t, i32);
+expose_repeated_field_methods(uint32_t, u32);
+expose_repeated_field_methods(float, f32);
+expose_repeated_field_methods(double, f64);
+expose_repeated_field_methods(bool, bool);
+expose_repeated_field_methods(uint64_t, u64);
+expose_repeated_field_methods(int64_t, i64);
+
+#undef expose_repeated_field_methods
+}

rust/cpp_kernel/cpp_api.cc

@@ -51,6 +51,17 @@ mod _opaque_pointees {
         _data: [u8; 0],
         _marker: std::marker::PhantomData<(*mut u8, ::std::marker::PhantomPinned)>,
     }
+
+    /// Opaque pointee for [`RawRepeatedField`]
+    ///
+    /// 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.
+    #[repr(C)]
+    pub struct RawRepeatedFieldData {
+        _data: [u8; 0],
+        _marker: std::marker::PhantomData<(*mut u8, ::std::marker::PhantomPinned)>,
+    }
 }
 
 /// A raw pointer to the underlying message for this runtime.
@@ -59,6 +70,9 @@ pub type RawMessage = NonNull<_opaque_pointees::RawMessageData>;
 /// A raw pointer to the underlying arena for this runtime.
 pub type RawArena = NonNull<_opaque_pointees::RawArenaData>;
 
+/// A raw pointer to the underlying repeated field container for this runtime.
+pub type RawRepeatedField = NonNull<_opaque_pointees::RawRepeatedFieldData>;
+
 /// Represents an ABI-stable version of `NonNull<[u8]>`/`string_view` (a
 /// borrowed slice of bytes) for FFI use only.
 ///