Add linkage assertions to all extern upb functions. This makes it a compiler error if you try to run the tests and are missing an extern fn. Will be used to ensure that the Cargo build's amalgamated upb has everything that's needed.

PiperOrigin-RevId: 672653265

rust/upb/arena.rs

@@ -205,6 +205,15 @@ extern "C" {
 mod tests {
     use super::*;
 
+    #[test]
+    fn assert_arena_linked() {
+        use super::super::assert_linked;
+        assert_linked!(upb_Arena_New);
+        assert_linked!(upb_Arena_Free);
+        assert_linked!(upb_Arena_Malloc);
+        assert_linked!(upb_Arena_Fuse);
+    }
+
     #[test]
     fn raw_ffi_test() {
         // SAFETY: FFI unit test uses C API under expected patterns.

rust/upb/array.rs

@@ -30,6 +30,21 @@ mod tests {
     use super::super::Arena;
     use super::*;
 
+    #[test]
+    fn assert_array_linked() {
+        use super::super::assert_linked;
+        assert_linked!(upb_Array_New);
+        assert_linked!(upb_Array_Size);
+        assert_linked!(upb_Array_Set);
+        assert_linked!(upb_Array_Get);
+        assert_linked!(upb_Array_Append);
+        assert_linked!(upb_Array_Resize);
+        assert_linked!(upb_Array_Reserve);
+        assert_linked!(upb_Array_MutableDataPtr);
+        assert_linked!(upb_Array_DataPtr);
+        assert_linked!(upb_Array_GetMutable);
+    }
+
     #[test]
     fn array_ffi_test() {
         // SAFETY: FFI unit test uses C API under expected patterns.

rust/upb/lib.rs

@@ -41,8 +41,8 @@ pub use message_value::{upb_MessageValue, upb_MutableMessageValue};
 
 mod mini_table;
 pub use mini_table::{
-    upb_MiniTable, upb_MiniTableField, upb_MiniTable_FindFieldByNumber, upb_MiniTable_SubMessage,
-    upb_MiniTable_GetFieldByIndex, RawMiniTable, RawMiniTableField,
+    upb_MiniTable, upb_MiniTableField, upb_MiniTable_FindFieldByNumber,
+    upb_MiniTable_GetFieldByIndex, upb_MiniTable_SubMessage, RawMiniTable, RawMiniTableField,
 };
 
 mod opaque_pointee;
@@ -58,3 +58,14 @@ pub use text::debug_string;
 
 pub mod wire;
 pub use wire::{upb_Decode, DecodeStatus, EncodeStatus};
+
+#[cfg(test)]
+mod test {
+    #[macro_export]
+    /// Force a compiler error if the passed in function is not linked.
+    macro_rules! assert_linked {
+        ($($vals:tt)+) => {
+            let _ = std::hint::black_box($($vals)+ as *const ());
+        }
+    }
+}

rust/upb/map.rs

@@ -52,6 +52,18 @@ mod tests {
     use super::super::Arena;
     use super::*;
 
+    #[test]
+    fn assert_map_linked() {
+        use super::super::assert_linked;
+        assert_linked!(upb_Map_New);
+        assert_linked!(upb_Map_Size);
+        assert_linked!(upb_Map_Insert);
+        assert_linked!(upb_Map_Get);
+        assert_linked!(upb_Map_Delete);
+        assert_linked!(upb_Map_Clear);
+        assert_linked!(upb_Map_Next);
+    }
+
     #[test]
     fn map_ffi_test() {
         // SAFETY: FFI unit test uses C API under expected patterns.

rust/upb/message.rs

@@ -302,3 +302,46 @@ extern "C" {
     /// - `f` must be a field within a oneof associated with `m`
     pub fn upb_Message_WhichOneofFieldNumber(m: RawMessage, f: *const upb_MiniTableField) -> u32;
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn assert_message_linked() {
+        use super::super::assert_linked;
+        assert_linked!(upb_Message_New);
+        assert_linked!(upb_Message_Clear);
+        assert_linked!(upb_Message_ClearBaseField);
+        assert_linked!(upb_Message_DeepCopy);
+        assert_linked!(upb_Message_DeepClone);
+        assert_linked!(upb_Message_GetBool);
+        assert_linked!(upb_Message_GetInt32);
+        assert_linked!(upb_Message_GetInt64);
+        assert_linked!(upb_Message_GetUInt32);
+        assert_linked!(upb_Message_GetUInt64);
+        assert_linked!(upb_Message_GetFloat);
+        assert_linked!(upb_Message_GetDouble);
+        assert_linked!(upb_Message_GetString);
+        assert_linked!(upb_Message_GetMessage);
+        assert_linked!(upb_Message_GetOrCreateMutableMessage);
+        assert_linked!(upb_Message_GetArray);
+        assert_linked!(upb_Message_GetOrCreateMutableArray);
+        assert_linked!(upb_Message_GetMap);
+        assert_linked!(upb_Message_GetOrCreateMutableMap);
+        assert_linked!(upb_Message_HasBaseField);
+        assert_linked!(upb_Message_SetBaseField);
+        assert_linked!(upb_Message_IsEqual);
+        assert_linked!(upb_Message_MergeFrom);
+        assert_linked!(upb_Message_SetBaseFieldBool);
+        assert_linked!(upb_Message_SetBaseFieldInt32);
+        assert_linked!(upb_Message_SetBaseFieldInt64);
+        assert_linked!(upb_Message_SetBaseFieldUInt32);
+        assert_linked!(upb_Message_SetBaseFieldUInt64);
+        assert_linked!(upb_Message_SetBaseFieldFloat);
+        assert_linked!(upb_Message_SetBaseFieldDouble);
+        assert_linked!(upb_Message_SetBaseFieldString);
+        assert_linked!(upb_Message_SetBaseFieldMessage);
+        assert_linked!(upb_Message_WhichOneofFieldNumber);
+    }
+}

rust/upb/mini_table.rs

@@ -46,3 +46,16 @@ extern "C" {
         f: *const upb_MiniTableField,
     ) -> *const upb_MiniTable;
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn assert_mini_table_linked() {
+        use super::super::assert_linked;
+        assert_linked!(upb_MiniTable_FindFieldByNumber);
+        assert_linked!(upb_MiniTable_GetFieldByIndex);
+        assert_linked!(upb_MiniTable_SubMessage);
+    }
+}

rust/upb/text.rs

@@ -64,3 +64,14 @@ pub unsafe fn debug_string(msg: RawMessage, mt: *const upb_MiniTable) -> String
     assert_eq!(len, written_len);
     String::from_utf8_lossy(buf.as_slice()).to_string()
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn assert_text_linked() {
+        use super::super::assert_linked;
+        assert_linked!(upb_DebugString);
+    }
+}

rust/upb/wire.rs

@@ -122,3 +122,15 @@ extern "C" {
         arena: RawArena,
     ) -> DecodeStatus;
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn assert_wire_linked() {
+        use super::super::assert_linked;
+        assert_linked!(upb_Encode);
+        assert_linked!(upb_Decode);
+    }
+}