rs_bindings_from_cc/generate_bindings/generate_function_test.rs

// Part of the Crubit project, under the Apache License v2.0 with LLVM
// Exceptions. See /LICENSE for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

use arc_anyhow::Result;
use code_gen_utils::make_rs_ident;
use database::code_snippet::BindingsTokens;
use database::rs_snippet::{format_generic_params, Lifetime};
use generate_function_thunk::thunk_ident;
use googletest::prelude::{assert_that, contains_substring, gtest, OrFail as _};
use ir::{Func, Item, UnqualifiedIdentifier};
use ir_testing::{retrieve_func, with_lifetime_macros};
use multiplatform_ir_testing::{ir_from_cc, ir_from_cc_dependency};
use quote::quote;
use test_generators::generate_bindings_tokens_for_test;
use token_stream_matchers::{
    assert_cc_matches, assert_cc_not_matches, assert_rs_matches, assert_rs_not_matches,
};

#[gtest]
fn test_simple_function() -> Result<()> {
    let ir = ir_from_cc("int Add(int a, int b);")?;
    let BindingsTokens { rs_api, rs_api_impl } = generate_bindings_tokens_for_test(ir)?;
    assert_rs_matches!(
        rs_api,
        quote! {
            #[inline(always)]
            pub fn Add(a: ::core::ffi::c_int, b: ::core::ffi::c_int) -> ::core::ffi::c_int {
                unsafe { crate::detail::__rust_thunk___Z3Addii(a, b) }
            }
        }
    );
    assert_rs_matches!(
        rs_api,
        quote! {
            mod detail {
                #[allow(unused_imports)]
                use super::*;
                unsafe extern "C" {
                    #[link_name = "_Z3Addii"]
                    pub(crate) unsafe fn __rust_thunk___Z3Addii(a: ::core::ffi::c_int, b: ::core::ffi::c_int) -> ::core::ffi::c_int;
                }
            }
        }
    );

    assert_cc_not_matches!(rs_api_impl, quote! {__rust_thunk___Z3Addii});

    Ok(())
}

#[gtest]
fn test_inline_function() -> Result<()> {
    let ir = ir_from_cc("inline int Add(int a, int b) { return a + b; }")?;
    let BindingsTokens { rs_api, rs_api_impl } = generate_bindings_tokens_for_test(ir)?;
    assert_rs_matches!(
        rs_api,
        quote! {
            #[inline(always)]
            pub fn Add(a: ::core::ffi::c_int, b: ::core::ffi::c_int) -> ::core::ffi::c_int {
                unsafe { crate::detail::__rust_thunk___Z3Addii(a, b) }
            }
        }
    );
    assert_rs_matches!(
        rs_api,
        quote! {
            mod detail {
                #[allow(unused_imports)]
                use super::*;
                unsafe extern "C" {
                    pub(crate) unsafe fn __rust_thunk___Z3Addii(a: ::core::ffi::c_int, b: ::core::ffi::c_int) -> ::core::ffi::c_int;
                }
            }
        }
    );

    assert_cc_matches!(
        rs_api_impl,
        quote! {
            extern "C" int __rust_thunk___Z3Addii(int a, int b) {
                return Add(a, b);
            }
        }
    );
    Ok(())
}

#[gtest]
fn test_simple_function_with_types_from_other_target() -> Result<()> {
    let ir = ir_from_cc_dependency(
        "inline ReturnStruct DoSomething(ParamStruct param) { return ReturnStruct {}; }",
        "struct ReturnStruct final {}; struct ParamStruct final {};",
    )?;

    let BindingsTokens { rs_api, rs_api_impl } = generate_bindings_tokens_for_test(ir)?;
    assert_rs_matches!(
        rs_api,
        quote! {
            #[inline(always)]
            pub fn DoSomething(mut param: dependency::ParamStruct) -> dependency::ReturnStruct {
                unsafe {
                    let mut __return = ::core::mem::MaybeUninit::<dependency::ReturnStruct>::uninit();
                    crate::detail::__rust_thunk___Z11DoSomething11ParamStruct(
                       &raw mut __return as *mut ::core::ffi::c_void,
                       &mut param
                    );
                    __return.assume_init()
                }
            }
        }
    );
    assert_rs_matches!(
        rs_api,
        quote! {
        mod detail {
            #[allow(unused_imports)]
            use super::*;
            unsafe extern "C" {
                pub(crate) unsafe fn __rust_thunk___Z11DoSomething11ParamStruct(
                    __return: *mut ::core::ffi::c_void,
                    param: &mut dependency::ParamStruct
                );
            }
        }}
    );

    assert_cc_matches!(
        rs_api_impl,
        quote! {
            extern "C" void __rust_thunk___Z11DoSomething11ParamStruct(
                    struct ReturnStruct* __return, struct ParamStruct* param) {
                new (__return) auto(DoSomething(std::move(*param)));
            }
        }
    );
    Ok(())
}

#[gtest]
fn test_ref_to_struct_in_thunk_impls() -> Result<()> {
    let ir = ir_from_cc("struct S{}; inline void foo(S& s) {} ")?;
    let rs_api_impl = generate_bindings_tokens_for_test(ir)?.rs_api_impl;
    assert_cc_matches!(
        rs_api_impl,
        quote! {
            extern "C" void __rust_thunk___Z3fooR1S(struct S* s) {
                foo(*s);
            }
        }
    );
    Ok(())
}

#[gtest]
fn test_const_ref_to_struct_in_thunk_impls() -> Result<()> {
    let ir = ir_from_cc("struct S{}; inline void foo(const S& s) {} ")?;
    let rs_api_impl = generate_bindings_tokens_for_test(ir)?.rs_api_impl;
    assert_cc_matches!(
        rs_api_impl,
        quote! {
            extern "C" void __rust_thunk___Z3fooRK1S(struct S const * s) {
                foo(*s);
            }
        }
    );
    Ok(())
}

#[gtest]
fn test_unsigned_int_in_thunk_impls() -> Result<()> {
    let ir = ir_from_cc("inline void foo(unsigned int i) {} ")?;
    let rs_api_impl = generate_bindings_tokens_for_test(ir)?.rs_api_impl;
    assert_cc_matches!(
        rs_api_impl,
        quote! {
            extern "C" void __rust_thunk___Z3fooj(unsigned int i) {
                foo(i);
            }
        }
    );
    Ok(())
}

#[gtest]
fn test_record_static_methods_qualify_call_in_thunk() -> Result<()> {
    let ir = ir_from_cc(
        r#"
        struct SomeStruct {
            static inline int some_func() { return 42; }
        }; "#,
    )?;

    assert_cc_matches!(
        generate_bindings_tokens_for_test(ir)?.rs_api_impl,
        quote! {
            extern "C" int __rust_thunk___ZN10SomeStruct9some_funcEv() {
                return SomeStruct::some_func();
            }
        }
    );
    Ok(())
}

#[gtest]
fn test_record_instance_methods_deref_this_in_thunk() -> Result<()> {
    let ir = ir_from_cc(
        r#"
        struct SomeStruct {
            inline int some_func(int arg) const { return 42 + arg; }
        }; "#,
    )?;

    assert_cc_matches!(
        generate_bindings_tokens_for_test(ir)?.rs_api_impl,
        quote! {
            extern "C" int __rust_thunk___ZNK10SomeStruct9some_funcEi(
                    struct SomeStruct const * __this, int arg) {
                return __this->some_func(arg);
            }
        }
    );
    Ok(())
}

