use expect_test::expect;
use test_utils::{bench, bench_fixture, skip_slow_tests};

use super::{check_infer, check_types};

#[test]
fn cfg_impl_def() {
    check_types(
        r#"
//- /main.rs crate:main deps:foo cfg:test
use foo::S as T;
struct S;

#[cfg(test)]
impl S {
    fn foo1(&self) -> i32 { 0 }
}

#[cfg(not(test))]
impl S {
    fn foo2(&self) -> i32 { 0 }
}

fn test() {
    let t = (S.foo1(), S.foo2(), T.foo3(), T.foo4());
    t;
} //^ (i32, {unknown}, i32, {unknown})

//- /foo.rs crate:foo
pub struct S;

#[cfg(not(test))]
impl S {
    pub fn foo3(&self) -> i32 { 0 }
}

#[cfg(test)]
impl S {
    pub fn foo4(&self) -> i32 { 0 }
}
"#,
    );
}

#[test]
fn infer_macros_expanded() {
    check_infer(
        r#"
        struct Foo(Vec<i32>);

        macro_rules! foo {
            ($($item:expr),*) => {
                    {
                        Foo(vec![$($item,)*])
                    }
            };
        }

        fn main() {
            let x = foo!(1,2);
        }
        "#,
        expect![[r#"
            !0..17 '{Foo(v...,2,])}': Foo
            !1..4 'Foo': Foo({unknown}) -> Foo
            !1..16 'Foo(vec![1,2,])': Foo
            !5..15 'vec![1,2,]': {unknown}
            155..181 '{     ...,2); }': ()
            165..166 'x': Foo
        "#]],
    );
}

#[test]
fn infer_legacy_textual_scoped_macros_expanded() {
    check_infer(
        r#"
        struct Foo(Vec<i32>);

        #[macro_use]
        mod m {
            macro_rules! foo {
                ($($item:expr),*) => {
                    {
                        Foo(vec![$($item,)*])
                    }
                };
            }
        }

        fn main() {
            let x = foo!(1,2);
            let y = crate::foo!(1,2);
        }
        "#,
        expect![[r#"
            !0..17 '{Foo(v...,2,])}': Foo
            !1..4 'Foo': Foo({unknown}) -> Foo
            !1..16 'Foo(vec![1,2,])': Foo
            !5..15 'vec![1,2,]': {unknown}
            194..250 '{     ...,2); }': ()
            204..205 'x': Foo
            227..228 'y': {unknown}
            231..247 'crate:...!(1,2)': {unknown}
        "#]],
    );
}

#[test]
fn infer_path_qualified_macros_expanded() {
    check_infer(
        r#"
        #[macro_export]
        macro_rules! foo {
            () => { 42i32 }
        }

        mod m {
            pub use super::foo as bar;
        }

        fn main() {
            let x = crate::foo!();
            let y = m::bar!();
        }
        "#,
        expect![[r#"
            !0..5 '42i32': i32
            !0..5 '42i32': i32
            110..163 '{     ...!(); }': ()
            120..121 'x': i32
            147..148 'y': i32
        "#]],
    );
}

#[test]
fn expr_macro_def_expanded_in_various_places() {
    check_infer(
        r#"
        macro spam() {
            1isize
        }

        fn spam() {
            spam!();
            (spam!());
            spam!().spam(spam!());
            for _ in spam!() {}
            || spam!();
            while spam!() {}
            break spam!();
            return spam!();
            match spam!() {
                _ if spam!() => spam!(),
            }
            spam!()(spam!());
            Spam { spam: spam!() };
            spam!()[spam!()];
            await spam!();
            spam!() as usize;
            &spam!();
            -spam!();
            spam!()..spam!();
            spam!() + spam!();
        }
        "#,
        expect![[r#"
            !0..6 '1isize': isize
            !0..6 '1isize': isize
            !0..6 '1isize': isize
            !0..6 '1isize': isize
            !0..6 '1isize': isize
            !0..6 '1isize': isize
            !0..6 '1isize': isize
            !0..6 '1isize': isize
            !0..6 '1isize': isize
            !0..6 '1isize': isize
            !0..6 '1isize': isize
            !0..6 '1isize': isize
            !0..6 '1isize': isize
            !0..6 '1isize': isize
            !0..6 '1isize': isize
            !0..6 '1isize': isize
            !0..6 '1isize': isize
            !0..6 '1isize': isize
            !0..6 '1isize': isize
            !0..6 '1isize': isize
            !0..6 '1isize': isize
            !0..6 '1isize': isize
            !0..6 '1isize': isize
            !0..6 '1isize': isize
            !0..6 '1isize': isize
            39..442 '{     ...!(); }': ()
            73..94 'spam!(...am!())': {unknown}
            100..119 'for _ ...!() {}': ()
            104..105 '_': {unknown}
            117..119 '{}': ()
            124..134 '|| spam!()': || -> isize
            140..156 'while ...!() {}': ()
            154..156 '{}': ()
            161..174 'break spam!()': !
            180..194 'return spam!()': !
            200..254 'match ...     }': isize
            224..225 '_': isize
            259..275 'spam!(...am!())': {unknown}
            281..303 'Spam {...m!() }': {unknown}
            309..325 'spam!(...am!()]': {unknown}
            350..366 'spam!(... usize': usize
            372..380 '&spam!()': &isize
            386..394 '-spam!()': isize
            400..416 'spam!(...pam!()': {unknown}
            422..439 'spam!(...pam!()': isize
        "#]],
    );
}

#[test]
fn expr_macro_rules_expanded_in_various_places() {
    check_infer(
        r#"
        macro_rules! spam {
            () => (1isize);
        }

        fn spam() {
            spam!();
            (spam!());
            spam!().spam(spam!());
            for _ in spam!() {}
            || spam!();
            while spam!() {}
            break spam!();
            return spam!();
            match spam!() {
                _ if spam!() => spam!(),
            }
            spam!()(spam!());
            Spam { spam: spam!() };
            spam!()[spam!()];
            await spam!();
            spam!() as usize;
            &spam!();
            -spam!();
            spam!()..spam!();
            spam!() + spam!();
        }
        "#,
        expect![[r#"
            !0..6 '1isize': isize
            !0..6 '1isize': isize
            !0..6 '1isize': isize
            !0..6 '1isize': isize
            !0..6 '1isize': isize
            !0..6 '1isize': isize
            !0..6 '1isize': isize
            !0..6 '1isize': isize
            !0..6 '1isize': isize
            !0..6 '1isize': isize
            !0..6 '1isize': isize
            !0..6 '1isize': isize
            !0..6 '1isize': isize
            !0..6 '1isize': isize
            !0..6 '1isize': isize
            !0..6 '1isize': isize
            !0..6 '1isize': isize
            !0..6 '1isize': isize
            !0..6 '1isize': isize
            !0..6 '1isize': isize
            !0..6 '1isize': isize
            !0..6 '1isize': isize
            !0..6 '1isize': isize
            !0..6 '1isize': isize
            !0..6 '1isize': isize
            53..456 '{     ...!(); }': ()
            87..108 'spam!(...am!())': {unknown}
            114..133 'for _ ...!() {}': ()
            118..119 '_': {unknown}
            131..133 '{}': ()
            138..148 '|| spam!()': || -> isize
            154..170 'while ...!() {}': ()
            168..170 '{}': ()
            175..188 'break spam!()': !
            194..208 'return spam!()': !
            214..268 'match ...     }': isize
            238..239 '_': isize
            273..289 'spam!(...am!())': {unknown}
            295..317 'Spam {...m!() }': {unknown}
            323..339 'spam!(...am!()]': {unknown}
            364..380 'spam!(... usize': usize
            386..394 '&spam!()': &isize
            400..408 '-spam!()': isize
            414..430 'spam!(...pam!()': {unknown}
            436..453 'spam!(...pam!()': isize
        "#]],
    );
}

#[test]
fn expr_macro_expanded_in_stmts() {
    check_infer(
        r#"
        macro_rules! id { ($($es:tt)*) => { $($es)* } }
        fn foo() {
            id! { let a = (); }
        }
        "#,
        expect![[r#"
            !0..8 'leta=();': ()
            !0..8 'leta=();': ()
            !3..4 'a': ()
            !5..7 '()': ()
            57..84 '{     ...); } }': ()
        "#]],
    );
}

#[test]
fn recurisve_macro_expanded_in_stmts() {
    check_infer(
        r#"
        macro_rules! ng {
            ([$($tts:tt)*]) => {
                $($tts)*;
            };
            ([$($tts:tt)*] $head:tt $($rest:tt)*) => {
                ng! {
                    [$($tts)* $head] $($rest)*
                }
            };
        }
        fn foo() {
            ng!([] let a = 3);
            let b = a;
        }
        "#,
        expect![[r#"
            !0..7 'leta=3;': {unknown}
            !0..7 'leta=3;': {unknown}
            !0..13 'ng!{[leta=3]}': {unknown}
            !0..13 'ng!{[leta=]3}': {unknown}
            !0..13 'ng!{[leta]=3}': {unknown}
            !3..4 'a': i32
            !5..6 '3': i32
            196..237 '{     ...= a; }': ()
            229..230 'b': i32
            233..234 'a': i32
        "#]],
    );
}

#[test]
fn recursive_inner_item_macro_rules() {
    check_infer(
        r#"
        macro_rules! mac {
            () => { mac!($)};
            ($x:tt) => { macro_rules! blub { () => { 1 }; } };
        }
        fn foo() {
            mac!();
            let a = blub!();
        }
        "#,
        expect![[r#"
            !0..1 '1': i32
            !0..26 'macro_...>{1};}': {unknown}
            !0..26 'macro_...>{1};}': {unknown}
            107..143 '{     ...!(); }': ()
            129..130 'a': i32
        "#]],
    );
}

#[test]
fn infer_macro_defining_block_with_items() {
    check_infer(
        r#"
        macro_rules! foo {
            () => {{
                fn bar() -> usize { 0 }
                bar()
            }};
        }
        fn main() {
            let _a = foo!();
        }
    "#,
        expect![[r#"
            !15..18 '{0}': usize
            !16..17 '0': usize
            !0..24 '{fnbar...bar()}': usize
            !18..21 'bar': fn bar() -> usize
            !18..23 'bar()': usize
            98..122 '{     ...!(); }': ()
            108..110 '_a': usize
        "#]],
    );
}

#[test]
fn infer_type_value_macro_having_same_name() {
    check_infer(
        r#"
        #[macro_export]
        macro_rules! foo {
            () => {
                mod foo {
                    pub use super::foo;
                }
            };
            ($x:tt) => {
                $x
            };
        }

        foo!();

        fn foo() {
            let foo = foo::foo!(42i32);
        }
        "#,
        expect![[r#"
            !0..5 '42i32': i32
            170..205 '{     ...32); }': ()
            180..183 'foo': i32
        "#]],
    );
}

#[test]
fn processes_impls_generated_by_macros() {
    check_types(
        r#"
macro_rules! m {
    ($ident:ident) => (impl Trait for $ident {})
}
trait Trait { fn foo(self) -> u128 { 0 } }
struct S;
m!(S);
fn test() { S.foo(); }
          //^^^^^^^ u128
"#,
    );
}

#[test]
fn infer_assoc_items_generated_by_macros() {
    check_types(
        r#"
macro_rules! m {
    () => (fn foo(&self) -> u128 {0})
}
struct S;
impl S {
    m!();
}

fn test() { S.foo(); }
          //^^^^^^^ u128
"#,
    );
}

#[test]
fn infer_assoc_items_generated_by_macros_chain() {
    check_types(
        r#"
macro_rules! m_inner {
    () => {fn foo(&self) -> u128 {0}}
}
macro_rules! m {
    () => {m_inner!();}
}

struct S;
impl S {
    m!();
}

fn test() { S.foo(); }
          //^^^^^^^ u128
"#,
    );
}

#[test]
fn infer_macro_with_dollar_crate_is_correct_in_expr() {
    check_types(
        r#"
//- /main.rs crate:main deps:foo
fn test() {
    let x = (foo::foo!(1), foo::foo!(2));
    x;
} //^ (i32, usize)

//- /lib.rs crate:foo
#[macro_export]
macro_rules! foo {
    (1) => { $crate::bar!() };
    (2) => { 1 + $crate::baz() };
}

#[macro_export]
macro_rules! bar {
    () => { 42 }
}

pub fn baz() -> usize { 31usize }
"#,
    );
}

#[test]
fn infer_macro_with_dollar_crate_is_correct_in_trait_associate_type() {
    check_types(
        r#"
//- /main.rs crate:main deps:foo
use foo::Trait;

fn test() {
    let msg = foo::Message(foo::MessageRef);
    let r = msg.deref();
    r;
  //^ &MessageRef
}

//- /lib.rs crate:foo
pub struct MessageRef;
pub struct Message(MessageRef);

pub trait Trait {
    type Target;
    fn deref(&self) -> &Self::Target;
}

#[macro_export]
macro_rules! expand {
    () => {
        impl Trait for Message {
            type Target = $crate::MessageRef;
            fn deref(&self) ->  &Self::Target {
                &self.0
            }
        }
    }
}

expand!();
"#,
    );
}

#[test]
fn infer_macro_with_dollar_crate_in_def_site() {
    check_types(
        r#"
//- /main.rs crate:main deps:foo
use foo::expand;

macro_rules! list {
    ($($tt:tt)*) => { $($tt)* }
}

fn test() {
    let r = expand!();
    r;
  //^ u128
}

//- /lib.rs crate:foo
#[macro_export]
macro_rules! expand {
    () => { list!($crate::m!()) };
}

#[macro_export]
macro_rules! m {
    () => { 0u128 };
}
"#,
    );
}

#[test]
fn infer_type_value_non_legacy_macro_use_as() {
    check_infer(
        r#"
        mod m {
            macro_rules! _foo {
                ($x:ident) => { type $x = u64; }
            }
            pub(crate) use _foo as foo;
        }

        m::foo!(foo);
        use foo as bar;
        fn f() -> bar { 0 }
        fn main() {
            let _a  = f();
        }
        "#,
        expect![[r#"
            158..163 '{ 0 }': u64
            160..161 '0': u64
            174..196 '{     ...f(); }': ()
            184..186 '_a': u64
            190..191 'f': fn f() -> u64
            190..193 'f()': u64
        "#]],
    );
}

#[test]
fn infer_local_macro() {
    check_infer(
        r#"
        fn main() {
            macro_rules! foo {
                () => { 1usize }
            }
            let _a  = foo!();
        }
        "#,
        expect![[r#"
            !0..6 '1usize': usize
            10..89 '{     ...!(); }': ()
            74..76 '_a': usize
        "#]],
    );
}

#[test]
fn infer_local_inner_macros() {
    check_types(
        r#"
//- /main.rs crate:main deps:foo
fn test() {
    let x = foo::foo!(1);
    x;
} //^ i32

//- /lib.rs crate:foo
#[macro_export(local_inner_macros)]
macro_rules! foo {
    (1) => { bar!() };
}

#[macro_export]
macro_rules! bar {
    () => { 42 }
}

"#,
    );
}

#[test]
fn infer_builtin_macros_line() {
    check_infer(
        r#"
        #[rustc_builtin_macro]
        macro_rules! line {() => {}}

        fn main() {
            let x = line!();
        }
        "#,
        expect![[r#"
            !0..1 '0': i32
            63..87 '{     ...!(); }': ()
            73..74 'x': i32
        "#]],
    );
}

#[test]
fn infer_builtin_macros_file() {
    check_infer(
        r#"
        #[rustc_builtin_macro]
        macro_rules! file {() => {}}

        fn main() {
            let x = file!();
        }
        "#,
        expect![[r#"
            !0..2 '""': &str
            63..87 '{     ...!(); }': ()
            73..74 'x': &str
        "#]],
    );
}

#[test]
fn infer_builtin_macros_column() {
    check_infer(
        r#"
        #[rustc_builtin_macro]
        macro_rules! column {() => {}}

        fn main() {
            let x = column!();
        }
        "#,
        expect![[r#"
            !0..1 '0': i32
            65..91 '{     ...!(); }': ()
            75..76 'x': i32
        "#]],
    );
}

#[test]
fn infer_builtin_macros_concat() {
    check_infer(
        r#"
        #[rustc_builtin_macro]
        macro_rules! concat {() => {}}

        fn main() {
            let x = concat!("hello", concat!("world", "!"));
        }
        "#,
        expect![[r#"
            !0..13 '"helloworld!"': &str
            65..121 '{     ...")); }': ()
            75..76 'x': &str
        "#]],
    );
}

#[test]
fn infer_builtin_macros_include() {
    check_types(
        r#"
//- /main.rs
#[rustc_builtin_macro]
macro_rules! include {() => {}}

include!("foo.rs");

fn main() {
    bar();
} //^^^^^ u32

//- /foo.rs
fn bar() -> u32 {0}
"#,
    );
}

#[test]
fn infer_builtin_macros_include_expression() {
    check_types(
        r#"
//- /main.rs
#[rustc_builtin_macro]
macro_rules! include {() => {}}
fn main() {
    let i = include!("bla.rs");
    i;
  //^ i32
}
//- /bla.rs
0
        "#,
    )
}

#[test]
fn infer_builtin_macros_include_child_mod() {
    check_types(
        r#"
//- /main.rs
#[rustc_builtin_macro]
macro_rules! include {() => {}}

include!("f/foo.rs");

fn main() {
    bar::bar();
} //^^^^^^^^^^ u32

//- /f/foo.rs
pub mod bar;

//- /f/bar.rs
pub fn bar() -> u32 {0}
"#,
    );
}

#[test]
fn infer_builtin_macros_include_str() {
    check_types(
        r#"
//- /main.rs
#[rustc_builtin_macro]
macro_rules! include_str {() => {}}

fn main() {
    let a = include_str!("foo.rs");
    a;
} //^ &str

//- /foo.rs
hello
"#,
    );
}

#[test]
fn infer_builtin_macros_include_str_with_lazy_nested() {
    check_types(
        r#"
//- /main.rs
#[rustc_builtin_macro]
macro_rules! concat {() => {}}
#[rustc_builtin_macro]
macro_rules! include_str {() => {}}

macro_rules! m {
    ($x:expr) => {
        concat!("foo", $x)
    };
}

fn main() {
    let a = include_str!(m!(".rs"));
    a;
} //^ &str

//- /foo.rs
hello
"#,
    );
}

#[test]
fn benchmark_include_macro() {
    if skip_slow_tests() {
        return;
    }
    let data = bench_fixture::big_struct();
    let fixture = r#"
//- /main.rs
#[rustc_builtin_macro]
macro_rules! include {() => {}}

include!("foo.rs");

fn main() {
    RegisterBlock { };
  //^^^^^^^^^^^^^^^^^ RegisterBlock
}
    "#;
    let fixture = format!("{}\n//- /foo.rs\n{}", fixture, data);

    {
        let _b = bench("include macro");
        check_types(&fixture);
    }
}

#[test]
fn infer_builtin_macros_include_concat() {
    check_types(
        r#"
//- /main.rs
#[rustc_builtin_macro]
macro_rules! include {() => {}}

#[rustc_builtin_macro]
macro_rules! concat {() => {}}

include!(concat!("f", "oo.rs"));

fn main() {
    bar();
} //^^^^^ u32

//- /foo.rs
fn bar() -> u32 {0}
"#,
    );
}

#[test]
fn infer_builtin_macros_include_concat_with_bad_env_should_failed() {
    check_types(
        r#"
//- /main.rs
#[rustc_builtin_macro]
macro_rules! include {() => {}}

#[rustc_builtin_macro]
macro_rules! concat {() => {}}

#[rustc_builtin_macro]
macro_rules! env {() => {}}

include!(concat!(env!("OUT_DIR"), "/foo.rs"));

fn main() {
    bar();
} //^^^^^ {unknown}

//- /foo.rs
fn bar() -> u32 {0}
"#,
    );
}

#[test]
fn infer_builtin_macros_include_itself_should_failed() {
    check_types(
        r#"
#[rustc_builtin_macro]
macro_rules! include {() => {}}

include!("main.rs");

fn main() {
    0;
} //^ i32
"#,
    );
}

#[test]
fn infer_builtin_macros_concat_with_lazy() {
    check_infer(
        r#"
        macro_rules! hello {() => {"hello"}}

        #[rustc_builtin_macro]
        macro_rules! concat {() => {}}

        fn main() {
            let x = concat!(hello!(), concat!("world", "!"));
        }
        "#,
        expect![[r#"
            !0..13 '"helloworld!"': &str
            103..160 '{     ...")); }': ()
            113..114 'x': &str
        "#]],
    );
}

#[test]
fn infer_builtin_macros_env() {
    check_infer(
        r#"
        //- /main.rs env:foo=bar
        #[rustc_builtin_macro]
        macro_rules! env {() => {}}

        fn main() {
            let x = env!("foo");
        }
        "#,
        expect![[r#"
            !0..22 '"__RA_...TED__"': &str
            62..90 '{     ...o"); }': ()
            72..73 'x': &str
        "#]],
    );
}

#[test]
fn infer_derive_clone_simple() {
    check_types(
        r#"
//- /main.rs crate:main deps:core
#[derive(Clone)]
struct S;
fn test() {
    S.clone();
} //^^^^^^^^^ S

//- /lib.rs crate:core
pub mod prelude {
    pub mod rust_2018 {
        #[rustc_builtin_macro]
        pub macro Clone {}
        pub use crate::clone::Clone;
    }
}

pub mod clone {
    pub trait Clone {
        fn clone(&self) -> Self;
    }
}
"#,
    );
}

#[test]
fn infer_derive_clone_in_core() {
    check_types(
        r#"
//- /lib.rs crate:core
#[prelude_import]
use prelude::rust_2018::*;

pub mod prelude {
    pub mod rust_2018 {
        #[rustc_builtin_macro]
        pub macro Clone {}
        pub use crate::clone::Clone;
    }
}

pub mod clone {
    pub trait Clone {
        fn clone(&self) -> Self;
    }
}

#[derive(Clone)]
pub struct S;

//- /main.rs crate:main deps:core
use core::S;
fn test() {
    S.clone();
} //^^^^^^^^^ S
"#,
    );
}

#[test]
fn infer_derive_clone_with_params() {
    check_types(
        r#"
//- /main.rs crate:main deps:core
#[derive(Clone)]
struct S;
#[derive(Clone)]
struct Wrapper<T>(T);
struct NonClone;
fn test() {
    let x = (Wrapper(S).clone(), Wrapper(NonClone).clone());
    x;
  //^ (Wrapper<S>, {unknown})
}

//- /lib.rs crate:core
pub mod prelude {
    pub mod rust_2018 {
        #[rustc_builtin_macro]
        pub macro Clone {}
        pub use crate::clone::Clone;
    }
}

pub mod clone {
    pub trait Clone {
        fn clone(&self) -> Self;
    }
}
"#,
    );
}

#[test]
fn infer_custom_derive_simple() {
    // FIXME: this test current now do nothing
    check_types(
        r#"
//- /main.rs crate:main
use foo::Foo;

#[derive(Foo)]
struct S{}

fn test() {
    S{};
} //^^^ S
"#,
    );
}

#[test]
fn macro_in_arm() {
    check_infer(
        r#"
        macro_rules! unit {
            () => { () };
        }

        fn main() {
            let x = match () {
                unit!() => 92u32,
            };
        }
        "#,
        expect![[r#"
            !0..2 '()': ()
            51..110 '{     ...  }; }': ()
            61..62 'x': u32
            65..107 'match ...     }': u32
            71..73 '()': ()
            95..100 '92u32': u32
        "#]],
    );
}

#[test]
fn macro_in_type_alias_position() {
    check_infer(
        r#"
        macro_rules! U32 {
            () => { u32 };
        }

        trait Foo {
            type Ty;
        }

        impl<T> Foo for T {
            type Ty = U32!();
        }

        type TayTo = U32!();

        fn testy() {
            let a: <() as Foo>::Ty;
            let b: TayTo;
        }
        "#,
        expect![[r#"
            147..196 '{     ...yTo; }': ()
            157..158 'a': u32
            185..186 'b': u32
        "#]],
    );
}

#[test]
fn nested_macro_in_type_alias_position() {
    check_infer(
        r#"
        macro_rules! U32Inner2 {
            () => { u32 };
        }

        macro_rules! U32Inner1 {
            () => { U32Inner2!() };
        }

        macro_rules! U32 {
            () => { U32Inner1!() };
        }

        trait Foo {
            type Ty;
        }

        impl<T> Foo for T {
            type Ty = U32!();
        }

        type TayTo = U32!();

        fn testy() {
            let a: <() as Foo>::Ty;
            let b: TayTo;
        }
        "#,
        expect![[r#"
            259..308 '{     ...yTo; }': ()
            269..270 'a': u32
            297..298 'b': u32
        "#]],
    );
}

#[test]
fn macros_in_type_alias_position_generics() {
    check_infer(
        r#"
        struct Foo<A, B>(A, B);

        macro_rules! U32 {
            () => { u32 };
        }

        macro_rules! Bar {
            () => { Foo<U32!(), U32!()> };
        }

        trait Moo {
            type Ty;
        }

        impl<T> Moo for T {
            type Ty = Bar!();
        }

        type TayTo = Bar!();

        fn main() {
            let a: <() as Moo>::Ty;
            let b: TayTo;
        }
        "#,
        expect![[r#"
            228..277 '{     ...yTo; }': ()
            238..239 'a': Foo<u32, u32>
            266..267 'b': Foo<u32, u32>
        "#]],
    );
}

#[test]
fn macros_in_type_position() {
    check_infer(
        r#"
        struct Foo<A, B>(A, B);

        macro_rules! U32 {
            () => { u32 };
        }

        macro_rules! Bar {
            () => { Foo<U32!(), U32!()> };
        }

        fn main() {
            let a: Bar!();
        }
        "#,
        expect![[r#"
            133..155 '{     ...!(); }': ()
            143..144 'a': Foo<u32, u32>
        "#]],
    );
}

#[test]
fn macros_in_type_generics() {
    check_infer(
        r#"
        struct Foo<A, B>(A, B);

        macro_rules! U32 {
            () => { u32 };
        }

        macro_rules! Bar {
            () => { Foo<U32!(), U32!()> };
        }

        trait Moo {
            type Ty;
        }

        impl<T> Moo for T {
            type Ty = Foo<Bar!(), Bar!()>;
        }

        type TayTo = Foo<Bar!(), U32!()>;

        fn main() {
            let a: <() as Moo>::Ty;
            let b: TayTo;
        }
        "#,
        expect![[r#"
            254..303 '{     ...yTo; }': ()
            264..265 'a': Foo<Foo<u32, u32>, Foo<u32, u32>>
            292..293 'b': Foo<Foo<u32, u32>, u32>
        "#]],
    );
}

#[test]
fn infinitely_recursive_macro_type() {
    check_infer(
        r#"
        struct Bar<T, X>(T, X);

        macro_rules! Foo {
            () => { Foo!() }
        }

        macro_rules! U32 {
            () => { u32 }
        }

        type A = Foo!();
        type B = Bar<Foo!(), U32!()>;

        fn main() {
            let a: A;
            let b: B;
        }
        "#,
        expect![[r#"
            166..197 '{     ...: B; }': ()
            176..177 'a': {unknown}
            190..191 'b': Bar<{unknown}, u32>
        "#]],
    );
}
