pub(crate) fn warnings(&self) -> impl ToTokens {
        let warnings = self.parse_warnings.iter().map(|err| {
            let msg = format!("found unrecognized input, {}", err);
            let msg = LitStr::new(&msg, err.span());
            // TODO(eliza): This is a bit of a hack, but it's just about the
            // only way to emit warnings from a proc macro on stable Rust.
            // Eventually, when the `proc_macro::Diagnostic` API stabilizes, we
            // should definitely use that instead.
            quote_spanned! {err.span()=>
                #[warn(deprecated)]
                {
                    #[deprecated(since = "not actually deprecated", note = #msg)]
                    const TRACING_INSTRUMENT_WARNING: () = ();
                    let _ = TRACING_INSTRUMENT_WARNING;
                }
            }
        });
        quote! {
            { #(#warnings)* }
        }
    }
/// Generate "deprecation" warnings for any unrecognized attribute inputs
/// that we skipped.
///
/// For backwards compatibility, we need to emit compiler warnings rather
/// than errors for unrecognized inputs. Generating a fake deprecation is
/// the only way to do this on stable Rust right now.
Generate "deprecation" warnings for any unrecognized attribute inputs
that we skipped.

For backwards compatibility, we need to emit compiler warnings rather
than errors for unrecognized inputs. Generating a fake deprecation is
the only way to do this on stable Rust right now.
Generate " deprecation " warnings for any unrecognized attribute inputs that we skipped . For backwards compatibility we need to emit compiler warnings rather than errors for unrecognized inputs . Generating a fake deprecation is the only way to do this on stable Rust right now .
pub(crate) fn warnings(&self) -> impl ToTokens {
        let warnings = self.parse_warnings.iter().map(|err| {
            let msg = format!("found unrecognized input, {}", err);
            let msg = LitStr::new(&msg, err.span());
            // TODO(eliza): This is a bit of a hack, but it's just about the
            // only way to emit warnings from a proc macro on stable Rust.
            // Eventually, when the `proc_macro::Diagnostic` API stabilizes, we
            // should definitely use that instead.
            quote_spanned! {err.span()=>
                #[warn(deprecated)]
                {
                    #[deprecated(since = "not actually deprecated", note = #msg)]
                    const TRACING_INSTRUMENT_WARNING: () = ();
                    let _ = TRACING_INSTRUMENT_WARNING;
                }
            }
        });
        quote! {
            { #(#warnings)* }
        }
    }
pub ( crate ) fn warnings ( & self ) -> impl ToTokens { let warnings = self . parse_warnings . iter ( ) . map ( | err | { let msg = format ! ( " " err ) ; let msg = LitStr :: new ( & msg , err . span ( ) ) ; // TODO(eliza): This is a bit of a hack, but it's just about the // only way to emit warnings from a proc macro on stable Rust. // Eventually, when the `proc_macro::Diagnostic` API stabilizes, we // should definitely use that instead. quote_spanned ! { err span ( ) [ warn ( deprecated ) ] { [ deprecated ( since " " note msg ) ] const TRACING_INSTRUMENT_WARNING ( ) ( ) let TRACING_INSTRUMENT_WARNING } } } ) ; quote ! { { ( warnings ) } } }
Generate "deprecation" warnings for any unrecognized attribute inputs
that we skipped.
Generate " deprecation " warnings for any unrecognized attribute inputs that we skipped .
&self