blob: 46466a5b427225b3db836b3ec3c2135f2c75f356 [file] [log] [blame]
// 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
#ifndef CRUBIT_RS_BINDINGS_FROM_CC_TEST_GOLDEN_NONTRIVIAL_TYPE_H_
#define CRUBIT_RS_BINDINGS_FROM_CC_TEST_GOLDEN_NONTRIVIAL_TYPE_H_
#pragma clang lifetime_elision
// Nontrivial due to (declared, but not yet defined) user-specified constructor
// and destructor.
//
// This makes it nontrivial for calls (so not trivially relocatable), as well
// as specifically giving it a nontrivial move constructor and destructor.
struct Nontrivial final {
explicit Nontrivial();
explicit Nontrivial(int field);
explicit Nontrivial(int field, int unused);
Nontrivial(const Nontrivial&);
Nontrivial(Nontrivial&&);
Nontrivial& operator=(const Nontrivial&);
Nontrivial& operator=(Nontrivial&&);
Nontrivial& operator=(int);
// NOLINTNEXTLINE(misc-unconventional-assign-operator)
Nontrivial operator=(float);
~Nontrivial();
void Unqualified();
void ConstQualified() const;
void LvalueRefQualified() &;
void ConstLvalueRefQualified() const&;
void RvalueRefQualified() &&;
void ConstRvalueRefQualified() const&&;
int field;
bool operator==(const Nontrivial& rhs) const;
bool operator!=(const Nontrivial& rhs) const;
bool operator<(const Nontrivial& rhs) const;
Nontrivial operator+(const Nontrivial& rhs) const;
// Bindings for `operator+=` are *not* supported for non-trivial types.
Nontrivial& operator+=(const Nontrivial& rhs);
};
// Nontrivial due to (inline) user-specified constructor and destructor.
//
// This makes it nontrivial for calls (so not trivially relocatable), as well
// as specifically giving it a nontrivial move constructor and destructor.
struct NontrivialInline final {
explicit NontrivialInline() : NontrivialInline(0) {}
explicit NontrivialInline(int field) : field(field) {}
explicit NontrivialInline(int field, int unused) : NontrivialInline(field) {}
NontrivialInline(const NontrivialInline&) {}
NontrivialInline(NontrivialInline&&) {}
NontrivialInline& operator=(const NontrivialInline&) { return *this; }
NontrivialInline& operator=(NontrivialInline&&) { return *this; }
NontrivialInline& operator=(int) { return *this; }
~NontrivialInline() {}
void MemberFunction() {}
int field;
};
// Nontrivial due to member variables.
//
// This changes how the destructor / drop impl work -- instead of calling
// the destructor for NontrivialMembers, it just calls the destructors for
// each field.
struct NontrivialMembers final {
Nontrivial nontrivial_member;
};
// Nontrivial, but trivially relocatable and final (and therefore Unpin).
struct [[clang::trivial_abi]] NontrivialUnpin final {
explicit NontrivialUnpin();
explicit NontrivialUnpin(int field);
explicit NontrivialUnpin(int field, int unused);
NontrivialUnpin(const NontrivialUnpin&);
NontrivialUnpin(NontrivialUnpin&&);
NontrivialUnpin(Nontrivial&&);
NontrivialUnpin& operator=(const NontrivialUnpin&);
NontrivialUnpin& operator=(NontrivialUnpin&&);
NontrivialUnpin& operator=(int);
~NontrivialUnpin();
void MemberFunction();
int field;
};
Nontrivial TakesByValue(Nontrivial nontrivial);
NontrivialInline TakesByValueInline(NontrivialInline nontrivial);
NontrivialUnpin TakesByValueUnpin(NontrivialUnpin nontrivial);
Nontrivial& TakesByReference(Nontrivial& nontrivial);
NontrivialUnpin& TakesUnpinByReference(NontrivialUnpin& nontrivial);
const Nontrivial& TakesByConstReference(const Nontrivial& nontrivial);
const NontrivialUnpin& TakesUnpinByConstReference(
const NontrivialUnpin& nontrivial);
Nontrivial&& TakesByRvalueReference(Nontrivial&& nontrivial);
NontrivialUnpin&& TakesUnpinByRvalueReference(NontrivialUnpin&& nontrivial);
const Nontrivial&& TakesByConstRvalueReference(const Nontrivial&& nontrivial);
const NontrivialUnpin&& TakesUnpinByConstRvalueReference(
const NontrivialUnpin&& nontrivial);
// Finally, testing for strange by-value APIs.
struct NontrivialByValue {
NontrivialByValue(const NontrivialByValue& other) = default;
NontrivialByValue(NontrivialByValue&& other) = default;
NontrivialByValue& operator=(const NontrivialByValue& other) = default;
NontrivialByValue& operator=(NontrivialByValue&& other) = default;
// // NOLINTNEXTLINE(misc-unconventional-assign-operator)
NontrivialByValue operator=(Nontrivial other);
NontrivialByValue operator==(NontrivialByValue other);
};
struct Nonmovable final {
explicit Nonmovable();
Nonmovable(const Nonmovable&) = delete;
Nonmovable(Nonmovable&&) = delete;
~Nonmovable();
void MemberFunction();
};
void TakesNonmovableByValue(Nonmovable nonmovable);
Nonmovable ReturnsNonmovableByValue();
#endif // CRUBIT_RS_BINDINGS_FROM_CC_TEST_GOLDEN_NONTRIVIAL_TYPE_H_