From a0f79ebc572a35b5262a841788bfa860ef014200 Mon Sep 17 00:00:00 2001 From: Derek Benson Date: Mon, 9 Sep 2024 13:27:05 -0700 Subject: [PATCH] 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 | 9 +++++++++ rust/upb/array.rs | 15 +++++++++++++++ rust/upb/lib.rs | 15 +++++++++++++-- rust/upb/map.rs | 12 ++++++++++++ rust/upb/message.rs | 43 ++++++++++++++++++++++++++++++++++++++++++ rust/upb/mini_table.rs | 13 +++++++++++++ rust/upb/text.rs | 11 +++++++++++ rust/upb/wire.rs | 12 ++++++++++++ 8 files changed, 128 insertions(+), 2 deletions(-) diff --git a/rust/upb/arena.rs b/rust/upb/arena.rs index 5f90c6b8d0..ebecac9dd8 100644 --- a/rust/upb/arena.rs +++ b/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. diff --git a/rust/upb/array.rs b/rust/upb/array.rs index 6fb7c30d01..8c2962424d 100644 --- a/rust/upb/array.rs +++ b/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. diff --git a/rust/upb/lib.rs b/rust/upb/lib.rs index 4258c61be3..49cea15e5b 100644 --- a/rust/upb/lib.rs +++ b/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 ()); + } + } +} diff --git a/rust/upb/map.rs b/rust/upb/map.rs index 554b43cff9..7b04d7a8a4 100644 --- a/rust/upb/map.rs +++ b/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. diff --git a/rust/upb/message.rs b/rust/upb/message.rs index 8d3974808f..fa94955d6f 100644 --- a/rust/upb/message.rs +++ b/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); + } +} diff --git a/rust/upb/mini_table.rs b/rust/upb/mini_table.rs index 6261891c66..e505834c44 100644 --- a/rust/upb/mini_table.rs +++ b/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); + } +} diff --git a/rust/upb/text.rs b/rust/upb/text.rs index 56dddb8b63..11ca752c57 100644 --- a/rust/upb/text.rs +++ b/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); + } +} diff --git a/rust/upb/wire.rs b/rust/upb/wire.rs index eb08e7b19f..ed3ce39934 100644 --- a/rust/upb/wire.rs +++ b/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); + } +}