Mark RECURSIVE_COUNT_* as const.

nnethercote · nnethercote · commit 27241c6921be · 2025-08-07T15:38:27.000+10:00
From the `thread_local` docs:

&gt; This macro supports a special `const {}` syntax that can be used when
&gt; the initialization expression can be evaluated as a constant. This can
&gt; enable a more efficient thread local implementation that can avoid
&gt; lazy initialization. For types that do not need to be dropped, this
&gt; can enable an even more efficient implementation that does not need to
&gt; track any additional state.

The `RECURSIVE_COUNT_*` values currently don't use this, but they can.
This changes the generated code from this:
```
    #[allow(non_upper_case_globals)]
    const RECURSIVE_COUNT_Example: ::std::thread::LocalKey&lt;::core::cell::Cell&lt;u32&gt;&gt; = {
        #[inline]
        fn __init() -&gt; ::core::cell::Cell&lt;u32&gt; {
            ::core::cell::Cell::new(0)
        }
        unsafe {
            ::std::thread::LocalKey::new(const {
                if ::std::mem::needs_drop::&lt;::core::cell::Cell&lt;u32&gt;&gt;() {
                    |init| {
                        #[thread_local]
                        static VAL: ::std::thread::local_impl::LazyStorage&lt;
                            ::core::cell::Cell&lt;u32&gt;,
                            (),
                        &gt; = ::std::thread::local_impl::LazyStorage::new();
                        VAL.get_or_init(init, __init)
                    }
                } else {
                    |init| {
                        #[thread_local]
                        static VAL: ::std::thread::local_impl::LazyStorage&lt;
                            ::core::cell::Cell&lt;u32&gt;,
                            !,
                        &gt; = ::std::thread::local_impl::LazyStorage::new();
                        VAL.get_or_init(init, __init)
                    }
                }
            })
        }
    };
```
to this:
```
    #[allow(non_upper_case_globals)]
    const RECURSIVE_COUNT_Example: ::std::thread::LocalKey&lt;::core::cell::Cell&lt;u32&gt;&gt; = {
        const __INIT: ::core::cell::Cell&lt;u32&gt; = { ::core::cell::Cell::new(0) };
        unsafe {
            ::std::thread::LocalKey::new(const {
                if ::std::mem::needs_drop::&lt;::core::cell::Cell&lt;u32&gt;&gt;() {
                    |_| {
                        #[thread_local]
                        static VAL: ::std::thread::local_impl::EagerStorage&lt;
                            ::core::cell::Cell&lt;u32&gt;,
                        &gt; = ::std::thread::local_impl::EagerStorage::new(__INIT);
                        VAL.get()
                    }
                } else {
                    |_| {
                        #[thread_local]
                        static VAL: ::core::cell::Cell&lt;u32&gt; = __INIT;
                        &amp;VAL
                    }
                }
            })
        }
    };
```
Note in both cases the `else` block is the relevant one because
`Cell&lt;u32&gt;` doesn't need drop.
diff --git a/derive/src/lib.rs b/derive/src/lib.rs
@@ -60,7 +60,9 @@ fn expand_derive_arbitrary(input: syn::DeriveInput) -> Result<TokenStream> {
         const _: () = {
             ::std::thread_local! {
                 #[allow(non_upper_case_globals)]
-                static #recursive_count: ::core::cell::Cell<u32> = ::core::cell::Cell::new(0);
+                static #recursive_count: ::core::cell::Cell<u32> = const {
+                    ::core::cell::Cell::new(0)
+                };
             }
 
             #[automatically_derived]
