});

    Tester::new_single_source_expect_err(

        "struct literal inference mismatch",

        "

        struct Pair<T>{ T first, T second }

        func call() -> s32 {

            s8 first_arg = 5;

            s64 second_arg = 2;

            auto pair = Pair{ first: first_arg, second: second_arg };

            return 3;

        }

        "

    ).error(|e| { e

        .assert_num(3)

        .assert_ctx_has(0, "Pair{ first: first_arg, second: second_arg }")

        .assert_occurs_at(0, "Pair{")

        .assert_msg_has(0, "Conflicting type for polymorphic variable 'T'")

        .assert_occurs_at(1, "second_arg")

        .assert_msg_has(1, "inferred it to 's64'")

        .assert_occurs_at(2, "first_arg")

        .assert_msg_has(2, "inferred it to 's8'");

    });

    // Cannot really test literal inference error, but this comes close

    Tester::new_single_source_expect_err(

        "enum literal inference mismatch",

        "

        enum Uninteresting<T>{ Variant }

        func fix_t<T>(Uninteresting<T> arg) -> s32 { return 0; }

        func call() -> s32 {

            auto a = Uninteresting::Variant;

            fix_t<s8>(a);

            fix_t<s32>(a);

            return 4;

        }

        "

    ).error(|e| { e

        .assert_num(2)

        .assert_any_msg_has("type 'Uninteresting<s8>'")

        .assert_any_msg_has("type 'Uninteresting<s32>'");

    });

    Tester::new_single_source_expect_err(

        "field access inference mismatch",

        "

        struct Holder<Shazam>{ Shazam a }

        func call() -> s32 {

            s8 to_hold = 0;

            auto holder = Holder{ a: to_hold };

            return holder.a;

        }

        "

    ).error(|e| { e

        .assert_num(3)

        .assert_ctx_has(0, "holder.a")

        .assert_occurs_at(0, ".")

        .assert_msg_has(0, "Conflicting type for polymorphic variable 'Shazam'")

        .assert_msg_has(1, "inferred it to 's8'")

        .assert_msg_has(2, "inferred it to 's32'");

    });

    // Silly regression test

    Tester::new_single_source_expect_err(

        "nested field access inference mismatch",

        "

        struct Node<T1, T2>{ T1 l, T2 r }

        func construct<T1, T2>(T1 l, T2 r) -> Node<T1, T2> { return Node{ l: l, r: r }; }

        func fix_poly<T>(Node<T, T> a) -> s32 { return 0; }

        func test() -> s32 {

            s8 assigned = 0;

            s64 another = 1;

            auto thing = construct(assigned, construct(another, 1));

            fix_poly(thing.r);

            thing.r.r = assigned;

            return 0;

        }

        ",

    );

}

#[test]

fn test_explicit_polymorph_argument() {

    // Failed because array was put at same type depth as u32. So interpreted

    // as a function with two polymorphic arguments

    Tester::new_single_source_expect_ok("explicit with array", "

    func foo<T>(T a, T b) -> T {

        return a @ b;

    }

    func test() -> u32 {

        return foo<u32[]>({1}, {2})[1];

    }").for_function("test", |f| { f

        .call_ok(Some(Value::UInt32(2)));

    });

    // Failed because type inferencer did not construct polymorph errors by

    // considering that argument/return types failed against explicitly

    // specified polymorphic arguments

    Tester::new_single_source_expect_err("explicit polymorph mismatch", "

    func foo<T>(T a, T b) -> T { return a + b; }

    struct Bar<A, B>{A a, B b}

    func test() -> u32 {

        return foo<Bar<u32, u64>[]>(5, 6);

    }").error(|e| { e

        .assert_num(2)

        .assert_occurs_at(0, "foo<Bar")

        .assert_msg_has(0, "'T' of 'foo'")

        .assert_occurs_at(1, "5, ")

        .assert_msg_has(1, "has type 'Bar<u32, u64>[]")

        .assert_msg_has(1, "inferred it to 'integerlike'");

    });

    // Similar to above, now for return type

    Tester::new_single_source_expect_err("explicit polymorph mismatch", "

    func foo<T>(T a, T b) -> T { return a + b; }

    func test() -> u32 {

        return foo<u64>(5, 6);

    }").error(|e| { e

        .assert_num(2)

        .assert_occurs_at(0, "foo<u64")

        .assert_msg_has(0, "'T' of 'foo'")

        .assert_occurs_at(1, "foo<u64")

        .assert_msg_has(1, "has type 'u64'")

        .assert_msg_has(1, "return type inferred it to 'u32'");

    });

}