#[gtest]
fn test_ptr_func() -> Result<()> {
    let ir = ir_from_cc(r#" inline int* Deref(int*const* p) { return *p; } "#)?;

    let BindingsTokens { rs_api, rs_api_impl } = generate_bindings_tokens_for_test(ir)?;
    assert_rs_matches!(
        rs_api,
        quote! {
            #[inline(always)]
            pub unsafe fn Deref(p: *const *mut ::core::ffi::c_int) -> *mut ::core::ffi::c_int {
                crate::detail::__rust_thunk___Z5DerefPKPi(p)
            }
        }
    );
    assert_rs_matches!(
        rs_api,
        quote! {
            mod detail {
                #[allow(unused_imports)]
                use super::*;
                unsafe extern "C" {
                    pub(crate) unsafe fn __rust_thunk___Z5DerefPKPi(p: *const *mut ::core::ffi::c_int) -> *mut ::core::ffi::c_int;
                }
            }
        }
    );

    assert_cc_matches!(
        rs_api_impl,
        quote! {
            extern "C" int* __rust_thunk___Z5DerefPKPi(int* const * p) {
                return Deref(p);
            }
        }
    );
    Ok(())
}

#[gtest]
fn test_const_char_ptr_func() -> Result<()> {
    // This is a regression test: We used to include the "const" in the name
    // of the CcType, which caused a panic in the code generator
    // ('"const char" is not a valid Ident').
    // It's therefore important that f() is inline so that we need to
    // generate a thunk for it (where we then process the CcType).
    let ir = ir_from_cc(r#" inline void f(const signed char *str) {} "#)?;

    let BindingsTokens { rs_api, rs_api_impl } = generate_bindings_tokens_for_test(ir)?;
    assert_rs_matches!(
        rs_api,
        quote! {
            #[inline(always)]
            pub unsafe fn f(str: *const ::core::ffi::c_schar) {
                crate::detail::__rust_thunk___Z1fPKa(str)
            }
        }
    );
    assert_rs_matches!(
        rs_api,
        quote! {
            extern "C" {
                pub(crate) unsafe fn __rust_thunk___Z1fPKa(str: *const ::core::ffi::c_schar);
            }
        }
    );

    assert_cc_matches!(
        rs_api_impl,
        quote! {
            extern "C" void __rust_thunk___Z1fPKa(signed char const * str){ f(str); }
        }
    );
    Ok(())
}

#[gtest]
fn test_func_ptr_thunk() -> Result<()> {
    // Using an `inline` keyword forces generation of a C++ thunk in
    // `rs_api_impl` (i.e. exercises `format_cpp_type` and similar code).
    let ir = ir_from_cc(
        r#"
        int multiply(int x, int y);
        inline int (*inline_get_pointer_to_function())(int, int) {
            return multiply;
        }
    "#,
    )?;
    let rs_api_impl = generate_bindings_tokens_for_test(ir)?.rs_api_impl;
    assert_cc_matches!(
        rs_api_impl,
        quote! {
            extern "C" crubit::type_identity_t<int(int , int)>*
            __rust_thunk___Z30inline_get_pointer_to_functionv() {
                return inline_get_pointer_to_function();
            }
        }
    );
    Ok(())
}

#[gtest]
fn test_doc_comment_func() -> Result<()> {
    let ir = ir_from_cc(
        "
    // Doc Comment
    // with two lines
    int func();",
    )?;

    assert_rs_matches!(
        generate_bindings_tokens_for_test(ir)?.rs_api,
        // leading space is intentional so there is a space between /// and the text of the
        // comment
        quote! {
            #[doc = " Doc Comment\n with two lines\n \n Generated from: ir_from_cc_virtual_header.h;l=6"]
            #[inline(always)]
            pub fn func
        }
    );

    Ok(())
}

/// Trivial types (at least those that are mapped to Copy rust types) do not
/// get a Drop impl.
#[gtest]
fn test_impl_drop_trivial() -> Result<()> {
    let ir = ir_from_cc(
        r#"struct Trivial final {
            ~Trivial() = default;
            int x;
        };"#,
    )?;
    let BindingsTokens { rs_api, rs_api_impl } = generate_bindings_tokens_for_test(ir)?;
    assert_rs_not_matches!(rs_api, quote! {impl Drop});
    assert_rs_not_matches!(rs_api, quote! {impl ::ctor::PinnedDrop});
    assert_rs_matches!(rs_api, quote! {pub x: ::core::ffi::c_int});
    assert_cc_not_matches!(rs_api_impl, quote! { std::destroy_at });
    Ok(())
}

#[gtest]
fn test_impl_default_explicitly_defaulted_constructor() -> Result<()> {
    let ir = ir_from_cc(
        r#"#pragma clang lifetime_elision
        struct DefaultedConstructor final {
            DefaultedConstructor() = default;
        };"#,
    )?;
    let BindingsTokens { rs_api, rs_api_impl } = generate_bindings_tokens_for_test(ir)?;
    assert_rs_matches!(
        rs_api,
        quote! {
            impl Default for DefaultedConstructor {
                #[inline(always)]
                fn default() -> Self {
                    let mut tmp = ::core::mem::MaybeUninit::<Self>::zeroed();
                    unsafe {
                        crate::detail::__rust_thunk___ZN20DefaultedConstructorC1Ev(&raw mut tmp as *mut _);
                        tmp.assume_init()
                    }
                }
            }
        }
    );
    assert_cc_matches!(
        rs_api_impl,
        quote! {
            extern "C" void __rust_thunk___ZN20DefaultedConstructorC1Ev(
                    struct DefaultedConstructor* __this) {
                crubit::construct_at(__this);
            }
        }
    );
    Ok(())
}

#[gtest]
fn test_impl_clone_that_propagates_lifetime() -> Result<()> {
    // This test covers the case where a single lifetime applies to 1)
    // the `__this` parameter and 2) other constructor parameters. For
    // example, maybe the newly constructed object needs to have the
    // same lifetime as the constructor's parameter. (This might require
    // annotating the whole C++ struct with a lifetime, so maybe the
    // example below is not fully realistic/accurate...).
    let ir = ir_from_cc(&with_lifetime_macros(
        r#"#pragma clang lifetime_elision
        struct Foo final {
            Foo(const int& $a i) $a;
        };"#,
    ))?;
    let ctor: &Func = ir
        .items()
        .filter_map(|item| match item {
            Item::Func(func) => Some(&**func),
            _ => None,
        })
        .find(|f| {
            matches!(&f.rs_name, UnqualifiedIdentifier::Constructor)
                && f.params
                    .get(1)
                    .map(|p| p.identifier.identifier.as_ref() == "i")
                    .unwrap_or_default()
        })
        .unwrap();
    {
        // Double-check that the test scenario set up above uses the same lifetime
        // for both of the constructor's parameters: `__this` and `i`.
        assert_eq!(ctor.params.len(), 2);
        let this_lifetime = ctor.params[0].type_.variant.as_pointer().unwrap().lifetime.unwrap();
        let i_lifetime = ctor.params[1].type_.variant.as_pointer().unwrap().lifetime.unwrap();
        assert_eq!(i_lifetime, this_lifetime);
    }

    // Before cl/423346348 the generated Rust code would incorrectly look
    // like this (note the mismatched 'a and 'b lifetimes):
    //     fn from<'b>(i: &'a i32) -> Self
    // After this CL, this scenario will result in an explicit error.
    let rs_api = generate_bindings_tokens_for_test(ir)?.rs_api;
    assert_rs_not_matches!(rs_api, quote! {impl From});
    assert_rs_matches!(rs_api, {
        let txt = "Generated from: ir_from_cc_virtual_header.h;l=34\n\
                       Error while generating bindings for constructor 'Foo::Foo':\n\
                       The lifetime of `__this` is \
                           unexpectedly also used by another parameter: &'a::core::ffi::c_int";
        quote! { __COMMENT__ #txt }
    });
    Ok(())
}

#[gtest]
fn test_impl_default_non_trivial_struct() -> Result<()> {
    let ir = ir_from_cc(
        r#"#pragma clang lifetime_elision
        struct NonTrivialStructWithConstructors final {
            NonTrivialStructWithConstructors();
            ~NonTrivialStructWithConstructors();  // Non-trivial
        };"#,
    )?;
    let rs_api = generate_bindings_tokens_for_test(ir)?.rs_api;
    assert_rs_not_matches!(rs_api, quote! {impl Default});
    Ok(())
}

#[gtest]
fn test_impl_from_for_1_arg_constructor() -> Result<()> {
    for explicit_qualifier in ["", "explicit"] {
        let ir = ir_from_cc(&format!(
            r#"#pragma clang lifetime_elision
            struct SomeStruct final {{
                {explicit_qualifier} SomeStruct(int i);  // implicit - no `explicit` keyword
            }};"#,
        ))?;
        let rs_api = generate_bindings_tokens_for_test(ir)?.rs_api;
        assert_rs_matches!(
            rs_api,
            quote! {
                impl From<::core::ffi::c_int> for SomeStruct {
                    #[inline(always)]
                    fn from(i: ::core::ffi::c_int) -> Self {
                        let mut tmp = ::core::mem::MaybeUninit::<Self>::zeroed();
                        unsafe {
                            crate::detail::__rust_thunk___ZN10SomeStructC1Ei(&raw mut tmp as *mut _, i);
                            tmp.assume_init()
                        }
                    }
                }
            }
        );
    }
    Ok(())
}

#[gtest]
fn test_impl_from_for_implicit_conversion_from_reference() -> Result<()> {
    let ir = ir_from_cc(
        r#"#pragma clang lifetime_elision
        struct SomeOtherStruct final { int i; };
        struct StructUnderTest final {
            StructUnderTest(const SomeOtherStruct& other);  // implicit - no `explicit` keyword
        };"#,
    )?;
    let rs_api = generate_bindings_tokens_for_test(ir)?.rs_api;
    // This is a regression test for b/223800038: We want to ensure that the
    // code says `impl<'b>` (instead of incorrectly declaring that lifetime
    // in `fn from<'b>`).
    assert_rs_matches!(
        rs_api,
        quote! {
            impl<'b> From<&'b crate::SomeOtherStruct> for StructUnderTest {
                #[inline(always)]
                fn from(other: &'b crate::SomeOtherStruct) -> Self {
                    let mut tmp = ::core::mem::MaybeUninit::<Self>::zeroed();
                    unsafe {
                        crate::detail::__rust_thunk___ZN15StructUnderTestC1ERK15SomeOtherStruct(
                            &raw mut tmp as *mut _, other);
                        tmp.assume_init()
                    }
                }
            }
        },
    );
    Ok(())
}

#[gtest]
fn test_impl_eq_for_member_function() -> Result<()> {
    let ir = ir_from_cc(
        r#"#pragma clang lifetime_elision
        struct SomeStruct final {
            inline bool operator==(const SomeStruct& other) const {
                return i == other.i;
            }
            int i;
        };"#,
    )?;
    let BindingsTokens { rs_api, rs_api_impl } = generate_bindings_tokens_for_test(ir)?;
    assert_rs_matches!(
        rs_api,
        quote! {
            impl PartialEq for SomeStruct {
                #[inline(always)]
                fn eq<'a, 'b>(&'a self, other: &'b Self) -> bool {
                    unsafe { crate::detail::__rust_thunk___ZNK10SomeStructeqERKS_(self, other) }
                }
            }
        }
    );
    assert_cc_matches!(
        rs_api_impl,
        quote! {
            extern "C" bool __rust_thunk___ZNK10SomeStructeqERKS_(
                    struct SomeStruct const * __this, struct SomeStruct const * other) {
                return __this->operator==(*other);
            }
        }
    );
    Ok(())
}

#[gtest]
fn test_impl_eq_for_free_function() -> Result<()> {
    let ir = ir_from_cc(
        r#"#pragma clang lifetime_elision
        namespace ns {
            struct SomeStruct final { int i; };
        }
        bool operator==(const ns::SomeStruct& lhs, const ns::SomeStruct& rhs) {
            return lhs.i == rhs.i;
        }
        "#,
    )?;
    let rs_api = generate_bindings_tokens_for_test(ir)?.rs_api;
    assert_rs_matches!(
        rs_api,
        quote! {
            impl PartialEq for crate::ns::SomeStruct {
                #[inline(always)]
                fn eq<'a, 'b>(&'a self, rhs: &'b Self) -> bool {
                    unsafe { crate::detail::__rust_thunk___ZeqRKN2ns10SomeStructES2_(self, rhs) }
                }
            }
        }
    );
    Ok(())
}

#[gtest]
fn test_impl_eq_for_free_function_different_types() -> Result<()> {
    let ir = ir_from_cc(
        r#"#pragma clang lifetime_elision
        struct SomeStruct final { int i; };
        struct SomeOtherStruct final { int i; };
        bool operator==(const SomeStruct& lhs, const SomeOtherStruct& rhs) {
            return lhs.i == rhs.i;
        }"#,
    )?;
    let rs_api = generate_bindings_tokens_for_test(ir)?.rs_api;
    assert_rs_matches!(
        rs_api,
        quote! {
            impl PartialEq<crate::SomeOtherStruct> for crate::SomeStruct {
                #[inline(always)]
                fn eq<'a, 'b>(&'a self, rhs: &'b crate::SomeOtherStruct) -> bool {
                    unsafe { crate::detail::__rust_thunk___ZeqRK10SomeStructRK15SomeOtherStruct(self, rhs) }
                }
            }
        }
    );
    Ok(())
}

#[gtest]
fn test_impl_eq_for_free_function_by_value() -> Result<()> {
    let ir = ir_from_cc(
        r#"#pragma clang lifetime_elision
        struct SomeStruct final { int i; };
        bool operator==(SomeStruct lhs, SomeStruct rhs) {
            return lhs.i == rhs.i;
        }"#,
    )?;
    let rs_api = generate_bindings_tokens_for_test(ir)?.rs_api;
    assert_rs_matches!(
        rs_api,
        quote! {
            impl PartialEq for crate::SomeStruct {
                #[inline(always)]
                fn eq(&self, rhs: &Self) -> bool {
                    unsafe {
                        crate::detail::__rust_thunk___Zeq10SomeStructS_(&mut self.clone(), &mut rhs.clone())
                    }
                }
            }
        }
    );
    Ok(())
}

#[gtest]
fn test_impl_lt_for_member_function() -> Result<()> {
    let ir = ir_from_cc(
        r#"#pragma clang lifetime_elision
        struct SomeStruct final {
            inline bool operator==(const SomeStruct& other) const {
                return i == other.i;
            }
            inline bool operator<(const SomeStruct& other) const {
                return i < other.i;
            }
            int i;
        };"#,
    )?;
    let BindingsTokens { rs_api, rs_api_impl } = generate_bindings_tokens_for_test(ir)?;
    assert_rs_matches!(
        rs_api,
        quote! {
            impl PartialOrd for SomeStruct {
                #[inline(always)]
                fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
                    if self == other {
                        return Some(core::cmp::Ordering::Equal);
                    }
                    if self < other {
                        return Some(core::cmp::Ordering::Less);
                    }
                    if other < self {
                        return Some(core::cmp::Ordering::Greater);
                    }
                    None
                }
                #[inline(always)]
                fn lt<'a, 'b>(&'a self, other: &'b Self) -> bool {
                    unsafe { crate::detail::__rust_thunk___ZNK10SomeStructltERKS_(self, other) }
                }
            }
        }
    );
    assert_cc_matches!(
        rs_api_impl,
        quote! {
            extern "C" bool __rust_thunk___ZNK10SomeStructltERKS_(
                    struct SomeStruct const * __this, struct SomeStruct const * other) {
                return __this->operator<(*other);
            }
        }
    );
    Ok(())
}

#[gtest]
fn test_impl_lt_for_free_function() -> Result<()> {
    let ir = ir_from_cc(
        r#"#pragma clang lifetime_elision
        struct SomeStruct final {
            inline bool operator==(const SomeStruct& other) const {
                return i == other.i;
            }
            int i;
        };
        bool operator<(const SomeStruct& lhs, const SomeStruct& rhs) {
            return lhs.i < rhs.i;
        }"#,
    )?;
    let rs_api = generate_bindings_tokens_for_test(ir)?.rs_api;
    assert_rs_matches!(
        rs_api,
        quote! {
            impl PartialOrd for crate::SomeStruct {
                #[inline(always)]
                fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
                    if self == other {
                        return Some(core::cmp::Ordering::Equal);
                    }
                    if self < other {
                        return Some(core::cmp::Ordering::Less);
                    }
                    if other < self {
                        return Some(core::cmp::Ordering::Greater);
                    }
                    None
                }
                #[inline(always)]
                fn lt<'a, 'b>(&'a self, rhs: &'b Self) -> bool {
                    unsafe { crate::detail::__rust_thunk___ZltRK10SomeStructS1_(self, rhs) }
                }
            }
        }
    );
    Ok(())
}

