pub fn into_compiler_error(self) -> TokenStream {
        //Darling's error type already produces a token stream for errors with useful context into,
        //so preserve that, otherwise build our own compiler error
        if let TracersError::DarlingError { darling_error, .. } = self {
            //Unwrap this error object from Arc and Mutex (it's not Send + Sync natively)
            //and use the write_error() method to generate a helpful TokenStream
            let lock =
                Arc::try_unwrap(darling_error).expect("Somehow a lock is still held on this error");
            let darling_error = lock
                .into_inner()
                .expect("The mutex can't possibly be locked");

            darling_error.write_errors()
        } else {
            self.into_syn_error().to_compile_error()
        }
    }
/// Convert this error into a `TokenStream` such that when the compiler consumes the token
/// stream it will evaluate to a compile error, with the span corresponding to whatever element
/// was used to report the error.  For those error types that don't have a corresponding
/// element, the call site of the macro will be used
Convert this error into a `TokenStream` such that when the compiler consumes the token
stream it will evaluate to a compile error, with the span corresponding to whatever element
was used to report the error.  For those error types that don't have a corresponding
element, the call site of the macro will be used
Convert this error into a ` TokenStream ` such that when the compiler consumes the token stream it will evaluate to a compile error with the span corresponding to whatever element was used to report the error . For those error types that don ' t have a corresponding element the call site of the macro will be used
pub fn into_compiler_error(self) -> TokenStream {
        //Darling's error type already produces a token stream for errors with useful context into,
        //so preserve that, otherwise build our own compiler error
        if let TracersError::DarlingError { darling_error, .. } = self {
            //Unwrap this error object from Arc and Mutex (it's not Send + Sync natively)
            //and use the write_error() method to generate a helpful TokenStream
            let lock =
                Arc::try_unwrap(darling_error).expect("Somehow a lock is still held on this error");
            let darling_error = lock
                .into_inner()
                .expect("The mutex can't possibly be locked");
            darling_error.write_errors()
        } else {
            self.into_syn_error().to_compile_error()
        }
    }
pub fn into_compiler_error ( self ) -> TokenStream { //Darling's error type already produces a token stream for errors with useful context into, //so preserve that, otherwise build our own compiler error if let TracersError :: DarlingError { darling_error , .. } = self { //Unwrap this error object from Arc and Mutex (it's not Send + Sync natively) //and use the write_error() method to generate a helpful TokenStream let lock = Arc :: try_unwrap ( darling_error ) . expect ( " " ) ; let darling_error = lock . into_inner ( ) . expect ( " " ) ; darling_error . write_errors ( ) } else { self . into_syn_error ( ) . to_compile_error ( ) } }
Convert this error into a `TokenStream` such that when the compiler consumes the token
stream it will evaluate to a compile error, with the span corresponding to whatever element
was used to report the error.
Convert this error into a ` TokenStream ` such that when the compiler consumes the token stream it will evaluate to a compile error with the span corresponding to whatever element was used to report the error .
self
self