`thread_local!` doesn’t like types whose definitions cannot be written more than once

[Jules-Bertholet]

I tried this (admittedly cursed) code:

thread_local! {
    pub static FOO: [(); {
        #[unsafe(no_mangle)]
        fn dont_duplicate_me() {}
        0
    }] = [];
}

I expected to see this happen: It compiles, just like the non-thread_local! version would

Instead, this happened:

error: symbol `dont_duplicate_me` is already defined
 --> src/lib.rs:4:9
  |
4 |         fn dont_duplicate_me() {}
  |         ^^^^^^^^^^^^^^^^^^^^^^

Meta

rustc --version:

1.92.0-nightly (2025-09-26 54a8a1db604e4caff93e)

@rustbot label T-libs A-macros A-thread-locals A-const-generics

[workingjubilee]

...Well, it did say not to duplicate it. :^)

[Noratrieb]

did you go looking for this issue or did you actually encounter it in practice 😨

[Jules-Bertholet]

I noticed it while working on #146281.

[theemathas]

Using proc macros, I can also cause a resource leak. As far as I can tell, this weirdness cannot cause UB, but it does come really close (I couldn't get a type coercion to happen inside the macro).

bar/src/lib.rs:

use proc_macro::TokenStream;
use std::sync::atomic::{AtomicU32, Ordering::SeqCst};

#[proc_macro]
pub fn counter(_: TokenStream) -> TokenStream {
    static COUNTER: AtomicU32 = AtomicU32::new(0);
    match COUNTER.fetch_add(1, SeqCst) {
        0 | 1 | 3 | 4 => "Thing",
        2 => "i32",
        _ => panic!(),
    }
    .parse()
    .unwrap()
}

src/main.rs:

use bar::counter;

thread_local! {
    static X: counter!() = Thing::new(String::from("abc"));
}

struct Thing(String);
impl Drop for Thing {
    fn drop(&mut self) {
        println!("drop {}", self.0);
    }
}
impl Thing {
    fn new(x: String) -> Self {
        println!("new {x}");
        Thing(x)
    }
}

fn main() {
    std::thread::spawn(|| {
        X.with(|_| {});
    })
    .join()
    .unwrap();
    println!("done");
}

Output of program:

new abc
done

This program leaks a String allocation for each time that: a new thread is created, the X thread-local is accessed, then the thread terminates.

This behavior occurs because, the third time the counter!() macro is called, it is used in a needs_drop() call. As a result, the thread-local implementation thinks that the type doesn't need to be dropped.