#[gtest]
fn test_impl_lt_for_free_function_by_value() -> Result<()> {
    let ir = ir_from_cc(
        r#"#pragma clang lifetime_elision
        struct SomeStruct final { int i; };
        bool operator==(SomeStruct lhs, SomeStruct rhs) {
            return lhs.i == rhs.i;
        }
        bool operator<(SomeStruct lhs, SomeStruct rhs) {
            return lhs.i < rhs.i;
        }"#,
    )?;
    let rs_api = generate_bindings_tokens_for_test(ir)?.rs_api;
    assert_rs_matches!(
        rs_api,
        quote! {
            impl PartialOrd for crate::SomeStruct {
                #[inline(always)]
                fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
                    if self == other {
                        return Some(core::cmp::Ordering::Equal);
                    }
                    if self < other {
                        return Some(core::cmp::Ordering::Less);
                    }
                    if other < self {
                        return Some(core::cmp::Ordering::Greater);
                    }
                    None
                }
                #[inline(always)]
                fn lt(& self, rhs: &Self) -> bool {
                    unsafe { crate::detail::__rust_thunk___Zlt10SomeStructS_(
                            &mut self.clone(), &mut rhs.clone()) }
                }
            }
        }
    );
    Ok(())
}

#[gtest]
fn test_assign() -> Result<()> {
    let ir = ir_from_cc(
        r#"
        #pragma clang lifetime_elision
        struct SomeStruct {
            ~SomeStruct();
            SomeStruct& operator=(const SomeStruct& other);
        };"#,
    )?;
    let BindingsTokens { rs_api, .. } = generate_bindings_tokens_for_test(ir)?;
    assert_rs_matches!(
        rs_api,
        quote! {
            impl<'b> ::ctor::Assign<&'b Self> for SomeStruct {
                #[inline(always)]
                fn assign<'a>(self: ::core::pin::Pin<&'a mut Self>, other: &'b Self) {
                    unsafe {
                        crate::detail::__rust_thunk___ZN10SomeStructaSERKS_(self, other);
                    }
                }
            }
        }
    );
    Ok(())
}

