defaulted 0.1.3

//! Hygiene tests: verifies the derive macro produces tokens that compile
//! even when the standard prelude is disabled and primitive type names
//! have been shadowed.

#![cfg(feature = "derive")]
#![no_implicit_prelude]
#![allow(dead_code, reason = "fields exist solely to exercise the derive")]
#![allow(
    non_camel_case_types,
    reason = "shadowing primitives is the point of this test"
)]

trait bool {}
trait char {}
trait f32 {}
trait f64 {}
trait i8 {}
trait i16 {}
trait i32 {}
trait i64 {}
trait i128 {}
trait isize {}
trait str {}
trait u8 {}
trait u16 {}
trait u32 {}
trait u64 {}
trait u128 {}
trait usize {}

#[derive(::defaulted::Defaulted)]
struct Plain
{
    value: ::core::primitive::u32,
    label: ::std::string::String,
}

#[derive(::defaulted::Defaulted)]
struct WithIgnore
{
    value:   ::core::primitive::u32,
    #[defaulted(ignore)]
    _opaque: ::core::primitive::u64,
}

#[derive(::defaulted::Defaulted)]
#[defaulted(Default)]
struct WithDefaults
{
    #[defaulted(default = 42)]
    magic:   ::core::primitive::i32,
    #[defaulted(default = true)]
    enabled: ::core::primitive::bool,
    #[defaulted(default_ref = "codemon")]
    theme:   ::std::string::String,
    name:    ::std::string::String,
}

#[derive(::defaulted::Defaulted)]
struct WithFunc
{
    #[defaulted(with = ::core::option::Option::is_none)]
    maybe: ::core::option::Option<::core::primitive::u32>,
}

#[derive(::defaulted::Defaulted)]
struct WithClosure
{
    #[defaulted(with = |v: &::core::primitive::u32| *v == 0)]
    n: ::core::primitive::u32,
}

#[derive(::defaulted::Defaulted)]
struct Generic<T>
{
    value: T,
}

#[derive(::defaulted::Defaulted)]
enum UnitEnum
{
    #[defaulted(default)]
    Idle,
    Running,
}

#[derive(::defaulted::Defaulted)]
enum NamedEnum
{
    #[defaulted(default)]
    On
    {
        #[defaulted(default = true)]
        active: ::core::primitive::bool,
        count:  ::core::primitive::u32,
    },
    Off(::core::primitive::u32),
}

#[derive(::defaulted::Defaulted)]
enum TupleEnum
{
    #[defaulted(default)]
    Pair(::core::primitive::u32, ::std::string::String),
    Single(::core::primitive::u32),
}

#[test]
fn derive_compiles_without_prelude()
{
    use ::defaulted::Defaulted as _;

    ::core::assert!(
        Plain {
            value: 0,
            label: ::std::string::String::new(),
        }
        .is_defaulted()
    );
    ::core::assert!(
        !WithIgnore {
            value:   1,
            _opaque: 0,
        }
        .is_defaulted()
    );
    ::core::assert!(<WithDefaults as ::core::default::Default>::default().is_defaulted());
    ::core::assert!(
        WithFunc {
            maybe: ::core::option::Option::None,
        }
        .is_defaulted()
    );
    ::core::assert!(WithClosure { n: 0 }.is_defaulted());
    ::core::assert!(Generic::<::core::primitive::u32> { value: 0 }.is_defaulted());
    ::core::assert!(UnitEnum::Idle.is_defaulted());
    ::core::assert!(
        NamedEnum::On {
            active: true,
            count:  0,
        }
        .is_defaulted()
    );
    ::core::assert!(TupleEnum::Pair(0, ::std::string::String::new()).is_defaulted());
}

#[cfg(feature = "serde")]
mod shadow_core
{
    pub mod core
    {}
    pub mod std
    {}

    #[::defaulted::skip_serializing_defaults]
    #[derive(::serde::Serialize, ::defaulted::Defaulted)]
    pub struct Generic<T>
    {
        pub value: T,
    }

    pub struct Marker;

    impl ::defaulted::Defaulted for Marker
    {
        fn is_defaulted(&self) -> ::core::primitive::bool
        {
            true
        }
    }

    impl ::serde::Serialize for Marker
    {
        fn serialize<S: ::serde::Serializer>(&self, s: S)
        -> ::core::result::Result<S::Ok, S::Error>
        {
            s.serialize_unit()
        }
    }
}

#[cfg(feature = "serde")]
#[test]
fn skip_serializing_works_when_core_is_shadowed()
{
    use ::defaulted::Defaulted as _;
    let g = shadow_core::Generic::<shadow_core::Marker> {
        value: shadow_core::Marker,
    };
    ::core::assert!(g.is_defaulted());
}