pub(crate) fn generate_provider_probe_type(&self) -> TokenStream {
        let arg_tuple = self.args_as_tuple_type_with_lifetimes();

        //In addition to the lifetime params for any ref args, all `ProviderProbe`s have a lifetime
        //param 'a which corresponds to the lifetime of the underlying `UnsafeProviderProbeImpl`
        //which they wrap.  That is the same for all probes, so we just hard-code it as 'a
        let a_lifetime = syn::Lifetime::new("'a", self.spec.span);

        let span = self.spec.span;
        quote_spanned! {span=>
            ::tracers::runtime::dynamic::ProviderProbe<#a_lifetime, ::tracers::runtime::dynamic::SystemProbe, #arg_tuple>
        }
    }
/// Each probe has a corresponding field in the struct that we build for the provider.  That
/// field is an instance of `ProviderProbe` which is a type-safe wrapper around the underlying
/// untyped implementation.  Because it's type safe it must necessarily have type parameters
/// corresponding to the arguments to the probe.  Thus its declaration gets a bit complicated.
///
/// Further complicating matters is that the lifetime elision that makes it so easy to declare
/// functions with reference args isn't available here, so every reference parameter the probe
/// takes needs to have a corresponding lifetime.  This gets messy, as you'll see.
Each probe has a corresponding field in the struct that we build for the provider.  That
field is an instance of `ProviderProbe` which is a type-safe wrapper around the underlying
untyped implementation.  Because it's type safe it must necessarily have type parameters
corresponding to the arguments to the probe.  Thus its declaration gets a bit complicated.

Further complicating matters is that the lifetime elision that makes it so easy to declare
functions with reference args isn't available here, so every reference parameter the probe
takes needs to have a corresponding lifetime.  This gets messy, as you'll see.
Each probe has a corresponding field in the struct that we build for the provider . That field is an instance of ` ProviderProbe ` which is a type - safe wrapper around the underlying untyped implementation . Because it ' s type safe it must necessarily have type parameters corresponding to the arguments to the probe . Thus its declaration gets a bit complicated . Further complicating matters is that the lifetime elision that makes it so easy to declare functions with reference args isn ' t available here so every reference parameter the probe takes needs to have a corresponding lifetime . This gets messy as you ' ll see .
pub(crate) fn generate_provider_probe_type(&self) -> TokenStream {
        let arg_tuple = self.args_as_tuple_type_with_lifetimes();
        //In addition to the lifetime params for any ref args, all `ProviderProbe`s have a lifetime
        //param 'a which corresponds to the lifetime of the underlying `UnsafeProviderProbeImpl`
        //which they wrap.  That is the same for all probes, so we just hard-code it as 'a
        let a_lifetime = syn::Lifetime::new("'a", self.spec.span);
        let span = self.spec.span;
        quote_spanned! {span=>
            ::tracers::runtime::dynamic::ProviderProbe<#a_lifetime, ::tracers::runtime::dynamic::SystemProbe, #arg_tuple>
        }
    }
pub ( crate ) fn generate_provider_probe_type ( & self ) -> TokenStream { let arg_tuple = self . args_as_tuple_type_with_lifetimes ( ) ; //In addition to the lifetime params for any ref args, all `ProviderProbe`s have a lifetime //param 'a which corresponds to the lifetime of the underlying `UnsafeProviderProbeImpl` //which they wrap.  That is the same for all probes, so we just hard-code it as 'a let a_lifetime = syn :: Lifetime :: new ( " " , self . spec . span ) ; let span = self . spec . span ; quote_spanned ! { span tracers runtime dynamic ProviderProbe a_lifetime tracers runtime dynamic SystemProbe arg_tuple } }
Each probe has a corresponding field in the struct that we build for the provider.
Each probe has a corresponding field in the struct that we build for the provider .
&self
&self