#[gtest]
fn test_assign_nonreference_other() -> Result<()> {
    let ir = ir_from_cc(
        r#"
        #pragma clang lifetime_elision
        struct SomeStruct {
            ~SomeStruct();
            SomeStruct& operator=(int other);
        };"#,
    )?;
    let BindingsTokens { rs_api, .. } = generate_bindings_tokens_for_test(ir)?;
    assert_rs_matches!(
        rs_api,
        quote! {
            impl<'b> ::ctor::Assign<&'b Self> for SomeStruct {
                #[inline(always)]
                fn assign<'a>(self: ::core::pin::Pin<&'a mut Self>, __param_0: &'b Self) {
                    unsafe {
                        crate::detail::__rust_thunk___ZN10SomeStructaSERKS_(self, __param_0);
                    }
                }
            }
        }
    );
    Ok(())
}

#[gtest]
fn test_assign_nonreference_return() -> Result<()> {
    let ir = ir_from_cc(
        r#"
        #pragma clang lifetime_elision
        struct SomeStruct {
            ~SomeStruct();
            int operator=(const SomeStruct& other);
        };"#,
    )?;
    let BindingsTokens { rs_api, .. } = generate_bindings_tokens_for_test(ir)?;
    assert_rs_matches!(
        rs_api,
        quote! {
            impl<'b> ::ctor::Assign<&'b Self> for SomeStruct {
                #[inline(always)]
                fn assign<'a>(self: ::core::pin::Pin<&'a mut Self>, other: &'b Self) {
                    unsafe {
                        crate::detail::__rust_thunk___ZN10SomeStructaSERKS_(self, other);
                    }
                }
            }
        }
    );
    Ok(())
}

#[gtest]
fn test_impl_eq_non_const_member_function() -> Result<()> {
    let ir = ir_from_cc(
        r#"#pragma clang lifetime_elision
        struct SomeStruct final {
            bool operator==(const SomeStruct& other) /* no `const` here */;
        };"#,
    )?;
    let rs_api = generate_bindings_tokens_for_test(ir)?.rs_api;
    assert_rs_not_matches!(rs_api, quote! {impl PartialEq});
    Ok(())
}

#[gtest]
fn test_impl_lt_different_operands() -> Result<()> {
    let ir = ir_from_cc(
        r#"#pragma clang lifetime_elision
        struct SomeStruct1 final {
            int i;
        };
        struct SomeStruct2 final {
            inline bool operator==(const SomeStruct1& other) const {
                return i == other.i;
            }
            inline bool operator<(const SomeStruct1& other) const {
                return i < other.i;
            };
            int i;
        };"#,
    )?;
    let rs_api = generate_bindings_tokens_for_test(ir)?.rs_api;
    assert_rs_not_matches!(rs_api, quote! {impl PartialOrd});
    Ok(())
}

#[gtest]
fn test_impl_lt_non_const_member_function() -> Result<()> {
    let ir = ir_from_cc(
        r#"#pragma clang lifetime_elision
        struct SomeStruct final {
            inline bool operator==(const SomeStruct& other) const {
                return i == other.i;
            }
            int i;
            bool operator<(const SomeStruct& other) /* no `const` here */;
        };"#,
    )?;
    let rs_api = generate_bindings_tokens_for_test(ir)?.rs_api;
    assert_rs_not_matches!(rs_api, quote! {impl PartialOrd});
    Ok(())
}

#[gtest]
fn test_impl_lt_rhs_by_value() -> Result<()> {
    let ir = ir_from_cc(
        r#"#pragma clang lifetime_elision
        struct SomeStruct final {
            inline bool operator==(const SomeStruct& other) const {
                return i == other.i;
            }
            int i;
            bool operator<(SomeStruct other) const;
        };"#,
    )?;
    let rs_api = generate_bindings_tokens_for_test(ir)?.rs_api;
    assert_rs_not_matches!(rs_api, quote! {impl PartialOrd});
    Ok(())
}

