Get error about missing "tracing" dependency when trying to use #[component] macro about leptos HOT 20 CLOSED

use leptos::{component, IntoView};

#[component]
fn SignupForm() -> impl IntoView {}

#![feature(prelude_import)]
#[prelude_import]
use std::prelude::rust_2021::*;
#[macro_use]
extern crate std;
use leptos::{component, view, IntoView};
/// Props for the [`SignupForm`] component.
///
///
#[builder(crate_module_path = ::leptos::typed_builder)]
struct SignupFormProps {}
#[automatically_derived]
impl SignupFormProps {
    /**
                Create a builder for building `SignupFormProps`.
                On the builder, call  to set the values of the fields.
                Finally, call `.build()` to create the instance of `SignupFormProps`.
                */
    #[allow(dead_code, clippy::default_trait_access)]
    fn builder() -> SignupFormPropsBuilder<()> {
        SignupFormPropsBuilder {
            fields: (),
            phantom: ::core::default::Default::default(),
        }
    }
}
#[must_use]
#[doc(hidden)]
#[allow(dead_code, non_camel_case_types, non_snake_case)]
struct SignupFormPropsBuilder<TypedBuilderFields = ()> {
    fields: TypedBuilderFields,
    phantom: ::core::marker::PhantomData<()>,
}
#[automatically_derived]
impl<TypedBuilderFields> Clone for SignupFormPropsBuilder<TypedBuilderFields>
where
    TypedBuilderFields: Clone,
{
    #[allow(clippy::default_trait_access)]
    fn clone(&self) -> Self {
        Self {
            fields: self.fields.clone(),
            phantom: ::core::default::Default::default(),
        }
    }
}
#[allow(dead_code, non_camel_case_types, missing_docs)]
#[automatically_derived]
impl SignupFormPropsBuilder<()> {
    #[allow(clippy::default_trait_access, clippy::used_underscore_binding)]
    pub fn build(self) -> SignupFormProps {
        let () = self.fields;
        #[allow(deprecated)] SignupFormProps {}.into()
    }
}
#[allow(missing_docs)]
impl ::leptos::Props for SignupFormProps {
    type Builder = SignupFormPropsBuilder;
    fn builder() -> Self::Builder {
        SignupFormProps::builder()
    }
}
impl ::leptos::DynAttrs for SignupFormProps {
    fn dyn_attrs(mut self, v: Vec<(&'static str, ::leptos::Attribute)>) -> Self {
        self
    }
}
impl ::leptos::IntoView for SignupFormProps {
    fn into_view(self) -> ::leptos::View {
        SignupForm().into_view()
    }
}
///
#[allow(non_snake_case, clippy::too_many_arguments)]
#[allow(clippy::needless_lifetimes)]
#[allow(clippy::let_with_type_underscore)]
fn SignupForm() -> impl IntoView {
    {}
    #[allow(clippy::suspicious_else_formatting)]
    {
        let __tracing_attr_span;
        let __tracing_attr_guard;
        if tracing::Level::INFO <= ::tracing::level_filters::STATIC_MAX_LEVEL
            && tracing::Level::INFO <= ::tracing::level_filters::LevelFilter::current()
            || { false }
        {
            __tracing_attr_span = {
                use ::tracing::__macro_support::Callsite as _;
                static __CALLSITE: ::tracing::callsite::DefaultCallsite = {
                    static META: ::tracing::Metadata<'static> = {
                        ::tracing_core::metadata::Metadata::new(
                            "<SignupForm />",
                            "leptos_bug",
                            tracing::Level::INFO,
                            ::core::option::Option::Some("src/main.rs"),
                            ::core::option::Option::Some(3u32),
                            ::core::option::Option::Some("leptos_bug"),
                            ::tracing_core::field::FieldSet::new(
                                &[],
                                ::tracing_core::callsite::Identifier(&__CALLSITE),
                            ),
                            ::tracing::metadata::Kind::SPAN,
                        )
                    };
                    ::tracing::callsite::DefaultCallsite::new(&META)
                };
                let mut interest = ::tracing::subscriber::Interest::never();
                if tracing::Level::INFO <= ::tracing::level_filters::STATIC_MAX_LEVEL
                    && tracing::Level::INFO
                        <= ::tracing::level_filters::LevelFilter::current()
                    && {
                        interest = __CALLSITE.interest();
                        !interest.is_never()
                    }
                    && ::tracing::__macro_support::__is_enabled(
                        __CALLSITE.metadata(),
                        interest,
                    )
                {
                    let meta = __CALLSITE.metadata();
                    ::tracing::Span::new(meta, &{ meta.fields().value_set(&[]) })
                } else {
                    let span = ::tracing::__macro_support::__disabled_span(
                        __CALLSITE.metadata(),
                    );
                    {};
                    span
                }
            };
            __tracing_attr_guard = __tracing_attr_span.enter();
        }
        #[warn(clippy::suspicious_else_formatting)]
        {
            #[allow(
                unknown_lints,
                unreachable_code,
                clippy::diverging_sub_expression,
                clippy::let_unit_value,
                clippy::unreachable,
                clippy::let_with_type_underscore,
                clippy::empty_loop
            )]
            if false {
                let __tracing_attr_fake_return: _ = loop {};
                return __tracing_attr_fake_return;
            }
            {
                let span = ::leptos::leptos_dom::tracing::Span::current();
                ::leptos::leptos_dom::Component::new(
                    "SignupForm",
                    move || {
                        #[cfg(debug_assertions)]
                        let _guard = span.entered();
                        __SignupForm()
                    },
                )
            }
        }
    }
}
#[doc(hidden)]
#[allow(non_snake_case, dead_code, clippy::too_many_arguments)]
fn __SignupForm() -> impl IntoView {
    {
        #[allow(unused_braces)]
        {
            let _ = ::leptos::leptos_dom::html::div;
            let _ = ::leptos::leptos_dom::html::div;
            let _ = ::leptos::leptos_dom::html::h1;
            let _ = ::leptos::leptos_dom::html::h1;
            ::leptos::HtmlElement::from_chunks(
                ::leptos::leptos_dom::html::Div::default(),
                [
                    leptos::leptos_dom::html::StringOrView::String(
                        {
                            let res = ::alloc::fmt::format(
                                format_args!(
                                    "<div{0}><h1{1}>Hello World</h1></div>",
                                    ::leptos::leptos_dom::HydrationCtx::peek().map(| id | { let
                                    res = ::alloc::fmt::format(format_args!(" data-hk=\"{0}\"",
                                    id)); res }).unwrap_or_default(),
                                    ::leptos::leptos_dom::HydrationCtx::id().map(| id | { let
                                    res = ::alloc::fmt::format(format_args!(" data-hk=\"{0}\"",
                                    id)); res }).unwrap_or_default()
                                ),
                            );
                            res
                        }
                            .into(),
                    ),
                ],
            )
        }
    }
}
fn main() {
    {
        ::std::io::_print(format_args!("Hello, world!\n"));
    };
}