THRIFT-XXXX: Rust codegen: forward-compatible union deserialization in structs

When a struct field has a union type, the generated Rust deserializer
now catches 'received empty union' errors from unknown variants and
treats them as None instead of propagating the error.

Previously, if a Thrift union received a field ID not present in the
local IDL, the union deserializer returned Err('received empty union'),
which cascaded up and caused the entire parent struct deserialization
to fail. This broke forward compatibility.

The fix wraps union field reads in struct deserializers with a match
that catches the specific 'received empty union' error and silently
skips the field. The struct field (already Option<UnionType>) remains
None, matching the behavior as if the field were absent. All other
errors (malformed data, I/O failures) still propagate normally.

Handles both direct union fields and Box<Union> (forward typedef)
fields by resolving the type before generating the method call.

This aligns Rust with Java, Go, Python, and C++ Thrift behavior.

Author: santiagomed

compiler/cpp/src/thrift/generate/t_rs_generator.cc

@@ -1699,10 +1699,37 @@ void t_rs_generator::render_struct_sync_read(const string& struct_name,
 
     for (members_iter = members.begin(); members_iter != members.end(); ++members_iter) {
       t_field* tfield = (*members_iter);
+      t_type* resolved = get_true_type(tfield->get_type());
+      bool is_union_field = resolved->is_struct() && ((t_struct*)resolved)->is_union();
       f_gen_ << indent() << rust_safe_field_id(tfield->get_key()) << " => {" << '\n';
       indent_up();
-      render_type_sync_read("val", tfield->get_type());
-      f_gen_ << indent() << struct_field_read_temp_variable(tfield) << " = Some(val);" << '\n';
+      if (is_union_field) {
+        // Union fields: catch "received empty union" errors from unknown
+        // variants and treat them as None for forward compatibility.
+        // This matches how Java, Go, and Python Thrift handle unknown
+        // union fields -- they skip silently instead of failing.
+        //
+        // Use the resolved (non-Box) type for the method call since
+        // Box<T>::method() is not valid Rust syntax for turbofish.
+        string resolved_type = to_rust_type(resolved);
+        bool is_boxed_union = to_rust_type(tfield->get_type()) != resolved_type;
+        string read_call(resolved_type + "::read_from_in_protocol(i_prot)");
+        string val_expr = is_boxed_union ? "Box::new(val)" : "val";
+        f_gen_ << indent() << "match " << read_call << " {" << '\n';
+        indent_up();
+        f_gen_ << indent() << "Ok(val) => { " << struct_field_read_temp_variable(tfield) << " = Some(" << val_expr << "); }," << '\n';
+        f_gen_ << indent() << "Err(thrift::Error::Protocol(ref e)) if e.message.contains(\"received empty union\") => {" << '\n';
+        indent_up();
+        f_gen_ << indent() << "// forward compatibility: unknown union variant skipped" << '\n';
+        indent_down();
+        f_gen_ << indent() << "}," << '\n';
+        f_gen_ << indent() << "Err(e) => return Err(e)," << '\n';
+        indent_down();
+        f_gen_ << indent() << "}" << '\n';
+      } else {
+        render_type_sync_read("val", tfield->get_type());
+        f_gen_ << indent() << struct_field_read_temp_variable(tfield) << " = Some(val);" << '\n';
+      }
       indent_down();
       f_gen_ << indent() << "}," << '\n';
     }