#[gtest]
fn test_impl_lt_missing_eq_impl() -> Result<()> {
    let ir = ir_from_cc(
        r#"#pragma clang lifetime_elision
        struct SomeStruct final {
            inline bool operator<(const SomeStruct& other) const {
                return i < other.i;
            }
            int i;
        };"#,
    )?;
    let rs_api = generate_bindings_tokens_for_test(ir)?.rs_api;
    assert_rs_not_matches!(rs_api, quote! {impl PartialOrd});
    Ok(())
}

#[gtest]
fn test_thunk_ident_function() -> Result<()> {
    let ir = ir_from_cc("inline int foo() { return 42; }")?;
    let func = retrieve_func(&ir, "foo");
    assert_eq!(thunk_ident(func), make_rs_ident("__rust_thunk___Z3foov"));
    Ok(())
}

#[gtest]
fn test_thunk_ident_special_names() {
    let ir = ir_from_cc("struct Class {};").unwrap();

    let destructor = ir.get_functions_by_name(&UnqualifiedIdentifier::Destructor).next().unwrap();
    assert_eq!(thunk_ident(destructor), make_rs_ident("__rust_thunk___ZN5ClassD1Ev"));

    let default_constructor = ir
        .get_functions_by_name(&UnqualifiedIdentifier::Constructor)
        .find(|f| f.params.len() == 1)
        .unwrap();
    assert_eq!(thunk_ident(default_constructor), make_rs_ident("__rust_thunk___ZN5ClassC1Ev"));
}

#[gtest]
fn test_elided_lifetimes() -> Result<()> {
    let ir = ir_from_cc(
        r#"#pragma clang lifetime_elision
      struct S final {
        int& f(int& i);
      };"#,
    )?;
    let rs_api = generate_bindings_tokens_for_test(ir)?.rs_api;
    assert_rs_matches!(
        rs_api,
        quote! {
            pub fn f<'a, 'b>(&'a mut self, i: &'b mut ::core::ffi::c_int) -> &'a mut ::core::ffi::c_int { ... }
        }
    );
    assert_rs_matches!(
        rs_api,
        quote! {
            pub(crate) unsafe fn __rust_thunk___ZN1S1fERi<'a, 'b>(__this: &'a mut crate::S, i: &'b mut ::core::ffi::c_int)
                -> &'a mut ::core::ffi::c_int;
        }
    );
    Ok(())
}

#[gtest]
fn test_annotated_lifetimes() -> Result<()> {
    let ir = ir_from_cc(&with_lifetime_macros(
        r#"
      int& $a f(int& $a i1, int& $a i2);
      "#,
    ))?;
    let rs_api = generate_bindings_tokens_for_test(ir)?.rs_api;
    assert_rs_matches!(
        rs_api,
        quote! {
            pub fn f<'a>(i1: &'a mut ::core::ffi::c_int, i2: &'a mut ::core::ffi::c_int) -> &'a mut ::core::ffi::c_int { ... }
        }
    );
    assert_rs_matches!(
        rs_api,
        quote! {
            pub(crate) unsafe fn __rust_thunk___Z1fRiS_<'a>(i1: &'a mut ::core::ffi::c_int, i2: &'a mut ::core::ffi::c_int)
                -> &'a mut ::core::ffi::c_int;
        }
    );
    Ok(())
}

#[gtest]
fn test_format_generic_params() -> Result<()> {
    assert!(
        format_generic_params(/* lifetimes= */ &[], std::iter::empty::<syn::Ident>()).is_empty(),
    );

    let idents = ["T1", "T2"].iter().map(|s| make_rs_ident(s));
    assert_rs_matches!(format_generic_params(/* lifetimes= */ &[], idents), quote! { < T1, T2 > });

    let lifetimes = ["a", "b", "_"].iter().map(|s| Lifetime::new(s)).collect::<Vec<_>>();
    assert_rs_matches!(
        format_generic_params(&lifetimes, std::iter::empty::<syn::Ident>()),
        quote! { < 'a, 'b > }
    );

    Ok(())
}

#[gtest]
fn test_overloaded_functions() -> Result<()> {
    // TODO(b/213280424): We don't support creating bindings for overloaded
    // functions yet, except in the case of overloaded constructors with a
    // single parameter.
    let ir = ir_from_cc(
        r#" #pragma clang lifetime_elision
            void f() {}
            void f(int i) {}
            struct S1 final {
              void f() {}
              void f(int i) {}
            };
            struct S2 final {
              void f();
            };
            struct S3 final {
              S3(int i);
              S3(double d);
            };

            namespace foo { void not_overloaded(); }
            namespace bar { void not_overloaded(); }
        "#,
    )?;
    let BindingsTokens { rs_api, rs_api_impl } = generate_bindings_tokens_for_test(ir)?;

    // Cannot overload free functions.
    assert_cc_matches!(rs_api, {
        let txt = "Generated from: ir_from_cc_virtual_header.h;l=4\n\
                       Error while generating bindings for function 'f':\n\
                       Cannot generate bindings for overloaded function";
        quote! { __COMMENT__ #txt }
    });
    assert_rs_not_matches!(rs_api, quote! {pub fn f()});
    assert_rs_not_matches!(rs_api, quote! {pub fn f(i: ::core::ffi::c_int)});

    assert_cc_matches!(rs_api, {
        let txt = "Generated from: ir_from_cc_virtual_header.h;l=7\n\
                       Error while generating bindings for function 'S1::f':\n\
                       Cannot generate bindings for overloaded function";
        quote! { __COMMENT__ #txt }
    });
    assert_rs_not_matches!(rs_api, quote! {pub fn f(... S1 ...)});

    // And thunks aren't generated for either.
    assert_cc_not_matches!(rs_api_impl, quote! {f ( ... )});

    // But we can import member functions that have the same name as a free
    // function.
    assert_rs_matches!(rs_api, quote! {pub fn f<'a>(&'a mut self)});

    // We can also import overloaded single-parameter constructors.
    assert_rs_matches!(rs_api, quote! {impl From<::core::ffi::c_int> for S3});
    assert_rs_matches!(rs_api, quote! {impl From<f64> for S3});

    // And we can import functions that have the same name + signature, but that are
    // in 2 different namespaces.
    assert_rs_matches!(rs_api, quote! { pub fn not_overloaded() });
    Ok(())
}

/// !Unpin references should not be pinned.
#[gtest]
fn test_nonunpin_ref_param() -> Result<()> {
    let rs_api = generate_bindings_tokens_for_test(ir_from_cc(
        r#"
        #pragma clang lifetime_elision
        struct S {~S();};
        void Function(const S& s);
    "#,
    )?)?
    .rs_api;
    assert_rs_matches!(
        rs_api,
        quote! {
            fn Function<'a>(s: &'a crate::S) { ... }
        }
    );
    Ok(())
}

/// !Unpin mut references must be pinned.
#[gtest]
fn test_nonunpin_mut_param() -> Result<()> {
    let rs_api = generate_bindings_tokens_for_test(ir_from_cc(
        r#"
        #pragma clang lifetime_elision
        struct S {~S();};
        void Function(S& s);
    "#,
    )?)?
    .rs_api;
    assert_rs_matches!(
        rs_api,
        quote! {
            fn Function<'a>(s: ::core::pin::Pin<&'a mut crate::S>) { ... }
        }
    );
    Ok(())
}

/// !Unpin &self should not be pinned.
#[gtest]
fn test_nonunpin_ref_self() -> Result<()> {
    let rs_api = generate_bindings_tokens_for_test(ir_from_cc(
        r#"
        #pragma clang lifetime_elision
        struct S {
          ~S();
          void Function() const;
        };
    "#,
    )?)?
    .rs_api;
    assert_rs_matches!(
        rs_api,
        quote! {
            fn Function<'a>(&'a self) { ... }
        }
    );
    Ok(())
}

