Add [clear_and_]parse_dont_enforce_required() to Rust protobuf.

PiperOrigin-RevId: 755791325

Author: protobuf-github-bot

rust/codegen_traits.rs

@@ -73,6 +73,7 @@ pub(crate) mod create {
     use super::SealedInternal;
     pub trait Parse: SealedInternal + Sized {
         fn parse(serialized: &[u8]) -> Result<Self, crate::ParseError>;
+        fn parse_dont_enforce_required(serialized: &[u8]) -> Result<Self, crate::ParseError>;
     }
 }
 
@@ -100,6 +101,10 @@ pub(crate) mod write {
 
     pub trait ClearAndParse: SealedInternal {
         fn clear_and_parse(&mut self, data: &[u8]) -> Result<(), crate::ParseError>;
+        fn clear_and_parse_dont_enforce_required(
+            &mut self,
+            data: &[u8],
+        ) -> Result<(), crate::ParseError>;
     }
 
     /// Copies the contents from `src` into `self`.

rust/test/shared/serialization_test.rs

@@ -12,7 +12,7 @@ use protobuf::View;
 use paste::paste;
 use unittest_proto3_optional_rust_proto::TestProto3Optional;
 use unittest_proto3_rust_proto::TestAllTypes as TestAllTypesProto3;
-use unittest_rust_proto::TestAllTypes;
+use unittest_rust_proto::{TestAllTypes, TestRequired};
 
 macro_rules! generate_parameterized_serialization_test {
     ($(($type: ident, $name_ext: ident)),*) => {
@@ -147,3 +147,24 @@ generate_parameterized_int32_byte_size_test!(
                                            * presence" semantics and setting it to 0 (default
                                            * value) will cause it to not be serialized */
 );
+
+#[gtest]
+fn test_required_field_enforced() {
+    // Empty bytes slice is a valid binaryproto with no fields set -- therefore it should not parse
+    // as a message with required fields.
+    expect_that!(TestRequired::parse(&[]), err(anything()));
+
+    let mut msg = TestRequired::new();
+    expect_that!(msg.clear_and_parse(&[]), err(anything()));
+}
+
+#[gtest]
+fn test_required_field_not_enforced() {
+    // Empty bytes slice is a valid binaryproto with no fields set.
+    let mut msg = TestRequired::parse_dont_enforce_required(&[]).unwrap();
+    expect_that!(msg.has_a(), eq(false));
+
+    msg.set_a(1);
+    msg.clear_and_parse_dont_enforce_required(&[]).unwrap();
+    expect_that!(msg.has_a(), eq(false));
+}

rust/upb/wire.rs

@@ -111,7 +111,7 @@ pub unsafe fn decode_with_options(
     // - `mini_table` is the one associated with `msg`
     // - `buf` is legally readable for at least `buf_size` bytes.
     // - `extreg` is null.
-    // - `decode_options` is a valid DecodeOptions, so contains only allowed bits.
+    // - `decode_options_bitmask` is a bitmask of constants from the `decode_options` module.
     let status = unsafe {
         upb_Decode(
             buf,

src/google/protobuf/compiler/rust/message.cc

@@ -111,10 +111,14 @@ void MessageMutClear(Context& ctx, const Descriptor& msg) {
   }
 }
 
-void MessageMutClearAndParse(Context& ctx, const Descriptor& msg) {
+void MessageMutClearAndParse(Context& ctx, const Descriptor& msg,
+                             bool enforce_required) {
   switch (ctx.opts().kernel) {
-    case Kernel::kCpp:
-      ctx.Emit({},
+    case Kernel::kCpp: {
+      absl::string_view parse_function =
+          enforce_required ? "proto2_rust_Message_parse"
+                           : "proto2_rust_Message_parse_dont_enforce_required";
+      ctx.Emit({{"parse_function", parse_function}},
                R"rs(
           let success = unsafe {
             // SAFETY: `data.as_ptr()` is valid to read for `data.len()`.
@@ -123,34 +127,41 @@ void MessageMutClearAndParse(Context& ctx, const Descriptor& msg) {
               data.len(),
             );
 
-            $pbr$::proto2_rust_Message_parse(self.raw_msg(), data)
+            $pbr$::$parse_function$(self.raw_msg(), data)
           };
           success.then_some(()).ok_or($pb$::ParseError)
         )rs");
       return;
-
-    case Kernel::kUpb:
-      ctx.Emit(
-          R"rs(
+    }
+
+    case Kernel::kUpb: {
+      absl::string_view decode_options =
+          enforce_required ? "$pbr$::wire::decode_options::CHECK_REQUIRED"
+                           : "0";
+      ctx.Emit({{"decode_options",
+                 [&ctx, decode_options] { ctx.Emit(decode_options); }}},
+               R"rs(
         $pb$::Clear::clear(self);
 
         // SAFETY:
         // - `data.as_ptr()` is valid to read for `data.len()`
         // - `mini_table` is the one used to construct `msg.raw_msg()`
         // - `msg.arena().raw()` is held for the same lifetime as `msg`.
         let status = unsafe {
-          $pbr$::wire::decode(
+          $pbr$::wire::decode_with_options(
               data,
               self.raw_msg(),
               <Self as $pbr$::AssociatedMiniTable>::mini_table(),
-              self.arena())
+              self.arena(),
+              $decode_options$)
         };
         match status {
           Ok(_) => Ok(()),
           Err(_) => Err($pb$::ParseError),
         }
       )rs");
       return;
+    }
   }
 
   ABSL_LOG(FATAL) << "unreachable";
@@ -700,7 +711,13 @@ void GenerateRs(Context& ctx, const Descriptor& msg) {
           {"Msg::serialize", [&] { MessageSerialize(ctx, msg); }},
           {"MsgMut::clear", [&] { MessageMutClear(ctx, msg); }},
           {"MsgMut::clear_and_parse",
-           [&] { MessageMutClearAndParse(ctx, msg); }},
+           [&] {
+             MessageMutClearAndParse(ctx, msg, /*enforce_required=*/true);
+           }},
+          {"MsgMut::clear_and_parse_dont_enforce_required",
+           [&] {
+             MessageMutClearAndParse(ctx, msg, /*enforce_required=*/false);
+           }},
           {"Msg::drop", [&] { MessageDrop(ctx, msg); }},
           {"Msg::debug", [&] { MessageDebug(ctx, msg); }},
           {"MsgMut::take_copy_merge_from",
@@ -830,6 +847,10 @@ void GenerateRs(Context& ctx, const Descriptor& msg) {
           fn parse(serialized: &[u8]) -> $Result$<Self, $pb$::ParseError> {
             Self::parse(serialized)
           }
+
+          fn parse_dont_enforce_required(serialized: &[u8]) -> $Result$<Self, $pb$::ParseError> {
+            Self::parse_dont_enforce_required(serialized)
+          }
         }
 
         impl $std$::fmt::Debug for $Msg$ {
@@ -877,6 +898,11 @@ void GenerateRs(Context& ctx, const Descriptor& msg) {
             let mut m = self.as_mut();
             $pb$::ClearAndParse::clear_and_parse(&mut m, data)
           }
+
+          fn clear_and_parse_dont_enforce_required(&mut self, data: &[u8]) -> $Result$<(), $pb$::ParseError> {
+            let mut m = self.as_mut();
+            $pb$::ClearAndParse::clear_and_parse_dont_enforce_required(&mut m, data)
+          }
         }
 
         // SAFETY:
@@ -1014,6 +1040,10 @@ void GenerateRs(Context& ctx, const Descriptor& msg) {
           fn clear_and_parse(&mut self, data: &[u8]) -> $Result$<(), $pb$::ParseError> {
             $MsgMut::clear_and_parse$
           }
+
+          fn clear_and_parse_dont_enforce_required(&mut self, data: &[u8]) -> $Result$<(), $pb$::ParseError> {
+            $MsgMut::clear_and_parse_dont_enforce_required$
+          }
         }
 
         $MsgMut::take_copy_merge_from$
@@ -1116,6 +1146,11 @@ void GenerateRs(Context& ctx, const Descriptor& msg) {
             $pb$::ClearAndParse::clear_and_parse(&mut msg, data).map(|_| msg)
           }
 
+          pub fn parse_dont_enforce_required(data: &[u8]) -> $Result$<Self, $pb$::ParseError> {
+            let mut msg = Self::new();
+            $pb$::ClearAndParse::clear_and_parse_dont_enforce_required(&mut msg, data).map(|_| msg)
+          }
+
           pub fn as_view(&self) -> $Msg$View {
             $Msg$View::new($pbi$::Private, self.inner.msg)
           }