Fix foreign-crate symbol registration (#4)

Author: simonask

CHANGELOG.md

@@ -2,6 +2,11 @@
 
 ## Next release
 
+### Bugfixes
+
+- Fixed the `stringleton::enable!()` macro when referring to foreign crates.
+- Fixed usage of `sym!()` in external tests.
+
 ### Dependencies
 
 - Bumped `spin` to `0.10.0`.

Cargo.lock

@@ -7,8 +7,10 @@ members = [
     "tests/dylib/dynamic-library",
     "tests/dylib/c-dynamic-library",
     "tests/check-codegen",
+    "tests/foreign-crate-registry",
+    "tests/foreign-crate",
 ]
-default-members = ["stringleton", "stringleton-registry"]
+default-members = ["stringleton", "stringleton-registry", "tests/check-codegen", "tests/foreign-crate-registry", "tests/foreign-crate"]
 resolver = "3"
 
 [workspace.dependencies]

Cargo.toml

@@ -66,6 +66,11 @@ assert_eq!(message, message2);
 assert_eq!(message.as_str().as_ptr(), message2.as_str().as_ptr());
 ```
 
+**NOTE:** In external tests (i.e. those in a separate `tests/` subdirectory), each
+test file should call `stringleton::enable!(main_library_crate)` instead of
+`stringleton::enable!()`. See the documentation of the `enable!()` macro for more
+details.
+
 ## Crate features
 
 - **std** *(enabled by default)*: Use synchronization primitives from the

stringleton/README.md

@@ -149,6 +149,17 @@ macro_rules! static_sym {
 /// Put a call to this macro somewhere in the root of each crate that uses the
 /// `sym!(...)` macro.
 ///
+/// The second variant reuses the symbol table of another crate, and this is
+/// particularly needed due to the way external tests (in the `tests/`
+/// subdirectory of the project) are compiled. Test files `tests/foo.rs`, are
+/// compiled as "pseudo-crates", so they are semantically a separate crate from
+/// the main library crate. But they are compiled into the same binary, so just
+/// using `stringleton::enable!()` without arguments will cause linker errors
+/// (`duplicate #[distributed_slice] with name "TABLE"`).
+///
+/// In external tests using [`sym!()`], the test file should instead use
+/// `stringleton::enable!(main_library_crate)`.
+///
 /// ## Details
 ///
 /// This creates a "distributed slice" containing all symbols in this crate, as
@@ -184,11 +195,11 @@ macro_rules! enable {
     () => {
         #[doc(hidden)]
         #[cfg(not(any(miri, target_arch = "wasm32")))]
-        pub(crate) mod _stringleton_enabled {
+        pub mod _stringleton_enabled {
             #[$crate::internal::linkme::distributed_slice]
             #[linkme(crate = $crate::internal::linkme)]
             #[doc(hidden)]
-            pub(crate) static TABLE: [$crate::internal::Site] = [..];
+            pub static TABLE: [$crate::internal::Site] = [..];
 
             $crate::internal::ctor::declarative::ctor! {
                 #[ctor]
@@ -207,10 +218,10 @@ macro_rules! enable {
         #[cfg(not(any(miri, target_arch = "wasm32")))]
         pub use _stringleton_enabled::_stringleton_register_symbols;
     };
-    ($krate:path) => {
+    ($($krate:tt)+) => {
         #[doc(hidden)]
         #[cfg(not(any(miri, target_arch = "wasm32")))]
-        pub(crate) use $krate::_stringleton_enabled;
+        pub use $($krate)*::_stringleton_enabled;
     };
 }
 

stringleton/lib.rs

@@ -0,0 +1,15 @@
+[package]
+name = "foreign-crate-registry"
+publish = false
+edition = "2024"
+
+[lib]
+path = "lib.rs"
+test = true
+doctest = false
+
+[lints]
+workspace = true
+
+[dependencies]
+stringleton = { path = "../../stringleton", features = ["debug-assertions"] }

tests/foreign-crate-registry/Cargo.toml

@@ -0,0 +1,7 @@
+use stringleton::sym;
+
+stringleton::enable!();
+
+pub fn foo() -> stringleton::Symbol {
+    sym!(foo)
+}

tests/foreign-crate-registry/lib.rs

@@ -0,0 +1,16 @@
+[package]
+name = "foreign-crate"
+publish = false
+edition = "2024"
+
+[lib]
+path = "lib.rs"
+test = true
+doctest = false
+
+[lints]
+workspace = true
+
+[dependencies]
+stringleton = { path = "../../stringleton", features = ["debug-assertions"] }
+foreign-crate-registry.path = "../foreign-crate-registry"

tests/foreign-crate/Cargo.toml

@@ -0,0 +1,5 @@
+stringleton::enable!(::foreign_crate_registry);
+
+pub fn bar() -> stringleton::Symbol {
+    stringleton::sym!(bar)
+}

tests/foreign-crate/lib.rs

@@ -0,0 +1,12 @@
+use foreign_crate::bar;
+use foreign_crate_registry::foo;
+use stringleton::sym;
+
+// Forwarding to `foreign_crate_registry` through `foreign_crate`.
+stringleton::enable!(foreign_crate);
+
+#[test]
+fn external_symbols_test() {
+    assert_eq!(foo(), sym!(foo));
+    assert_eq!(bar(), sym!(bar));
+}