/// !Unpin &mut self must be pinned.
#[gtest]
fn test_nonunpin_mut_self() -> Result<()> {
    let rs_api = generate_bindings_tokens_for_test(ir_from_cc(
        r#"
        #pragma clang lifetime_elision
        struct S {
          ~S();
          void Function();
        };
    "#,
    )?)?
    .rs_api;
    assert_rs_matches!(
        rs_api,
        quote! {
            fn Function<'a>(self: ::core::pin::Pin<&'a mut Self>) { ... }
        }
    );
    Ok(())
}

/// Drop::drop must not use self : Pin<...>.
#[gtest]
fn test_nonunpin_drop() -> Result<()> {
    let rs_api = generate_bindings_tokens_for_test(ir_from_cc(
        r#"
        struct S {~S();};
    "#,
    )?)?
    .rs_api;
    assert_rs_matches!(
        rs_api,
        quote! {
            unsafe fn pinned_drop<'a>(self: ::core::pin::Pin<&'a mut Self>) { ... }
        }
    );
    Ok(())
}

#[gtest]
fn test_nonunpin_0_arg_constructor() -> Result<()> {
    let ir = ir_from_cc(
        r#"#pragma clang lifetime_elision
        // This type must be `!Unpin`.
        struct HasConstructor {
            explicit HasConstructor() {}
            ~HasConstructor();
        };"#,
    )?;
    let rs_api = generate_bindings_tokens_for_test(ir)?.rs_api;
    assert_rs_matches!(rs_api, quote! {#[::ctor::recursively_pinned(PinnedDrop)]});
    assert_rs_matches!(
        rs_api,
        quote! {
            impl ::ctor::CtorNew<()> for HasConstructor {
                type CtorType = impl ::ctor::Ctor<Output = Self, Error = ::ctor::Infallible>;
                type Error = ::ctor::Infallible;

                #[inline(always)]
                fn ctor_new(args: ()) -> Self::CtorType {
                    let () = args;
                    unsafe {
                        ::ctor::FnCtor::new(move |dest: *mut Self| {
                            crate::detail::__rust_thunk___ZN14HasConstructorC1Ev(dest as *mut ::core::ffi::c_void);
                        })
                    }
                }
            }
        }
    );
    Ok(())
}

#[gtest]
fn test_nonunpin_1_arg_constructor() -> Result<()> {
    let ir = ir_from_cc(
        r#"#pragma clang lifetime_elision
        // This type must be `!Unpin`.
        struct HasConstructor {
            explicit HasConstructor(unsigned char input) {}
            ~HasConstructor();
        };"#,
    )?;
    let rs_api = generate_bindings_tokens_for_test(ir)?.rs_api;
    assert_rs_matches!(rs_api, quote! {#[::ctor::recursively_pinned(PinnedDrop)]});
    assert_rs_matches!(
        rs_api,
        quote! {
            impl ::ctor::CtorNew<::core::ffi::c_uchar> for HasConstructor {
                type CtorType = impl ::ctor::Ctor<Output = Self, Error = ::ctor::Infallible>;
                type Error = ::ctor::Infallible;

                #[inline (always)]
                fn ctor_new(args: ::core::ffi::c_uchar) -> Self::CtorType {
                    let mut input = args;
                    unsafe {
                        ::ctor::FnCtor::new(move |dest: *mut Self| {
                            crate::detail::__rust_thunk___ZN14HasConstructorC1Eh(dest as *mut ::core::ffi::c_void, input);
                        })
                    }
                }
            }
        }
    );
    Ok(())
}

#[gtest]
fn test_nonunpin_2_arg_constructor() -> Result<()> {
    let ir = ir_from_cc(
        r#"#pragma clang lifetime_elision
        // This type must be `!Unpin`.
        struct HasConstructor {
            explicit HasConstructor(unsigned char input1, signed char input2) {}
            ~HasConstructor();
        };"#,
    )?;
    let rs_api = generate_bindings_tokens_for_test(ir)?.rs_api;
    assert_rs_matches!(rs_api, quote! {#[::ctor::recursively_pinned(PinnedDrop)]});
    assert_rs_matches!(
        rs_api,
        quote! {
            impl ::ctor::CtorNew<(::core::ffi::c_uchar, ::core::ffi::c_schar)> for HasConstructor {
                type CtorType = impl ::ctor::Ctor<Output = Self, Error = ::ctor::Infallible>;
                type Error = ::ctor::Infallible;

                #[inline (always)]
                fn ctor_new(args: (::core::ffi::c_uchar, ::core::ffi::c_schar)) -> Self::CtorType {
                    let (mut input1, mut input2) = args;
                    unsafe {
                        ::ctor::FnCtor::new(move |dest: *mut Self| {
                            crate::detail::__rust_thunk___ZN14HasConstructorC1Eha(dest as *mut ::core::ffi::c_void, input1, input2);
                        })
                    }
                }
            }
        }
    );
    Ok(())
}

/// Traits which monomorphize the `Ctor` parameter into the caller must
/// synthesize an RvalueReference parameter, with an appropriate
/// lifetime parameter.
#[gtest]
fn test_nonunpin_by_value_params() -> Result<()> {
    let ir = ir_from_cc(
        r#"#pragma clang lifetime_elision
        // This type must be `!Unpin`.
        struct HasConstructor {
            // int& x is here to create a 'b lifetime, which collides with a synthesized
            // lifetime name. But that's OK! We handle collisions!
            // (`a` would also work, but that's just because the left hand doesn't know what
            // the right is doing: the `a` lifetime is present in some places, but eventually
            // removed from the public interface.)
            explicit HasConstructor(const int& x, HasConstructor y, HasConstructor b) {}
            ~HasConstructor();
        };"#,
    )?;
    let rs_api = generate_bindings_tokens_for_test(ir)?.rs_api;
    assert_rs_matches!(rs_api, quote! {#[::ctor::recursively_pinned(PinnedDrop)]});
    assert_rs_matches!(
        rs_api,
        quote! {
            impl <'b, 'y, 'b_2> ::ctor::CtorNew<(
                &'b ::core::ffi::c_int,
                ::ctor::RvalueReference<'y, Self>,
                ::ctor::RvalueReference<'b_2, Self>)
            > for HasConstructor {
                // The captures are why we need explicit lifetimes for the two rvalue reference
                // parameters.
                type CtorType = impl ::ctor::Ctor<Output = Self, Error = ::ctor::Infallible> + use<'b, 'y, 'b_2>;
                type Error = ::ctor::Infallible;

                #[inline (always)]
                fn ctor_new(args: (
                    &'b ::core::ffi::c_int,
                    ::ctor::RvalueReference<'y, Self>,
                    ::ctor::RvalueReference<'b_2, Self>)
                ) -> Self::CtorType {
                    let (mut x, mut y, mut b) = args;
                    unsafe {
                        ::ctor::FnCtor::new(move |dest: *mut Self| {
                            crate::detail::__rust_thunk___ZN14HasConstructorC1ERKiS_S_(dest as *mut ::core::ffi::c_void, x, y, b);
                        })
                    }
                }
            }
        }
    );
    Ok(())
}

#[gtest]
fn test_nonunpin_return() -> Result<()> {
    let ir = ir_from_cc(
        r#"#pragma clang lifetime_elision
        // This type must be `!Unpin`.
        struct Nontrivial {~Nontrivial();};

        Nontrivial ReturnsByValue(const int& x, const int& y);
        "#,
    )?;
    let BindingsTokens { rs_api, rs_api_impl } = generate_bindings_tokens_for_test(ir)?;
    assert_rs_matches!(
        rs_api,
        quote! {
            pub fn ReturnsByValue<'a, 'b>(x: &'a ::core::ffi::c_int, y: &'b ::core::ffi::c_int)
            -> impl ::ctor::Ctor<Output=crate::Nontrivial, Error=::ctor::Infallible> + use<'a, 'b> {
                unsafe {
                    ::ctor::FnCtor::new(move |dest: *mut crate::Nontrivial| {
                        crate::detail::__rust_thunk___Z14ReturnsByValueRKiS0_(dest as *mut ::core::ffi::c_void, x, y);
                    })
                }

            }
        }
    );

    assert_cc_matches!(
        rs_api_impl,
        quote! {
            extern "C" void __rust_thunk___Z14ReturnsByValueRKiS0_(
                    struct Nontrivial* __return, int const* x, int const* y) {
                new(__return) auto(ReturnsByValue(*x, *y));
            }
        }
    );
    Ok(())
}

#[gtest]
fn test_nonunpin_const_return() -> Result<()> {
    let ir = ir_from_cc(
        r#"#pragma clang lifetime_elision
        // This type must be `!Unpin`.
        struct Nontrivial {~Nontrivial();};

        const Nontrivial ReturnsByValue(const int& x, const int& y);
        "#,
    )?;
    let BindingsTokens { rs_api, rs_api_impl } = generate_bindings_tokens_for_test(ir)?;
    assert_rs_matches!(
        rs_api,
        quote! {
            pub fn ReturnsByValue<'a, 'b>(x: &'a ::core::ffi::c_int, y: &'b ::core::ffi::c_int)
            -> impl ::ctor::Ctor<Output=crate::Nontrivial, Error=::ctor::Infallible> + use<'a, 'b> {
                unsafe {
                    ::ctor::FnCtor::new(move |dest: *mut crate::Nontrivial| {
                        crate::detail::__rust_thunk___Z14ReturnsByValueRKiS0_(dest as *mut ::core::ffi::c_void, x, y);
                    })
                }

            }
        }
    );

    assert_cc_matches!(
        rs_api_impl,
        quote! {
            extern "C" void __rust_thunk___Z14ReturnsByValueRKiS0_(
                    struct Nontrivial* __return, int const* x, int const* y) {
                new(__return) auto(ReturnsByValue(*x, *y));
            }
        }
    );
    Ok(())
}

#[gtest]
fn test_unpin_by_value_param() -> Result<()> {
    let ir = ir_from_cc(
        r#"#pragma clang lifetime_elision
        struct Trivial final {
          int trivial_field;
        };

        void foo(Trivial param);
        "#,
    )?;
    let BindingsTokens { rs_api, rs_api_impl } = generate_bindings_tokens_for_test(ir)?;
    assert_rs_matches!(
        rs_api,
        quote! {
            #[inline(always)]
            pub fn foo(mut param: crate::Trivial) {
                unsafe { crate::detail::__rust_thunk___Z3foo7Trivial(&mut param) }
            }
        }
    );
    assert_rs_matches!(
        rs_api,
        quote! {
            pub(crate) unsafe fn __rust_thunk___Z3foo7Trivial(param: &mut crate::Trivial);
        }
    );
    assert_cc_matches!(
        rs_api_impl,
        quote! {
            extern "C" void __rust_thunk___Z3foo7Trivial(struct Trivial* param) {
                foo(std::move(*param));
            }
        }
    );
    Ok(())
}

#[gtest]
fn test_unpin_by_value_return() -> Result<()> {
    let ir = ir_from_cc(
        r#"#pragma clang lifetime_elision
        struct Trivial final {
          int trivial_field;
        };

        Trivial foo();
        "#,
    )?;
    let BindingsTokens { rs_api, rs_api_impl } = generate_bindings_tokens_for_test(ir)?;
    assert_rs_matches!(
        rs_api,
        quote! {
            #[inline(always)]
            pub fn foo() -> crate::Trivial {
                unsafe {
                    let mut __return = ::core::mem::MaybeUninit::<crate::Trivial>::uninit();
                    crate::detail::__rust_thunk___Z3foov(&raw mut __return as *mut ::core::ffi::c_void);
                    __return.assume_init()
                }
            }
        }
    );
    assert_rs_matches!(
        rs_api,
        quote! {
            pub(crate) unsafe fn __rust_thunk___Z3foov(
                __return: *mut ::core::ffi::c_void
            );
        }
    );
    assert_cc_matches!(
        rs_api_impl,
        quote! {
            extern "C" void __rust_thunk___Z3foov(struct Trivial* __return) {
                new (__return) auto(foo());
            }
        }
    );
    Ok(())
}

#[gtest]
fn test_unpin_rvalue_ref_qualified_method() -> Result<()> {
    let ir = ir_from_cc(
        r#"#pragma clang lifetime_elision
        struct TrivialWithRvalueRefQualifiedMethod final {
          void rvalue_ref_qualified_method() &&;
        };
        "#,
    )?;
    let BindingsTokens { rs_api, .. } = generate_bindings_tokens_for_test(ir)?;
    assert_rs_matches!(
        rs_api,
        quote! {
            #[inline(always)]
            pub fn rvalue_ref_qualified_method<'a>(self: ::ctor::RvalueReference<'a, Self>) {
                unsafe {
                    crate::detail::__rust_thunk___ZNO35TrivialWithRvalueRefQualifiedMethod27rvalue_ref_qualified_methodEv(self)
                }
            }
        }
    );
    assert_rs_matches!(
        rs_api,
        quote! {
            #[link_name = "_ZNO35TrivialWithRvalueRefQualifiedMethod27rvalue_ref_qualified_methodEv"]
            pub(crate) unsafe fn __rust_thunk___ZNO35TrivialWithRvalueRefQualifiedMethod27rvalue_ref_qualified_methodEv < 'a > (__this :
                :: ctor :: RvalueReference < 'a , crate :: TrivialWithRvalueRefQualifiedMethod >) ;
        }
    );
    Ok(())
}

#[gtest]
fn test_unpin_rvalue_ref_const_qualified_method() -> Result<()> {
    let ir = ir_from_cc(
        r#"#pragma clang lifetime_elision
        struct TrivialWithRvalueRefConstQualifiedMethod final {
          void rvalue_ref_const_qualified_method() const &&;
        };
        "#,
    )?;
    let BindingsTokens { rs_api, .. } = generate_bindings_tokens_for_test(ir)?;
    assert_rs_matches!(
        rs_api,
        quote! {
            #[inline(always)]
            pub fn rvalue_ref_const_qualified_method<'a>(self: ::ctor::ConstRvalueReference<'a, Self>) {
                unsafe {
                    crate::detail::__rust_thunk___ZNKO40TrivialWithRvalueRefConstQualifiedMethod33rvalue_ref_const_qualified_methodEv(self)
                }
            }
        }
    );
    assert_rs_matches!(
        rs_api,
        quote! {
            #[link_name = "_ZNKO40TrivialWithRvalueRefConstQualifiedMethod33rvalue_ref_const_qualified_methodEv"]
            pub(crate) unsafe fn __rust_thunk___ZNKO40TrivialWithRvalueRefConstQualifiedMethod33rvalue_ref_const_qualified_methodEv < 'a > (__this :
                :: ctor :: ConstRvalueReference < 'a , crate :: TrivialWithRvalueRefConstQualifiedMethod >) ;
        }
    );
    Ok(())
}

/// Assignment is special in that it discards the return type.
/// So if the return type is !Unpin, it needs to emplace!() it.
#[gtest]
fn test_nonunpin_return_assign() -> Result<()> {
    let ir = ir_from_cc(
        r#"#pragma clang lifetime_elision
        // This type must be `!Unpin`.
        struct Nontrivial {
            ~Nontrivial();
            Nontrivial operator=(const Nontrivial& other);
        };
        "#,
    )?;
    let BindingsTokens { rs_api, rs_api_impl } = generate_bindings_tokens_for_test(ir)?;
    assert_rs_matches!(
        rs_api,
        quote! {
            impl<'b> ::ctor::Assign<&'b Self> for Nontrivial {
                #[inline(always)]
                fn assign<'a>(self: ::core::pin::Pin<&'a mut Self>, other: &'b Self) {
                    unsafe {
                        let _ = ::ctor::emplace!(::ctor::FnCtor::new(
                            move |dest: *mut Self| {
                                crate::detail::__rust_thunk___ZN10NontrivialaSERKS_(
                                    dest as *mut ::core::ffi::c_void,
                                    self,
                                    other
                                );
                            }
                        ));
                    }
                }
            }
        }
    );

    assert_cc_matches!(
        rs_api_impl,
        quote! {
            extern "C" void __rust_thunk___ZN10NontrivialaSERKS_(
                struct Nontrivial* __return, struct Nontrivial* __this,
                struct Nontrivial const * other
            ) {
                new(__return) auto(__this->operator=(*other));
            }
        }
    );
    Ok(())
}

#[gtest]
fn test_nonunpin_param() -> Result<()> {
    let ir = ir_from_cc(
        r#"#pragma clang lifetime_elision
        // This type must be `!Unpin`.
        struct Nontrivial {
            Nontrivial(Nontrivial&&);
            ~Nontrivial();
        };

        void TakesByValue(Nontrivial x);
        "#,
    )?;
    let BindingsTokens { rs_api, rs_api_impl } = generate_bindings_tokens_for_test(ir)?;
    assert_rs_matches!(
        rs_api,
        quote! {
            pub fn TakesByValue(x: impl ::ctor::Ctor<Output=crate::Nontrivial, Error=::ctor::Infallible>) {
                unsafe {
                    crate::detail::__rust_thunk___Z12TakesByValue10Nontrivial(::core::pin::Pin::into_inner_unchecked(::ctor::emplace!(x)))
                }
            }
        }
    );

    assert_cc_matches!(
        rs_api_impl,
        quote! {
            extern "C" void __rust_thunk___Z12TakesByValue10Nontrivial(struct Nontrivial*x) {
                TakesByValue(std::move(*x));
            }
        }
    );
    Ok(())
}

#[gtest]
fn test_nonunpin_trait_param() -> Result<()> {
    let ir = ir_from_cc(
        r#"#pragma clang lifetime_elision
        // This type must be `!Unpin`.
        struct Nontrivial {
            Nontrivial(Nontrivial&&);
            Nontrivial& operator=(Nontrivial) {}
            ~Nontrivial();
        };

        struct Trivial final {
            /*implicit*/ Trivial(Nontrivial) {}
        };
        "#,
    )?;
    let rs_api = generate_bindings_tokens_for_test(ir)?.rs_api;
    assert_rs_matches!(
        rs_api,
        quote! {
            impl<'__param_0> From<::ctor::RvalueReference<'__param_0, crate::Nontrivial>> for Trivial {
                #[inline(always)]
                fn from(__param_0: ::ctor::RvalueReference<'__param_0, crate::Nontrivial>) -> Self {
                    let mut tmp = ::core::mem::MaybeUninit::<Self>::zeroed();
                    unsafe {
                        crate::detail::__rust_thunk___ZN7TrivialC1E10Nontrivial(
                            &raw mut tmp as *mut _,
                            __param_0
                        );
                        tmp.assume_init()
                    }
                }
            }
        }
    );
    Ok(())
}

#[gtest]
fn test_nonmovable_param() -> Result<()> {
    let ir = ir_from_cc(
        r#"#pragma clang lifetime_elision
        // This type must be `!Unpin` and non-move constructible.
        struct Nonmovable {
            Nonmovable(Nonmovable&&) = delete;
        };

        void TakesByValue(Nonmovable) {}
        "#,
    )?;
    let BindingsTokens { rs_api, rs_api_impl } = generate_bindings_tokens_for_test(ir)?;
    // Bindings for TakesByValue cannot be generated.
    assert_rs_matches!(rs_api, quote! {TakesByValue<'error>});
    assert_cc_not_matches!(rs_api_impl, quote! {TakesByValue});
    Ok(())
}

#[gtest]
fn test_invalid_unsafe_annotation_causes_fatal_error() -> googletest::Result<()> {
    let ir = ir_from_cc(
        r#"
        struct Trivial final {
            [[clang::annotate("crubit_override_unsafe", true)]]
            ~Trivial();
        };
        "#,
    )
    .or_fail()?;
    let error_message = generate_bindings_tokens_for_test(ir).err().or_fail()?.to_string();
    assert_that!(
        error_message,
        contains_substring("Unsafe annotations on destructors are not supported")
    );
    Ok(())
}

#[gtest]
fn test_function_returning_rvalue_reference() -> Result<()> {
    let ir = ir_from_cc(
        r#"#pragma clang lifetime_elision
        struct SomeStruct final {
            // Inline to force generation (and test coverage) of C++ thunks.
            inline SomeStruct&& GetRValueReference() {
              return static_cast<SomeStruct&&>(*this);
            }
            int field;
        };
        "#,
    )?;
    let BindingsTokens { rs_api, rs_api_impl } = generate_bindings_tokens_for_test(ir)?;
    assert_rs_matches!(
        rs_api,
        quote! {
            impl SomeStruct {
                ...
                #[inline(always)]
                pub fn GetRValueReference<'a>(&'a mut self)
                        -> ::ctor::RvalueReference<'a, crate::SomeStruct> {
                    unsafe {
                        crate::detail::__rust_thunk___ZN10SomeStruct18GetRValueReferenceEv(self)
                    }
                }
            }
        }
    );
    assert_rs_matches!(
        rs_api,
        quote! {
            extern "C" {
                ...
                pub(crate) unsafe fn __rust_thunk___ZN10SomeStruct18GetRValueReferenceEv<'a>(
                        __this: &'a mut crate::SomeStruct
                   ) -> ::ctor::RvalueReference<'a, crate::SomeStruct>;
                ...
            }
        }
    );

    // Note that you can't just convert directly from xvalue to lvalue:
    //
    //     return &static_cast<SomeStruct&>(__this->GetRValueReference());
    //
    // For the above, Clang will emit an error that "non-const lvalue reference to
    // type 'struct SomeStruct' cannot bind to a temporary of type
    // 'SomeStruct'" (This is somewhat misleading, because there are no
    // temporaries here).  We must first bind the return value to a name
    // (`lvalue` below), so that it becomes an lvalue. Only then can it be
    // converted to a pointer.
    assert_cc_matches!(
        rs_api_impl,
        quote! {
            extern "C" struct SomeStruct*
            __rust_thunk___ZN10SomeStruct18GetRValueReferenceEv(struct SomeStruct* __this) {
                struct SomeStruct&& lvalue = __this->GetRValueReference();
                return &lvalue;
            }
        }
    );

    Ok(())
}

#[gtest]
fn test_c_abi_compatible_type_by_value_with_move() -> Result<()> {
    let ir = ir_from_cc(
        r#"
            typedef int MyTypedefDecl;

            inline void f(MyTypedefDecl a, void* b, int c) {}
        "#,
    )?;
    let BindingsTokens { rs_api_impl, .. } = generate_bindings_tokens_for_test(ir)?;
    assert_cc_matches!(
        rs_api_impl,
        quote! {
            extern "C" void __rust_thunk___Z1fiPvi(MyTypedefDecl a, void* b, int c) {
                f(a, b, c);
            }
        }
    );
    Ok(())
}