From 1cade8c97ef45a568a0d1037154930b3ee35495f Mon Sep 17 00:00:00 2001 From: Lucian Popescu Date: Mon, 16 Nov 2026 13:17:35 +0000 Subject: [PATCH 01/15] Add standard tests for member pointers --- ...6.1-zero-initialized-pointer-to-member.cpp | 28 ++++++++++++++ .../dcl.mptr/p2-pointer-to-array-member.cpp | 20 ++++++++++ .../dcl.mptr/p2-pointer-to-data-member.cpp | 24 ++++++++++++ .../p2-pointer-to-member-function.cpp | 24 ++++++++++++ ...-pointer-to-member-of-incomplete-class.cpp | 21 +++++++++++ ...er-to-member-of-pointer-to-member-type.cpp | 23 ++++++++++++ .../conv/conv.bool/p1-pointer-to-member.cpp | 29 +++++++++++++++ ...p1-pointer-to-noexcept-member-function.cpp | 19 ++++++++++ .../p1-null-distinct-from-first-member.cpp | 18 +++++++++ .../p1-null-distinct-from-member-function.cpp | 20 ++++++++++ .../conv.mem/p1-null-values-compare-equal.cpp | 20 ++++++++++ .../p2-base-to-derived-data-member.cpp | 32 ++++++++++++++++ .../p2-base-to-derived-member-function.cpp | 32 ++++++++++++++++ .../conv.mem/p2-null-converts-to-null.cpp | 25 +++++++++++++ ...7.4-base-and-derived-pointer-to-member.cpp | 31 ++++++++++++++++ .../p7.4-pointer-to-member-and-null.cpp | 21 +++++++++++ .../expr.compound/expr.eq/p4.1-both-null.cpp | 17 +++++++++ .../expr.compound/expr.eq/p4.2-one-null.cpp | 19 ++++++++++ ...4.3-pointer-to-virtual-member-function.cpp | 14 +++++++ .../p4.4-members-of-unrelated-classes.cpp | 23 ++++++++++++ .../expr.eq/p4.5-members-of-same-union.cpp | 17 +++++++++ .../p4.6-data-member-of-repeated-base.cpp | 32 ++++++++++++++++ .../expr.eq/p4.6-data-members.cpp | 21 +++++++++++ .../p4.6-member-function-of-repeated-base.cpp | 37 +++++++++++++++++++ .../expr.eq/p4.6-member-functions.cpp | 22 +++++++++++ .../p2-object-of-derived-class.cpp | 30 +++++++++++++++ ...p3-arrow-star-pointer-to-derived-class.cpp | 31 ++++++++++++++++ .../expr.mptr.oper/p3-arrow-star.cpp | 20 ++++++++++ .../p4-dynamic-type-lacks-member.cpp | 19 ++++++++++ .../p4-object-expression-sequenced-first.cpp | 29 +++++++++++++++ .../p4-object-type-not-similar.cpp | 21 +++++++++++ .../p6-data-member-of-lvalue-is-lvalue.cpp | 20 ++++++++++ .../p6-data-member-of-rvalue-is-xvalue.cpp | 30 +++++++++++++++ .../p6-member-function-call.cpp | 26 +++++++++++++ .../p6-null-pointer-to-data-member.cpp | 16 ++++++++ .../p6-null-pointer-to-member-function.cpp | 16 ++++++++ .../p6-pointer-to-virtual-member-function.cpp | 29 +++++++++++++++ .../p10-null-converts-to-null.cpp | 20 ++++++++++ .../p10-result-is-unspecified.cpp | 20 ++++++++++ .../p10.1-member-function-round-trip.cpp | 24 ++++++++++++ .../p10.2-data-member-round-trip.cpp | 24 ++++++++++++ .../p13-base-unrelated-to-member-class.cpp | 23 ++++++++++++ .../p13-derived-to-base-data-member.cpp | 26 +++++++++++++ .../p13-derived-to-base-member-function.cpp | 27 ++++++++++++++ .../p13-null-converts-to-null.cpp | 21 +++++++++++ .../p13-round-trip-yields-original.cpp | 23 ++++++++++++ .../p3.1-anonymous-union-member.cpp | 24 ++++++++++++ ...3.1-member-named-through-derived-class.cpp | 22 +++++++++++ ...p3.2-static-member-is-ordinary-pointer.cpp | 22 +++++++++++ ...hesized-qualified-id-is-object-pointer.cpp | 26 +++++++++++++ .../p2.6-pointer-to-member-argument.cpp | 30 +++++++++++++++ .../p1.1-member-function-with-object.cpp | 27 ++++++++++++++ ...member-function-with-reference-wrapper.cpp | 23 ++++++++++++ .../p1.3-member-function-with-pointer.cpp | 23 ++++++++++++ .../p1.4-data-member-with-object.cpp | 24 ++++++++++++ ...1.5-data-member-with-reference-wrapper.cpp | 22 +++++++++++ .../p1.6-data-member-with-pointer.cpp | 22 +++++++++++ 57 files changed, 1349 insertions(+) create mode 100644 tests/std/dcl.dcl/dcl.decl/dcl.init/dcl.init.general/p6.1-zero-initialized-pointer-to-member.cpp create mode 100644 tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/p2-pointer-to-array-member.cpp create mode 100644 tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/p2-pointer-to-data-member.cpp create mode 100644 tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/p2-pointer-to-member-function.cpp create mode 100644 tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/p2-pointer-to-member-of-incomplete-class.cpp create mode 100644 tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/p2-pointer-to-member-of-pointer-to-member-type.cpp create mode 100644 tests/std/expr/conv/conv.bool/p1-pointer-to-member.cpp create mode 100644 tests/std/expr/conv/conv.fctptr/p1-pointer-to-noexcept-member-function.cpp create mode 100644 tests/std/expr/conv/conv.mem/p1-null-distinct-from-first-member.cpp create mode 100644 tests/std/expr/conv/conv.mem/p1-null-distinct-from-member-function.cpp create mode 100644 tests/std/expr/conv/conv.mem/p1-null-values-compare-equal.cpp create mode 100644 tests/std/expr/conv/conv.mem/p2-base-to-derived-data-member.cpp create mode 100644 tests/std/expr/conv/conv.mem/p2-base-to-derived-member-function.cpp create mode 100644 tests/std/expr/conv/conv.mem/p2-null-converts-to-null.cpp create mode 100644 tests/std/expr/expr.compound/expr.cond/p7.4-base-and-derived-pointer-to-member.cpp create mode 100644 tests/std/expr/expr.compound/expr.cond/p7.4-pointer-to-member-and-null.cpp create mode 100644 tests/std/expr/expr.compound/expr.eq/p4.1-both-null.cpp create mode 100644 tests/std/expr/expr.compound/expr.eq/p4.2-one-null.cpp create mode 100644 tests/std/expr/expr.compound/expr.eq/p4.3-pointer-to-virtual-member-function.cpp create mode 100644 tests/std/expr/expr.compound/expr.eq/p4.4-members-of-unrelated-classes.cpp create mode 100644 tests/std/expr/expr.compound/expr.eq/p4.5-members-of-same-union.cpp create mode 100644 tests/std/expr/expr.compound/expr.eq/p4.6-data-member-of-repeated-base.cpp create mode 100644 tests/std/expr/expr.compound/expr.eq/p4.6-data-members.cpp create mode 100644 tests/std/expr/expr.compound/expr.eq/p4.6-member-function-of-repeated-base.cpp create mode 100644 tests/std/expr/expr.compound/expr.eq/p4.6-member-functions.cpp create mode 100644 tests/std/expr/expr.compound/expr.mptr.oper/p2-object-of-derived-class.cpp create mode 100644 tests/std/expr/expr.compound/expr.mptr.oper/p3-arrow-star-pointer-to-derived-class.cpp create mode 100644 tests/std/expr/expr.compound/expr.mptr.oper/p3-arrow-star.cpp create mode 100644 tests/std/expr/expr.compound/expr.mptr.oper/p4-dynamic-type-lacks-member.cpp create mode 100644 tests/std/expr/expr.compound/expr.mptr.oper/p4-object-expression-sequenced-first.cpp create mode 100644 tests/std/expr/expr.compound/expr.mptr.oper/p4-object-type-not-similar.cpp create mode 100644 tests/std/expr/expr.compound/expr.mptr.oper/p6-data-member-of-lvalue-is-lvalue.cpp create mode 100644 tests/std/expr/expr.compound/expr.mptr.oper/p6-data-member-of-rvalue-is-xvalue.cpp create mode 100644 tests/std/expr/expr.compound/expr.mptr.oper/p6-member-function-call.cpp create mode 100644 tests/std/expr/expr.compound/expr.mptr.oper/p6-null-pointer-to-data-member.cpp create mode 100644 tests/std/expr/expr.compound/expr.mptr.oper/p6-null-pointer-to-member-function.cpp create mode 100644 tests/std/expr/expr.compound/expr.mptr.oper/p6-pointer-to-virtual-member-function.cpp create mode 100644 tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/p10-null-converts-to-null.cpp create mode 100644 tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/p10-result-is-unspecified.cpp create mode 100644 tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/p10.1-member-function-round-trip.cpp create mode 100644 tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/p10.2-data-member-round-trip.cpp create mode 100644 tests/std/expr/expr.compound/expr.post/expr.static.cast/p13-base-unrelated-to-member-class.cpp create mode 100644 tests/std/expr/expr.compound/expr.post/expr.static.cast/p13-derived-to-base-data-member.cpp create mode 100644 tests/std/expr/expr.compound/expr.post/expr.static.cast/p13-derived-to-base-member-function.cpp create mode 100644 tests/std/expr/expr.compound/expr.post/expr.static.cast/p13-null-converts-to-null.cpp create mode 100644 tests/std/expr/expr.compound/expr.post/expr.static.cast/p13-round-trip-yields-original.cpp create mode 100644 tests/std/expr/expr.compound/expr.unary/expr.unary.op/p3.1-anonymous-union-member.cpp create mode 100644 tests/std/expr/expr.compound/expr.unary/expr.unary.op/p3.1-member-named-through-derived-class.cpp create mode 100644 tests/std/expr/expr.compound/expr.unary/expr.unary.op/p3.2-static-member-is-ordinary-pointer.cpp create mode 100644 tests/std/expr/expr.compound/expr.unary/expr.unary.op/p4-parenthesized-qualified-id-is-object-pointer.cpp create mode 100644 tests/std/temp/temp.type/p2.6-pointer-to-member-argument.cpp create mode 100644 tests/std/utilities/function.objects/func.require/p1.1-member-function-with-object.cpp create mode 100644 tests/std/utilities/function.objects/func.require/p1.2-member-function-with-reference-wrapper.cpp create mode 100644 tests/std/utilities/function.objects/func.require/p1.3-member-function-with-pointer.cpp create mode 100644 tests/std/utilities/function.objects/func.require/p1.4-data-member-with-object.cpp create mode 100644 tests/std/utilities/function.objects/func.require/p1.5-data-member-with-reference-wrapper.cpp create mode 100644 tests/std/utilities/function.objects/func.require/p1.6-data-member-with-pointer.cpp diff --git a/tests/std/dcl.dcl/dcl.decl/dcl.init/dcl.init.general/p6.1-zero-initialized-pointer-to-member.cpp b/tests/std/dcl.dcl/dcl.decl/dcl.init/dcl.init.general/p6.1-zero-initialized-pointer-to-member.cpp new file mode 100644 index 0000000000..60ab37f3b2 --- /dev/null +++ b/tests/std/dcl.dcl/dcl.decl/dcl.init/dcl.init.general/p6.1-zero-initialized-pointer-to-member.cpp @@ -0,0 +1,28 @@ +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +// N4950 [dcl.init.general]/6.1: zero-initializing a scalar converts the +// integer literal 0 to its type; for a pointer to member that is the null +// member pointer value. +#include + +struct HasTwoInts { + int first; + int second; +}; + +struct HoldsSelector { + int HasTwoInts::*selector; +}; + +static int HasTwoInts::*static_pm; + +int main() { + assert(static_pm == nullptr); + assert(static_pm != &HasTwoInts::first); + int HasTwoInts::*value_initialized{}; + assert(value_initialized == nullptr); + assert(value_initialized != &HasTwoInts::first); + HoldsSelector holder{}; + assert(holder.selector == nullptr); + assert(holder.selector != &HasTwoInts::first); + return 0; +} diff --git a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/p2-pointer-to-array-member.cpp b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/p2-pointer-to-array-member.cpp new file mode 100644 index 0000000000..6daf337c45 --- /dev/null +++ b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/p2-pointer-to-array-member.cpp @@ -0,0 +1,20 @@ +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +// N4950 [dcl.mptr]/2: the type is "derived-declarator-type-list pointer to +// member of class C of type T"; T can be an array type. +#include + +struct HasIntArray { + int before; + int elements[3]; +}; + +int main() { + int (HasIntArray::*pm)[3] = &HasIntArray::elements; + HasIntArray obj{1, {2, 3, 4}}; + assert((obj.*pm)[0] == 2); + assert((obj.*pm)[2] == 4); + (obj.*pm)[1] = 7; + assert(obj.elements[1] == 7); + assert(obj.before == 1); + return 0; +} diff --git a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/p2-pointer-to-data-member.cpp b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/p2-pointer-to-data-member.cpp new file mode 100644 index 0000000000..c4897bca79 --- /dev/null +++ b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/p2-pointer-to-data-member.cpp @@ -0,0 +1,24 @@ +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +// N4950 [dcl.mptr]/2: "T C::*" declares a pointer to member of class C of +// type T. +#include + +struct HasTwoInts { + int first; + int second; +}; + +int main() { + int HasTwoInts::*pm = &HasTwoInts::first; + HasTwoInts obj{3, 4}; + assert(obj.*pm == 3); + obj.*pm = 5; + assert(obj.first == 5); + assert(obj.second == 4); + pm = &HasTwoInts::second; + assert(obj.*pm == 4); + obj.*pm = 6; + assert(obj.first == 5); + assert(obj.second == 6); + return 0; +} diff --git a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/p2-pointer-to-member-function.cpp b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/p2-pointer-to-member-function.cpp new file mode 100644 index 0000000000..49154b76b7 --- /dev/null +++ b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/p2-pointer-to-member-function.cpp @@ -0,0 +1,24 @@ +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +// N4950 [dcl.mptr]/2: "T (C::*)(parameters)" declares a pointer to member of +// class C of function type. +#include + +struct HasTwoMemberFunctions { + int first_total = 0; + int second_total = 0; + void first(int amount) { first_total += amount; } + void second(int amount) { second_total += amount; } +}; + +int main() { + void (HasTwoMemberFunctions::*pmf)(int) = &HasTwoMemberFunctions::first; + HasTwoMemberFunctions obj; + (obj.*pmf)(3); + assert(obj.first_total == 3); + assert(obj.second_total == 0); + pmf = &HasTwoMemberFunctions::second; + (obj.*pmf)(4); + assert(obj.first_total == 3); + assert(obj.second_total == 4); + return 0; +} diff --git a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/p2-pointer-to-member-of-incomplete-class.cpp b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/p2-pointer-to-member-of-incomplete-class.cpp new file mode 100644 index 0000000000..4f363a15db --- /dev/null +++ b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/p2-pointer-to-member-of-incomplete-class.cpp @@ -0,0 +1,21 @@ +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +// N4950 [dcl.mptr]/2: the nested-name-specifier denotes a class; the class +// need not be complete. +#include + +struct CompletedLater; + +static int CompletedLater::*pm = nullptr; + +struct CompletedLater { + int first; + int second; +}; + +int main() { + assert(pm == nullptr); + pm = &CompletedLater::second; + CompletedLater obj{3, 4}; + assert(obj.*pm == 4); + return 0; +} diff --git a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/p2-pointer-to-member-of-pointer-to-member-type.cpp b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/p2-pointer-to-member-of-pointer-to-member-type.cpp new file mode 100644 index 0000000000..0106d49f10 --- /dev/null +++ b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/p2-pointer-to-member-of-pointer-to-member-type.cpp @@ -0,0 +1,23 @@ +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +// N4950 [dcl.mptr]/2: the type is "derived-declarator-type-list pointer to +// member of class C of type T"; T can itself be a pointer-to-member type. +#include + +struct HasTwoInts { + int first; + int second; +}; + +struct HoldsSelector { + int HasTwoInts::*selector; +}; + +int main() { + int HasTwoInts::*HoldsSelector::*pm = &HoldsSelector::selector; + HoldsSelector holder{&HasTwoInts::second}; + HasTwoInts obj{3, 4}; + assert(obj.*(holder.*pm) == 4); + holder.*pm = &HasTwoInts::first; + assert(obj.*(holder.selector) == 3); + return 0; +} diff --git a/tests/std/expr/conv/conv.bool/p1-pointer-to-member.cpp b/tests/std/expr/conv/conv.bool/p1-pointer-to-member.cpp new file mode 100644 index 0000000000..93b369542a --- /dev/null +++ b/tests/std/expr/conv/conv.bool/p1-pointer-to-member.cpp @@ -0,0 +1,29 @@ +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +// N4950 [conv.bool]/1: a prvalue of pointer-to-member type can be converted to +// bool; the null member pointer value becomes false, any other value true. +#include + +struct HasTwoInts { + int first; + int second; + void run() {} +}; + +int main() { + int HasTwoInts::*null_pm = nullptr; + int HasTwoInts::*first_pm = &HasTwoInts::first; + int HasTwoInts::*second_pm = &HasTwoInts::second; + void (HasTwoInts::*null_pmf)() = nullptr; + void (HasTwoInts::*run_pmf)() = &HasTwoInts::run; + bool null_as_bool = static_cast(null_pm); + assert(!null_as_bool); + bool first_as_bool = static_cast(first_pm); + assert(first_as_bool); + bool second_as_bool = static_cast(second_pm); + assert(second_as_bool); + bool null_function_as_bool = static_cast(null_pmf); + assert(!null_function_as_bool); + bool run_as_bool = static_cast(run_pmf); + assert(run_as_bool); + return 0; +} diff --git a/tests/std/expr/conv/conv.fctptr/p1-pointer-to-noexcept-member-function.cpp b/tests/std/expr/conv/conv.fctptr/p1-pointer-to-noexcept-member-function.cpp new file mode 100644 index 0000000000..fd8ba9ea2b --- /dev/null +++ b/tests/std/expr/conv/conv.fctptr/p1-pointer-to-noexcept-member-function.cpp @@ -0,0 +1,19 @@ +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +// N4950 [conv.fctptr]/1: "pointer to member of type noexcept function" +// converts to "pointer to member of type function"; the result designates the +// member function. +#include + +struct HasNoexceptMember { + int calls = 0; + void run() noexcept { ++calls; } +}; + +int main() { + void (HasNoexceptMember::*noexcept_pmf)() noexcept = &HasNoexceptMember::run; + void (HasNoexceptMember::*pmf)() = noexcept_pmf; + HasNoexceptMember obj; + (obj.*pmf)(); + assert(obj.calls == 1); + return 0; +} diff --git a/tests/std/expr/conv/conv.mem/p1-null-distinct-from-first-member.cpp b/tests/std/expr/conv/conv.mem/p1-null-distinct-from-first-member.cpp new file mode 100644 index 0000000000..edddb4e6a4 --- /dev/null +++ b/tests/std/expr/conv/conv.mem/p1-null-distinct-from-first-member.cpp @@ -0,0 +1,18 @@ +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +// N4950 [conv.mem]/1: the null member pointer value is distinguishable from +// any pointer to member not created from a null pointer constant. +#include + +struct HasTwoInts { + int first; + int second; +}; + +int main() { + int HasTwoInts::*null_pm = nullptr; + int HasTwoInts::*first_pm = &HasTwoInts::first; + int HasTwoInts::*second_pm = &HasTwoInts::second; + assert(first_pm != null_pm); + assert(second_pm != null_pm); + return 0; +} diff --git a/tests/std/expr/conv/conv.mem/p1-null-distinct-from-member-function.cpp b/tests/std/expr/conv/conv.mem/p1-null-distinct-from-member-function.cpp new file mode 100644 index 0000000000..99ee32d94d --- /dev/null +++ b/tests/std/expr/conv/conv.mem/p1-null-distinct-from-member-function.cpp @@ -0,0 +1,20 @@ +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +// N4950 [conv.mem]/1: the null member pointer value is distinguishable from +// any pointer to member not created from a null pointer constant. +#include + +struct HasVirtualAndNonVirtual { + virtual void first_virtual() {} + void non_virtual() {} +}; + +int main() { + void (HasVirtualAndNonVirtual::*null_pmf)() = nullptr; + void (HasVirtualAndNonVirtual::*virtual_pmf)() = + &HasVirtualAndNonVirtual::first_virtual; + void (HasVirtualAndNonVirtual::*non_virtual_pmf)() = + &HasVirtualAndNonVirtual::non_virtual; + assert(virtual_pmf != null_pmf); + assert(non_virtual_pmf != null_pmf); + return 0; +} diff --git a/tests/std/expr/conv/conv.mem/p1-null-values-compare-equal.cpp b/tests/std/expr/conv/conv.mem/p1-null-values-compare-equal.cpp new file mode 100644 index 0000000000..811950bc9c --- /dev/null +++ b/tests/std/expr/conv/conv.mem/p1-null-values-compare-equal.cpp @@ -0,0 +1,20 @@ +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +// N4950 [conv.mem]/1: a null pointer constant can be converted to a +// pointer-to-member type; two null member pointer values of the same type +// compare equal. +#include + +struct HasTwoInts { + int first; + int second; +}; + +int main() { + int HasTwoInts::*from_nullptr = nullptr; + int HasTwoInts::*from_zero = 0; + assert(from_nullptr == from_zero); + void (HasTwoInts::*function_from_nullptr)() = nullptr; + void (HasTwoInts::*function_from_zero)() = 0; + assert(function_from_nullptr == function_from_zero); + return 0; +} diff --git a/tests/std/expr/conv/conv.mem/p2-base-to-derived-data-member.cpp b/tests/std/expr/conv/conv.mem/p2-base-to-derived-data-member.cpp new file mode 100644 index 0000000000..f863fcaa90 --- /dev/null +++ b/tests/std/expr/conv/conv.mem/p2-base-to-derived-data-member.cpp @@ -0,0 +1,32 @@ +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +// N4950 [conv.mem]/2: "pointer to member of B of type T" converts to "pointer +// to member of D of type T"; the result refers to the member in D's instance +// of B. +#include + +struct Precedes { + int preceding; +}; + +struct DeclaresValue { + int value; +}; + +struct InheritsValue : Precedes, DeclaresValue { + int own; +}; + +int main() { + int DeclaresValue::*base_pm = &DeclaresValue::value; + int InheritsValue::*derived_pm = base_pm; + InheritsValue obj; + obj.preceding = 1; + obj.value = 2; + obj.own = 3; + assert(obj.*derived_pm == 2); + obj.*derived_pm = 4; + assert(obj.value == 4); + assert(obj.preceding == 1); + assert(obj.own == 3); + return 0; +} diff --git a/tests/std/expr/conv/conv.mem/p2-base-to-derived-member-function.cpp b/tests/std/expr/conv/conv.mem/p2-base-to-derived-member-function.cpp new file mode 100644 index 0000000000..f21a89dfb0 --- /dev/null +++ b/tests/std/expr/conv/conv.mem/p2-base-to-derived-member-function.cpp @@ -0,0 +1,32 @@ +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +// N4950 [conv.mem]/2: indirection through the converted pointer with a D +// object is the same as indirecting through the pointer to member of B with +// the B subobject of D. +#include + +struct Precedes { + int preceding; +}; + +struct DeclaresIncrement { + int value; + void increment() { ++value; } +}; + +struct InheritsIncrement : Precedes, DeclaresIncrement { + int own; +}; + +int main() { + void (DeclaresIncrement::*base_pmf)() = &DeclaresIncrement::increment; + void (InheritsIncrement::*derived_pmf)() = base_pmf; + InheritsIncrement obj; + obj.preceding = 1; + obj.value = 2; + obj.own = 3; + (obj.*derived_pmf)(); + assert(obj.value == 3); + assert(obj.preceding == 1); + assert(obj.own == 3); + return 0; +} diff --git a/tests/std/expr/conv/conv.mem/p2-null-converts-to-null.cpp b/tests/std/expr/conv/conv.mem/p2-null-converts-to-null.cpp new file mode 100644 index 0000000000..565736406c --- /dev/null +++ b/tests/std/expr/conv/conv.mem/p2-null-converts-to-null.cpp @@ -0,0 +1,25 @@ +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +// N4950 [conv.mem]/2: the null member pointer value is converted to the null +// member pointer value of the destination type. +#include + +struct Precedes { + int preceding; +}; + +struct DeclaresValue { + int value; + void increment() { ++value; } +}; + +struct InheritsValue : Precedes, DeclaresValue {}; + +int main() { + int DeclaresValue::*base_pm = nullptr; + int InheritsValue::*derived_pm = base_pm; + assert(derived_pm == nullptr); + void (DeclaresValue::*base_pmf)() = nullptr; + void (InheritsValue::*derived_pmf)() = base_pmf; + assert(derived_pmf == nullptr); + return 0; +} diff --git a/tests/std/expr/expr.compound/expr.cond/p7.4-base-and-derived-pointer-to-member.cpp b/tests/std/expr/expr.compound/expr.cond/p7.4-base-and-derived-pointer-to-member.cpp new file mode 100644 index 0000000000..6f1bbf66f5 --- /dev/null +++ b/tests/std/expr/expr.compound/expr.cond/p7.4-base-and-derived-pointer-to-member.cpp @@ -0,0 +1,31 @@ +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +// N4950 [expr.cond]/7.4: if one or both of the second and third operands have +// pointer-to-member type, pointer-to-member conversions bring them to their +// composite pointer type. +#include + +struct Precedes { + int preceding; +}; + +struct DeclaresValue { + int value; +}; + +struct InheritsValue : Precedes, DeclaresValue { + int own; +}; + +int main() { + int DeclaresValue::*base_pm = &DeclaresValue::value; + int InheritsValue::*derived_pm = &InheritsValue::own; + InheritsValue obj; + obj.preceding = 1; + obj.value = 2; + obj.own = 3; + bool choose_base = true; + assert(obj.*(choose_base ? base_pm : derived_pm) == 2); + choose_base = false; + assert(obj.*(choose_base ? base_pm : derived_pm) == 3); + return 0; +} diff --git a/tests/std/expr/expr.compound/expr.cond/p7.4-pointer-to-member-and-null.cpp b/tests/std/expr/expr.compound/expr.cond/p7.4-pointer-to-member-and-null.cpp new file mode 100644 index 0000000000..1df8833025 --- /dev/null +++ b/tests/std/expr/expr.compound/expr.cond/p7.4-pointer-to-member-and-null.cpp @@ -0,0 +1,21 @@ +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +// N4950 [expr.cond]/7.4: if one or both of the second and third operands have +// pointer-to-member type, they are brought to their composite pointer type. +#include + +struct HasTwoInts { + int first; + int second; +}; + +static int HasTwoInts::*second_or_null(bool choose_second) { + return choose_second ? &HasTwoInts::second : nullptr; +} + +int main() { + HasTwoInts obj{3, 4}; + assert(second_or_null(false) == nullptr); + assert(second_or_null(true) == &HasTwoInts::second); + assert(obj.*second_or_null(true) == 4); + return 0; +} diff --git a/tests/std/expr/expr.compound/expr.eq/p4.1-both-null.cpp b/tests/std/expr/expr.compound/expr.eq/p4.1-both-null.cpp new file mode 100644 index 0000000000..7de5adfd59 --- /dev/null +++ b/tests/std/expr/expr.compound/expr.eq/p4.1-both-null.cpp @@ -0,0 +1,17 @@ +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +// N4950 [expr.eq]/4.1: two pointers to members that are both the null member +// pointer value compare equal. +#include + +struct HasTwoInts { + int first; + int second; +}; + +int main() { + int HasTwoInts::*first_null = nullptr; + int HasTwoInts::*second_null = nullptr; + assert(first_null == second_null); + assert(!(first_null != second_null)); + return 0; +} diff --git a/tests/std/expr/expr.compound/expr.eq/p4.2-one-null.cpp b/tests/std/expr/expr.compound/expr.eq/p4.2-one-null.cpp new file mode 100644 index 0000000000..77df4c4fe7 --- /dev/null +++ b/tests/std/expr/expr.compound/expr.eq/p4.2-one-null.cpp @@ -0,0 +1,19 @@ +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +// N4950 [expr.eq]/4.2: if only one of two pointers to members is the null +// member pointer value, they compare unequal. +#include + +struct HasTwoInts { + int first; + int second; +}; + +int main() { + int HasTwoInts::*null_pm = nullptr; + int HasTwoInts::*first_pm = &HasTwoInts::first; + assert(first_pm != null_pm); + assert(!(first_pm == null_pm)); + assert(null_pm != first_pm); + assert(!(null_pm == first_pm)); + return 0; +} diff --git a/tests/std/expr/expr.compound/expr.eq/p4.3-pointer-to-virtual-member-function.cpp b/tests/std/expr/expr.compound/expr.eq/p4.3-pointer-to-virtual-member-function.cpp new file mode 100644 index 0000000000..d24cf3d078 --- /dev/null +++ b/tests/std/expr/expr.compound/expr.eq/p4.3-pointer-to-virtual-member-function.cpp @@ -0,0 +1,14 @@ +// nondet-result +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +// N4950 [expr.eq]/4.3: if either operand is a pointer to a virtual member +// function, the result is unspecified. + +struct DeclaresVirtual { + virtual void run() {} +}; + +int main() { + void (DeclaresVirtual::*first_pmf)() = &DeclaresVirtual::run; + void (DeclaresVirtual::*second_pmf)() = &DeclaresVirtual::run; + return first_pmf == second_pmf; +} diff --git a/tests/std/expr/expr.compound/expr.eq/p4.4-members-of-unrelated-classes.cpp b/tests/std/expr/expr.compound/expr.eq/p4.4-members-of-unrelated-classes.cpp new file mode 100644 index 0000000000..2aedde08cc --- /dev/null +++ b/tests/std/expr/expr.compound/expr.eq/p4.4-members-of-unrelated-classes.cpp @@ -0,0 +1,23 @@ +// nondet-result +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +// N4950 [expr.eq]/4.4: if one operand refers to a member of class C1 and the +// other to a member of a different class C2, neither a base class of the +// other, the result is unspecified. + +struct CommonBase {}; + +struct FirstDerived : CommonBase { + int value; +}; + +struct SecondDerived : CommonBase { + int value; +}; + +int main() { + int CommonBase::*first_pm = + static_cast(&FirstDerived::value); + int CommonBase::*second_pm = + static_cast(&SecondDerived::value); + return first_pm == second_pm; +} diff --git a/tests/std/expr/expr.compound/expr.eq/p4.5-members-of-same-union.cpp b/tests/std/expr/expr.compound/expr.eq/p4.5-members-of-same-union.cpp new file mode 100644 index 0000000000..e74fd2b756 --- /dev/null +++ b/tests/std/expr/expr.compound/expr.eq/p4.5-members-of-same-union.cpp @@ -0,0 +1,17 @@ +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +// N4950 [expr.eq]/4.5: pointers to (possibly different) members of the same +// union compare equal. +#include + +union HasTwoIntMembers { + int first; + int second; +}; + +int main() { + int HasTwoIntMembers::*first_pm = &HasTwoIntMembers::first; + int HasTwoIntMembers::*second_pm = &HasTwoIntMembers::second; + assert(first_pm == second_pm); + assert(!(first_pm != second_pm)); + return 0; +} diff --git a/tests/std/expr/expr.compound/expr.eq/p4.6-data-member-of-repeated-base.cpp b/tests/std/expr/expr.compound/expr.eq/p4.6-data-member-of-repeated-base.cpp new file mode 100644 index 0000000000..f893043335 --- /dev/null +++ b/tests/std/expr/expr.compound/expr.eq/p4.6-data-member-of-repeated-base.cpp @@ -0,0 +1,32 @@ +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +// N4950 [expr.eq]/4.6: two pointers to members compare equal if they would +// refer to the same member of the same subobject, otherwise they compare +// unequal. +#include + +struct RepeatedBase { + int value; +}; + +struct FirstPath : RepeatedBase {}; + +struct SecondPath : RepeatedBase {}; + +struct JoinsPaths : FirstPath, SecondPath {}; + +int main() { + int RepeatedBase::*base_pm = &RepeatedBase::value; + int FirstPath::*first_pm = base_pm; + int SecondPath::*second_pm = base_pm; + int JoinsPaths::*through_first = first_pm; + int JoinsPaths::*through_second = second_pm; + assert(base_pm == first_pm); + assert(through_first != through_second); + assert(!(through_first == through_second)); + JoinsPaths obj; + obj.FirstPath::value = 3; + obj.SecondPath::value = 4; + assert(obj.*through_first == 3); + assert(obj.*through_second == 4); + return 0; +} diff --git a/tests/std/expr/expr.compound/expr.eq/p4.6-data-members.cpp b/tests/std/expr/expr.compound/expr.eq/p4.6-data-members.cpp new file mode 100644 index 0000000000..f52c54b8a2 --- /dev/null +++ b/tests/std/expr/expr.compound/expr.eq/p4.6-data-members.cpp @@ -0,0 +1,21 @@ +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +// N4950 [expr.eq]/4.6: two pointers to members compare equal if they would +// refer to the same member of the same most derived object, otherwise they +// compare unequal. +#include + +struct HasTwoInts { + int first; + int second; +}; + +int main() { + int HasTwoInts::*first_pm = &HasTwoInts::first; + int HasTwoInts::*also_first_pm = &HasTwoInts::first; + int HasTwoInts::*second_pm = &HasTwoInts::second; + assert(first_pm == also_first_pm); + assert(!(first_pm != also_first_pm)); + assert(first_pm != second_pm); + assert(!(first_pm == second_pm)); + return 0; +} diff --git a/tests/std/expr/expr.compound/expr.eq/p4.6-member-function-of-repeated-base.cpp b/tests/std/expr/expr.compound/expr.eq/p4.6-member-function-of-repeated-base.cpp new file mode 100644 index 0000000000..44a95c3880 --- /dev/null +++ b/tests/std/expr/expr.compound/expr.eq/p4.6-member-function-of-repeated-base.cpp @@ -0,0 +1,37 @@ +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +// N4950 [expr.eq]/4.6: two pointers to members compare equal if they would +// refer to the same member of the same subobject, otherwise they compare +// unequal. +#include + +struct RepeatedBase { + int value; + void increment() { ++value; } +}; + +struct FirstPath : RepeatedBase {}; + +struct SecondPath : RepeatedBase {}; + +struct JoinsPaths : FirstPath, SecondPath {}; + +int main() { + void (RepeatedBase::*base_pmf)() = &RepeatedBase::increment; + void (FirstPath::*first_pmf)() = base_pmf; + void (SecondPath::*second_pmf)() = base_pmf; + void (JoinsPaths::*through_first)() = first_pmf; + void (JoinsPaths::*through_second)() = second_pmf; + assert(base_pmf == first_pmf); + assert(through_first != through_second); + assert(!(through_first == through_second)); + JoinsPaths obj; + obj.FirstPath::value = 3; + obj.SecondPath::value = 5; + (obj.*through_first)(); + assert(obj.FirstPath::value == 4); + assert(obj.SecondPath::value == 5); + (obj.*through_second)(); + assert(obj.FirstPath::value == 4); + assert(obj.SecondPath::value == 6); + return 0; +} diff --git a/tests/std/expr/expr.compound/expr.eq/p4.6-member-functions.cpp b/tests/std/expr/expr.compound/expr.eq/p4.6-member-functions.cpp new file mode 100644 index 0000000000..6909410459 --- /dev/null +++ b/tests/std/expr/expr.compound/expr.eq/p4.6-member-functions.cpp @@ -0,0 +1,22 @@ +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +// N4950 [expr.eq]/4.6: two pointers to members compare equal if they would +// refer to the same member of the same most derived object, otherwise they +// compare unequal. +#include + +struct HasTwoMemberFunctions { + void first() {} + void second() {} +}; + +int main() { + void (HasTwoMemberFunctions::*first_pmf)() = &HasTwoMemberFunctions::first; + void (HasTwoMemberFunctions::*also_first_pmf)() = + &HasTwoMemberFunctions::first; + void (HasTwoMemberFunctions::*second_pmf)() = &HasTwoMemberFunctions::second; + assert(first_pmf == also_first_pmf); + assert(!(first_pmf != also_first_pmf)); + assert(first_pmf != second_pmf); + assert(!(first_pmf == second_pmf)); + return 0; +} diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/p2-object-of-derived-class.cpp b/tests/std/expr/expr.compound/expr.mptr.oper/p2-object-of-derived-class.cpp new file mode 100644 index 0000000000..9edaab778a --- /dev/null +++ b/tests/std/expr/expr.compound/expr.mptr.oper/p2-object-of-derived-class.cpp @@ -0,0 +1,30 @@ +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +// N4950 [expr.mptr.oper]/2: .* binds a "pointer to member of T" to a glvalue +// of class T or of a class of which T is an unambiguous and accessible base. +#include + +struct Precedes { + int preceding; +}; + +struct DeclaresValue { + int value; +}; + +struct InheritsValue : Precedes, DeclaresValue { + int own; +}; + +int main() { + int DeclaresValue::*pm = &DeclaresValue::value; + InheritsValue obj; + obj.preceding = 1; + obj.value = 2; + obj.own = 3; + assert(obj.*pm == 2); + obj.*pm = 4; + assert(obj.value == 4); + assert(obj.preceding == 1); + assert(obj.own == 3); + return 0; +} diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/p3-arrow-star-pointer-to-derived-class.cpp b/tests/std/expr/expr.compound/expr.mptr.oper/p3-arrow-star-pointer-to-derived-class.cpp new file mode 100644 index 0000000000..0e415dd22e --- /dev/null +++ b/tests/std/expr/expr.compound/expr.mptr.oper/p3-arrow-star-pointer-to-derived-class.cpp @@ -0,0 +1,31 @@ +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +// N4950 [expr.mptr.oper]/3: the first operand of ->* is a "pointer to U" where +// U is T or a class of which T is an unambiguous and accessible base. +#include + +struct Precedes { + int preceding; +}; + +struct DeclaresValue { + int value; +}; + +struct InheritsValue : Precedes, DeclaresValue { + int own; +}; + +int main() { + int DeclaresValue::*pm = &DeclaresValue::value; + InheritsValue obj; + obj.preceding = 1; + obj.value = 2; + obj.own = 3; + InheritsValue *p = &obj; + assert(p->*pm == 2); + p->*pm = 4; + assert(obj.value == 4); + assert(obj.preceding == 1); + assert(obj.own == 3); + return 0; +} diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/p3-arrow-star.cpp b/tests/std/expr/expr.compound/expr.mptr.oper/p3-arrow-star.cpp new file mode 100644 index 0000000000..e144c9c8d6 --- /dev/null +++ b/tests/std/expr/expr.compound/expr.mptr.oper/p3-arrow-star.cpp @@ -0,0 +1,20 @@ +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +// N4950 [expr.mptr.oper]/3: E1->*E2 is converted into (*(E1)).*E2. +#include + +struct HasTwoInts { + int first; + int second; +}; + +int main() { + int HasTwoInts::*pm = &HasTwoInts::second; + HasTwoInts obj{3, 4}; + HasTwoInts *p = &obj; + assert(p->*pm == 4); + p->*pm = 5; + assert(obj.second == 5); + assert(obj.first == 3); + assert(&(p->*pm) == &((*p).*pm)); + return 0; +} diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/p4-dynamic-type-lacks-member.cpp b/tests/std/expr/expr.compound/expr.mptr.oper/p4-dynamic-type-lacks-member.cpp new file mode 100644 index 0000000000..35207e7da2 --- /dev/null +++ b/tests/std/expr/expr.compound/expr.mptr.oper/p4-dynamic-type-lacks-member.cpp @@ -0,0 +1,19 @@ +// panic-ub: refcount +// nondet-result: unsafe +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +// N4950 [expr.mptr.oper]/4: the behavior is undefined if the most derived +// object of E1 does not contain the member to which E2 refers. + +struct LacksValue { + int own; +}; + +struct AddsValue : LacksValue { + int value; +}; + +int main() { + int LacksValue::*pm = static_cast(&AddsValue::value); + LacksValue obj{1}; + return obj.*pm; +} diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/p4-object-expression-sequenced-first.cpp b/tests/std/expr/expr.compound/expr.mptr.oper/p4-object-expression-sequenced-first.cpp new file mode 100644 index 0000000000..70932c22c4 --- /dev/null +++ b/tests/std/expr/expr.compound/expr.mptr.oper/p4-object-expression-sequenced-first.cpp @@ -0,0 +1,29 @@ +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +// N4950 [expr.mptr.oper]/4: in E1.*E2, E1 is sequenced before E2. +#include + +struct HasValue { + int value; +}; + +static int sequence; +static int object_stamp; +static int member_stamp; +static HasValue object{7}; + +static HasValue &select_object() { + object_stamp = ++sequence; + return object; +} + +static int HasValue::*select_member() { + member_stamp = ++sequence; + return &HasValue::value; +} + +int main() { + assert(select_object().*select_member() == 7); + assert(object_stamp == 1); + assert(member_stamp == 2); + return 0; +} diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/p4-object-type-not-similar.cpp b/tests/std/expr/expr.compound/expr.mptr.oper/p4-object-type-not-similar.cpp new file mode 100644 index 0000000000..a5e9643f8b --- /dev/null +++ b/tests/std/expr/expr.compound/expr.mptr.oper/p4-object-type-not-similar.cpp @@ -0,0 +1,21 @@ +// panic-ub: refcount +// nondet-result: unsafe +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +// N4950 [expr.mptr.oper]/4: the behavior is undefined if the result of E1 is +// an object whose type is not similar to the type of E1. + +struct HasTwoInts { + int first; + int second; +}; + +struct HasTwoShorts { + short first; + short second; +}; + +int main() { + int HasTwoInts::*pm = &HasTwoInts::second; + HasTwoShorts obj{3, 4}; + return reinterpret_cast(obj).*pm; +} diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/p6-data-member-of-lvalue-is-lvalue.cpp b/tests/std/expr/expr.compound/expr.mptr.oper/p6-data-member-of-lvalue-is-lvalue.cpp new file mode 100644 index 0000000000..872f4f872d --- /dev/null +++ b/tests/std/expr/expr.compound/expr.mptr.oper/p6-data-member-of-lvalue-is-lvalue.cpp @@ -0,0 +1,20 @@ +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +// N4950 [expr.mptr.oper]/6: the result of .* with a pointer to data member is +// an lvalue if the first operand is an lvalue. +#include + +struct HasTwoInts { + int first; + int second; +}; + +int main() { + int HasTwoInts::*pm = &HasTwoInts::second; + HasTwoInts obj{3, 4}; + assert(&(obj.*pm) == &obj.second); + int &ref = obj.*pm; + ref = 5; + assert(obj.second == 5); + assert(obj.first == 3); + return 0; +} diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/p6-data-member-of-rvalue-is-xvalue.cpp b/tests/std/expr/expr.compound/expr.mptr.oper/p6-data-member-of-rvalue-is-xvalue.cpp new file mode 100644 index 0000000000..5f76b1b90f --- /dev/null +++ b/tests/std/expr/expr.compound/expr.mptr.oper/p6-data-member-of-rvalue-is-xvalue.cpp @@ -0,0 +1,30 @@ +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +// N4950 [expr.mptr.oper]/6: the result of .* with a pointer to data member is +// an lvalue if the first operand is an lvalue and an xvalue otherwise. +#include +#include + +struct CountsCopiesAndMoves { + static inline int copyCount = 0; + static inline int moveCount = 0; + + CountsCopiesAndMoves() = default; + CountsCopiesAndMoves(const CountsCopiesAndMoves &) { ++copyCount; } + CountsCopiesAndMoves(CountsCopiesAndMoves &&) { ++moveCount; } +}; + +struct HoldsCounted { + CountsCopiesAndMoves member; +}; + +int main() { + CountsCopiesAndMoves HoldsCounted::*pm = &HoldsCounted::member; + HoldsCounted holder; + CountsCopiesAndMoves from_lvalue = holder.*pm; + assert(CountsCopiesAndMoves::copyCount == 1); + assert(CountsCopiesAndMoves::moveCount == 0); + CountsCopiesAndMoves from_xvalue = std::move(holder).*pm; + assert(CountsCopiesAndMoves::copyCount == 1); + assert(CountsCopiesAndMoves::moveCount == 1); + return 0; +} diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/p6-member-function-call.cpp b/tests/std/expr/expr.compound/expr.mptr.oper/p6-member-function-call.cpp new file mode 100644 index 0000000000..901384b37b --- /dev/null +++ b/tests/std/expr/expr.compound/expr.mptr.oper/p6-member-function-call.cpp @@ -0,0 +1,26 @@ +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +// N4950 [expr.mptr.oper]/6: if the result of .* or ->* is a function, it can +// be used only as the operand of the function call operator (). +#include + +struct AccumulatesCalls { + int total = 0; + int add(int amount) { + total += amount; + return total; + } +}; + +int main() { + int (AccumulatesCalls::*pmf)(int) = &AccumulatesCalls::add; + AccumulatesCalls first; + AccumulatesCalls second; + assert((first.*pmf)(3) == 3); + assert(first.total == 3); + assert(second.total == 0); + AccumulatesCalls *p = &second; + assert((p->*pmf)(4) == 4); + assert(first.total == 3); + assert(second.total == 4); + return 0; +} diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/p6-null-pointer-to-data-member.cpp b/tests/std/expr/expr.compound/expr.mptr.oper/p6-null-pointer-to-data-member.cpp new file mode 100644 index 0000000000..0429af16ac --- /dev/null +++ b/tests/std/expr/expr.compound/expr.mptr.oper/p6-null-pointer-to-data-member.cpp @@ -0,0 +1,16 @@ +// panic-ub: refcount +// nondet-result: unsafe +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +// N4950 [expr.mptr.oper]/6: if the second operand is the null member pointer +// value, the behavior is undefined. + +struct HasTwoInts { + int first; + int second; +}; + +int main() { + int HasTwoInts::*pm = nullptr; + HasTwoInts obj{3, 4}; + return obj.*pm; +} diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/p6-null-pointer-to-member-function.cpp b/tests/std/expr/expr.compound/expr.mptr.oper/p6-null-pointer-to-member-function.cpp new file mode 100644 index 0000000000..6ba2e12147 --- /dev/null +++ b/tests/std/expr/expr.compound/expr.mptr.oper/p6-null-pointer-to-member-function.cpp @@ -0,0 +1,16 @@ +// panic-ub: refcount +// nondet-result: unsafe +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +// N4950 [expr.mptr.oper]/6: if the second operand is the null member pointer +// value, the behavior is undefined. + +struct HasMemberFunction { + int value; + int read() { return value; } +}; + +int main() { + int (HasMemberFunction::*pmf)() = nullptr; + HasMemberFunction obj{3}; + return (obj.*pmf)(); +} diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/p6-pointer-to-virtual-member-function.cpp b/tests/std/expr/expr.compound/expr.mptr.oper/p6-pointer-to-virtual-member-function.cpp new file mode 100644 index 0000000000..58432e220c --- /dev/null +++ b/tests/std/expr/expr.compound/expr.mptr.oper/p6-pointer-to-virtual-member-function.cpp @@ -0,0 +1,29 @@ +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +// N4950 [expr.mptr.oper]/6: if the result of .* or ->* is a function, it can +// be used only as the operand of the function call operator (). +#include + +static int base_calls; +static int override_calls; + +struct DeclaresVirtual { + virtual void run() { ++base_calls; } +}; + +struct OverridesVirtual : DeclaresVirtual { + void run() override { ++override_calls; } +}; + +int main() { + void (DeclaresVirtual::*pmf)() = &DeclaresVirtual::run; + DeclaresVirtual base; + OverridesVirtual overrider; + (base.*pmf)(); + assert(base_calls == 1); + assert(override_calls == 0); + DeclaresVirtual &ref = overrider; + (ref.*pmf)(); + assert(base_calls == 1); + assert(override_calls == 1); + return 0; +} diff --git a/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/p10-null-converts-to-null.cpp b/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/p10-null-converts-to-null.cpp new file mode 100644 index 0000000000..0e25e92190 --- /dev/null +++ b/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/p10-null-converts-to-null.cpp @@ -0,0 +1,20 @@ +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +// N4950 [expr.reinterpret.cast]/10: the null member pointer value is converted +// to the null member pointer value of the destination type. +#include + +struct HasTwoInts { + int first; + int second; +}; + +struct HasChar { + char character; +}; + +int main() { + int HasTwoInts::*pm = nullptr; + char HasChar::*converted = reinterpret_cast(pm); + assert(converted == nullptr); + return 0; +} diff --git a/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/p10-result-is-unspecified.cpp b/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/p10-result-is-unspecified.cpp new file mode 100644 index 0000000000..93a1076f81 --- /dev/null +++ b/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/p10-result-is-unspecified.cpp @@ -0,0 +1,20 @@ +// nondet-result +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +// N4950 [expr.reinterpret.cast]/10: the result of converting a pointer to +// member to a different pointer-to-member type is unspecified. + +struct HasTwoInts { + int first; + int second; +}; + +struct AlsoHasTwoInts { + int first; + int second; +}; + +int main() { + int AlsoHasTwoInts::*converted = + reinterpret_cast(&HasTwoInts::second); + return converted == &AlsoHasTwoInts::second; +} diff --git a/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/p10.1-member-function-round-trip.cpp b/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/p10.1-member-function-round-trip.cpp new file mode 100644 index 0000000000..52839d8668 --- /dev/null +++ b/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/p10.1-member-function-round-trip.cpp @@ -0,0 +1,24 @@ +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +// N4950 [expr.reinterpret.cast]/10.1: converting a pointer to member function +// to a different pointer-to-member-function type and back yields the original +// value. +#include + +struct CountsCalls { + int calls = 0; + void run() { ++calls; } +}; + +struct Unrelated {}; + +int main() { + void (Unrelated::*converted)(int) = + reinterpret_cast(&CountsCalls::run); + void (CountsCalls::*back)() = + reinterpret_cast(converted); + assert(back == &CountsCalls::run); + CountsCalls obj; + (obj.*back)(); + assert(obj.calls == 1); + return 0; +} diff --git a/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/p10.2-data-member-round-trip.cpp b/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/p10.2-data-member-round-trip.cpp new file mode 100644 index 0000000000..c81149f721 --- /dev/null +++ b/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/p10.2-data-member-round-trip.cpp @@ -0,0 +1,24 @@ +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +// N4950 [expr.reinterpret.cast]/10.2: converting "pointer to data member of X +// of type T1" to "pointer to data member of Y of type T2" (T2 no more strictly +// aligned than T1) and back yields the original value. +#include + +struct HasTwoInts { + int first; + int second; +}; + +struct HasChar { + char character; +}; + +int main() { + char HasChar::*converted = + reinterpret_cast(&HasTwoInts::second); + int HasTwoInts::*back = reinterpret_cast(converted); + assert(back == &HasTwoInts::second); + HasTwoInts obj{3, 4}; + assert(obj.*back == 4); + return 0; +} diff --git a/tests/std/expr/expr.compound/expr.post/expr.static.cast/p13-base-unrelated-to-member-class.cpp b/tests/std/expr/expr.compound/expr.post/expr.static.cast/p13-base-unrelated-to-member-class.cpp new file mode 100644 index 0000000000..2bc1b66214 --- /dev/null +++ b/tests/std/expr/expr.compound/expr.post/expr.static.cast/p13-base-unrelated-to-member-class.cpp @@ -0,0 +1,23 @@ +// panic-ub: refcount +// nondet-result: unsafe +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +// N4950 [expr.static.cast]/13: if class B neither contains the original member +// nor is a base or derived class of the class containing it, the behavior is +// undefined. + +struct DeclaresValue { + int value; +}; + +struct Unrelated { + int other; +}; + +struct InheritsBoth : DeclaresValue, Unrelated {}; + +int main() { + int InheritsBoth::*derived_pm = &DeclaresValue::value; + int Unrelated::*unrelated_pm = static_cast(derived_pm); + Unrelated obj{1}; + return obj.*unrelated_pm; +} diff --git a/tests/std/expr/expr.compound/expr.post/expr.static.cast/p13-derived-to-base-data-member.cpp b/tests/std/expr/expr.compound/expr.post/expr.static.cast/p13-derived-to-base-data-member.cpp new file mode 100644 index 0000000000..ade05418e9 --- /dev/null +++ b/tests/std/expr/expr.compound/expr.post/expr.static.cast/p13-derived-to-base-data-member.cpp @@ -0,0 +1,26 @@ +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +// N4950 [expr.static.cast]/13: "pointer to member of D of type T" can be +// converted to "pointer to member of B of type T", B a base class of D; the +// result points to the original member. +#include + +struct LacksValue { + int own; +}; + +struct AddsValue : LacksValue { + int value; +}; + +int main() { + int LacksValue::*pm = static_cast(&AddsValue::value); + AddsValue obj; + obj.own = 1; + obj.value = 2; + LacksValue &base = obj; + assert(base.*pm == 2); + base.*pm = 3; + assert(obj.value == 3); + assert(obj.own == 1); + return 0; +} diff --git a/tests/std/expr/expr.compound/expr.post/expr.static.cast/p13-derived-to-base-member-function.cpp b/tests/std/expr/expr.compound/expr.post/expr.static.cast/p13-derived-to-base-member-function.cpp new file mode 100644 index 0000000000..478215e05c --- /dev/null +++ b/tests/std/expr/expr.compound/expr.post/expr.static.cast/p13-derived-to-base-member-function.cpp @@ -0,0 +1,27 @@ +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +// N4950 [expr.static.cast]/13: "pointer to member of D of type T" can be +// converted to "pointer to member of B of type T", B a base class of D; the +// result points to the original member. +#include + +struct LacksIncrement { + int own; +}; + +struct AddsIncrement : LacksIncrement { + int value; + void increment() { ++value; } +}; + +int main() { + void (LacksIncrement::*pmf)() = + static_cast(&AddsIncrement::increment); + AddsIncrement obj; + obj.own = 1; + obj.value = 2; + LacksIncrement &base = obj; + (base.*pmf)(); + assert(obj.value == 3); + assert(obj.own == 1); + return 0; +} diff --git a/tests/std/expr/expr.compound/expr.post/expr.static.cast/p13-null-converts-to-null.cpp b/tests/std/expr/expr.compound/expr.post/expr.static.cast/p13-null-converts-to-null.cpp new file mode 100644 index 0000000000..2caaa83380 --- /dev/null +++ b/tests/std/expr/expr.compound/expr.post/expr.static.cast/p13-null-converts-to-null.cpp @@ -0,0 +1,21 @@ +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +// N4950 [expr.static.cast]/13: the null member pointer value is converted to +// the null member pointer value of the destination type. +#include + +struct Precedes { + int preceding; +}; + +struct DeclaresValue { + int value; +}; + +struct InheritsValue : Precedes, DeclaresValue {}; + +int main() { + int InheritsValue::*derived_pm = nullptr; + int DeclaresValue::*base_pm = static_cast(derived_pm); + assert(base_pm == nullptr); + return 0; +} diff --git a/tests/std/expr/expr.compound/expr.post/expr.static.cast/p13-round-trip-yields-original.cpp b/tests/std/expr/expr.compound/expr.post/expr.static.cast/p13-round-trip-yields-original.cpp new file mode 100644 index 0000000000..efbebca41f --- /dev/null +++ b/tests/std/expr/expr.compound/expr.post/expr.static.cast/p13-round-trip-yields-original.cpp @@ -0,0 +1,23 @@ +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +// N4950 [expr.static.cast]/13: if class B contains the original member, the +// resulting pointer to member points to the original member. +#include + +struct Precedes { + int preceding; +}; + +struct DeclaresValue { + int value; +}; + +struct InheritsValue : Precedes, DeclaresValue {}; + +int main() { + int InheritsValue::*derived_pm = &DeclaresValue::value; + int DeclaresValue::*base_pm = static_cast(derived_pm); + assert(base_pm == &DeclaresValue::value); + DeclaresValue obj{2}; + assert(obj.*base_pm == 2); + return 0; +} diff --git a/tests/std/expr/expr.compound/expr.unary/expr.unary.op/p3.1-anonymous-union-member.cpp b/tests/std/expr/expr.compound/expr.unary/expr.unary.op/p3.1-anonymous-union-member.cpp new file mode 100644 index 0000000000..5b7c95dab7 --- /dev/null +++ b/tests/std/expr/expr.compound/expr.unary/expr.unary.op/p3.1-anonymous-union-member.cpp @@ -0,0 +1,24 @@ +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +// N4950 [expr.unary.op]/3.1: a qualified-id naming a variant member of some +// class C yields a pointer to member of class C. +#include + +struct HasAnonymousUnion { + int before; + union { + int as_int; + unsigned as_unsigned; + }; +}; + +int main() { + int HasAnonymousUnion::*pm = &HasAnonymousUnion::as_int; + HasAnonymousUnion obj; + obj.before = 1; + obj.as_int = 2; + assert(obj.*pm == 2); + obj.*pm = 3; + assert(obj.as_int == 3); + assert(obj.before == 1); + return 0; +} diff --git a/tests/std/expr/expr.compound/expr.unary/expr.unary.op/p3.1-member-named-through-derived-class.cpp b/tests/std/expr/expr.compound/expr.unary/expr.unary.op/p3.1-member-named-through-derived-class.cpp new file mode 100644 index 0000000000..6f306dee27 --- /dev/null +++ b/tests/std/expr/expr.compound/expr.unary/expr.unary.op/p3.1-member-named-through-derived-class.cpp @@ -0,0 +1,22 @@ +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +// N4950 [expr.unary.op]/3.1: for a qualified-id naming a non-static member m +// of some class C, the result has type "pointer to member of class C" and +// designates C::m; C is the class m is a member of, not the class named. +#include + +struct DeclaresValue { + int value; +}; + +struct InheritsValue : DeclaresValue { + int own; +}; + +int main() { + auto pm = &InheritsValue::value; + DeclaresValue base{3}; + assert(base.*pm == 3); + InheritsValue derived{{4}, 5}; + assert(derived.*pm == 4); + return 0; +} diff --git a/tests/std/expr/expr.compound/expr.unary/expr.unary.op/p3.2-static-member-is-ordinary-pointer.cpp b/tests/std/expr/expr.compound/expr.unary/expr.unary.op/p3.2-static-member-is-ordinary-pointer.cpp new file mode 100644 index 0000000000..d8403050b0 --- /dev/null +++ b/tests/std/expr/expr.compound/expr.unary/expr.unary.op/p3.2-static-member-is-ordinary-pointer.cpp @@ -0,0 +1,22 @@ +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +// N4950 [expr.unary.op]/3.2: for an operand that is not a non-static member, +// the result has type "pointer to T" and points to the designated object or +// function; a static member is such an operand. +#include + +struct HasStaticMembers { + static inline int shared = 3; + static inline int calls = 0; + static void run() { ++calls; } +}; + +int main() { + int *object_pointer = &HasStaticMembers::shared; + assert(*object_pointer == 3); + *object_pointer = 4; + assert(HasStaticMembers::shared == 4); + void (*function_pointer)() = &HasStaticMembers::run; + function_pointer(); + assert(HasStaticMembers::calls == 1); + return 0; +} diff --git a/tests/std/expr/expr.compound/expr.unary/expr.unary.op/p4-parenthesized-qualified-id-is-object-pointer.cpp b/tests/std/expr/expr.compound/expr.unary/expr.unary.op/p4-parenthesized-qualified-id-is-object-pointer.cpp new file mode 100644 index 0000000000..2ecacf4cd3 --- /dev/null +++ b/tests/std/expr/expr.compound/expr.unary/expr.unary.op/p4-parenthesized-qualified-id-is-object-pointer.cpp @@ -0,0 +1,26 @@ +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +// N4950 [expr.unary.op]/4: a pointer to member is only formed when an explicit +// & is used and its operand is a qualified-id not enclosed in parentheses. +#include + +struct TakesAddressOfOwnMember { + int value; + int *parenthesized() { return &(TakesAddressOfOwnMember::value); } + int *unqualified() { return &value; } +}; + +int main() { + TakesAddressOfOwnMember first{3}; + TakesAddressOfOwnMember second{4}; + int *p = first.parenthesized(); + assert(p == &first.value); + *p = 5; + assert(first.value == 5); + assert(second.value == 4); + int *q = second.unqualified(); + assert(q == &second.value); + *q = 6; + assert(first.value == 5); + assert(second.value == 6); + return 0; +} diff --git a/tests/std/temp/temp.type/p2.6-pointer-to-member-argument.cpp b/tests/std/temp/temp.type/p2.6-pointer-to-member-argument.cpp new file mode 100644 index 0000000000..6c41ec8c6a --- /dev/null +++ b/tests/std/temp/temp.type/p2.6-pointer-to-member-argument.cpp @@ -0,0 +1,30 @@ +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +// N4950 [temp.type]/2.6: two values of pointer-to-member type are +// template-argument-equivalent if they refer to the same class member or are +// both the null member pointer value. +#include + +struct HasTwoInts { + int first; + int second; +}; + +template struct CountsPerMember { + static inline int count = 0; +}; + +int main() { + ++CountsPerMember<&HasTwoInts::first>::count; + assert(CountsPerMember<&HasTwoInts::first>::count == 1); + assert(CountsPerMember<&HasTwoInts::second>::count == 0); + assert(CountsPerMember::count == 0); + CountsPerMember<&HasTwoInts::second>::count += 2; + assert(CountsPerMember<&HasTwoInts::first>::count == 1); + assert(CountsPerMember<&HasTwoInts::second>::count == 2); + assert(CountsPerMember::count == 0); + CountsPerMember::count += 3; + assert(CountsPerMember<&HasTwoInts::first>::count == 1); + assert(CountsPerMember<&HasTwoInts::second>::count == 2); + assert(CountsPerMember::count == 3); + return 0; +} diff --git a/tests/std/utilities/function.objects/func.require/p1.1-member-function-with-object.cpp b/tests/std/utilities/function.objects/func.require/p1.1-member-function-with-object.cpp new file mode 100644 index 0000000000..5b923288f1 --- /dev/null +++ b/tests/std/utilities/function.objects/func.require/p1.1-member-function-with-object.cpp @@ -0,0 +1,27 @@ +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +// N4950 [func.require]/1.1: INVOKE(f, t1, t2) is (t1.*f)(t2) when f is a +// pointer to a member function of a class T and t1 is a T or derived from T. +#include +#include + +struct AccumulatesCalls { + int total = 0; + int add(int amount) { + total += amount; + return total; + } +}; + +struct InheritsAccumulator : AccumulatesCalls {}; + +int main() { + int (AccumulatesCalls::*pmf)(int) = &AccumulatesCalls::add; + AccumulatesCalls obj; + assert(std::invoke(pmf, obj, 3) == 3); + assert(obj.total == 3); + InheritsAccumulator derived; + assert(std::invoke(pmf, derived, 4) == 4); + assert(derived.total == 4); + assert(obj.total == 3); + return 0; +} diff --git a/tests/std/utilities/function.objects/func.require/p1.2-member-function-with-reference-wrapper.cpp b/tests/std/utilities/function.objects/func.require/p1.2-member-function-with-reference-wrapper.cpp new file mode 100644 index 0000000000..39b9998efa --- /dev/null +++ b/tests/std/utilities/function.objects/func.require/p1.2-member-function-with-reference-wrapper.cpp @@ -0,0 +1,23 @@ +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +// N4950 [func.require]/1.2: INVOKE(f, t1, t2) is (t1.get().*f)(t2) when f is a +// pointer to a member function and t1 is a reference_wrapper. +#include +#include + +struct AccumulatesCalls { + int total = 0; + int add(int amount) { + total += amount; + return total; + } +}; + +struct InheritsAccumulator : AccumulatesCalls {}; + +int main() { + int (AccumulatesCalls::*pmf)(int) = &AccumulatesCalls::add; + AccumulatesCalls obj; + assert(std::invoke(pmf, std::ref(obj), 3) == 3); + assert(obj.total == 3); + return 0; +} diff --git a/tests/std/utilities/function.objects/func.require/p1.3-member-function-with-pointer.cpp b/tests/std/utilities/function.objects/func.require/p1.3-member-function-with-pointer.cpp new file mode 100644 index 0000000000..593b7acc77 --- /dev/null +++ b/tests/std/utilities/function.objects/func.require/p1.3-member-function-with-pointer.cpp @@ -0,0 +1,23 @@ +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +// N4950 [func.require]/1.3: INVOKE(f, t1, t2) is ((*t1).*f)(t2) when f is a +// pointer to a member function and t1 is neither a T nor a reference_wrapper. +#include +#include + +struct AccumulatesCalls { + int total = 0; + int add(int amount) { + total += amount; + return total; + } +}; + +struct InheritsAccumulator : AccumulatesCalls {}; + +int main() { + int (AccumulatesCalls::*pmf)(int) = &AccumulatesCalls::add; + AccumulatesCalls obj; + assert(std::invoke(pmf, &obj, 3) == 3); + assert(obj.total == 3); + return 0; +} diff --git a/tests/std/utilities/function.objects/func.require/p1.4-data-member-with-object.cpp b/tests/std/utilities/function.objects/func.require/p1.4-data-member-with-object.cpp new file mode 100644 index 0000000000..0cd1dd5a59 --- /dev/null +++ b/tests/std/utilities/function.objects/func.require/p1.4-data-member-with-object.cpp @@ -0,0 +1,24 @@ +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +// N4950 [func.require]/1.4: INVOKE(f, t1) is t1.*f when f is a pointer to data +// member of a class T and t1 is a T or derived from T. +#include +#include + +struct HasTwoInts { + int first; + int second; +}; + +struct InheritsTwoInts : HasTwoInts {}; + +int main() { + int HasTwoInts::*pm = &HasTwoInts::second; + HasTwoInts obj{3, 4}; + assert(std::invoke(pm, obj) == 4); + std::invoke(pm, obj) = 5; + assert(obj.second == 5); + assert(obj.first == 3); + InheritsTwoInts derived{{6, 7}}; + assert(std::invoke(pm, derived) == 7); + return 0; +} diff --git a/tests/std/utilities/function.objects/func.require/p1.5-data-member-with-reference-wrapper.cpp b/tests/std/utilities/function.objects/func.require/p1.5-data-member-with-reference-wrapper.cpp new file mode 100644 index 0000000000..7ce2df28c1 --- /dev/null +++ b/tests/std/utilities/function.objects/func.require/p1.5-data-member-with-reference-wrapper.cpp @@ -0,0 +1,22 @@ +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +// N4950 [func.require]/1.5: INVOKE(f, t1) is t1.get().*f when f is a pointer +// to data member and t1 is a reference_wrapper. +#include +#include + +struct HasTwoInts { + int first; + int second; +}; + +struct InheritsTwoInts : HasTwoInts {}; + +int main() { + int HasTwoInts::*pm = &HasTwoInts::second; + HasTwoInts obj{3, 4}; + assert(std::invoke(pm, std::ref(obj)) == 4); + std::invoke(pm, std::ref(obj)) = 5; + assert(obj.second == 5); + assert(obj.first == 3); + return 0; +} diff --git a/tests/std/utilities/function.objects/func.require/p1.6-data-member-with-pointer.cpp b/tests/std/utilities/function.objects/func.require/p1.6-data-member-with-pointer.cpp new file mode 100644 index 0000000000..ab364b05c4 --- /dev/null +++ b/tests/std/utilities/function.objects/func.require/p1.6-data-member-with-pointer.cpp @@ -0,0 +1,22 @@ +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +// N4950 [func.require]/1.6: INVOKE(f, t1) is (*t1).*f when f is a pointer to +// data member and t1 is neither a T nor a reference_wrapper. +#include +#include + +struct HasTwoInts { + int first; + int second; +}; + +struct InheritsTwoInts : HasTwoInts {}; + +int main() { + int HasTwoInts::*pm = &HasTwoInts::second; + HasTwoInts obj{3, 4}; + assert(std::invoke(pm, &obj) == 4); + std::invoke(pm, &obj) = 5; + assert(obj.second == 5); + assert(obj.first == 3); + return 0; +} From d87f4a66ca4325f0f8bb53b461c03624cfb5df8a Mon Sep 17 00:00:00 2001 From: Lucian Popescu Date: Mon, 16 Nov 2026 13:24:44 +0000 Subject: [PATCH 02/15] Add tests about the layout of mptr --- ...ointer-to-data-member-bytes-round-trip.cpp | 30 ++++++++++++ ...er-to-member-function-bytes-round-trip.cpp | 34 +++++++++++++ ...rtual-member-function-bytes-round-trip.cpp | 33 +++++++++++++ ...lding-pointers-to-members-bytes-copied.cpp | 31 ++++++++++++ ...ta-member-bytes-copied-to-other-object.cpp | 25 ++++++++++ ...-function-bytes-copied-to-other-object.cpp | 29 +++++++++++ ...6.1-zero-initialized-pointer-to-member.cpp | 1 + .../p6-array-of-pointers-to-data-members.cpp | 30 ++++++++++++ ...-array-of-pointers-to-member-functions.cpp | 37 ++++++++++++++ .../dcl.mptr/p2-pointer-to-array-member.cpp | 1 + .../dcl.mptr/p2-pointer-to-data-member.cpp | 1 + .../p2-pointer-to-member-function.cpp | 1 + ...-pointer-to-member-of-incomplete-class.cpp | 1 + ...er-to-member-of-pointer-to-member-type.cpp | 1 + .../conv/conv.bool/p1-pointer-to-member.cpp | 1 + ...p1-pointer-to-noexcept-member-function.cpp | 1 + .../p1-null-distinct-from-first-member.cpp | 1 + .../p1-null-distinct-from-member-function.cpp | 1 + .../conv.mem/p1-null-values-compare-equal.cpp | 1 + .../p2-base-to-derived-data-member.cpp | 1 + .../p2-base-to-derived-member-function.cpp | 1 + .../conv.mem/p2-null-converts-to-null.cpp | 1 + ...7.4-base-and-derived-pointer-to-member.cpp | 1 + .../p7.4-pointer-to-member-and-null.cpp | 1 + .../expr.compound/expr.eq/p4.1-both-null.cpp | 1 + .../expr.compound/expr.eq/p4.2-one-null.cpp | 1 + ...4.3-pointer-to-virtual-member-function.cpp | 1 + .../p4.4-members-of-unrelated-classes.cpp | 1 + .../expr.eq/p4.5-members-of-same-union.cpp | 1 + .../p4.6-data-member-of-repeated-base.cpp | 1 + .../expr.eq/p4.6-data-members.cpp | 1 + .../p4.6-member-function-of-repeated-base.cpp | 1 + .../expr.eq/p4.6-member-functions.cpp | 1 + .../p2-object-of-derived-class.cpp | 1 + ...p3-arrow-star-pointer-to-derived-class.cpp | 1 + .../expr.mptr.oper/p3-arrow-star.cpp | 1 + .../p4-dynamic-type-lacks-member.cpp | 1 + .../p4-object-expression-sequenced-first.cpp | 1 + .../p4-object-type-not-similar.cpp | 1 + .../p6-data-member-of-lvalue-is-lvalue.cpp | 1 + .../p6-data-member-of-rvalue-is-xvalue.cpp | 1 + .../p6-member-function-call.cpp | 1 + .../p6-null-pointer-to-data-member.cpp | 1 + .../p6-null-pointer-to-member-function.cpp | 1 + .../p6-pointer-to-virtual-member-function.cpp | 1 + .../p10-null-converts-to-null.cpp | 1 + .../p10-result-is-unspecified.cpp | 1 + .../p10.1-member-function-round-trip.cpp | 1 + .../p10.2-data-member-round-trip.cpp | 1 + .../p13-base-unrelated-to-member-class.cpp | 1 + .../p13-derived-to-base-data-member.cpp | 1 + .../p13-derived-to-base-member-function.cpp | 1 + .../p13-null-converts-to-null.cpp | 1 + .../p13-round-trip-yields-original.cpp | 1 + .../p3.2-static-member-is-ordinary-pointer.rs | 40 ++++++++++++++++ ...thesized-qualified-id-is-object-pointer.rs | 48 +++++++++++++++++++ .../p3.2-static-member-is-ordinary-pointer.rs | 39 +++++++++++++++ ...thesized-qualified-id-is-object-pointer.rs | 43 +++++++++++++++++ .../p3.1-anonymous-union-member.cpp | 1 + ...3.1-member-named-through-derived-class.cpp | 1 + .../p2.6-pointer-to-member-argument.cpp | 1 + .../p1.1-member-function-with-object.cpp | 1 + ...member-function-with-reference-wrapper.cpp | 1 + .../p1.3-member-function-with-pointer.cpp | 1 + .../p1.4-data-member-with-object.cpp | 1 + ...1.5-data-member-with-reference-wrapper.cpp | 1 + .../p1.6-data-member-with-pointer.cpp | 1 + 67 files changed, 474 insertions(+) create mode 100644 tests/std/basic/basic.types/basic.types.general/p2-pointer-to-data-member-bytes-round-trip.cpp create mode 100644 tests/std/basic/basic.types/basic.types.general/p2-pointer-to-member-function-bytes-round-trip.cpp create mode 100644 tests/std/basic/basic.types/basic.types.general/p2-pointer-to-virtual-member-function-bytes-round-trip.cpp create mode 100644 tests/std/basic/basic.types/basic.types.general/p3-class-holding-pointers-to-members-bytes-copied.cpp create mode 100644 tests/std/basic/basic.types/basic.types.general/p3-pointer-to-data-member-bytes-copied-to-other-object.cpp create mode 100644 tests/std/basic/basic.types/basic.types.general/p3-pointer-to-member-function-bytes-copied-to-other-object.cpp create mode 100644 tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.array/p6-array-of-pointers-to-data-members.cpp create mode 100644 tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.array/p6-array-of-pointers-to-member-functions.cpp create mode 100644 tests/std/expr/expr.compound/expr.unary/expr.unary.op/out/refcount/p3.2-static-member-is-ordinary-pointer.rs create mode 100644 tests/std/expr/expr.compound/expr.unary/expr.unary.op/out/refcount/p4-parenthesized-qualified-id-is-object-pointer.rs create mode 100644 tests/std/expr/expr.compound/expr.unary/expr.unary.op/out/unsafe/p3.2-static-member-is-ordinary-pointer.rs create mode 100644 tests/std/expr/expr.compound/expr.unary/expr.unary.op/out/unsafe/p4-parenthesized-qualified-id-is-object-pointer.rs diff --git a/tests/std/basic/basic.types/basic.types.general/p2-pointer-to-data-member-bytes-round-trip.cpp b/tests/std/basic/basic.types/basic.types.general/p2-pointer-to-data-member-bytes-round-trip.cpp new file mode 100644 index 0000000000..661d5efa54 --- /dev/null +++ b/tests/std/basic/basic.types/basic.types.general/p2-pointer-to-data-member-bytes-round-trip.cpp @@ -0,0 +1,30 @@ +// translation-fail: refcount, unsafe +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +// N4950 [basic.types.general]/2: the underlying bytes of an object of +// trivially copyable type can be copied into an array of unsigned char; if +// they are copied back, the object holds its original value. +#include +#include + +struct HasTwoInts { + int first; + int second; +}; + +int main() { + int HasTwoInts::*pm = &HasTwoInts::second; + unsigned char bytes[sizeof(pm)]; + std::memcpy(bytes, &pm, sizeof(pm)); + pm = &HasTwoInts::first; + std::memcpy(&pm, bytes, sizeof(pm)); + assert(pm == &HasTwoInts::second); + HasTwoInts obj{3, 4}; + assert(obj.*pm == 4); + + int HasTwoInts::*null_pm = nullptr; + std::memcpy(bytes, &null_pm, sizeof(null_pm)); + null_pm = &HasTwoInts::first; + std::memcpy(&null_pm, bytes, sizeof(null_pm)); + assert(null_pm == nullptr); + return 0; +} diff --git a/tests/std/basic/basic.types/basic.types.general/p2-pointer-to-member-function-bytes-round-trip.cpp b/tests/std/basic/basic.types/basic.types.general/p2-pointer-to-member-function-bytes-round-trip.cpp new file mode 100644 index 0000000000..4ac7c9ae0a --- /dev/null +++ b/tests/std/basic/basic.types/basic.types.general/p2-pointer-to-member-function-bytes-round-trip.cpp @@ -0,0 +1,34 @@ +// translation-fail: refcount, unsafe +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +// N4950 [basic.types.general]/2: the underlying bytes of an object of +// trivially copyable type can be copied into an array of unsigned char; if +// they are copied back, the object holds its original value. +#include +#include + +struct HasTwoMemberFunctions { + int first_calls = 0; + int second_calls = 0; + void first() { ++first_calls; } + void second() { ++second_calls; } +}; + +int main() { + void (HasTwoMemberFunctions::*pmf)() = &HasTwoMemberFunctions::second; + unsigned char bytes[sizeof(pmf)]; + std::memcpy(bytes, &pmf, sizeof(pmf)); + pmf = &HasTwoMemberFunctions::first; + std::memcpy(&pmf, bytes, sizeof(pmf)); + assert(pmf == &HasTwoMemberFunctions::second); + HasTwoMemberFunctions obj; + (obj.*pmf)(); + assert(obj.first_calls == 0); + assert(obj.second_calls == 1); + + void (HasTwoMemberFunctions::*null_pmf)() = nullptr; + std::memcpy(bytes, &null_pmf, sizeof(null_pmf)); + null_pmf = &HasTwoMemberFunctions::first; + std::memcpy(&null_pmf, bytes, sizeof(null_pmf)); + assert(null_pmf == nullptr); + return 0; +} diff --git a/tests/std/basic/basic.types/basic.types.general/p2-pointer-to-virtual-member-function-bytes-round-trip.cpp b/tests/std/basic/basic.types/basic.types.general/p2-pointer-to-virtual-member-function-bytes-round-trip.cpp new file mode 100644 index 0000000000..56c4cfce3f --- /dev/null +++ b/tests/std/basic/basic.types/basic.types.general/p2-pointer-to-virtual-member-function-bytes-round-trip.cpp @@ -0,0 +1,33 @@ +// translation-fail: refcount, unsafe +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +// N4950 [basic.types.general]/2: the underlying bytes of an object of +// trivially copyable type can be copied into an array of unsigned char; if +// they are copied back, the object holds its original value. +#include +#include + +static int base_calls; +static int override_calls; + +struct DeclaresVirtual { + virtual void run() { ++base_calls; } + void other() {} +}; + +struct OverridesVirtual : DeclaresVirtual { + void run() override { ++override_calls; } +}; + +int main() { + void (DeclaresVirtual::*pmf)() = &DeclaresVirtual::run; + unsigned char bytes[sizeof(pmf)]; + std::memcpy(bytes, &pmf, sizeof(pmf)); + pmf = &DeclaresVirtual::other; + std::memcpy(&pmf, bytes, sizeof(pmf)); + OverridesVirtual overrider; + DeclaresVirtual &ref = overrider; + (ref.*pmf)(); + assert(base_calls == 0); + assert(override_calls == 1); + return 0; +} diff --git a/tests/std/basic/basic.types/basic.types.general/p3-class-holding-pointers-to-members-bytes-copied.cpp b/tests/std/basic/basic.types/basic.types.general/p3-class-holding-pointers-to-members-bytes-copied.cpp new file mode 100644 index 0000000000..9eacb358bb --- /dev/null +++ b/tests/std/basic/basic.types/basic.types.general/p3-class-holding-pointers-to-members-bytes-copied.cpp @@ -0,0 +1,31 @@ +// translation-fail: refcount, unsafe +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +// N4950 [basic.types.general]/3: if the underlying bytes of obj1 of trivially +// copyable type are copied into obj2, obj2 holds the same value as obj1. +#include +#include + +struct HasValueAndIncrement { + int padding; + int value; + void increment() { ++value; } +}; + +struct HoldsPointersToMembers { + int HasValueAndIncrement::*data; + void (HasValueAndIncrement::*function)(); +}; + +int main() { + HoldsPointersToMembers source{&HasValueAndIncrement::value, + &HasValueAndIncrement::increment}; + HoldsPointersToMembers destination{nullptr, nullptr}; + std::memcpy(&destination, &source, sizeof(source)); + assert(destination.data == &HasValueAndIncrement::value); + assert(destination.function == &HasValueAndIncrement::increment); + HasValueAndIncrement obj{1, 2}; + (obj.*destination.function)(); + assert(obj.*destination.data == 3); + assert(obj.padding == 1); + return 0; +} diff --git a/tests/std/basic/basic.types/basic.types.general/p3-pointer-to-data-member-bytes-copied-to-other-object.cpp b/tests/std/basic/basic.types/basic.types.general/p3-pointer-to-data-member-bytes-copied-to-other-object.cpp new file mode 100644 index 0000000000..5ac76334a6 --- /dev/null +++ b/tests/std/basic/basic.types/basic.types.general/p3-pointer-to-data-member-bytes-copied-to-other-object.cpp @@ -0,0 +1,25 @@ +// translation-fail: refcount, unsafe +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +// N4950 [basic.types.general]/3: if the underlying bytes of obj1 of trivially +// copyable type are copied into obj2, obj2 holds the same value as obj1. +#include +#include + +struct HasTwoInts { + int first; + int second; +}; + +int main() { + int HasTwoInts::*source = &HasTwoInts::second; + int HasTwoInts::*destination = &HasTwoInts::first; + std::memcpy(&destination, &source, sizeof(source)); + assert(destination == source); + HasTwoInts obj{3, 4}; + assert(obj.*destination == 4); + + int HasTwoInts::*null_source = nullptr; + std::memcpy(&destination, &null_source, sizeof(null_source)); + assert(destination == nullptr); + return 0; +} diff --git a/tests/std/basic/basic.types/basic.types.general/p3-pointer-to-member-function-bytes-copied-to-other-object.cpp b/tests/std/basic/basic.types/basic.types.general/p3-pointer-to-member-function-bytes-copied-to-other-object.cpp new file mode 100644 index 0000000000..3a87d53028 --- /dev/null +++ b/tests/std/basic/basic.types/basic.types.general/p3-pointer-to-member-function-bytes-copied-to-other-object.cpp @@ -0,0 +1,29 @@ +// translation-fail: refcount, unsafe +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +// N4950 [basic.types.general]/3: if the underlying bytes of obj1 of trivially +// copyable type are copied into obj2, obj2 holds the same value as obj1. +#include +#include + +struct HasTwoMemberFunctions { + int first_calls = 0; + int second_calls = 0; + void first() { ++first_calls; } + void second() { ++second_calls; } +}; + +int main() { + void (HasTwoMemberFunctions::*source)() = &HasTwoMemberFunctions::second; + void (HasTwoMemberFunctions::*destination)() = &HasTwoMemberFunctions::first; + std::memcpy(&destination, &source, sizeof(source)); + assert(destination == source); + HasTwoMemberFunctions obj; + (obj.*destination)(); + assert(obj.first_calls == 0); + assert(obj.second_calls == 1); + + void (HasTwoMemberFunctions::*null_source)() = nullptr; + std::memcpy(&destination, &null_source, sizeof(null_source)); + assert(destination == nullptr); + return 0; +} diff --git a/tests/std/dcl.dcl/dcl.decl/dcl.init/dcl.init.general/p6.1-zero-initialized-pointer-to-member.cpp b/tests/std/dcl.dcl/dcl.decl/dcl.init/dcl.init.general/p6.1-zero-initialized-pointer-to-member.cpp index 60ab37f3b2..0093c1e811 100644 --- a/tests/std/dcl.dcl/dcl.decl/dcl.init/dcl.init.general/p6.1-zero-initialized-pointer-to-member.cpp +++ b/tests/std/dcl.dcl/dcl.decl/dcl.init/dcl.init.general/p6.1-zero-initialized-pointer-to-member.cpp @@ -1,3 +1,4 @@ +// translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [dcl.init.general]/6.1: zero-initializing a scalar converts the // integer literal 0 to its type; for a pointer to member that is the null diff --git a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.array/p6-array-of-pointers-to-data-members.cpp b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.array/p6-array-of-pointers-to-data-members.cpp new file mode 100644 index 0000000000..ff57990f12 --- /dev/null +++ b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.array/p6-array-of-pointers-to-data-members.cpp @@ -0,0 +1,30 @@ +// translation-fail: refcount, unsafe +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +// N4950 [dcl.array]/6: an object of type "array of N U" consists of a +// contiguously allocated set of N subobjects of type U, numbered 0 to N-1. +#include + +struct HasThreeInts { + int first; + int second; + int third; +}; + +int main() { + int HasThreeInts::*members[3] = {&HasThreeInts::third, &HasThreeInts::first, + &HasThreeInts::second}; + HasThreeInts obj{4, 5, 6}; + assert(obj.*members[0] == 6); + assert(obj.*members[1] == 4); + assert(obj.*members[2] == 5); + int HasThreeInts::**element = members; + assert(element + 1 == &members[1]); + assert(obj.*element[1] == 4); + ++element; + ++element; + assert(element == &members[2]); + assert(obj.**element == 5); + members[2] = &HasThreeInts::third; + assert(obj.**element == 6); + return 0; +} diff --git a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.array/p6-array-of-pointers-to-member-functions.cpp b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.array/p6-array-of-pointers-to-member-functions.cpp new file mode 100644 index 0000000000..8bff99f21c --- /dev/null +++ b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.array/p6-array-of-pointers-to-member-functions.cpp @@ -0,0 +1,37 @@ +// translation-fail: refcount, unsafe +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +// N4950 [dcl.array]/6: an object of type "array of N U" consists of a +// contiguously allocated set of N subobjects of type U, numbered 0 to N-1. +#include + +struct HasThreeMemberFunctions { + int first_calls = 0; + int second_calls = 0; + int third_calls = 0; + void first() { ++first_calls; } + void second() { ++second_calls; } + void third() { ++third_calls; } +}; + +int main() { + void (HasThreeMemberFunctions::*functions[3])() = { + &HasThreeMemberFunctions::third, &HasThreeMemberFunctions::first, + &HasThreeMemberFunctions::second}; + HasThreeMemberFunctions obj; + (obj.*functions[0])(); + assert(obj.first_calls == 0); + assert(obj.second_calls == 0); + assert(obj.third_calls == 1); + void (HasThreeMemberFunctions::**element)() = functions; + ++element; + assert(element == &functions[1]); + (obj.**element)(); + assert(obj.first_calls == 1); + assert(obj.second_calls == 0); + assert(obj.third_calls == 1); + (obj.*element[1])(); + assert(obj.first_calls == 1); + assert(obj.second_calls == 1); + assert(obj.third_calls == 1); + return 0; +} diff --git a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/p2-pointer-to-array-member.cpp b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/p2-pointer-to-array-member.cpp index 6daf337c45..54084e3088 100644 --- a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/p2-pointer-to-array-member.cpp +++ b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/p2-pointer-to-array-member.cpp @@ -1,3 +1,4 @@ +// translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [dcl.mptr]/2: the type is "derived-declarator-type-list pointer to // member of class C of type T"; T can be an array type. diff --git a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/p2-pointer-to-data-member.cpp b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/p2-pointer-to-data-member.cpp index c4897bca79..65333f4b0e 100644 --- a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/p2-pointer-to-data-member.cpp +++ b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/p2-pointer-to-data-member.cpp @@ -1,3 +1,4 @@ +// translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [dcl.mptr]/2: "T C::*" declares a pointer to member of class C of // type T. diff --git a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/p2-pointer-to-member-function.cpp b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/p2-pointer-to-member-function.cpp index 49154b76b7..269b7512f4 100644 --- a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/p2-pointer-to-member-function.cpp +++ b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/p2-pointer-to-member-function.cpp @@ -1,3 +1,4 @@ +// translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [dcl.mptr]/2: "T (C::*)(parameters)" declares a pointer to member of // class C of function type. diff --git a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/p2-pointer-to-member-of-incomplete-class.cpp b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/p2-pointer-to-member-of-incomplete-class.cpp index 4f363a15db..2915aa9685 100644 --- a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/p2-pointer-to-member-of-incomplete-class.cpp +++ b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/p2-pointer-to-member-of-incomplete-class.cpp @@ -1,3 +1,4 @@ +// translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [dcl.mptr]/2: the nested-name-specifier denotes a class; the class // need not be complete. diff --git a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/p2-pointer-to-member-of-pointer-to-member-type.cpp b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/p2-pointer-to-member-of-pointer-to-member-type.cpp index 0106d49f10..2f84ce6260 100644 --- a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/p2-pointer-to-member-of-pointer-to-member-type.cpp +++ b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/p2-pointer-to-member-of-pointer-to-member-type.cpp @@ -1,3 +1,4 @@ +// translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [dcl.mptr]/2: the type is "derived-declarator-type-list pointer to // member of class C of type T"; T can itself be a pointer-to-member type. diff --git a/tests/std/expr/conv/conv.bool/p1-pointer-to-member.cpp b/tests/std/expr/conv/conv.bool/p1-pointer-to-member.cpp index 93b369542a..9c59757010 100644 --- a/tests/std/expr/conv/conv.bool/p1-pointer-to-member.cpp +++ b/tests/std/expr/conv/conv.bool/p1-pointer-to-member.cpp @@ -1,3 +1,4 @@ +// translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [conv.bool]/1: a prvalue of pointer-to-member type can be converted to // bool; the null member pointer value becomes false, any other value true. diff --git a/tests/std/expr/conv/conv.fctptr/p1-pointer-to-noexcept-member-function.cpp b/tests/std/expr/conv/conv.fctptr/p1-pointer-to-noexcept-member-function.cpp index fd8ba9ea2b..24af176fbc 100644 --- a/tests/std/expr/conv/conv.fctptr/p1-pointer-to-noexcept-member-function.cpp +++ b/tests/std/expr/conv/conv.fctptr/p1-pointer-to-noexcept-member-function.cpp @@ -1,3 +1,4 @@ +// translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [conv.fctptr]/1: "pointer to member of type noexcept function" // converts to "pointer to member of type function"; the result designates the diff --git a/tests/std/expr/conv/conv.mem/p1-null-distinct-from-first-member.cpp b/tests/std/expr/conv/conv.mem/p1-null-distinct-from-first-member.cpp index edddb4e6a4..ebe16af069 100644 --- a/tests/std/expr/conv/conv.mem/p1-null-distinct-from-first-member.cpp +++ b/tests/std/expr/conv/conv.mem/p1-null-distinct-from-first-member.cpp @@ -1,3 +1,4 @@ +// translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [conv.mem]/1: the null member pointer value is distinguishable from // any pointer to member not created from a null pointer constant. diff --git a/tests/std/expr/conv/conv.mem/p1-null-distinct-from-member-function.cpp b/tests/std/expr/conv/conv.mem/p1-null-distinct-from-member-function.cpp index 99ee32d94d..79e5b4f9f6 100644 --- a/tests/std/expr/conv/conv.mem/p1-null-distinct-from-member-function.cpp +++ b/tests/std/expr/conv/conv.mem/p1-null-distinct-from-member-function.cpp @@ -1,3 +1,4 @@ +// translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [conv.mem]/1: the null member pointer value is distinguishable from // any pointer to member not created from a null pointer constant. diff --git a/tests/std/expr/conv/conv.mem/p1-null-values-compare-equal.cpp b/tests/std/expr/conv/conv.mem/p1-null-values-compare-equal.cpp index 811950bc9c..fcd7a44087 100644 --- a/tests/std/expr/conv/conv.mem/p1-null-values-compare-equal.cpp +++ b/tests/std/expr/conv/conv.mem/p1-null-values-compare-equal.cpp @@ -1,3 +1,4 @@ +// translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [conv.mem]/1: a null pointer constant can be converted to a // pointer-to-member type; two null member pointer values of the same type diff --git a/tests/std/expr/conv/conv.mem/p2-base-to-derived-data-member.cpp b/tests/std/expr/conv/conv.mem/p2-base-to-derived-data-member.cpp index f863fcaa90..5321c9fb95 100644 --- a/tests/std/expr/conv/conv.mem/p2-base-to-derived-data-member.cpp +++ b/tests/std/expr/conv/conv.mem/p2-base-to-derived-data-member.cpp @@ -1,3 +1,4 @@ +// translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [conv.mem]/2: "pointer to member of B of type T" converts to "pointer // to member of D of type T"; the result refers to the member in D's instance diff --git a/tests/std/expr/conv/conv.mem/p2-base-to-derived-member-function.cpp b/tests/std/expr/conv/conv.mem/p2-base-to-derived-member-function.cpp index f21a89dfb0..1510592ab1 100644 --- a/tests/std/expr/conv/conv.mem/p2-base-to-derived-member-function.cpp +++ b/tests/std/expr/conv/conv.mem/p2-base-to-derived-member-function.cpp @@ -1,3 +1,4 @@ +// translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [conv.mem]/2: indirection through the converted pointer with a D // object is the same as indirecting through the pointer to member of B with diff --git a/tests/std/expr/conv/conv.mem/p2-null-converts-to-null.cpp b/tests/std/expr/conv/conv.mem/p2-null-converts-to-null.cpp index 565736406c..483e682adc 100644 --- a/tests/std/expr/conv/conv.mem/p2-null-converts-to-null.cpp +++ b/tests/std/expr/conv/conv.mem/p2-null-converts-to-null.cpp @@ -1,3 +1,4 @@ +// translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [conv.mem]/2: the null member pointer value is converted to the null // member pointer value of the destination type. diff --git a/tests/std/expr/expr.compound/expr.cond/p7.4-base-and-derived-pointer-to-member.cpp b/tests/std/expr/expr.compound/expr.cond/p7.4-base-and-derived-pointer-to-member.cpp index 6f1bbf66f5..9e83e57e18 100644 --- a/tests/std/expr/expr.compound/expr.cond/p7.4-base-and-derived-pointer-to-member.cpp +++ b/tests/std/expr/expr.compound/expr.cond/p7.4-base-and-derived-pointer-to-member.cpp @@ -1,3 +1,4 @@ +// translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [expr.cond]/7.4: if one or both of the second and third operands have // pointer-to-member type, pointer-to-member conversions bring them to their diff --git a/tests/std/expr/expr.compound/expr.cond/p7.4-pointer-to-member-and-null.cpp b/tests/std/expr/expr.compound/expr.cond/p7.4-pointer-to-member-and-null.cpp index 1df8833025..3e31fd06bc 100644 --- a/tests/std/expr/expr.compound/expr.cond/p7.4-pointer-to-member-and-null.cpp +++ b/tests/std/expr/expr.compound/expr.cond/p7.4-pointer-to-member-and-null.cpp @@ -1,3 +1,4 @@ +// translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [expr.cond]/7.4: if one or both of the second and third operands have // pointer-to-member type, they are brought to their composite pointer type. diff --git a/tests/std/expr/expr.compound/expr.eq/p4.1-both-null.cpp b/tests/std/expr/expr.compound/expr.eq/p4.1-both-null.cpp index 7de5adfd59..9465396fbf 100644 --- a/tests/std/expr/expr.compound/expr.eq/p4.1-both-null.cpp +++ b/tests/std/expr/expr.compound/expr.eq/p4.1-both-null.cpp @@ -1,3 +1,4 @@ +// translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [expr.eq]/4.1: two pointers to members that are both the null member // pointer value compare equal. diff --git a/tests/std/expr/expr.compound/expr.eq/p4.2-one-null.cpp b/tests/std/expr/expr.compound/expr.eq/p4.2-one-null.cpp index 77df4c4fe7..ee016fc500 100644 --- a/tests/std/expr/expr.compound/expr.eq/p4.2-one-null.cpp +++ b/tests/std/expr/expr.compound/expr.eq/p4.2-one-null.cpp @@ -1,3 +1,4 @@ +// translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [expr.eq]/4.2: if only one of two pointers to members is the null // member pointer value, they compare unequal. diff --git a/tests/std/expr/expr.compound/expr.eq/p4.3-pointer-to-virtual-member-function.cpp b/tests/std/expr/expr.compound/expr.eq/p4.3-pointer-to-virtual-member-function.cpp index d24cf3d078..c90d255878 100644 --- a/tests/std/expr/expr.compound/expr.eq/p4.3-pointer-to-virtual-member-function.cpp +++ b/tests/std/expr/expr.compound/expr.eq/p4.3-pointer-to-virtual-member-function.cpp @@ -1,3 +1,4 @@ +// translation-fail: refcount, unsafe // nondet-result // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [expr.eq]/4.3: if either operand is a pointer to a virtual member diff --git a/tests/std/expr/expr.compound/expr.eq/p4.4-members-of-unrelated-classes.cpp b/tests/std/expr/expr.compound/expr.eq/p4.4-members-of-unrelated-classes.cpp index 2aedde08cc..1b1c0e5aff 100644 --- a/tests/std/expr/expr.compound/expr.eq/p4.4-members-of-unrelated-classes.cpp +++ b/tests/std/expr/expr.compound/expr.eq/p4.4-members-of-unrelated-classes.cpp @@ -1,3 +1,4 @@ +// translation-fail: refcount, unsafe // nondet-result // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [expr.eq]/4.4: if one operand refers to a member of class C1 and the diff --git a/tests/std/expr/expr.compound/expr.eq/p4.5-members-of-same-union.cpp b/tests/std/expr/expr.compound/expr.eq/p4.5-members-of-same-union.cpp index e74fd2b756..b0756392ea 100644 --- a/tests/std/expr/expr.compound/expr.eq/p4.5-members-of-same-union.cpp +++ b/tests/std/expr/expr.compound/expr.eq/p4.5-members-of-same-union.cpp @@ -1,3 +1,4 @@ +// translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [expr.eq]/4.5: pointers to (possibly different) members of the same // union compare equal. diff --git a/tests/std/expr/expr.compound/expr.eq/p4.6-data-member-of-repeated-base.cpp b/tests/std/expr/expr.compound/expr.eq/p4.6-data-member-of-repeated-base.cpp index f893043335..b247410628 100644 --- a/tests/std/expr/expr.compound/expr.eq/p4.6-data-member-of-repeated-base.cpp +++ b/tests/std/expr/expr.compound/expr.eq/p4.6-data-member-of-repeated-base.cpp @@ -1,3 +1,4 @@ +// translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [expr.eq]/4.6: two pointers to members compare equal if they would // refer to the same member of the same subobject, otherwise they compare diff --git a/tests/std/expr/expr.compound/expr.eq/p4.6-data-members.cpp b/tests/std/expr/expr.compound/expr.eq/p4.6-data-members.cpp index f52c54b8a2..b4c875d0e4 100644 --- a/tests/std/expr/expr.compound/expr.eq/p4.6-data-members.cpp +++ b/tests/std/expr/expr.compound/expr.eq/p4.6-data-members.cpp @@ -1,3 +1,4 @@ +// translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [expr.eq]/4.6: two pointers to members compare equal if they would // refer to the same member of the same most derived object, otherwise they diff --git a/tests/std/expr/expr.compound/expr.eq/p4.6-member-function-of-repeated-base.cpp b/tests/std/expr/expr.compound/expr.eq/p4.6-member-function-of-repeated-base.cpp index 44a95c3880..6e74da2816 100644 --- a/tests/std/expr/expr.compound/expr.eq/p4.6-member-function-of-repeated-base.cpp +++ b/tests/std/expr/expr.compound/expr.eq/p4.6-member-function-of-repeated-base.cpp @@ -1,3 +1,4 @@ +// translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [expr.eq]/4.6: two pointers to members compare equal if they would // refer to the same member of the same subobject, otherwise they compare diff --git a/tests/std/expr/expr.compound/expr.eq/p4.6-member-functions.cpp b/tests/std/expr/expr.compound/expr.eq/p4.6-member-functions.cpp index 6909410459..21ecdfc3e2 100644 --- a/tests/std/expr/expr.compound/expr.eq/p4.6-member-functions.cpp +++ b/tests/std/expr/expr.compound/expr.eq/p4.6-member-functions.cpp @@ -1,3 +1,4 @@ +// translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [expr.eq]/4.6: two pointers to members compare equal if they would // refer to the same member of the same most derived object, otherwise they diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/p2-object-of-derived-class.cpp b/tests/std/expr/expr.compound/expr.mptr.oper/p2-object-of-derived-class.cpp index 9edaab778a..666c7eed70 100644 --- a/tests/std/expr/expr.compound/expr.mptr.oper/p2-object-of-derived-class.cpp +++ b/tests/std/expr/expr.compound/expr.mptr.oper/p2-object-of-derived-class.cpp @@ -1,3 +1,4 @@ +// translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [expr.mptr.oper]/2: .* binds a "pointer to member of T" to a glvalue // of class T or of a class of which T is an unambiguous and accessible base. diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/p3-arrow-star-pointer-to-derived-class.cpp b/tests/std/expr/expr.compound/expr.mptr.oper/p3-arrow-star-pointer-to-derived-class.cpp index 0e415dd22e..59342d8cbd 100644 --- a/tests/std/expr/expr.compound/expr.mptr.oper/p3-arrow-star-pointer-to-derived-class.cpp +++ b/tests/std/expr/expr.compound/expr.mptr.oper/p3-arrow-star-pointer-to-derived-class.cpp @@ -1,3 +1,4 @@ +// translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [expr.mptr.oper]/3: the first operand of ->* is a "pointer to U" where // U is T or a class of which T is an unambiguous and accessible base. diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/p3-arrow-star.cpp b/tests/std/expr/expr.compound/expr.mptr.oper/p3-arrow-star.cpp index e144c9c8d6..bba387eb05 100644 --- a/tests/std/expr/expr.compound/expr.mptr.oper/p3-arrow-star.cpp +++ b/tests/std/expr/expr.compound/expr.mptr.oper/p3-arrow-star.cpp @@ -1,3 +1,4 @@ +// translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [expr.mptr.oper]/3: E1->*E2 is converted into (*(E1)).*E2. #include diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/p4-dynamic-type-lacks-member.cpp b/tests/std/expr/expr.compound/expr.mptr.oper/p4-dynamic-type-lacks-member.cpp index 35207e7da2..829c7af5d2 100644 --- a/tests/std/expr/expr.compound/expr.mptr.oper/p4-dynamic-type-lacks-member.cpp +++ b/tests/std/expr/expr.compound/expr.mptr.oper/p4-dynamic-type-lacks-member.cpp @@ -1,3 +1,4 @@ +// translation-fail: refcount, unsafe // panic-ub: refcount // nondet-result: unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/p4-object-expression-sequenced-first.cpp b/tests/std/expr/expr.compound/expr.mptr.oper/p4-object-expression-sequenced-first.cpp index 70932c22c4..2ebf23b79b 100644 --- a/tests/std/expr/expr.compound/expr.mptr.oper/p4-object-expression-sequenced-first.cpp +++ b/tests/std/expr/expr.compound/expr.mptr.oper/p4-object-expression-sequenced-first.cpp @@ -1,3 +1,4 @@ +// translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [expr.mptr.oper]/4: in E1.*E2, E1 is sequenced before E2. #include diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/p4-object-type-not-similar.cpp b/tests/std/expr/expr.compound/expr.mptr.oper/p4-object-type-not-similar.cpp index a5e9643f8b..c3c974d676 100644 --- a/tests/std/expr/expr.compound/expr.mptr.oper/p4-object-type-not-similar.cpp +++ b/tests/std/expr/expr.compound/expr.mptr.oper/p4-object-type-not-similar.cpp @@ -1,3 +1,4 @@ +// translation-fail: refcount, unsafe // panic-ub: refcount // nondet-result: unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/p6-data-member-of-lvalue-is-lvalue.cpp b/tests/std/expr/expr.compound/expr.mptr.oper/p6-data-member-of-lvalue-is-lvalue.cpp index 872f4f872d..25d2a9a1b8 100644 --- a/tests/std/expr/expr.compound/expr.mptr.oper/p6-data-member-of-lvalue-is-lvalue.cpp +++ b/tests/std/expr/expr.compound/expr.mptr.oper/p6-data-member-of-lvalue-is-lvalue.cpp @@ -1,3 +1,4 @@ +// translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [expr.mptr.oper]/6: the result of .* with a pointer to data member is // an lvalue if the first operand is an lvalue. diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/p6-data-member-of-rvalue-is-xvalue.cpp b/tests/std/expr/expr.compound/expr.mptr.oper/p6-data-member-of-rvalue-is-xvalue.cpp index 5f76b1b90f..9cf2d636d5 100644 --- a/tests/std/expr/expr.compound/expr.mptr.oper/p6-data-member-of-rvalue-is-xvalue.cpp +++ b/tests/std/expr/expr.compound/expr.mptr.oper/p6-data-member-of-rvalue-is-xvalue.cpp @@ -1,3 +1,4 @@ +// translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [expr.mptr.oper]/6: the result of .* with a pointer to data member is // an lvalue if the first operand is an lvalue and an xvalue otherwise. diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/p6-member-function-call.cpp b/tests/std/expr/expr.compound/expr.mptr.oper/p6-member-function-call.cpp index 901384b37b..bbb1fa9239 100644 --- a/tests/std/expr/expr.compound/expr.mptr.oper/p6-member-function-call.cpp +++ b/tests/std/expr/expr.compound/expr.mptr.oper/p6-member-function-call.cpp @@ -1,3 +1,4 @@ +// translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [expr.mptr.oper]/6: if the result of .* or ->* is a function, it can // be used only as the operand of the function call operator (). diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/p6-null-pointer-to-data-member.cpp b/tests/std/expr/expr.compound/expr.mptr.oper/p6-null-pointer-to-data-member.cpp index 0429af16ac..6fb2193672 100644 --- a/tests/std/expr/expr.compound/expr.mptr.oper/p6-null-pointer-to-data-member.cpp +++ b/tests/std/expr/expr.compound/expr.mptr.oper/p6-null-pointer-to-data-member.cpp @@ -1,3 +1,4 @@ +// translation-fail: refcount, unsafe // panic-ub: refcount // nondet-result: unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/p6-null-pointer-to-member-function.cpp b/tests/std/expr/expr.compound/expr.mptr.oper/p6-null-pointer-to-member-function.cpp index 6ba2e12147..c1499582d1 100644 --- a/tests/std/expr/expr.compound/expr.mptr.oper/p6-null-pointer-to-member-function.cpp +++ b/tests/std/expr/expr.compound/expr.mptr.oper/p6-null-pointer-to-member-function.cpp @@ -1,3 +1,4 @@ +// translation-fail: refcount, unsafe // panic-ub: refcount // nondet-result: unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/p6-pointer-to-virtual-member-function.cpp b/tests/std/expr/expr.compound/expr.mptr.oper/p6-pointer-to-virtual-member-function.cpp index 58432e220c..a51b7d955d 100644 --- a/tests/std/expr/expr.compound/expr.mptr.oper/p6-pointer-to-virtual-member-function.cpp +++ b/tests/std/expr/expr.compound/expr.mptr.oper/p6-pointer-to-virtual-member-function.cpp @@ -1,3 +1,4 @@ +// translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [expr.mptr.oper]/6: if the result of .* or ->* is a function, it can // be used only as the operand of the function call operator (). diff --git a/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/p10-null-converts-to-null.cpp b/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/p10-null-converts-to-null.cpp index 0e25e92190..0569858cb6 100644 --- a/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/p10-null-converts-to-null.cpp +++ b/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/p10-null-converts-to-null.cpp @@ -1,3 +1,4 @@ +// translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [expr.reinterpret.cast]/10: the null member pointer value is converted // to the null member pointer value of the destination type. diff --git a/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/p10-result-is-unspecified.cpp b/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/p10-result-is-unspecified.cpp index 93a1076f81..f126bd9363 100644 --- a/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/p10-result-is-unspecified.cpp +++ b/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/p10-result-is-unspecified.cpp @@ -1,3 +1,4 @@ +// translation-fail: refcount, unsafe // nondet-result // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [expr.reinterpret.cast]/10: the result of converting a pointer to diff --git a/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/p10.1-member-function-round-trip.cpp b/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/p10.1-member-function-round-trip.cpp index 52839d8668..e447ac526b 100644 --- a/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/p10.1-member-function-round-trip.cpp +++ b/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/p10.1-member-function-round-trip.cpp @@ -1,3 +1,4 @@ +// translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [expr.reinterpret.cast]/10.1: converting a pointer to member function // to a different pointer-to-member-function type and back yields the original diff --git a/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/p10.2-data-member-round-trip.cpp b/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/p10.2-data-member-round-trip.cpp index c81149f721..d7302ed5b3 100644 --- a/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/p10.2-data-member-round-trip.cpp +++ b/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/p10.2-data-member-round-trip.cpp @@ -1,3 +1,4 @@ +// translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [expr.reinterpret.cast]/10.2: converting "pointer to data member of X // of type T1" to "pointer to data member of Y of type T2" (T2 no more strictly diff --git a/tests/std/expr/expr.compound/expr.post/expr.static.cast/p13-base-unrelated-to-member-class.cpp b/tests/std/expr/expr.compound/expr.post/expr.static.cast/p13-base-unrelated-to-member-class.cpp index 2bc1b66214..82905a108d 100644 --- a/tests/std/expr/expr.compound/expr.post/expr.static.cast/p13-base-unrelated-to-member-class.cpp +++ b/tests/std/expr/expr.compound/expr.post/expr.static.cast/p13-base-unrelated-to-member-class.cpp @@ -1,3 +1,4 @@ +// translation-fail: refcount, unsafe // panic-ub: refcount // nondet-result: unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 diff --git a/tests/std/expr/expr.compound/expr.post/expr.static.cast/p13-derived-to-base-data-member.cpp b/tests/std/expr/expr.compound/expr.post/expr.static.cast/p13-derived-to-base-data-member.cpp index ade05418e9..2cbd8303db 100644 --- a/tests/std/expr/expr.compound/expr.post/expr.static.cast/p13-derived-to-base-data-member.cpp +++ b/tests/std/expr/expr.compound/expr.post/expr.static.cast/p13-derived-to-base-data-member.cpp @@ -1,3 +1,4 @@ +// translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [expr.static.cast]/13: "pointer to member of D of type T" can be // converted to "pointer to member of B of type T", B a base class of D; the diff --git a/tests/std/expr/expr.compound/expr.post/expr.static.cast/p13-derived-to-base-member-function.cpp b/tests/std/expr/expr.compound/expr.post/expr.static.cast/p13-derived-to-base-member-function.cpp index 478215e05c..7a800b6c7a 100644 --- a/tests/std/expr/expr.compound/expr.post/expr.static.cast/p13-derived-to-base-member-function.cpp +++ b/tests/std/expr/expr.compound/expr.post/expr.static.cast/p13-derived-to-base-member-function.cpp @@ -1,3 +1,4 @@ +// translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [expr.static.cast]/13: "pointer to member of D of type T" can be // converted to "pointer to member of B of type T", B a base class of D; the diff --git a/tests/std/expr/expr.compound/expr.post/expr.static.cast/p13-null-converts-to-null.cpp b/tests/std/expr/expr.compound/expr.post/expr.static.cast/p13-null-converts-to-null.cpp index 2caaa83380..b39b04694a 100644 --- a/tests/std/expr/expr.compound/expr.post/expr.static.cast/p13-null-converts-to-null.cpp +++ b/tests/std/expr/expr.compound/expr.post/expr.static.cast/p13-null-converts-to-null.cpp @@ -1,3 +1,4 @@ +// translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [expr.static.cast]/13: the null member pointer value is converted to // the null member pointer value of the destination type. diff --git a/tests/std/expr/expr.compound/expr.post/expr.static.cast/p13-round-trip-yields-original.cpp b/tests/std/expr/expr.compound/expr.post/expr.static.cast/p13-round-trip-yields-original.cpp index efbebca41f..ab2be9d16f 100644 --- a/tests/std/expr/expr.compound/expr.post/expr.static.cast/p13-round-trip-yields-original.cpp +++ b/tests/std/expr/expr.compound/expr.post/expr.static.cast/p13-round-trip-yields-original.cpp @@ -1,3 +1,4 @@ +// translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [expr.static.cast]/13: if class B contains the original member, the // resulting pointer to member points to the original member. diff --git a/tests/std/expr/expr.compound/expr.unary/expr.unary.op/out/refcount/p3.2-static-member-is-ordinary-pointer.rs b/tests/std/expr/expr.compound/expr.unary/expr.unary.op/out/refcount/p3.2-static-member-is-ordinary-pointer.rs new file mode 100644 index 0000000000..c92f8a48e8 --- /dev/null +++ b/tests/std/expr/expr.compound/expr.unary/expr.unary.op/out/refcount/p3.2-static-member-is-ordinary-pointer.rs @@ -0,0 +1,40 @@ +extern crate libcc2rs; +use libcc2rs::*; +use std::cell::RefCell; +use std::collections::BTreeMap; +use std::io::prelude::*; +use std::io::{Read, Seek, Write}; +use std::os::fd::AsFd; +use std::rc::{Rc, Weak}; +thread_local!( + pub static shared_0: Value = Rc::new(RefCell::new(3)); +); +thread_local!( + pub static calls_1: Value = Rc::new(RefCell::new(0)); +); +#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] +#[byte_size(1)] +pub struct HasStaticMembers {} +impl HasStaticMembers { + pub fn run() { + (*calls_1.with(Value::clone).borrow_mut()).prefix_inc(); + } +} +pub fn main() { + __cpp2rust_init_globals(); + std::process::exit(main_0()); +} +fn main_0() -> i32 { + let mut object_pointer: Ptr = (shared_0.with(|v| v.as_pointer())); + assert!(((object_pointer.read()) == 3)); + object_pointer.write(4); + assert!((shared_0.with(|rc| *rc.borrow()) == 4)); + let mut function_pointer: FnPtr = (FnPtr::::new(HasStaticMembers::run)); + ({ function_pointer.call() }); + assert!((calls_1.with(|rc| *rc.borrow()) == 1)); + return 0; +} +pub fn __cpp2rust_init_globals() { + let _ = shared_0.with(|_| ()); + let _ = calls_1.with(|_| ()); +} diff --git a/tests/std/expr/expr.compound/expr.unary/expr.unary.op/out/refcount/p4-parenthesized-qualified-id-is-object-pointer.rs b/tests/std/expr/expr.compound/expr.unary/expr.unary.op/out/refcount/p4-parenthesized-qualified-id-is-object-pointer.rs new file mode 100644 index 0000000000..e776b36531 --- /dev/null +++ b/tests/std/expr/expr.compound/expr.unary/expr.unary.op/out/refcount/p4-parenthesized-qualified-id-is-object-pointer.rs @@ -0,0 +1,48 @@ +extern crate libcc2rs; +use libcc2rs::*; +use std::cell::RefCell; +use std::collections::BTreeMap; +use std::io::prelude::*; +use std::io::{Read, Seek, Write}; +use std::os::fd::AsFd; +use std::rc::{Rc, Weak}; +#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] +#[byte_size(4)] +pub struct TakesAddressOfOwnMember { + #[offset(0)] + pub value: i32, +} +pub fn main() { + __cpp2rust_init_globals(); + std::process::exit(main_0()); +} +fn main_0() -> i32 { + let first: Value = + Rc::new(RefCell::new(TakesAddressOfOwnMember { value: 3 })); + let second: Value = + Rc::new(RefCell::new(TakesAddressOfOwnMember { value: 4 })); + let mut p: Ptr = ({ TakesAddressOfOwnMemberImpl::parenthesized(&first.as_pointer()) }); + assert!(({ (p).clone() } == { (field_ptr!(first.as_pointer(), value)) })); + p.write(5); + assert!(({ ({ (*first.borrow()).value } == 5) })); + assert!(({ ({ (*second.borrow()).value } == 4) })); + let mut q: Ptr = ({ TakesAddressOfOwnMemberImpl::unqualified(&second.as_pointer()) }); + assert!(({ (q).clone() } == { (field_ptr!(second.as_pointer(), value)) })); + q.write(6); + assert!(({ ({ (*first.borrow()).value } == 5) })); + assert!(({ ({ (*second.borrow()).value } == 6) })); + return 0; +} +pub trait TakesAddressOfOwnMemberImpl { + fn parenthesized(&self) -> Ptr; + fn unqualified(&self) -> Ptr; +} +impl TakesAddressOfOwnMemberImpl for Ptr { + fn parenthesized(&self) -> Ptr { + return (field_ptr!((*self), value)); + } + fn unqualified(&self) -> Ptr { + return (field_ptr!((*self), value)); + } +} +pub fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/expr.compound/expr.unary/expr.unary.op/out/unsafe/p3.2-static-member-is-ordinary-pointer.rs b/tests/std/expr/expr.compound/expr.unary/expr.unary.op/out/unsafe/p3.2-static-member-is-ordinary-pointer.rs new file mode 100644 index 0000000000..83acaff04d --- /dev/null +++ b/tests/std/expr/expr.compound/expr.unary/expr.unary.op/out/unsafe/p3.2-static-member-is-ordinary-pointer.rs @@ -0,0 +1,39 @@ +extern crate libc; +use libc::*; +extern crate libcc2rs; +use libcc2rs::*; +use std::collections::BTreeMap; +use std::io::{Read, Seek, Write}; +use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; +use std::rc::Rc; +pub static mut shared_0: std::cell::LazyCell = std::cell::LazyCell::new(|| unsafe { 3 }); +pub static mut calls_1: std::cell::LazyCell = std::cell::LazyCell::new(|| unsafe { 0 }); +#[repr(C)] +#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] +pub struct HasStaticMembers {} +impl HasStaticMembers { + pub unsafe fn run() { + (*std::cell::LazyCell::force_mut(&mut *&raw mut calls_1)).prefix_inc(); + } +} +pub fn main() { + unsafe { + __cpp2rust_init_globals(); + std::process::exit(main_0() as i32); + } +} +unsafe fn main_0() -> i32 { + let mut object_pointer: *mut i32 = + (&raw mut (*std::cell::LazyCell::force_mut(&mut *&raw mut shared_0)) as *mut i32); + assert!(((*object_pointer) == (3))); + (*object_pointer) = 4; + assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut shared_0)) == (4))); + let mut function_pointer: Option = (Some(HasStaticMembers::run)); + (unsafe { (function_pointer).unwrap()() }); + assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut calls_1)) == (1))); + return 0; +} +pub unsafe fn __cpp2rust_init_globals() { + std::cell::LazyCell::force(&*&raw const shared_0); + std::cell::LazyCell::force(&*&raw const calls_1); +} diff --git a/tests/std/expr/expr.compound/expr.unary/expr.unary.op/out/unsafe/p4-parenthesized-qualified-id-is-object-pointer.rs b/tests/std/expr/expr.compound/expr.unary/expr.unary.op/out/unsafe/p4-parenthesized-qualified-id-is-object-pointer.rs new file mode 100644 index 0000000000..455511d14d --- /dev/null +++ b/tests/std/expr/expr.compound/expr.unary/expr.unary.op/out/unsafe/p4-parenthesized-qualified-id-is-object-pointer.rs @@ -0,0 +1,43 @@ +extern crate libc; +use libc::*; +extern crate libcc2rs; +use libcc2rs::*; +use std::collections::BTreeMap; +use std::io::{Read, Seek, Write}; +use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; +use std::rc::Rc; +#[repr(C)] +#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] +pub struct TakesAddressOfOwnMember { + pub value: i32, +} +impl TakesAddressOfOwnMember { + pub unsafe fn parenthesized(&mut self) -> *mut i32 { + return (&mut (self.value) as *mut i32); + } + pub unsafe fn unqualified(&mut self) -> *mut i32 { + return (&mut self.value as *mut i32); + } +} +pub fn main() { + unsafe { + __cpp2rust_init_globals(); + std::process::exit(main_0() as i32); + } +} +unsafe fn main_0() -> i32 { + let mut first: TakesAddressOfOwnMember = TakesAddressOfOwnMember { value: 3 }; + let mut second: TakesAddressOfOwnMember = TakesAddressOfOwnMember { value: 4 }; + let mut p: *mut i32 = (unsafe { TakesAddressOfOwnMember::parenthesized(&mut first) }); + assert!(((p) == (&mut first.value as *mut i32))); + (*p) = 5; + assert!(((first.value) == (5))); + assert!(((second.value) == (4))); + let mut q: *mut i32 = (unsafe { TakesAddressOfOwnMember::unqualified(&mut second) }); + assert!(((q) == (&mut second.value as *mut i32))); + (*q) = 6; + assert!(((first.value) == (5))); + assert!(((second.value) == (6))); + return 0; +} +pub unsafe fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/expr.compound/expr.unary/expr.unary.op/p3.1-anonymous-union-member.cpp b/tests/std/expr/expr.compound/expr.unary/expr.unary.op/p3.1-anonymous-union-member.cpp index 5b7c95dab7..a472196d4e 100644 --- a/tests/std/expr/expr.compound/expr.unary/expr.unary.op/p3.1-anonymous-union-member.cpp +++ b/tests/std/expr/expr.compound/expr.unary/expr.unary.op/p3.1-anonymous-union-member.cpp @@ -1,3 +1,4 @@ +// translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [expr.unary.op]/3.1: a qualified-id naming a variant member of some // class C yields a pointer to member of class C. diff --git a/tests/std/expr/expr.compound/expr.unary/expr.unary.op/p3.1-member-named-through-derived-class.cpp b/tests/std/expr/expr.compound/expr.unary/expr.unary.op/p3.1-member-named-through-derived-class.cpp index 6f306dee27..4ce1eb21f5 100644 --- a/tests/std/expr/expr.compound/expr.unary/expr.unary.op/p3.1-member-named-through-derived-class.cpp +++ b/tests/std/expr/expr.compound/expr.unary/expr.unary.op/p3.1-member-named-through-derived-class.cpp @@ -1,3 +1,4 @@ +// translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [expr.unary.op]/3.1: for a qualified-id naming a non-static member m // of some class C, the result has type "pointer to member of class C" and diff --git a/tests/std/temp/temp.type/p2.6-pointer-to-member-argument.cpp b/tests/std/temp/temp.type/p2.6-pointer-to-member-argument.cpp index 6c41ec8c6a..c691c1c862 100644 --- a/tests/std/temp/temp.type/p2.6-pointer-to-member-argument.cpp +++ b/tests/std/temp/temp.type/p2.6-pointer-to-member-argument.cpp @@ -1,3 +1,4 @@ +// translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [temp.type]/2.6: two values of pointer-to-member type are // template-argument-equivalent if they refer to the same class member or are diff --git a/tests/std/utilities/function.objects/func.require/p1.1-member-function-with-object.cpp b/tests/std/utilities/function.objects/func.require/p1.1-member-function-with-object.cpp index 5b923288f1..b98bc12117 100644 --- a/tests/std/utilities/function.objects/func.require/p1.1-member-function-with-object.cpp +++ b/tests/std/utilities/function.objects/func.require/p1.1-member-function-with-object.cpp @@ -1,3 +1,4 @@ +// translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [func.require]/1.1: INVOKE(f, t1, t2) is (t1.*f)(t2) when f is a // pointer to a member function of a class T and t1 is a T or derived from T. diff --git a/tests/std/utilities/function.objects/func.require/p1.2-member-function-with-reference-wrapper.cpp b/tests/std/utilities/function.objects/func.require/p1.2-member-function-with-reference-wrapper.cpp index 39b9998efa..da4476fe46 100644 --- a/tests/std/utilities/function.objects/func.require/p1.2-member-function-with-reference-wrapper.cpp +++ b/tests/std/utilities/function.objects/func.require/p1.2-member-function-with-reference-wrapper.cpp @@ -1,3 +1,4 @@ +// translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [func.require]/1.2: INVOKE(f, t1, t2) is (t1.get().*f)(t2) when f is a // pointer to a member function and t1 is a reference_wrapper. diff --git a/tests/std/utilities/function.objects/func.require/p1.3-member-function-with-pointer.cpp b/tests/std/utilities/function.objects/func.require/p1.3-member-function-with-pointer.cpp index 593b7acc77..548ecb86f2 100644 --- a/tests/std/utilities/function.objects/func.require/p1.3-member-function-with-pointer.cpp +++ b/tests/std/utilities/function.objects/func.require/p1.3-member-function-with-pointer.cpp @@ -1,3 +1,4 @@ +// translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [func.require]/1.3: INVOKE(f, t1, t2) is ((*t1).*f)(t2) when f is a // pointer to a member function and t1 is neither a T nor a reference_wrapper. diff --git a/tests/std/utilities/function.objects/func.require/p1.4-data-member-with-object.cpp b/tests/std/utilities/function.objects/func.require/p1.4-data-member-with-object.cpp index 0cd1dd5a59..1185ea172c 100644 --- a/tests/std/utilities/function.objects/func.require/p1.4-data-member-with-object.cpp +++ b/tests/std/utilities/function.objects/func.require/p1.4-data-member-with-object.cpp @@ -1,3 +1,4 @@ +// translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [func.require]/1.4: INVOKE(f, t1) is t1.*f when f is a pointer to data // member of a class T and t1 is a T or derived from T. diff --git a/tests/std/utilities/function.objects/func.require/p1.5-data-member-with-reference-wrapper.cpp b/tests/std/utilities/function.objects/func.require/p1.5-data-member-with-reference-wrapper.cpp index 7ce2df28c1..bf8b0f60d0 100644 --- a/tests/std/utilities/function.objects/func.require/p1.5-data-member-with-reference-wrapper.cpp +++ b/tests/std/utilities/function.objects/func.require/p1.5-data-member-with-reference-wrapper.cpp @@ -1,3 +1,4 @@ +// translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [func.require]/1.5: INVOKE(f, t1) is t1.get().*f when f is a pointer // to data member and t1 is a reference_wrapper. diff --git a/tests/std/utilities/function.objects/func.require/p1.6-data-member-with-pointer.cpp b/tests/std/utilities/function.objects/func.require/p1.6-data-member-with-pointer.cpp index ab364b05c4..ef9111380e 100644 --- a/tests/std/utilities/function.objects/func.require/p1.6-data-member-with-pointer.cpp +++ b/tests/std/utilities/function.objects/func.require/p1.6-data-member-with-pointer.cpp @@ -1,3 +1,4 @@ +// translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [func.require]/1.6: INVOKE(f, t1) is (*t1).*f when f is a pointer to // data member and t1 is neither a T nor a reference_wrapper. From f2e19f6d7a50d25b96a2c696392bdb6ce04a16fa Mon Sep 17 00:00:00 2001 From: Lucian Popescu Date: Mon, 16 Nov 2026 13:56:46 +0000 Subject: [PATCH 03/15] Update tests --- .../out/refcount/p3.5-pointer-to-member.rs | 69 ++++++++++++ .../out/unsafe/p3.5-pointer-to-member.rs | 66 ++++++++++++ .../basic.def.odr/p3.5-pointer-to-member.cpp | 1 - ...pointer-to-data-member-bytes-round-trip.rs | 63 +++++++++++ ...ata-member-bytes-copied-to-other-object.rs | 49 +++++++++ ...pointer-to-data-member-bytes-round-trip.rs | 102 ++++++++++++++++++ ...ata-member-bytes-copied-to-other-object.rs | 67 ++++++++++++ ...ointer-to-data-member-bytes-round-trip.cpp | 1 - ...ta-member-bytes-copied-to-other-object.cpp | 1 - ...p6.1-zero-initialized-pointer-to-member.rs | 45 ++++++++ ...p6.1-zero-initialized-pointer-to-member.rs | 57 ++++++++++ ...6.1-zero-initialized-pointer-to-member.cpp | 1 - .../p6-array-of-pointers-to-data-members.rs | 69 ++++++++++++ .../p6-array-of-pointers-to-data-members.rs | 61 +++++++++++ .../p6-array-of-pointers-to-data-members.cpp | 1 - .../refcount/p2-pointer-to-array-member.rs | 45 ++++++++ .../out/refcount/p2-pointer-to-data-member.rs | 38 +++++++ ...2-pointer-to-member-of-incomplete-class.rs | 42 ++++++++ ...ter-to-member-of-pointer-to-member-type.rs | 57 ++++++++++ .../out/unsafe/p2-pointer-to-array-member.rs | 38 +++++++ .../out/unsafe/p2-pointer-to-data-member.rs | 40 +++++++ ...2-pointer-to-member-of-incomplete-class.rs | 43 ++++++++ ...ter-to-member-of-pointer-to-member-type.rs | 50 +++++++++ .../dcl.mptr/p2-pointer-to-array-member.cpp | 1 - .../dcl.mptr/p2-pointer-to-data-member.cpp | 1 - ...-pointer-to-member-of-incomplete-class.cpp | 1 - ...er-to-member-of-pointer-to-member-type.cpp | 1 - .../p1-null-distinct-from-first-member.rs | 29 +++++ .../p1-null-distinct-from-first-member.rs | 32 ++++++ .../p1-null-distinct-from-first-member.cpp | 1 - .../p7.4-pointer-to-member-and-null.rs | 43 ++++++++ .../unsafe/p7.4-pointer-to-member-and-null.rs | 43 ++++++++ .../p7.4-pointer-to-member-and-null.cpp | 1 - .../expr.eq/out/refcount/p4.1-both-null.rs | 28 +++++ .../expr.eq/out/refcount/p4.2-one-null.rs | 30 ++++++ .../expr.eq/out/refcount/p4.6-data-members.rs | 31 ++++++ .../expr.eq/out/unsafe/p4.1-both-null.rs | 30 ++++++ .../expr.eq/out/unsafe/p4.2-one-null.rs | 32 ++++++ .../out/unsafe/p4.5-members-of-same-union.rs | 35 ++++++ .../expr.eq/out/unsafe/p4.6-data-members.rs | 34 ++++++ .../expr.compound/expr.eq/p4.1-both-null.cpp | 1 - .../expr.compound/expr.eq/p4.2-one-null.cpp | 1 - .../expr.eq/p4.5-members-of-same-union.cpp | 1 - .../expr.eq/p4.6-data-members.cpp | 1 - .../refcount/p2-object-of-derived-class.rs | 44 ++++++++ .../p3-arrow-star-pointer-to-derived-class.rs | 45 ++++++++ .../out/refcount/p3-arrow-star.rs | 35 ++++++ .../p4-object-expression-sequenced-first.rs | 57 ++++++++++ .../p6-data-member-of-lvalue-is-lvalue.rs | 34 ++++++ .../p6-data-member-of-rvalue-is-xvalue.rs | 70 ++++++++++++ .../p6-null-pointer-to-data-member.rs | 29 +++++ .../out/unsafe/p2-object-of-derived-class.rs | 44 ++++++++ .../p3-arrow-star-pointer-to-derived-class.rs | 45 ++++++++ .../out/unsafe/p3-arrow-star.rs | 39 +++++++ .../p4-object-expression-sequenced-first.rs | 48 +++++++++ .../out/unsafe/p4-object-type-not-similar.rs | 36 +++++++ .../p6-data-member-of-lvalue-is-lvalue.rs | 38 +++++++ .../p6-data-member-of-rvalue-is-xvalue.rs | 70 ++++++++++++ .../unsafe/p6-null-pointer-to-data-member.rs | 29 +++++ .../p2-object-of-derived-class.cpp | 2 +- ...p3-arrow-star-pointer-to-derived-class.cpp | 2 +- .../expr.mptr.oper/p3-arrow-star.cpp | 1 - .../p4-object-expression-sequenced-first.cpp | 1 - .../p4-object-type-not-similar.cpp | 1 - .../p6-data-member-of-lvalue-is-lvalue.cpp | 1 - .../p6-data-member-of-rvalue-is-xvalue.cpp | 1 - .../p6-null-pointer-to-data-member.cpp | 1 - .../out/unsafe/p10-null-converts-to-null.rs | 33 ++++++ .../out/unsafe/p10-result-is-unspecified.rs | 40 +++++++ .../unsafe/p10.2-data-member-round-trip.rs | 48 +++++++++ .../p10-null-converts-to-null.cpp | 1 - .../p10-result-is-unspecified.cpp | 1 - .../p10.2-data-member-round-trip.cpp | 1 - ...p3.1-member-named-through-derived-class.rs | 35 ++++++ ...p3.1-member-named-through-derived-class.rs | 36 +++++++ .../p3.1-anonymous-union-member.cpp | 1 - ...3.1-member-named-through-derived-class.cpp | 2 +- .../p2.6-pointer-to-member-argument.rs | 58 ++++++++++ .../unsafe/p2.6-pointer-to-member-argument.rs | 52 +++++++++ .../p2.6-pointer-to-member-argument.cpp | 1 - .../refcount/p1.4-data-member-with-object.rs | 39 +++++++ ...p1.5-data-member-with-reference-wrapper.rs | 49 +++++++++ .../refcount/p1.6-data-member-with-pointer.rs | 48 +++++++++ .../unsafe/p1.4-data-member-with-object.rs | 39 +++++++ ...p1.5-data-member-with-reference-wrapper.rs | 45 ++++++++ .../unsafe/p1.6-data-member-with-pointer.rs | 45 ++++++++ .../p1.4-data-member-with-object.cpp | 1 - ...1.5-data-member-with-reference-wrapper.cpp | 1 - .../p1.6-data-member-with-pointer.cpp | 1 - 89 files changed, 2601 insertions(+), 32 deletions(-) create mode 100644 tests/std/basic/basic.def.odr/out/refcount/p3.5-pointer-to-member.rs create mode 100644 tests/std/basic/basic.def.odr/out/unsafe/p3.5-pointer-to-member.rs create mode 100644 tests/std/basic/basic.types/basic.types.general/out/refcount/p2-pointer-to-data-member-bytes-round-trip.rs create mode 100644 tests/std/basic/basic.types/basic.types.general/out/refcount/p3-pointer-to-data-member-bytes-copied-to-other-object.rs create mode 100644 tests/std/basic/basic.types/basic.types.general/out/unsafe/p2-pointer-to-data-member-bytes-round-trip.rs create mode 100644 tests/std/basic/basic.types/basic.types.general/out/unsafe/p3-pointer-to-data-member-bytes-copied-to-other-object.rs create mode 100644 tests/std/dcl.dcl/dcl.decl/dcl.init/dcl.init.general/out/refcount/p6.1-zero-initialized-pointer-to-member.rs create mode 100644 tests/std/dcl.dcl/dcl.decl/dcl.init/dcl.init.general/out/unsafe/p6.1-zero-initialized-pointer-to-member.rs create mode 100644 tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.array/out/refcount/p6-array-of-pointers-to-data-members.rs create mode 100644 tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.array/out/unsafe/p6-array-of-pointers-to-data-members.rs create mode 100644 tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/refcount/p2-pointer-to-array-member.rs create mode 100644 tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/refcount/p2-pointer-to-data-member.rs create mode 100644 tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/refcount/p2-pointer-to-member-of-incomplete-class.rs create mode 100644 tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/refcount/p2-pointer-to-member-of-pointer-to-member-type.rs create mode 100644 tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/unsafe/p2-pointer-to-array-member.rs create mode 100644 tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/unsafe/p2-pointer-to-data-member.rs create mode 100644 tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/unsafe/p2-pointer-to-member-of-incomplete-class.rs create mode 100644 tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/unsafe/p2-pointer-to-member-of-pointer-to-member-type.rs create mode 100644 tests/std/expr/conv/conv.mem/out/refcount/p1-null-distinct-from-first-member.rs create mode 100644 tests/std/expr/conv/conv.mem/out/unsafe/p1-null-distinct-from-first-member.rs create mode 100644 tests/std/expr/expr.compound/expr.cond/out/refcount/p7.4-pointer-to-member-and-null.rs create mode 100644 tests/std/expr/expr.compound/expr.cond/out/unsafe/p7.4-pointer-to-member-and-null.rs create mode 100644 tests/std/expr/expr.compound/expr.eq/out/refcount/p4.1-both-null.rs create mode 100644 tests/std/expr/expr.compound/expr.eq/out/refcount/p4.2-one-null.rs create mode 100644 tests/std/expr/expr.compound/expr.eq/out/refcount/p4.6-data-members.rs create mode 100644 tests/std/expr/expr.compound/expr.eq/out/unsafe/p4.1-both-null.rs create mode 100644 tests/std/expr/expr.compound/expr.eq/out/unsafe/p4.2-one-null.rs create mode 100644 tests/std/expr/expr.compound/expr.eq/out/unsafe/p4.5-members-of-same-union.rs create mode 100644 tests/std/expr/expr.compound/expr.eq/out/unsafe/p4.6-data-members.rs create mode 100644 tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p2-object-of-derived-class.rs create mode 100644 tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p3-arrow-star-pointer-to-derived-class.rs create mode 100644 tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p3-arrow-star.rs create mode 100644 tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p4-object-expression-sequenced-first.rs create mode 100644 tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p6-data-member-of-lvalue-is-lvalue.rs create mode 100644 tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p6-data-member-of-rvalue-is-xvalue.rs create mode 100644 tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p6-null-pointer-to-data-member.rs create mode 100644 tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p2-object-of-derived-class.rs create mode 100644 tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p3-arrow-star-pointer-to-derived-class.rs create mode 100644 tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p3-arrow-star.rs create mode 100644 tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p4-object-expression-sequenced-first.rs create mode 100644 tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p4-object-type-not-similar.rs create mode 100644 tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p6-data-member-of-lvalue-is-lvalue.rs create mode 100644 tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p6-data-member-of-rvalue-is-xvalue.rs create mode 100644 tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p6-null-pointer-to-data-member.rs create mode 100644 tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/out/unsafe/p10-null-converts-to-null.rs create mode 100644 tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/out/unsafe/p10-result-is-unspecified.rs create mode 100644 tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/out/unsafe/p10.2-data-member-round-trip.rs create mode 100644 tests/std/expr/expr.compound/expr.unary/expr.unary.op/out/refcount/p3.1-member-named-through-derived-class.rs create mode 100644 tests/std/expr/expr.compound/expr.unary/expr.unary.op/out/unsafe/p3.1-member-named-through-derived-class.rs create mode 100644 tests/std/temp/temp.type/out/refcount/p2.6-pointer-to-member-argument.rs create mode 100644 tests/std/temp/temp.type/out/unsafe/p2.6-pointer-to-member-argument.rs create mode 100644 tests/std/utilities/function.objects/func.require/out/refcount/p1.4-data-member-with-object.rs create mode 100644 tests/std/utilities/function.objects/func.require/out/refcount/p1.5-data-member-with-reference-wrapper.rs create mode 100644 tests/std/utilities/function.objects/func.require/out/refcount/p1.6-data-member-with-pointer.rs create mode 100644 tests/std/utilities/function.objects/func.require/out/unsafe/p1.4-data-member-with-object.rs create mode 100644 tests/std/utilities/function.objects/func.require/out/unsafe/p1.5-data-member-with-reference-wrapper.rs create mode 100644 tests/std/utilities/function.objects/func.require/out/unsafe/p1.6-data-member-with-pointer.rs diff --git a/tests/std/basic/basic.def.odr/out/refcount/p3.5-pointer-to-member.rs b/tests/std/basic/basic.def.odr/out/refcount/p3.5-pointer-to-member.rs new file mode 100644 index 0000000000..b156bd0113 --- /dev/null +++ b/tests/std/basic/basic.def.odr/out/refcount/p3.5-pointer-to-member.rs @@ -0,0 +1,69 @@ +extern crate libcc2rs; +use libcc2rs::*; +use std::cell::RefCell; +use std::collections::BTreeMap; +use std::io::prelude::*; +use std::io::{Read, Seek, Write}; +use std::os::fd::AsFd; +use std::rc::{Rc, Weak}; +thread_local!( + pub static copyCount_0: Value = Rc::new(RefCell::new(0)); +); +#[derive(Record, ByteRepr, VaArg, FnPtrArg, CppFrom, CopyAssign, Default)] +#[cpp_from(i32, new, value)] +#[byte_size(4)] +pub struct HasConstexprCtor { + #[offset(0)] + pub m: i32, +} +impl HasConstexprCtor { + pub fn new(mut v: i32) -> Self { + Self { m: v } + } + pub fn copy_from(o: Ptr) -> Self { + let __this: HasConstexprCtor = Self { + m: o.with(|__s| __s.m), + }; + (*copyCount_0.with(Value::clone).borrow_mut()).prefix_inc(); + __this + } +} +impl Clone for HasConstexprCtor { + fn clone(&self) -> Self { + let __src: Value = + Rc::new(RefCell::new(HasConstexprCtor { m: self.m.clone() })); + HasConstexprCtor::copy_from(__src.as_pointer()) + } +} +pub fn main() { + __cpp2rust_init_globals(); + std::process::exit(main_0()); +} +fn main_0() -> i32 { + let k: Value = Rc::new(RefCell::new(HasConstexprCtor::new({ 5 }))); + let mut pm: MemberPtr = member_ptr!(HasConstexprCtor, m); + let f: Value i32>> = + Rc::new(RefCell::new(FnPtr:: i32>::new(|| -> i32 { + { + return ((HasConstexprCtor::new({ 5 })) + .member(member_ptr!(HasConstexprCtor, m)) + .read()); + } + }))); + assert!((copyCount_0.with(|rc| *rc.borrow()) == 0)); + assert!(({ (({ (*f.borrow()).call() }) == 5) })); + assert!((copyCount_0.with(|rc| *rc.borrow()) == 0)); + return 0; +} +pub trait HasConstexprCtorImpl { + fn copy_assign(&self, _a0: Ptr) -> Ptr; +} +impl HasConstexprCtorImpl for Ptr { + fn copy_assign(&self, _a0: Ptr) -> Ptr { + field!((*self), m).write({ _a0.with(|__s| __s.m) }); + return (*self).clone(); + } +} +pub fn __cpp2rust_init_globals() { + let _ = copyCount_0.with(|_| ()); +} diff --git a/tests/std/basic/basic.def.odr/out/unsafe/p3.5-pointer-to-member.rs b/tests/std/basic/basic.def.odr/out/unsafe/p3.5-pointer-to-member.rs new file mode 100644 index 0000000000..fbeaccc27a --- /dev/null +++ b/tests/std/basic/basic.def.odr/out/unsafe/p3.5-pointer-to-member.rs @@ -0,0 +1,66 @@ +extern crate libc; +use libc::*; +extern crate libcc2rs; +use libcc2rs::*; +use std::collections::BTreeMap; +use std::io::{Read, Seek, Write}; +use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; +use std::rc::Rc; +pub static mut copyCount_0: std::cell::LazyCell = std::cell::LazyCell::new(|| unsafe { 0 }); +#[repr(C)] +#[derive(VaArg, FnPtrArg, CppFromUnsafe, CopyAssignUnsafe, Default)] +#[cpp_from(i32, new, value)] +pub struct HasConstexprCtor { + pub m: i32, +} +impl HasConstexprCtor { + pub unsafe fn new(mut v: i32) -> Self { + let mut this = Self { m: v }; + this + } + pub unsafe fn copy_from(o: *const HasConstexprCtor) -> Self { + let mut this = Self { m: (*o).m }; + (*std::cell::LazyCell::force_mut(&mut *&raw mut copyCount_0)).prefix_inc(); + this + } + pub unsafe fn copy_assign(&mut self, _a0: *const HasConstexprCtor) -> *mut HasConstexprCtor { + self.m = (*_a0).m; + return &mut (*(self as *mut HasConstexprCtor)); + } +} +impl Clone for HasConstexprCtor { + fn clone(&self) -> Self { + unsafe { HasConstexprCtor::copy_from(self as *const HasConstexprCtor) } + } +} +pub fn main() { + unsafe { + __cpp2rust_init_globals(); + std::process::exit(main_0() as i32); + } +} +unsafe fn main_0() -> i32 { + let k: HasConstexprCtor = HasConstexprCtor::new({ 5 }); + let pm: MemberPtrUnsafe = + >::from_offset(::std::mem::offset_of!( + HasConstexprCtor, + m + )); + let mut f: FnPtr i32> = FnPtr:: i32>::new(|| -> i32 { + unsafe { + return (*(&HasConstexprCtor::new({ 5 }) as *const HasConstexprCtor).member( + >::from_offset(::std::mem::offset_of!( + HasConstexprCtor, + m + )), + )); + } + }); + assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut copyCount_0)) == (0))); + assert!(((unsafe { f.call() }) == (5))); + assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut copyCount_0)) == (0))); + return 0; +} +pub unsafe fn __cpp2rust_init_globals() { + std::cell::LazyCell::force(&*&raw const copyCount_0); +} diff --git a/tests/std/basic/basic.def.odr/p3.5-pointer-to-member.cpp b/tests/std/basic/basic.def.odr/p3.5-pointer-to-member.cpp index 35731e76c7..db4bc07e36 100644 --- a/tests/std/basic/basic.def.odr/p3.5-pointer-to-member.cpp +++ b/tests/std/basic/basic.def.odr/p3.5-pointer-to-member.cpp @@ -1,4 +1,3 @@ -// XFAIL: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [basic.def.odr]/3.5: the potential results of E1.*E2 are those of E1. // Reading k.*pm does not odr-use k, so [=] does not capture it. diff --git a/tests/std/basic/basic.types/basic.types.general/out/refcount/p2-pointer-to-data-member-bytes-round-trip.rs b/tests/std/basic/basic.types/basic.types.general/out/refcount/p2-pointer-to-data-member-bytes-round-trip.rs new file mode 100644 index 0000000000..bfb8cbe495 --- /dev/null +++ b/tests/std/basic/basic.types/basic.types.general/out/refcount/p2-pointer-to-data-member-bytes-round-trip.rs @@ -0,0 +1,63 @@ +extern crate libcc2rs; +use libcc2rs::*; +use std::cell::RefCell; +use std::collections::BTreeMap; +use std::io::prelude::*; +use std::io::{Read, Seek, Write}; +use std::os::fd::AsFd; +use std::rc::{Rc, Weak}; +#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] +#[byte_size(8)] +pub struct HasTwoInts { + #[offset(0)] + pub first: i32, + #[offset(4)] + pub second: i32, +} +pub fn main() { + __cpp2rust_init_globals(); + std::process::exit(main_0()); +} +fn main_0() -> i32 { + let pm: Value> = + Rc::new(RefCell::new(member_ptr!(HasTwoInts, second))); + let bytes: Value> = + Rc::new(RefCell::new((0..8).map(|_| 0_u8).collect::>())); + match ({ (bytes.decay()).to_any() },) { + (mut __tmp_0,) => { + __tmp_0.memcpy(&(pm.as_pointer()).to_any(), 8usize); + (__tmp_0).clone() + } + }; + (*pm.borrow_mut()) = member_ptr!(HasTwoInts, first); + match ({ (pm.as_pointer()).to_any() },) { + (mut __tmp_1,) => { + __tmp_1.memcpy(&(bytes.decay()).to_any(), 8usize); + (__tmp_1).clone() + } + }; + assert!(({ ((*pm.borrow()) == member_ptr!(HasTwoInts, second)) })); + let obj: Value = Rc::new(RefCell::new(HasTwoInts { + first: 3, + second: 4, + })); + assert!(({ (((obj.as_pointer()).member((*pm.borrow())).read()) == 4) })); + let null_pm: Value> = + Rc::new(RefCell::new(>::default())); + match ({ (bytes.decay()).to_any() },) { + (mut __tmp_2,) => { + __tmp_2.memcpy(&(null_pm.as_pointer()).to_any(), 8usize); + (__tmp_2).clone() + } + }; + (*null_pm.borrow_mut()) = member_ptr!(HasTwoInts, first); + match ({ (null_pm.as_pointer()).to_any() },) { + (mut __tmp_3,) => { + __tmp_3.memcpy(&(bytes.decay()).to_any(), 8usize); + (__tmp_3).clone() + } + }; + assert!(({ (*null_pm.borrow()).is_null() })); + return 0; +} +pub fn __cpp2rust_init_globals() {} diff --git a/tests/std/basic/basic.types/basic.types.general/out/refcount/p3-pointer-to-data-member-bytes-copied-to-other-object.rs b/tests/std/basic/basic.types/basic.types.general/out/refcount/p3-pointer-to-data-member-bytes-copied-to-other-object.rs new file mode 100644 index 0000000000..4626321138 --- /dev/null +++ b/tests/std/basic/basic.types/basic.types.general/out/refcount/p3-pointer-to-data-member-bytes-copied-to-other-object.rs @@ -0,0 +1,49 @@ +extern crate libcc2rs; +use libcc2rs::*; +use std::cell::RefCell; +use std::collections::BTreeMap; +use std::io::prelude::*; +use std::io::{Read, Seek, Write}; +use std::os::fd::AsFd; +use std::rc::{Rc, Weak}; +#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] +#[byte_size(8)] +pub struct HasTwoInts { + #[offset(0)] + pub first: i32, + #[offset(4)] + pub second: i32, +} +pub fn main() { + __cpp2rust_init_globals(); + std::process::exit(main_0()); +} +fn main_0() -> i32 { + let source: Value> = + Rc::new(RefCell::new(member_ptr!(HasTwoInts, second))); + let destination: Value> = + Rc::new(RefCell::new(member_ptr!(HasTwoInts, first))); + match ({ (destination.as_pointer()).to_any() },) { + (mut __tmp_0,) => { + __tmp_0.memcpy(&(source.as_pointer()).to_any(), 8usize); + (__tmp_0).clone() + } + }; + assert!(({ ((*destination.borrow()) == (*source.borrow())) })); + let obj: Value = Rc::new(RefCell::new(HasTwoInts { + first: 3, + second: 4, + })); + assert!(({ (((obj.as_pointer()).member((*destination.borrow())).read()) == 4) })); + let null_source: Value> = + Rc::new(RefCell::new(>::default())); + match ({ (destination.as_pointer()).to_any() },) { + (mut __tmp_1,) => { + __tmp_1.memcpy(&(null_source.as_pointer()).to_any(), 8usize); + (__tmp_1).clone() + } + }; + assert!(({ (*destination.borrow()).is_null() })); + return 0; +} +pub fn __cpp2rust_init_globals() {} diff --git a/tests/std/basic/basic.types/basic.types.general/out/unsafe/p2-pointer-to-data-member-bytes-round-trip.rs b/tests/std/basic/basic.types/basic.types.general/out/unsafe/p2-pointer-to-data-member-bytes-round-trip.rs new file mode 100644 index 0000000000..ecb5473b65 --- /dev/null +++ b/tests/std/basic/basic.types/basic.types.general/out/unsafe/p2-pointer-to-data-member-bytes-round-trip.rs @@ -0,0 +1,102 @@ +extern crate libc; +use libc::*; +extern crate libcc2rs; +use libcc2rs::*; +use std::collections::BTreeMap; +use std::io::{Read, Seek, Write}; +use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; +use std::rc::Rc; +#[repr(C)] +#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] +pub struct HasTwoInts { + pub first: i32, + pub second: i32, +} +pub fn main() { + unsafe { + __cpp2rust_init_globals(); + std::process::exit(main_0() as i32); + } +} +unsafe fn main_0() -> i32 { + let mut pm: MemberPtrUnsafe = + >::from_offset(::std::mem::offset_of!(HasTwoInts, second)); + let mut bytes: [u8; 8] = [0_u8; 8]; + match ({ (bytes.as_mut_ptr() as *mut ::libc::c_void) }, { + ((&mut pm as *mut MemberPtrUnsafe) as *const ::libc::c_void) + }) { + (mut __tmp_0, mut __tmp_1) => { + if ::std::mem::size_of::>() != 0 { + ::std::ptr::copy_nonoverlapping( + __tmp_1, + __tmp_0, + ::std::mem::size_of::>(), + ) + } + __tmp_0 + } + }; + pm = >::from_offset(::std::mem::offset_of!(HasTwoInts, first)); + match ( + { ((&mut pm as *mut MemberPtrUnsafe) as *mut ::libc::c_void) }, + { (bytes.as_mut_ptr() as *const ::libc::c_void) }, + ) { + (mut __tmp_2, mut __tmp_3) => { + if ::std::mem::size_of::>() != 0 { + ::std::ptr::copy_nonoverlapping( + __tmp_3, + __tmp_2, + ::std::mem::size_of::>(), + ) + } + __tmp_2 + } + }; + assert!( + ((pm) + == (>::from_offset(::std::mem::offset_of!( + HasTwoInts, second + )))) + ); + let mut obj: HasTwoInts = HasTwoInts { + first: 3, + second: 4, + }; + assert!(((*(&mut obj as *mut HasTwoInts).member(pm)) == (4))); + let mut null_pm: MemberPtrUnsafe = + >::default(); + match ({ (bytes.as_mut_ptr() as *mut ::libc::c_void) }, { + ((&mut null_pm as *mut MemberPtrUnsafe) as *const ::libc::c_void) + }) { + (mut __tmp_4, mut __tmp_5) => { + if ::std::mem::size_of::>() != 0 { + ::std::ptr::copy_nonoverlapping( + __tmp_5, + __tmp_4, + ::std::mem::size_of::>(), + ) + } + __tmp_4 + } + }; + null_pm = + >::from_offset(::std::mem::offset_of!(HasTwoInts, first)); + match ( + { ((&mut null_pm as *mut MemberPtrUnsafe) as *mut ::libc::c_void) }, + { (bytes.as_mut_ptr() as *const ::libc::c_void) }, + ) { + (mut __tmp_6, mut __tmp_7) => { + if ::std::mem::size_of::>() != 0 { + ::std::ptr::copy_nonoverlapping( + __tmp_7, + __tmp_6, + ::std::mem::size_of::>(), + ) + } + __tmp_6 + } + }; + assert!((null_pm).is_null()); + return 0; +} +pub unsafe fn __cpp2rust_init_globals() {} diff --git a/tests/std/basic/basic.types/basic.types.general/out/unsafe/p3-pointer-to-data-member-bytes-copied-to-other-object.rs b/tests/std/basic/basic.types/basic.types.general/out/unsafe/p3-pointer-to-data-member-bytes-copied-to-other-object.rs new file mode 100644 index 0000000000..aaf8f0ea69 --- /dev/null +++ b/tests/std/basic/basic.types/basic.types.general/out/unsafe/p3-pointer-to-data-member-bytes-copied-to-other-object.rs @@ -0,0 +1,67 @@ +extern crate libc; +use libc::*; +extern crate libcc2rs; +use libcc2rs::*; +use std::collections::BTreeMap; +use std::io::{Read, Seek, Write}; +use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; +use std::rc::Rc; +#[repr(C)] +#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] +pub struct HasTwoInts { + pub first: i32, + pub second: i32, +} +pub fn main() { + unsafe { + __cpp2rust_init_globals(); + std::process::exit(main_0() as i32); + } +} +unsafe fn main_0() -> i32 { + let mut source: MemberPtrUnsafe = + >::from_offset(::std::mem::offset_of!(HasTwoInts, second)); + let mut destination: MemberPtrUnsafe = + >::from_offset(::std::mem::offset_of!(HasTwoInts, first)); + match ( + { ((&mut destination as *mut MemberPtrUnsafe) as *mut ::libc::c_void) }, + { ((&mut source as *mut MemberPtrUnsafe) as *const ::libc::c_void) }, + ) { + (mut __tmp_0, mut __tmp_1) => { + if ::std::mem::size_of::>() != 0 { + ::std::ptr::copy_nonoverlapping( + __tmp_1, + __tmp_0, + ::std::mem::size_of::>(), + ) + } + __tmp_0 + } + }; + assert!(((destination) == (source))); + let mut obj: HasTwoInts = HasTwoInts { + first: 3, + second: 4, + }; + assert!(((*(&mut obj as *mut HasTwoInts).member(destination)) == (4))); + let mut null_source: MemberPtrUnsafe = + >::default(); + match ( + { ((&mut destination as *mut MemberPtrUnsafe) as *mut ::libc::c_void) }, + { ((&mut null_source as *mut MemberPtrUnsafe) as *const ::libc::c_void) }, + ) { + (mut __tmp_2, mut __tmp_3) => { + if ::std::mem::size_of::>() != 0 { + ::std::ptr::copy_nonoverlapping( + __tmp_3, + __tmp_2, + ::std::mem::size_of::>(), + ) + } + __tmp_2 + } + }; + assert!((destination).is_null()); + return 0; +} +pub unsafe fn __cpp2rust_init_globals() {} diff --git a/tests/std/basic/basic.types/basic.types.general/p2-pointer-to-data-member-bytes-round-trip.cpp b/tests/std/basic/basic.types/basic.types.general/p2-pointer-to-data-member-bytes-round-trip.cpp index 661d5efa54..4bf5c849ad 100644 --- a/tests/std/basic/basic.types/basic.types.general/p2-pointer-to-data-member-bytes-round-trip.cpp +++ b/tests/std/basic/basic.types/basic.types.general/p2-pointer-to-data-member-bytes-round-trip.cpp @@ -1,4 +1,3 @@ -// translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [basic.types.general]/2: the underlying bytes of an object of // trivially copyable type can be copied into an array of unsigned char; if diff --git a/tests/std/basic/basic.types/basic.types.general/p3-pointer-to-data-member-bytes-copied-to-other-object.cpp b/tests/std/basic/basic.types/basic.types.general/p3-pointer-to-data-member-bytes-copied-to-other-object.cpp index 5ac76334a6..4053e89f44 100644 --- a/tests/std/basic/basic.types/basic.types.general/p3-pointer-to-data-member-bytes-copied-to-other-object.cpp +++ b/tests/std/basic/basic.types/basic.types.general/p3-pointer-to-data-member-bytes-copied-to-other-object.cpp @@ -1,4 +1,3 @@ -// translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [basic.types.general]/3: if the underlying bytes of obj1 of trivially // copyable type are copied into obj2, obj2 holds the same value as obj1. diff --git a/tests/std/dcl.dcl/dcl.decl/dcl.init/dcl.init.general/out/refcount/p6.1-zero-initialized-pointer-to-member.rs b/tests/std/dcl.dcl/dcl.decl/dcl.init/dcl.init.general/out/refcount/p6.1-zero-initialized-pointer-to-member.rs new file mode 100644 index 0000000000..40990591b6 --- /dev/null +++ b/tests/std/dcl.dcl/dcl.decl/dcl.init/dcl.init.general/out/refcount/p6.1-zero-initialized-pointer-to-member.rs @@ -0,0 +1,45 @@ +extern crate libcc2rs; +use libcc2rs::*; +use std::cell::RefCell; +use std::collections::BTreeMap; +use std::io::prelude::*; +use std::io::{Read, Seek, Write}; +use std::os::fd::AsFd; +use std::rc::{Rc, Weak}; +#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] +#[byte_size(8)] +pub struct HasTwoInts { + #[offset(0)] + pub first: i32, + #[offset(4)] + pub second: i32, +} +#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] +#[byte_size(8)] +pub struct HoldsSelector { + #[offset(0)] + #[byte_size(8)] + pub selector: MemberPtr, +} +thread_local!( + pub static static_pm_0: Value> = + >>::default(); +); +pub fn main() { + __cpp2rust_init_globals(); + std::process::exit(main_0()); +} +fn main_0() -> i32 { + assert!((static_pm_0.with(|rc| *rc.borrow())).is_null()); + assert!((static_pm_0.with(|rc| *rc.borrow()) != member_ptr!(HasTwoInts, first))); + let mut value_initialized: MemberPtr = >::default(); + assert!((value_initialized).is_null()); + assert!((value_initialized != member_ptr!(HasTwoInts, first))); + let mut holder: HoldsSelector = ::default(); + assert!((holder.selector).is_null()); + assert!((holder.selector != member_ptr!(HasTwoInts, first))); + return 0; +} +pub fn __cpp2rust_init_globals() { + let _ = static_pm_0.with(|_| ()); +} diff --git a/tests/std/dcl.dcl/dcl.decl/dcl.init/dcl.init.general/out/unsafe/p6.1-zero-initialized-pointer-to-member.rs b/tests/std/dcl.dcl/dcl.decl/dcl.init/dcl.init.general/out/unsafe/p6.1-zero-initialized-pointer-to-member.rs new file mode 100644 index 0000000000..4b157f423e --- /dev/null +++ b/tests/std/dcl.dcl/dcl.decl/dcl.init/dcl.init.general/out/unsafe/p6.1-zero-initialized-pointer-to-member.rs @@ -0,0 +1,57 @@ +extern crate libc; +use libc::*; +extern crate libcc2rs; +use libcc2rs::*; +use std::collections::BTreeMap; +use std::io::{Read, Seek, Write}; +use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; +use std::rc::Rc; +#[repr(C)] +#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] +pub struct HasTwoInts { + pub first: i32, + pub second: i32, +} +#[repr(C)] +#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] +pub struct HoldsSelector { + pub selector: MemberPtrUnsafe, +} +pub static mut static_pm_0: std::cell::LazyCell> = + std::cell::LazyCell::new(|| unsafe { >::default() }); +pub fn main() { + unsafe { + __cpp2rust_init_globals(); + std::process::exit(main_0() as i32); + } +} +unsafe fn main_0() -> i32 { + assert!((*std::cell::LazyCell::force_mut(&mut *&raw mut static_pm_0)).is_null()); + assert!( + ((*std::cell::LazyCell::force_mut(&mut *&raw mut static_pm_0)) + != (>::from_offset(::std::mem::offset_of!( + HasTwoInts, first + )))) + ); + let mut value_initialized: MemberPtrUnsafe = + >::default(); + assert!((value_initialized).is_null()); + assert!( + ((value_initialized) + != (>::from_offset(::std::mem::offset_of!( + HasTwoInts, first + )))) + ); + let mut holder: HoldsSelector = ::default(); + assert!((holder.selector).is_null()); + assert!( + ((holder.selector) + != (>::from_offset(::std::mem::offset_of!( + HasTwoInts, first + )))) + ); + return 0; +} +pub unsafe fn __cpp2rust_init_globals() { + std::cell::LazyCell::force(&*&raw const static_pm_0); +} diff --git a/tests/std/dcl.dcl/dcl.decl/dcl.init/dcl.init.general/p6.1-zero-initialized-pointer-to-member.cpp b/tests/std/dcl.dcl/dcl.decl/dcl.init/dcl.init.general/p6.1-zero-initialized-pointer-to-member.cpp index 0093c1e811..60ab37f3b2 100644 --- a/tests/std/dcl.dcl/dcl.decl/dcl.init/dcl.init.general/p6.1-zero-initialized-pointer-to-member.cpp +++ b/tests/std/dcl.dcl/dcl.decl/dcl.init/dcl.init.general/p6.1-zero-initialized-pointer-to-member.cpp @@ -1,4 +1,3 @@ -// translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [dcl.init.general]/6.1: zero-initializing a scalar converts the // integer literal 0 to its type; for a pointer to member that is the null diff --git a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.array/out/refcount/p6-array-of-pointers-to-data-members.rs b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.array/out/refcount/p6-array-of-pointers-to-data-members.rs new file mode 100644 index 0000000000..f1ade7c9fe --- /dev/null +++ b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.array/out/refcount/p6-array-of-pointers-to-data-members.rs @@ -0,0 +1,69 @@ +extern crate libcc2rs; +use libcc2rs::*; +use std::cell::RefCell; +use std::collections::BTreeMap; +use std::io::prelude::*; +use std::io::{Read, Seek, Write}; +use std::os::fd::AsFd; +use std::rc::{Rc, Weak}; +#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] +#[byte_size(12)] +pub struct HasThreeInts { + #[offset(0)] + pub first: i32, + #[offset(4)] + pub second: i32, + #[offset(8)] + pub third: i32, +} +pub fn main() { + __cpp2rust_init_globals(); + std::process::exit(main_0()); +} +fn main_0() -> i32 { + let members: Value]>> = Rc::new(RefCell::new(Box::new([ + member_ptr!(HasThreeInts, third), + member_ptr!(HasThreeInts, first), + member_ptr!(HasThreeInts, second), + ]))); + let obj: Value = Rc::new(RefCell::new(HasThreeInts { + first: 4, + second: 5, + third: 6, + })); + assert!( + ({ + (((obj.as_pointer()) + .member((*members.borrow())[(0) as usize]) + .read()) + == 6) + }) + ); + assert!( + ({ + (((obj.as_pointer()) + .member((*members.borrow())[(1) as usize]) + .read()) + == 4) + }) + ); + assert!( + ({ + (((obj.as_pointer()) + .member((*members.borrow())[(2) as usize]) + .read()) + == 5) + }) + ); + let mut element: Ptr> = members.decay(); + assert!(({ element.offset((1) as isize) } == { (members.decay().offset(1)) })); + assert!((((obj.as_pointer()).member((elem!(element, 1).read())).read()) == 4)); + element.prefix_inc(); + element.prefix_inc(); + assert!(({ (element).clone() } == { (members.decay().offset(2)) })); + assert!((((obj.as_pointer()).member((element.read())).read()) == 5)); + (*members.borrow_mut())[(2) as usize] = member_ptr!(HasThreeInts, third); + assert!((((obj.as_pointer()).member((element.read())).read()) == 6)); + return 0; +} +pub fn __cpp2rust_init_globals() {} diff --git a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.array/out/unsafe/p6-array-of-pointers-to-data-members.rs b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.array/out/unsafe/p6-array-of-pointers-to-data-members.rs new file mode 100644 index 0000000000..2e5b2c7a47 --- /dev/null +++ b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.array/out/unsafe/p6-array-of-pointers-to-data-members.rs @@ -0,0 +1,61 @@ +extern crate libc; +use libc::*; +extern crate libcc2rs; +use libcc2rs::*; +use std::collections::BTreeMap; +use std::io::{Read, Seek, Write}; +use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; +use std::rc::Rc; +#[repr(C)] +#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] +pub struct HasThreeInts { + pub first: i32, + pub second: i32, + pub third: i32, +} +pub fn main() { + unsafe { + __cpp2rust_init_globals(); + std::process::exit(main_0() as i32); + } +} +unsafe fn main_0() -> i32 { + let mut members: [MemberPtrUnsafe; 3] = [ + >::from_offset(::std::mem::offset_of!( + HasThreeInts, + third + )), + >::from_offset(::std::mem::offset_of!( + HasThreeInts, + first + )), + >::from_offset(::std::mem::offset_of!( + HasThreeInts, + second + )), + ]; + let mut obj: HasThreeInts = HasThreeInts { + first: 4, + second: 5, + third: 6, + }; + assert!(((*(&mut obj as *mut HasThreeInts).member(members[(0) as usize])) == (6))); + assert!(((*(&mut obj as *mut HasThreeInts).member(members[(1) as usize])) == (4))); + assert!(((*(&mut obj as *mut HasThreeInts).member(members[(2) as usize])) == (5))); + let mut element: *mut MemberPtrUnsafe = members.as_mut_ptr(); + assert!( + ((element.offset((1) as isize)) + == (&mut members[(1) as usize] as *mut MemberPtrUnsafe)) + ); + assert!(((*(&mut obj as *mut HasThreeInts).member((*element.offset((1) as isize)))) == (4))); + element.prefix_inc(); + element.prefix_inc(); + assert!(((element) == (&mut members[(2) as usize] as *mut MemberPtrUnsafe))); + assert!(((*(&mut obj as *mut HasThreeInts).member((*element))) == (5))); + members[(2) as usize] = >::from_offset( + ::std::mem::offset_of!(HasThreeInts, third), + ); + assert!(((*(&mut obj as *mut HasThreeInts).member((*element))) == (6))); + return 0; +} +pub unsafe fn __cpp2rust_init_globals() {} diff --git a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.array/p6-array-of-pointers-to-data-members.cpp b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.array/p6-array-of-pointers-to-data-members.cpp index ff57990f12..b6c973166d 100644 --- a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.array/p6-array-of-pointers-to-data-members.cpp +++ b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.array/p6-array-of-pointers-to-data-members.cpp @@ -1,4 +1,3 @@ -// translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [dcl.array]/6: an object of type "array of N U" consists of a // contiguously allocated set of N subobjects of type U, numbered 0 to N-1. diff --git a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/refcount/p2-pointer-to-array-member.rs b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/refcount/p2-pointer-to-array-member.rs new file mode 100644 index 0000000000..6e3ecd70ef --- /dev/null +++ b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/refcount/p2-pointer-to-array-member.rs @@ -0,0 +1,45 @@ +extern crate libcc2rs; +use libcc2rs::*; +use std::cell::RefCell; +use std::collections::BTreeMap; +use std::io::prelude::*; +use std::io::{Read, Seek, Write}; +use std::os::fd::AsFd; +use std::rc::{Rc, Weak}; +#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg)] +#[byte_size(16)] +pub struct HasIntArray { + #[offset(0)] + pub before: i32, + #[offset(4)] + #[byte_size(12)] + pub elements: Box<[i32]>, +} +impl Default for HasIntArray { + fn default() -> Self { + { + HasIntArray { + before: 0_i32, + elements: (0..3).map(|_| 0_i32).collect::>(), + } + } + } +} +pub fn main() { + __cpp2rust_init_globals(); + std::process::exit(main_0()); +} +fn main_0() -> i32 { + let mut pm: MemberPtr> = member_ptr!(HasIntArray, elements); + let obj: Value = Rc::new(RefCell::new(HasIntArray { + before: 1, + elements: Box::new([2, 3, 4]), + })); + assert!((((obj.as_pointer()).member(pm).read())[(0) as usize] == 2)); + assert!((((obj.as_pointer()).member(pm).read())[(2) as usize] == 4)); + index!((obj.as_pointer()).member(pm), 1).write(7); + assert!(((array_elem!(obj.as_pointer(), elements, 1).read()) == 7)); + assert!(({ ({ (*obj.borrow()).before } == 1) })); + return 0; +} +pub fn __cpp2rust_init_globals() {} diff --git a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/refcount/p2-pointer-to-data-member.rs b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/refcount/p2-pointer-to-data-member.rs new file mode 100644 index 0000000000..bce9afa21d --- /dev/null +++ b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/refcount/p2-pointer-to-data-member.rs @@ -0,0 +1,38 @@ +extern crate libcc2rs; +use libcc2rs::*; +use std::cell::RefCell; +use std::collections::BTreeMap; +use std::io::prelude::*; +use std::io::{Read, Seek, Write}; +use std::os::fd::AsFd; +use std::rc::{Rc, Weak}; +#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] +#[byte_size(8)] +pub struct HasTwoInts { + #[offset(0)] + pub first: i32, + #[offset(4)] + pub second: i32, +} +pub fn main() { + __cpp2rust_init_globals(); + std::process::exit(main_0()); +} +fn main_0() -> i32 { + let mut pm: MemberPtr = member_ptr!(HasTwoInts, first); + let obj: Value = Rc::new(RefCell::new(HasTwoInts { + first: 3, + second: 4, + })); + assert!((((obj.as_pointer()).member(pm).read()) == 3)); + (obj.as_pointer()).member(pm).write(5); + assert!(({ ({ (*obj.borrow()).first } == 5) })); + assert!(({ ({ (*obj.borrow()).second } == 4) })); + pm = member_ptr!(HasTwoInts, second); + assert!((((obj.as_pointer()).member(pm).read()) == 4)); + (obj.as_pointer()).member(pm).write(6); + assert!(({ ({ (*obj.borrow()).first } == 5) })); + assert!(({ ({ (*obj.borrow()).second } == 6) })); + return 0; +} +pub fn __cpp2rust_init_globals() {} diff --git a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/refcount/p2-pointer-to-member-of-incomplete-class.rs b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/refcount/p2-pointer-to-member-of-incomplete-class.rs new file mode 100644 index 0000000000..4b4b74a167 --- /dev/null +++ b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/refcount/p2-pointer-to-member-of-incomplete-class.rs @@ -0,0 +1,42 @@ +extern crate libcc2rs; +use libcc2rs::*; +use std::cell::RefCell; +use std::collections::BTreeMap; +use std::io::prelude::*; +use std::io::{Read, Seek, Write}; +use std::os::fd::AsFd; +use std::rc::{Rc, Weak}; +thread_local!( + pub static pm_0: Value> = + Rc::new(RefCell::new(>::default())); +); +#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] +#[byte_size(8)] +pub struct CompletedLater { + #[offset(0)] + pub first: i32, + #[offset(4)] + pub second: i32, +} +pub fn main() { + __cpp2rust_init_globals(); + std::process::exit(main_0()); +} +fn main_0() -> i32 { + assert!((pm_0.with(|rc| *rc.borrow())).is_null()); + pm_0.with(|rc| *rc.borrow_mut() = member_ptr!(CompletedLater, second)); + let obj: Value = Rc::new(RefCell::new(CompletedLater { + first: 3, + second: 4, + })); + assert!( + (((obj.as_pointer()) + .member(pm_0.with(|rc| *rc.borrow())) + .read()) + == 4) + ); + return 0; +} +pub fn __cpp2rust_init_globals() { + let _ = pm_0.with(|_| ()); +} diff --git a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/refcount/p2-pointer-to-member-of-pointer-to-member-type.rs b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/refcount/p2-pointer-to-member-of-pointer-to-member-type.rs new file mode 100644 index 0000000000..f6692e90da --- /dev/null +++ b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/refcount/p2-pointer-to-member-of-pointer-to-member-type.rs @@ -0,0 +1,57 @@ +extern crate libcc2rs; +use libcc2rs::*; +use std::cell::RefCell; +use std::collections::BTreeMap; +use std::io::prelude::*; +use std::io::{Read, Seek, Write}; +use std::os::fd::AsFd; +use std::rc::{Rc, Weak}; +#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] +#[byte_size(8)] +pub struct HasTwoInts { + #[offset(0)] + pub first: i32, + #[offset(4)] + pub second: i32, +} +#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] +#[byte_size(8)] +pub struct HoldsSelector { + #[offset(0)] + #[byte_size(8)] + pub selector: MemberPtr, +} +pub fn main() { + __cpp2rust_init_globals(); + std::process::exit(main_0()); +} +fn main_0() -> i32 { + let mut pm: MemberPtr> = + member_ptr!(HoldsSelector, selector); + let holder: Value = Rc::new(RefCell::new(HoldsSelector { + selector: member_ptr!(HasTwoInts, second), + })); + let obj: Value = Rc::new(RefCell::new(HasTwoInts { + first: 3, + second: 4, + })); + assert!( + (((obj.as_pointer()) + .member(((holder.as_pointer()).member(pm).read())) + .read()) + == 4) + ); + (holder.as_pointer()) + .member(pm) + .write(member_ptr!(HasTwoInts, first)); + assert!( + ({ + (((obj.as_pointer()) + .member(({ (*holder.borrow()).selector })) + .read()) + == 3) + }) + ); + return 0; +} +pub fn __cpp2rust_init_globals() {} diff --git a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/unsafe/p2-pointer-to-array-member.rs b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/unsafe/p2-pointer-to-array-member.rs new file mode 100644 index 0000000000..9038f09fec --- /dev/null +++ b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/unsafe/p2-pointer-to-array-member.rs @@ -0,0 +1,38 @@ +extern crate libc; +use libc::*; +extern crate libcc2rs; +use libcc2rs::*; +use std::collections::BTreeMap; +use std::io::{Read, Seek, Write}; +use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; +use std::rc::Rc; +#[repr(C)] +#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] +pub struct HasIntArray { + pub before: i32, + pub elements: [i32; 3], +} +pub fn main() { + unsafe { + __cpp2rust_init_globals(); + std::process::exit(main_0() as i32); + } +} +unsafe fn main_0() -> i32 { + let mut pm: MemberPtrUnsafe = + >::from_offset(::std::mem::offset_of!( + HasIntArray, + elements + )); + let mut obj: HasIntArray = HasIntArray { + before: 1, + elements: [2, 3, 4], + }; + assert!((((*(&mut obj as *mut HasIntArray).member(pm))[(0) as usize]) == (2))); + assert!((((*(&mut obj as *mut HasIntArray).member(pm))[(2) as usize]) == (4))); + (*(&mut obj as *mut HasIntArray).member(pm))[(1) as usize] = 7; + assert!(((obj.elements[(1) as usize]) == (7))); + assert!(((obj.before) == (1))); + return 0; +} +pub unsafe fn __cpp2rust_init_globals() {} diff --git a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/unsafe/p2-pointer-to-data-member.rs b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/unsafe/p2-pointer-to-data-member.rs new file mode 100644 index 0000000000..5f30cd39a0 --- /dev/null +++ b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/unsafe/p2-pointer-to-data-member.rs @@ -0,0 +1,40 @@ +extern crate libc; +use libc::*; +extern crate libcc2rs; +use libcc2rs::*; +use std::collections::BTreeMap; +use std::io::{Read, Seek, Write}; +use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; +use std::rc::Rc; +#[repr(C)] +#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] +pub struct HasTwoInts { + pub first: i32, + pub second: i32, +} +pub fn main() { + unsafe { + __cpp2rust_init_globals(); + std::process::exit(main_0() as i32); + } +} +unsafe fn main_0() -> i32 { + let mut pm: MemberPtrUnsafe = + >::from_offset(::std::mem::offset_of!(HasTwoInts, first)); + let mut obj: HasTwoInts = HasTwoInts { + first: 3, + second: 4, + }; + assert!(((*(&mut obj as *mut HasTwoInts).member(pm)) == (3))); + (*(&mut obj as *mut HasTwoInts).member(pm)) = 5; + assert!(((obj.first) == (5))); + assert!(((obj.second) == (4))); + pm = + >::from_offset(::std::mem::offset_of!(HasTwoInts, second)); + assert!(((*(&mut obj as *mut HasTwoInts).member(pm)) == (4))); + (*(&mut obj as *mut HasTwoInts).member(pm)) = 6; + assert!(((obj.first) == (5))); + assert!(((obj.second) == (6))); + return 0; +} +pub unsafe fn __cpp2rust_init_globals() {} diff --git a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/unsafe/p2-pointer-to-member-of-incomplete-class.rs b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/unsafe/p2-pointer-to-member-of-incomplete-class.rs new file mode 100644 index 0000000000..3538fd7b83 --- /dev/null +++ b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/unsafe/p2-pointer-to-member-of-incomplete-class.rs @@ -0,0 +1,43 @@ +extern crate libc; +use libc::*; +extern crate libcc2rs; +use libcc2rs::*; +use std::collections::BTreeMap; +use std::io::{Read, Seek, Write}; +use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; +use std::rc::Rc; +pub static mut pm_0: std::cell::LazyCell> = + std::cell::LazyCell::new(|| unsafe { >::default() }); +#[repr(C)] +#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] +pub struct CompletedLater { + pub first: i32, + pub second: i32, +} +pub fn main() { + unsafe { + __cpp2rust_init_globals(); + std::process::exit(main_0() as i32); + } +} +unsafe fn main_0() -> i32 { + assert!((*std::cell::LazyCell::force_mut(&mut *&raw mut pm_0)).is_null()); + (*std::cell::LazyCell::force_mut(&mut *&raw mut pm_0)) = + >::from_offset(::std::mem::offset_of!( + CompletedLater, + second + )); + let mut obj: CompletedLater = CompletedLater { + first: 3, + second: 4, + }; + assert!( + ((*(&mut obj as *mut CompletedLater) + .member((*std::cell::LazyCell::force_mut(&mut *&raw mut pm_0)))) + == (4)) + ); + return 0; +} +pub unsafe fn __cpp2rust_init_globals() { + std::cell::LazyCell::force(&*&raw const pm_0); +} diff --git a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/unsafe/p2-pointer-to-member-of-pointer-to-member-type.rs b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/unsafe/p2-pointer-to-member-of-pointer-to-member-type.rs new file mode 100644 index 0000000000..98beae3bf0 --- /dev/null +++ b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/unsafe/p2-pointer-to-member-of-pointer-to-member-type.rs @@ -0,0 +1,50 @@ +extern crate libc; +use libc::*; +extern crate libcc2rs; +use libcc2rs::*; +use std::collections::BTreeMap; +use std::io::{Read, Seek, Write}; +use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; +use std::rc::Rc; +#[repr(C)] +#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] +pub struct HasTwoInts { + pub first: i32, + pub second: i32, +} +#[repr(C)] +#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] +pub struct HoldsSelector { + pub selector: MemberPtrUnsafe, +} +pub fn main() { + unsafe { + __cpp2rust_init_globals(); + std::process::exit(main_0() as i32); + } +} +unsafe fn main_0() -> i32 { + let mut pm: MemberPtrUnsafe> = + >>::from_offset( + ::std::mem::offset_of!(HoldsSelector, selector), + ); + let mut holder: HoldsSelector = HoldsSelector { + selector: >::from_offset(::std::mem::offset_of!( + HasTwoInts, second + )), + }; + let mut obj: HasTwoInts = HasTwoInts { + first: 3, + second: 4, + }; + assert!( + ((*(&mut obj as *mut HasTwoInts) + .member((*(&mut holder as *mut HoldsSelector).member(pm)))) + == (4)) + ); + (*(&mut holder as *mut HoldsSelector).member(pm)) = + >::from_offset(::std::mem::offset_of!(HasTwoInts, first)); + assert!(((*(&mut obj as *mut HasTwoInts).member((holder.selector))) == (3))); + return 0; +} +pub unsafe fn __cpp2rust_init_globals() {} diff --git a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/p2-pointer-to-array-member.cpp b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/p2-pointer-to-array-member.cpp index 54084e3088..6daf337c45 100644 --- a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/p2-pointer-to-array-member.cpp +++ b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/p2-pointer-to-array-member.cpp @@ -1,4 +1,3 @@ -// translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [dcl.mptr]/2: the type is "derived-declarator-type-list pointer to // member of class C of type T"; T can be an array type. diff --git a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/p2-pointer-to-data-member.cpp b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/p2-pointer-to-data-member.cpp index 65333f4b0e..c4897bca79 100644 --- a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/p2-pointer-to-data-member.cpp +++ b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/p2-pointer-to-data-member.cpp @@ -1,4 +1,3 @@ -// translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [dcl.mptr]/2: "T C::*" declares a pointer to member of class C of // type T. diff --git a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/p2-pointer-to-member-of-incomplete-class.cpp b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/p2-pointer-to-member-of-incomplete-class.cpp index 2915aa9685..4f363a15db 100644 --- a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/p2-pointer-to-member-of-incomplete-class.cpp +++ b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/p2-pointer-to-member-of-incomplete-class.cpp @@ -1,4 +1,3 @@ -// translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [dcl.mptr]/2: the nested-name-specifier denotes a class; the class // need not be complete. diff --git a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/p2-pointer-to-member-of-pointer-to-member-type.cpp b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/p2-pointer-to-member-of-pointer-to-member-type.cpp index 2f84ce6260..0106d49f10 100644 --- a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/p2-pointer-to-member-of-pointer-to-member-type.cpp +++ b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/p2-pointer-to-member-of-pointer-to-member-type.cpp @@ -1,4 +1,3 @@ -// translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [dcl.mptr]/2: the type is "derived-declarator-type-list pointer to // member of class C of type T"; T can itself be a pointer-to-member type. diff --git a/tests/std/expr/conv/conv.mem/out/refcount/p1-null-distinct-from-first-member.rs b/tests/std/expr/conv/conv.mem/out/refcount/p1-null-distinct-from-first-member.rs new file mode 100644 index 0000000000..dad1e505cc --- /dev/null +++ b/tests/std/expr/conv/conv.mem/out/refcount/p1-null-distinct-from-first-member.rs @@ -0,0 +1,29 @@ +extern crate libcc2rs; +use libcc2rs::*; +use std::cell::RefCell; +use std::collections::BTreeMap; +use std::io::prelude::*; +use std::io::{Read, Seek, Write}; +use std::os::fd::AsFd; +use std::rc::{Rc, Weak}; +#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] +#[byte_size(8)] +pub struct HasTwoInts { + #[offset(0)] + pub first: i32, + #[offset(4)] + pub second: i32, +} +pub fn main() { + __cpp2rust_init_globals(); + std::process::exit(main_0()); +} +fn main_0() -> i32 { + let mut null_pm: MemberPtr = >::default(); + let mut first_pm: MemberPtr = member_ptr!(HasTwoInts, first); + let mut second_pm: MemberPtr = member_ptr!(HasTwoInts, second); + assert!((first_pm != null_pm)); + assert!((second_pm != null_pm)); + return 0; +} +pub fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/conv/conv.mem/out/unsafe/p1-null-distinct-from-first-member.rs b/tests/std/expr/conv/conv.mem/out/unsafe/p1-null-distinct-from-first-member.rs new file mode 100644 index 0000000000..540884aabb --- /dev/null +++ b/tests/std/expr/conv/conv.mem/out/unsafe/p1-null-distinct-from-first-member.rs @@ -0,0 +1,32 @@ +extern crate libc; +use libc::*; +extern crate libcc2rs; +use libcc2rs::*; +use std::collections::BTreeMap; +use std::io::{Read, Seek, Write}; +use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; +use std::rc::Rc; +#[repr(C)] +#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] +pub struct HasTwoInts { + pub first: i32, + pub second: i32, +} +pub fn main() { + unsafe { + __cpp2rust_init_globals(); + std::process::exit(main_0() as i32); + } +} +unsafe fn main_0() -> i32 { + let mut null_pm: MemberPtrUnsafe = + >::default(); + let mut first_pm: MemberPtrUnsafe = + >::from_offset(::std::mem::offset_of!(HasTwoInts, first)); + let mut second_pm: MemberPtrUnsafe = + >::from_offset(::std::mem::offset_of!(HasTwoInts, second)); + assert!(((first_pm) != (null_pm))); + assert!(((second_pm) != (null_pm))); + return 0; +} +pub unsafe fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/conv/conv.mem/p1-null-distinct-from-first-member.cpp b/tests/std/expr/conv/conv.mem/p1-null-distinct-from-first-member.cpp index ebe16af069..edddb4e6a4 100644 --- a/tests/std/expr/conv/conv.mem/p1-null-distinct-from-first-member.cpp +++ b/tests/std/expr/conv/conv.mem/p1-null-distinct-from-first-member.cpp @@ -1,4 +1,3 @@ -// translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [conv.mem]/1: the null member pointer value is distinguishable from // any pointer to member not created from a null pointer constant. diff --git a/tests/std/expr/expr.compound/expr.cond/out/refcount/p7.4-pointer-to-member-and-null.rs b/tests/std/expr/expr.compound/expr.cond/out/refcount/p7.4-pointer-to-member-and-null.rs new file mode 100644 index 0000000000..6223b58d15 --- /dev/null +++ b/tests/std/expr/expr.compound/expr.cond/out/refcount/p7.4-pointer-to-member-and-null.rs @@ -0,0 +1,43 @@ +extern crate libcc2rs; +use libcc2rs::*; +use std::cell::RefCell; +use std::collections::BTreeMap; +use std::io::prelude::*; +use std::io::{Read, Seek, Write}; +use std::os::fd::AsFd; +use std::rc::{Rc, Weak}; +#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] +#[byte_size(8)] +pub struct HasTwoInts { + #[offset(0)] + pub first: i32, + #[offset(4)] + pub second: i32, +} +pub fn second_or_null_0(mut choose_second: bool) -> MemberPtr { + return if choose_second { + member_ptr!(HasTwoInts, second) + } else { + >::default() + }; +} +pub fn main() { + __cpp2rust_init_globals(); + std::process::exit(main_0()); +} +fn main_0() -> i32 { + let obj: Value = Rc::new(RefCell::new(HasTwoInts { + first: 3, + second: 4, + })); + assert!(({ second_or_null_0(false,) }).is_null()); + assert!((({ second_or_null_0(true,) }) == member_ptr!(HasTwoInts, second))); + assert!( + (((obj.as_pointer()) + .member(({ second_or_null_0(true,) })) + .read()) + == 4) + ); + return 0; +} +pub fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/expr.compound/expr.cond/out/unsafe/p7.4-pointer-to-member-and-null.rs b/tests/std/expr/expr.compound/expr.cond/out/unsafe/p7.4-pointer-to-member-and-null.rs new file mode 100644 index 0000000000..bea466c4a0 --- /dev/null +++ b/tests/std/expr/expr.compound/expr.cond/out/unsafe/p7.4-pointer-to-member-and-null.rs @@ -0,0 +1,43 @@ +extern crate libc; +use libc::*; +extern crate libcc2rs; +use libcc2rs::*; +use std::collections::BTreeMap; +use std::io::{Read, Seek, Write}; +use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; +use std::rc::Rc; +#[repr(C)] +#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] +pub struct HasTwoInts { + pub first: i32, + pub second: i32, +} +pub unsafe fn second_or_null_0(mut choose_second: bool) -> MemberPtrUnsafe { + return if choose_second { + >::from_offset(::std::mem::offset_of!(HasTwoInts, second)) + } else { + >::default() + }; +} +pub fn main() { + unsafe { + __cpp2rust_init_globals(); + std::process::exit(main_0() as i32); + } +} +unsafe fn main_0() -> i32 { + let mut obj: HasTwoInts = HasTwoInts { + first: 3, + second: 4, + }; + assert!((unsafe { second_or_null_0(false,) }).is_null()); + assert!( + ((unsafe { second_or_null_0(true,) }) + == (>::from_offset(::std::mem::offset_of!( + HasTwoInts, second + )))) + ); + assert!(((*(&mut obj as *mut HasTwoInts).member((unsafe { second_or_null_0(true,) }))) == (4))); + return 0; +} +pub unsafe fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/expr.compound/expr.cond/p7.4-pointer-to-member-and-null.cpp b/tests/std/expr/expr.compound/expr.cond/p7.4-pointer-to-member-and-null.cpp index 3e31fd06bc..1df8833025 100644 --- a/tests/std/expr/expr.compound/expr.cond/p7.4-pointer-to-member-and-null.cpp +++ b/tests/std/expr/expr.compound/expr.cond/p7.4-pointer-to-member-and-null.cpp @@ -1,4 +1,3 @@ -// translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [expr.cond]/7.4: if one or both of the second and third operands have // pointer-to-member type, they are brought to their composite pointer type. diff --git a/tests/std/expr/expr.compound/expr.eq/out/refcount/p4.1-both-null.rs b/tests/std/expr/expr.compound/expr.eq/out/refcount/p4.1-both-null.rs new file mode 100644 index 0000000000..1a0a6ea210 --- /dev/null +++ b/tests/std/expr/expr.compound/expr.eq/out/refcount/p4.1-both-null.rs @@ -0,0 +1,28 @@ +extern crate libcc2rs; +use libcc2rs::*; +use std::cell::RefCell; +use std::collections::BTreeMap; +use std::io::prelude::*; +use std::io::{Read, Seek, Write}; +use std::os::fd::AsFd; +use std::rc::{Rc, Weak}; +#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] +#[byte_size(8)] +pub struct HasTwoInts { + #[offset(0)] + pub first: i32, + #[offset(4)] + pub second: i32, +} +pub fn main() { + __cpp2rust_init_globals(); + std::process::exit(main_0()); +} +fn main_0() -> i32 { + let mut first_null: MemberPtr = >::default(); + let mut second_null: MemberPtr = >::default(); + assert!((first_null == second_null)); + assert!(!(first_null != second_null)); + return 0; +} +pub fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/expr.compound/expr.eq/out/refcount/p4.2-one-null.rs b/tests/std/expr/expr.compound/expr.eq/out/refcount/p4.2-one-null.rs new file mode 100644 index 0000000000..d9f772998a --- /dev/null +++ b/tests/std/expr/expr.compound/expr.eq/out/refcount/p4.2-one-null.rs @@ -0,0 +1,30 @@ +extern crate libcc2rs; +use libcc2rs::*; +use std::cell::RefCell; +use std::collections::BTreeMap; +use std::io::prelude::*; +use std::io::{Read, Seek, Write}; +use std::os::fd::AsFd; +use std::rc::{Rc, Weak}; +#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] +#[byte_size(8)] +pub struct HasTwoInts { + #[offset(0)] + pub first: i32, + #[offset(4)] + pub second: i32, +} +pub fn main() { + __cpp2rust_init_globals(); + std::process::exit(main_0()); +} +fn main_0() -> i32 { + let mut null_pm: MemberPtr = >::default(); + let mut first_pm: MemberPtr = member_ptr!(HasTwoInts, first); + assert!((first_pm != null_pm)); + assert!(!(first_pm == null_pm)); + assert!((null_pm != first_pm)); + assert!(!(null_pm == first_pm)); + return 0; +} +pub fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/expr.compound/expr.eq/out/refcount/p4.6-data-members.rs b/tests/std/expr/expr.compound/expr.eq/out/refcount/p4.6-data-members.rs new file mode 100644 index 0000000000..e1a1ca0147 --- /dev/null +++ b/tests/std/expr/expr.compound/expr.eq/out/refcount/p4.6-data-members.rs @@ -0,0 +1,31 @@ +extern crate libcc2rs; +use libcc2rs::*; +use std::cell::RefCell; +use std::collections::BTreeMap; +use std::io::prelude::*; +use std::io::{Read, Seek, Write}; +use std::os::fd::AsFd; +use std::rc::{Rc, Weak}; +#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] +#[byte_size(8)] +pub struct HasTwoInts { + #[offset(0)] + pub first: i32, + #[offset(4)] + pub second: i32, +} +pub fn main() { + __cpp2rust_init_globals(); + std::process::exit(main_0()); +} +fn main_0() -> i32 { + let mut first_pm: MemberPtr = member_ptr!(HasTwoInts, first); + let mut also_first_pm: MemberPtr = member_ptr!(HasTwoInts, first); + let mut second_pm: MemberPtr = member_ptr!(HasTwoInts, second); + assert!((first_pm == also_first_pm)); + assert!(!(first_pm != also_first_pm)); + assert!((first_pm != second_pm)); + assert!(!(first_pm == second_pm)); + return 0; +} +pub fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/expr.compound/expr.eq/out/unsafe/p4.1-both-null.rs b/tests/std/expr/expr.compound/expr.eq/out/unsafe/p4.1-both-null.rs new file mode 100644 index 0000000000..169c2c6c13 --- /dev/null +++ b/tests/std/expr/expr.compound/expr.eq/out/unsafe/p4.1-both-null.rs @@ -0,0 +1,30 @@ +extern crate libc; +use libc::*; +extern crate libcc2rs; +use libcc2rs::*; +use std::collections::BTreeMap; +use std::io::{Read, Seek, Write}; +use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; +use std::rc::Rc; +#[repr(C)] +#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] +pub struct HasTwoInts { + pub first: i32, + pub second: i32, +} +pub fn main() { + unsafe { + __cpp2rust_init_globals(); + std::process::exit(main_0() as i32); + } +} +unsafe fn main_0() -> i32 { + let mut first_null: MemberPtrUnsafe = + >::default(); + let mut second_null: MemberPtrUnsafe = + >::default(); + assert!(((first_null) == (second_null))); + assert!(!((first_null) != (second_null))); + return 0; +} +pub unsafe fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/expr.compound/expr.eq/out/unsafe/p4.2-one-null.rs b/tests/std/expr/expr.compound/expr.eq/out/unsafe/p4.2-one-null.rs new file mode 100644 index 0000000000..012f881f45 --- /dev/null +++ b/tests/std/expr/expr.compound/expr.eq/out/unsafe/p4.2-one-null.rs @@ -0,0 +1,32 @@ +extern crate libc; +use libc::*; +extern crate libcc2rs; +use libcc2rs::*; +use std::collections::BTreeMap; +use std::io::{Read, Seek, Write}; +use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; +use std::rc::Rc; +#[repr(C)] +#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] +pub struct HasTwoInts { + pub first: i32, + pub second: i32, +} +pub fn main() { + unsafe { + __cpp2rust_init_globals(); + std::process::exit(main_0() as i32); + } +} +unsafe fn main_0() -> i32 { + let mut null_pm: MemberPtrUnsafe = + >::default(); + let mut first_pm: MemberPtrUnsafe = + >::from_offset(::std::mem::offset_of!(HasTwoInts, first)); + assert!(((first_pm) != (null_pm))); + assert!(!((first_pm) == (null_pm))); + assert!(((null_pm) != (first_pm))); + assert!(!((null_pm) == (first_pm))); + return 0; +} +pub unsafe fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/expr.compound/expr.eq/out/unsafe/p4.5-members-of-same-union.rs b/tests/std/expr/expr.compound/expr.eq/out/unsafe/p4.5-members-of-same-union.rs new file mode 100644 index 0000000000..a16cf56afc --- /dev/null +++ b/tests/std/expr/expr.compound/expr.eq/out/unsafe/p4.5-members-of-same-union.rs @@ -0,0 +1,35 @@ +extern crate libc; +use libc::*; +extern crate libcc2rs; +use libcc2rs::*; +use std::collections::BTreeMap; +use std::io::{Read, Seek, Write}; +use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; +use std::rc::Rc; +#[repr(C)] +#[derive(Copy, Clone, FnPtrArg, VaArg)] +pub union HasTwoIntMembers { + pub first: i32, + pub second: i32, +} +impl Default for HasTwoIntMembers { + fn default() -> Self { + unsafe { std::mem::zeroed() } + } +} +pub fn main() { + unsafe { + __cpp2rust_init_globals(); + std::process::exit(main_0() as i32); + } +} +unsafe fn main_0() -> i32 { + let mut first_pm: MemberPtrUnsafe = + >::from_offset(0); + let mut second_pm: MemberPtrUnsafe = + >::from_offset(0); + assert!(((first_pm) == (second_pm))); + assert!(!((first_pm) != (second_pm))); + return 0; +} +pub unsafe fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/expr.compound/expr.eq/out/unsafe/p4.6-data-members.rs b/tests/std/expr/expr.compound/expr.eq/out/unsafe/p4.6-data-members.rs new file mode 100644 index 0000000000..f320aa6d12 --- /dev/null +++ b/tests/std/expr/expr.compound/expr.eq/out/unsafe/p4.6-data-members.rs @@ -0,0 +1,34 @@ +extern crate libc; +use libc::*; +extern crate libcc2rs; +use libcc2rs::*; +use std::collections::BTreeMap; +use std::io::{Read, Seek, Write}; +use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; +use std::rc::Rc; +#[repr(C)] +#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] +pub struct HasTwoInts { + pub first: i32, + pub second: i32, +} +pub fn main() { + unsafe { + __cpp2rust_init_globals(); + std::process::exit(main_0() as i32); + } +} +unsafe fn main_0() -> i32 { + let mut first_pm: MemberPtrUnsafe = + >::from_offset(::std::mem::offset_of!(HasTwoInts, first)); + let mut also_first_pm: MemberPtrUnsafe = + >::from_offset(::std::mem::offset_of!(HasTwoInts, first)); + let mut second_pm: MemberPtrUnsafe = + >::from_offset(::std::mem::offset_of!(HasTwoInts, second)); + assert!(((first_pm) == (also_first_pm))); + assert!(!((first_pm) != (also_first_pm))); + assert!(((first_pm) != (second_pm))); + assert!(!((first_pm) == (second_pm))); + return 0; +} +pub unsafe fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/expr.compound/expr.eq/p4.1-both-null.cpp b/tests/std/expr/expr.compound/expr.eq/p4.1-both-null.cpp index 9465396fbf..7de5adfd59 100644 --- a/tests/std/expr/expr.compound/expr.eq/p4.1-both-null.cpp +++ b/tests/std/expr/expr.compound/expr.eq/p4.1-both-null.cpp @@ -1,4 +1,3 @@ -// translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [expr.eq]/4.1: two pointers to members that are both the null member // pointer value compare equal. diff --git a/tests/std/expr/expr.compound/expr.eq/p4.2-one-null.cpp b/tests/std/expr/expr.compound/expr.eq/p4.2-one-null.cpp index ee016fc500..77df4c4fe7 100644 --- a/tests/std/expr/expr.compound/expr.eq/p4.2-one-null.cpp +++ b/tests/std/expr/expr.compound/expr.eq/p4.2-one-null.cpp @@ -1,4 +1,3 @@ -// translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [expr.eq]/4.2: if only one of two pointers to members is the null // member pointer value, they compare unequal. diff --git a/tests/std/expr/expr.compound/expr.eq/p4.5-members-of-same-union.cpp b/tests/std/expr/expr.compound/expr.eq/p4.5-members-of-same-union.cpp index b0756392ea..e74fd2b756 100644 --- a/tests/std/expr/expr.compound/expr.eq/p4.5-members-of-same-union.cpp +++ b/tests/std/expr/expr.compound/expr.eq/p4.5-members-of-same-union.cpp @@ -1,4 +1,3 @@ -// translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [expr.eq]/4.5: pointers to (possibly different) members of the same // union compare equal. diff --git a/tests/std/expr/expr.compound/expr.eq/p4.6-data-members.cpp b/tests/std/expr/expr.compound/expr.eq/p4.6-data-members.cpp index b4c875d0e4..f52c54b8a2 100644 --- a/tests/std/expr/expr.compound/expr.eq/p4.6-data-members.cpp +++ b/tests/std/expr/expr.compound/expr.eq/p4.6-data-members.cpp @@ -1,4 +1,3 @@ -// translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [expr.eq]/4.6: two pointers to members compare equal if they would // refer to the same member of the same most derived object, otherwise they diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p2-object-of-derived-class.rs b/tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p2-object-of-derived-class.rs new file mode 100644 index 0000000000..72643b6338 --- /dev/null +++ b/tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p2-object-of-derived-class.rs @@ -0,0 +1,44 @@ +extern crate libcc2rs; +use libcc2rs::*; +use std::cell::RefCell; +use std::collections::BTreeMap; +use std::io::prelude::*; +use std::io::{Read, Seek, Write}; +use std::os::fd::AsFd; +use std::rc::{Rc, Weak}; +#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] +#[byte_size(4)] +pub struct Precedes { + #[offset(0)] + pub preceding: i32, +} +#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] +#[byte_size(4)] +pub struct DeclaresValue { + #[offset(0)] + pub value: i32, +} +#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] +#[byte_size(12)] +pub struct InheritsValue { + #[offset(8)] + pub own: i32, +} +pub fn main() { + __cpp2rust_init_globals(); + std::process::exit(main_0()); +} +fn main_0() -> i32 { + let mut pm: MemberPtr = member_ptr!(DeclaresValue, value); + let obj: Value = Rc::new(RefCell::new(::default())); + ((*obj.borrow_mut()) as Precedes).preceding = 1; + ((*obj.borrow_mut()) as DeclaresValue).value = 2; + (*obj.borrow_mut()).own = 3; + assert!((((obj.as_pointer()).member(pm).read()) == 2)); + (obj.as_pointer()).member(pm).write(4); + assert!(({ ({ ((*obj.borrow()) as DeclaresValue).value } == 4) })); + assert!(({ ({ ((*obj.borrow()) as Precedes).preceding } == 1) })); + assert!(({ ({ (*obj.borrow()).own } == 3) })); + return 0; +} +pub fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p3-arrow-star-pointer-to-derived-class.rs b/tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p3-arrow-star-pointer-to-derived-class.rs new file mode 100644 index 0000000000..142ec20c97 --- /dev/null +++ b/tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p3-arrow-star-pointer-to-derived-class.rs @@ -0,0 +1,45 @@ +extern crate libcc2rs; +use libcc2rs::*; +use std::cell::RefCell; +use std::collections::BTreeMap; +use std::io::prelude::*; +use std::io::{Read, Seek, Write}; +use std::os::fd::AsFd; +use std::rc::{Rc, Weak}; +#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] +#[byte_size(4)] +pub struct Precedes { + #[offset(0)] + pub preceding: i32, +} +#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] +#[byte_size(4)] +pub struct DeclaresValue { + #[offset(0)] + pub value: i32, +} +#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] +#[byte_size(12)] +pub struct InheritsValue { + #[offset(8)] + pub own: i32, +} +pub fn main() { + __cpp2rust_init_globals(); + std::process::exit(main_0()); +} +fn main_0() -> i32 { + let mut pm: MemberPtr = member_ptr!(DeclaresValue, value); + let obj: Value = Rc::new(RefCell::new(::default())); + ((*obj.borrow_mut()) as Precedes).preceding = 1; + ((*obj.borrow_mut()) as DeclaresValue).value = 2; + (*obj.borrow_mut()).own = 3; + let mut p: Ptr = (obj.as_pointer()); + assert!((((p).member(pm).read()) == 2)); + (p).member(pm).write(4); + assert!(({ ({ ((*obj.borrow()) as DeclaresValue).value } == 4) })); + assert!(({ ({ ((*obj.borrow()) as Precedes).preceding } == 1) })); + assert!(({ ({ (*obj.borrow()).own } == 3) })); + return 0; +} +pub fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p3-arrow-star.rs b/tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p3-arrow-star.rs new file mode 100644 index 0000000000..4eafcc79d7 --- /dev/null +++ b/tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p3-arrow-star.rs @@ -0,0 +1,35 @@ +extern crate libcc2rs; +use libcc2rs::*; +use std::cell::RefCell; +use std::collections::BTreeMap; +use std::io::prelude::*; +use std::io::{Read, Seek, Write}; +use std::os::fd::AsFd; +use std::rc::{Rc, Weak}; +#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] +#[byte_size(8)] +pub struct HasTwoInts { + #[offset(0)] + pub first: i32, + #[offset(4)] + pub second: i32, +} +pub fn main() { + __cpp2rust_init_globals(); + std::process::exit(main_0()); +} +fn main_0() -> i32 { + let mut pm: MemberPtr = member_ptr!(HasTwoInts, second); + let obj: Value = Rc::new(RefCell::new(HasTwoInts { + first: 3, + second: 4, + })); + let mut p: Ptr = (obj.as_pointer()); + assert!((((p).member(pm).read()) == 4)); + (p).member(pm).write(5); + assert!(({ ({ (*obj.borrow()).second } == 5) })); + assert!(({ ({ (*obj.borrow()).first } == 3) })); + assert!((((p).member(pm)) == ((p).member(pm)))); + return 0; +} +pub fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p4-object-expression-sequenced-first.rs b/tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p4-object-expression-sequenced-first.rs new file mode 100644 index 0000000000..891b967771 --- /dev/null +++ b/tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p4-object-expression-sequenced-first.rs @@ -0,0 +1,57 @@ +extern crate libcc2rs; +use libcc2rs::*; +use std::cell::RefCell; +use std::collections::BTreeMap; +use std::io::prelude::*; +use std::io::{Read, Seek, Write}; +use std::os::fd::AsFd; +use std::rc::{Rc, Weak}; +#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] +#[byte_size(4)] +pub struct HasValue { + #[offset(0)] + pub value: i32, +} +thread_local!( + pub static sequence_0: Value = Rc::new(RefCell::new(0_i32)); +); +thread_local!( + pub static object_stamp_1: Value = Rc::new(RefCell::new(0_i32)); +); +thread_local!( + pub static member_stamp_2: Value = Rc::new(RefCell::new(0_i32)); +); +thread_local!( + pub static object_3: Value = Rc::new(RefCell::new(HasValue { value: 7 })); +); +pub fn select_object_4() -> Ptr { + object_stamp_1 + .with(|rc| *rc.borrow_mut() = (*sequence_0.with(Value::clone).borrow_mut()).prefix_inc()); + return object_3.with(|v| v.as_pointer()); +} +pub fn select_member_5() -> MemberPtr { + member_stamp_2 + .with(|rc| *rc.borrow_mut() = (*sequence_0.with(Value::clone).borrow_mut()).prefix_inc()); + return member_ptr!(HasValue, value); +} +pub fn main() { + __cpp2rust_init_globals(); + std::process::exit(main_0()); +} +fn main_0() -> i32 { + assert!( + ((({ select_object_4() }) + .member(({ select_member_5() })) + .read()) + == 7) + ); + assert!((object_stamp_1.with(|rc| *rc.borrow()) == 1)); + assert!((member_stamp_2.with(|rc| *rc.borrow()) == 2)); + return 0; +} +pub fn __cpp2rust_init_globals() { + let _ = sequence_0.with(|_| ()); + let _ = object_stamp_1.with(|_| ()); + let _ = member_stamp_2.with(|_| ()); + let _ = object_3.with(|_| ()); +} diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p6-data-member-of-lvalue-is-lvalue.rs b/tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p6-data-member-of-lvalue-is-lvalue.rs new file mode 100644 index 0000000000..7b5ac59a35 --- /dev/null +++ b/tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p6-data-member-of-lvalue-is-lvalue.rs @@ -0,0 +1,34 @@ +extern crate libcc2rs; +use libcc2rs::*; +use std::cell::RefCell; +use std::collections::BTreeMap; +use std::io::prelude::*; +use std::io::{Read, Seek, Write}; +use std::os::fd::AsFd; +use std::rc::{Rc, Weak}; +#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] +#[byte_size(8)] +pub struct HasTwoInts { + #[offset(0)] + pub first: i32, + #[offset(4)] + pub second: i32, +} +pub fn main() { + __cpp2rust_init_globals(); + std::process::exit(main_0()); +} +fn main_0() -> i32 { + let mut pm: MemberPtr = member_ptr!(HasTwoInts, second); + let obj: Value = Rc::new(RefCell::new(HasTwoInts { + first: 3, + second: 4, + })); + assert!((((obj.as_pointer()).member(pm)) == (field_ptr!(obj.as_pointer(), second)))); + let ref_: Ptr = (obj.as_pointer()).member(pm); + ref_.write(5); + assert!(({ ({ (*obj.borrow()).second } == 5) })); + assert!(({ ({ (*obj.borrow()).first } == 3) })); + return 0; +} +pub fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p6-data-member-of-rvalue-is-xvalue.rs b/tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p6-data-member-of-rvalue-is-xvalue.rs new file mode 100644 index 0000000000..17da7ba7ac --- /dev/null +++ b/tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p6-data-member-of-rvalue-is-xvalue.rs @@ -0,0 +1,70 @@ +extern crate libcc2rs; +use libcc2rs::*; +use std::cell::RefCell; +use std::collections::BTreeMap; +use std::io::prelude::*; +use std::io::{Read, Seek, Write}; +use std::os::fd::AsFd; +use std::rc::{Rc, Weak}; +thread_local!( + pub static copyCount_0: Value = Rc::new(RefCell::new(0)); +); +thread_local!( + pub static moveCount_1: Value = Rc::new(RefCell::new(0)); +); +#[derive(Record, ByteRepr, VaArg, FnPtrArg, MoveCtor, Default)] +#[byte_size(1)] +pub struct CountsCopiesAndMoves {} +impl CountsCopiesAndMoves { + pub fn copy_from(_a0: Ptr) -> Self { + let __this: CountsCopiesAndMoves = Self {}; + (*copyCount_0.with(Value::clone).borrow_mut()).prefix_inc(); + __this + } + pub fn move_from(_a0: Ptr) -> Self { + let __this: CountsCopiesAndMoves = Self {}; + (*moveCount_1.with(Value::clone).borrow_mut()).prefix_inc(); + __this + } +} +impl Clone for CountsCopiesAndMoves { + fn clone(&self) -> Self { + let __src: Value = Rc::new(RefCell::new(CountsCopiesAndMoves {})); + CountsCopiesAndMoves::copy_from(__src.as_pointer()) + } +} +#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, MoveCtor, Default)] +#[byte_size(1)] +pub struct HoldsCounted { + #[offset(0)] + #[byte_size(1)] + pub member: CountsCopiesAndMoves, +} +impl HoldsCounted { + pub fn move_from(_a0: Ptr) -> Self { + Self { + member: CountsCopiesAndMoves::move_from({ field_ptr!(_a0, member) }), + } + } +} +pub fn main() { + __cpp2rust_init_globals(); + std::process::exit(main_0()); +} +fn main_0() -> i32 { + let mut pm: MemberPtr = member_ptr!(HoldsCounted, member); + let holder: Value = Rc::new(RefCell::new(::default())); + let mut from_lvalue: CountsCopiesAndMoves = + CountsCopiesAndMoves::copy_from({ (holder.as_pointer()).member(pm) }); + assert!((copyCount_0.with(|rc| *rc.borrow()) == 1)); + assert!((moveCount_1.with(|rc| *rc.borrow()) == 0)); + let mut from_xvalue: CountsCopiesAndMoves = + CountsCopiesAndMoves::move_from({ (holder.as_pointer()).member(pm) }); + assert!((copyCount_0.with(|rc| *rc.borrow()) == 1)); + assert!((moveCount_1.with(|rc| *rc.borrow()) == 1)); + return 0; +} +pub fn __cpp2rust_init_globals() { + let _ = copyCount_0.with(|_| ()); + let _ = moveCount_1.with(|_| ()); +} diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p6-null-pointer-to-data-member.rs b/tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p6-null-pointer-to-data-member.rs new file mode 100644 index 0000000000..aff9b95623 --- /dev/null +++ b/tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p6-null-pointer-to-data-member.rs @@ -0,0 +1,29 @@ +extern crate libcc2rs; +use libcc2rs::*; +use std::cell::RefCell; +use std::collections::BTreeMap; +use std::io::prelude::*; +use std::io::{Read, Seek, Write}; +use std::os::fd::AsFd; +use std::rc::{Rc, Weak}; +#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] +#[byte_size(8)] +pub struct HasTwoInts { + #[offset(0)] + pub first: i32, + #[offset(4)] + pub second: i32, +} +pub fn main() { + __cpp2rust_init_globals(); + std::process::exit(main_0()); +} +fn main_0() -> i32 { + let mut pm: MemberPtr = >::default(); + let obj: Value = Rc::new(RefCell::new(HasTwoInts { + first: 3, + second: 4, + })); + return ((obj.as_pointer()).member(pm).read()); +} +pub fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p2-object-of-derived-class.rs b/tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p2-object-of-derived-class.rs new file mode 100644 index 0000000000..feb9de323c --- /dev/null +++ b/tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p2-object-of-derived-class.rs @@ -0,0 +1,44 @@ +extern crate libc; +use libc::*; +extern crate libcc2rs; +use libcc2rs::*; +use std::collections::BTreeMap; +use std::io::{Read, Seek, Write}; +use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; +use std::rc::Rc; +#[repr(C)] +#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] +pub struct Precedes { + pub preceding: i32, +} +#[repr(C)] +#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] +pub struct DeclaresValue { + pub value: i32, +} +#[repr(C)] +#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] +pub struct InheritsValue { + pub own: i32, +} +pub fn main() { + unsafe { + __cpp2rust_init_globals(); + std::process::exit(main_0() as i32); + } +} +unsafe fn main_0() -> i32 { + let mut pm: MemberPtr = + >::from_offset(::std::mem::offset_of!(DeclaresValue, value)); + let mut obj: InheritsValue = ::default(); + (obj as Precedes).preceding = 1; + (obj as DeclaresValue).value = 2; + obj.own = 3; + assert!(((*(&mut obj as *mut DeclaresValue).member(pm)) == (2))); + (*(&mut obj as *mut DeclaresValue).member(pm)) = 4; + assert!((((obj as DeclaresValue).value) == (4))); + assert!((((obj as Precedes).preceding) == (1))); + assert!(((obj.own) == (3))); + return 0; +} +pub unsafe fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p3-arrow-star-pointer-to-derived-class.rs b/tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p3-arrow-star-pointer-to-derived-class.rs new file mode 100644 index 0000000000..a9ed48054a --- /dev/null +++ b/tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p3-arrow-star-pointer-to-derived-class.rs @@ -0,0 +1,45 @@ +extern crate libc; +use libc::*; +extern crate libcc2rs; +use libcc2rs::*; +use std::collections::BTreeMap; +use std::io::{Read, Seek, Write}; +use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; +use std::rc::Rc; +#[repr(C)] +#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] +pub struct Precedes { + pub preceding: i32, +} +#[repr(C)] +#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] +pub struct DeclaresValue { + pub value: i32, +} +#[repr(C)] +#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] +pub struct InheritsValue { + pub own: i32, +} +pub fn main() { + unsafe { + __cpp2rust_init_globals(); + std::process::exit(main_0() as i32); + } +} +unsafe fn main_0() -> i32 { + let mut pm: MemberPtr = + >::from_offset(::std::mem::offset_of!(DeclaresValue, value)); + let mut obj: InheritsValue = ::default(); + (obj as Precedes).preceding = 1; + (obj as DeclaresValue).value = 2; + obj.own = 3; + let mut p: *mut InheritsValue = (&mut obj as *mut InheritsValue); + assert!(((*(p).member(pm)) == (2))); + (*(p).member(pm)) = 4; + assert!((((obj as DeclaresValue).value) == (4))); + assert!((((obj as Precedes).preceding) == (1))); + assert!(((obj.own) == (3))); + return 0; +} +pub unsafe fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p3-arrow-star.rs b/tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p3-arrow-star.rs new file mode 100644 index 0000000000..b174fd9c24 --- /dev/null +++ b/tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p3-arrow-star.rs @@ -0,0 +1,39 @@ +extern crate libc; +use libc::*; +extern crate libcc2rs; +use libcc2rs::*; +use std::collections::BTreeMap; +use std::io::{Read, Seek, Write}; +use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; +use std::rc::Rc; +#[repr(C)] +#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] +pub struct HasTwoInts { + pub first: i32, + pub second: i32, +} +pub fn main() { + unsafe { + __cpp2rust_init_globals(); + std::process::exit(main_0() as i32); + } +} +unsafe fn main_0() -> i32 { + let mut pm: MemberPtrUnsafe = + >::from_offset(::std::mem::offset_of!(HasTwoInts, second)); + let mut obj: HasTwoInts = HasTwoInts { + first: 3, + second: 4, + }; + let mut p: *mut HasTwoInts = (&mut obj as *mut HasTwoInts); + assert!(((*(p).member(pm)) == (4))); + (*(p).member(pm)) = 5; + assert!(((obj.second) == (5))); + assert!(((obj.first) == (3))); + assert!( + ((&mut (*(p).member(pm)) as *mut i32) + == (&mut (*(&mut (*p) as *mut HasTwoInts).member(pm)) as *mut i32)) + ); + return 0; +} +pub unsafe fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p4-object-expression-sequenced-first.rs b/tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p4-object-expression-sequenced-first.rs new file mode 100644 index 0000000000..72ee744095 --- /dev/null +++ b/tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p4-object-expression-sequenced-first.rs @@ -0,0 +1,48 @@ +extern crate libc; +use libc::*; +extern crate libcc2rs; +use libcc2rs::*; +use std::collections::BTreeMap; +use std::io::{Read, Seek, Write}; +use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; +use std::rc::Rc; +#[repr(C)] +#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] +pub struct HasValue { + pub value: i32, +} +pub static mut sequence_0: std::cell::LazyCell = std::cell::LazyCell::new(|| unsafe { 0_i32 }); +pub static mut object_stamp_1: std::cell::LazyCell = + std::cell::LazyCell::new(|| unsafe { 0_i32 }); +pub static mut member_stamp_2: std::cell::LazyCell = + std::cell::LazyCell::new(|| unsafe { 0_i32 }); +pub static mut object_3: std::cell::LazyCell = + std::cell::LazyCell::new(|| unsafe { HasValue { value: 7 } }); +pub unsafe fn select_object_4() -> *mut HasValue { + (*std::cell::LazyCell::force_mut(&mut *&raw mut object_stamp_1)) = + (*std::cell::LazyCell::force_mut(&mut *&raw mut sequence_0)).prefix_inc(); + return &mut (*std::cell::LazyCell::force_mut(&mut *&raw mut object_3)); +} +pub unsafe fn select_member_5() -> MemberPtrUnsafe { + (*std::cell::LazyCell::force_mut(&mut *&raw mut member_stamp_2)) = + (*std::cell::LazyCell::force_mut(&mut *&raw mut sequence_0)).prefix_inc(); + return >::from_offset(::std::mem::offset_of!(HasValue, value)); +} +pub fn main() { + unsafe { + __cpp2rust_init_globals(); + std::process::exit(main_0() as i32); + } +} +unsafe fn main_0() -> i32 { + assert!(((*(unsafe { select_object_4() }).member((unsafe { select_member_5() }))) == (7))); + assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut object_stamp_1)) == (1))); + assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut member_stamp_2)) == (2))); + return 0; +} +pub unsafe fn __cpp2rust_init_globals() { + std::cell::LazyCell::force(&*&raw const sequence_0); + std::cell::LazyCell::force(&*&raw const object_stamp_1); + std::cell::LazyCell::force(&*&raw const member_stamp_2); + std::cell::LazyCell::force(&*&raw const object_3); +} diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p4-object-type-not-similar.rs b/tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p4-object-type-not-similar.rs new file mode 100644 index 0000000000..e4fec1b297 --- /dev/null +++ b/tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p4-object-type-not-similar.rs @@ -0,0 +1,36 @@ +extern crate libc; +use libc::*; +extern crate libcc2rs; +use libcc2rs::*; +use std::collections::BTreeMap; +use std::io::{Read, Seek, Write}; +use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; +use std::rc::Rc; +#[repr(C)] +#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] +pub struct HasTwoInts { + pub first: i32, + pub second: i32, +} +#[repr(C)] +#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] +pub struct HasTwoShorts { + pub first: i16, + pub second: i16, +} +pub fn main() { + unsafe { + __cpp2rust_init_globals(); + std::process::exit(main_0() as i32); + } +} +unsafe fn main_0() -> i32 { + let mut pm: MemberPtrUnsafe = + >::from_offset(::std::mem::offset_of!(HasTwoInts, second)); + let mut obj: HasTwoShorts = HasTwoShorts { + first: 3_i16, + second: 4_i16, + }; + return (*(&mut obj as *mut HasTwoInts).member(pm)); +} +pub unsafe fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p6-data-member-of-lvalue-is-lvalue.rs b/tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p6-data-member-of-lvalue-is-lvalue.rs new file mode 100644 index 0000000000..7a7bf49cd4 --- /dev/null +++ b/tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p6-data-member-of-lvalue-is-lvalue.rs @@ -0,0 +1,38 @@ +extern crate libc; +use libc::*; +extern crate libcc2rs; +use libcc2rs::*; +use std::collections::BTreeMap; +use std::io::{Read, Seek, Write}; +use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; +use std::rc::Rc; +#[repr(C)] +#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] +pub struct HasTwoInts { + pub first: i32, + pub second: i32, +} +pub fn main() { + unsafe { + __cpp2rust_init_globals(); + std::process::exit(main_0() as i32); + } +} +unsafe fn main_0() -> i32 { + let mut pm: MemberPtrUnsafe = + >::from_offset(::std::mem::offset_of!(HasTwoInts, second)); + let mut obj: HasTwoInts = HasTwoInts { + first: 3, + second: 4, + }; + assert!( + ((&mut (*(&mut obj as *mut HasTwoInts).member(pm)) as *mut i32) + == (&mut obj.second as *mut i32)) + ); + let ref_: *mut i32 = &mut (*(&mut obj as *mut HasTwoInts).member(pm)); + (*ref_) = 5; + assert!(((obj.second) == (5))); + assert!(((obj.first) == (3))); + return 0; +} +pub unsafe fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p6-data-member-of-rvalue-is-xvalue.rs b/tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p6-data-member-of-rvalue-is-xvalue.rs new file mode 100644 index 0000000000..4087c54ed8 --- /dev/null +++ b/tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p6-data-member-of-rvalue-is-xvalue.rs @@ -0,0 +1,70 @@ +extern crate libc; +use libc::*; +extern crate libcc2rs; +use libcc2rs::*; +use std::collections::BTreeMap; +use std::io::{Read, Seek, Write}; +use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; +use std::rc::Rc; +pub static mut copyCount_0: std::cell::LazyCell = std::cell::LazyCell::new(|| unsafe { 0 }); +pub static mut moveCount_1: std::cell::LazyCell = std::cell::LazyCell::new(|| unsafe { 0 }); +#[repr(C)] +#[derive(VaArg, FnPtrArg, MoveCtorUnsafe, Default)] +pub struct CountsCopiesAndMoves {} +impl CountsCopiesAndMoves { + pub unsafe fn copy_from(_a0: *const CountsCopiesAndMoves) -> Self { + let mut this = Self {}; + (*std::cell::LazyCell::force_mut(&mut *&raw mut copyCount_0)).prefix_inc(); + this + } + pub unsafe fn move_from(_a0: *mut CountsCopiesAndMoves) -> Self { + let mut this = Self {}; + (*std::cell::LazyCell::force_mut(&mut *&raw mut moveCount_1)).prefix_inc(); + this + } +} +impl Clone for CountsCopiesAndMoves { + fn clone(&self) -> Self { + unsafe { CountsCopiesAndMoves::copy_from(self as *const CountsCopiesAndMoves) } + } +} +#[repr(C)] +#[derive(Clone, VaArg, FnPtrArg, MoveCtorUnsafe, Default)] +pub struct HoldsCounted { + pub member: CountsCopiesAndMoves, +} +impl HoldsCounted { + pub unsafe fn move_from(_a0: *mut HoldsCounted) -> Self { + let mut this = Self { + member: CountsCopiesAndMoves::move_from({ &mut (*_a0).member }), + }; + this + } +} +pub fn main() { + unsafe { + __cpp2rust_init_globals(); + std::process::exit(main_0() as i32); + } +} +unsafe fn main_0() -> i32 { + let mut pm: MemberPtrUnsafe = + >::from_offset(::std::mem::offset_of!( + HoldsCounted, + member + )); + let mut holder: HoldsCounted = ::default(); + let mut from_lvalue: CountsCopiesAndMoves = + CountsCopiesAndMoves::copy_from({ &(*(&mut holder as *mut HoldsCounted).member(pm)) }); + assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut copyCount_0)) == (1))); + assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut moveCount_1)) == (0))); + let mut from_xvalue: CountsCopiesAndMoves = + CountsCopiesAndMoves::move_from({ &mut (*(&mut holder as *mut HoldsCounted).member(pm)) }); + assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut copyCount_0)) == (1))); + assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut moveCount_1)) == (1))); + return 0; +} +pub unsafe fn __cpp2rust_init_globals() { + std::cell::LazyCell::force(&*&raw const copyCount_0); + std::cell::LazyCell::force(&*&raw const moveCount_1); +} diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p6-null-pointer-to-data-member.rs b/tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p6-null-pointer-to-data-member.rs new file mode 100644 index 0000000000..f7455947ff --- /dev/null +++ b/tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p6-null-pointer-to-data-member.rs @@ -0,0 +1,29 @@ +extern crate libc; +use libc::*; +extern crate libcc2rs; +use libcc2rs::*; +use std::collections::BTreeMap; +use std::io::{Read, Seek, Write}; +use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; +use std::rc::Rc; +#[repr(C)] +#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] +pub struct HasTwoInts { + pub first: i32, + pub second: i32, +} +pub fn main() { + unsafe { + __cpp2rust_init_globals(); + std::process::exit(main_0() as i32); + } +} +unsafe fn main_0() -> i32 { + let mut pm: MemberPtrUnsafe = >::default(); + let mut obj: HasTwoInts = HasTwoInts { + first: 3, + second: 4, + }; + return (*(&mut obj as *mut HasTwoInts).member(pm)); +} +pub unsafe fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/p2-object-of-derived-class.cpp b/tests/std/expr/expr.compound/expr.mptr.oper/p2-object-of-derived-class.cpp index 666c7eed70..0ceef4799c 100644 --- a/tests/std/expr/expr.compound/expr.mptr.oper/p2-object-of-derived-class.cpp +++ b/tests/std/expr/expr.compound/expr.mptr.oper/p2-object-of-derived-class.cpp @@ -1,4 +1,4 @@ -// translation-fail: refcount, unsafe +// no-compile: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [expr.mptr.oper]/2: .* binds a "pointer to member of T" to a glvalue // of class T or of a class of which T is an unambiguous and accessible base. diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/p3-arrow-star-pointer-to-derived-class.cpp b/tests/std/expr/expr.compound/expr.mptr.oper/p3-arrow-star-pointer-to-derived-class.cpp index 59342d8cbd..e0612bfdac 100644 --- a/tests/std/expr/expr.compound/expr.mptr.oper/p3-arrow-star-pointer-to-derived-class.cpp +++ b/tests/std/expr/expr.compound/expr.mptr.oper/p3-arrow-star-pointer-to-derived-class.cpp @@ -1,4 +1,4 @@ -// translation-fail: refcount, unsafe +// no-compile: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [expr.mptr.oper]/3: the first operand of ->* is a "pointer to U" where // U is T or a class of which T is an unambiguous and accessible base. diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/p3-arrow-star.cpp b/tests/std/expr/expr.compound/expr.mptr.oper/p3-arrow-star.cpp index bba387eb05..e144c9c8d6 100644 --- a/tests/std/expr/expr.compound/expr.mptr.oper/p3-arrow-star.cpp +++ b/tests/std/expr/expr.compound/expr.mptr.oper/p3-arrow-star.cpp @@ -1,4 +1,3 @@ -// translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [expr.mptr.oper]/3: E1->*E2 is converted into (*(E1)).*E2. #include diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/p4-object-expression-sequenced-first.cpp b/tests/std/expr/expr.compound/expr.mptr.oper/p4-object-expression-sequenced-first.cpp index 2ebf23b79b..70932c22c4 100644 --- a/tests/std/expr/expr.compound/expr.mptr.oper/p4-object-expression-sequenced-first.cpp +++ b/tests/std/expr/expr.compound/expr.mptr.oper/p4-object-expression-sequenced-first.cpp @@ -1,4 +1,3 @@ -// translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [expr.mptr.oper]/4: in E1.*E2, E1 is sequenced before E2. #include diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/p4-object-type-not-similar.cpp b/tests/std/expr/expr.compound/expr.mptr.oper/p4-object-type-not-similar.cpp index c3c974d676..a5e9643f8b 100644 --- a/tests/std/expr/expr.compound/expr.mptr.oper/p4-object-type-not-similar.cpp +++ b/tests/std/expr/expr.compound/expr.mptr.oper/p4-object-type-not-similar.cpp @@ -1,4 +1,3 @@ -// translation-fail: refcount, unsafe // panic-ub: refcount // nondet-result: unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/p6-data-member-of-lvalue-is-lvalue.cpp b/tests/std/expr/expr.compound/expr.mptr.oper/p6-data-member-of-lvalue-is-lvalue.cpp index 25d2a9a1b8..872f4f872d 100644 --- a/tests/std/expr/expr.compound/expr.mptr.oper/p6-data-member-of-lvalue-is-lvalue.cpp +++ b/tests/std/expr/expr.compound/expr.mptr.oper/p6-data-member-of-lvalue-is-lvalue.cpp @@ -1,4 +1,3 @@ -// translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [expr.mptr.oper]/6: the result of .* with a pointer to data member is // an lvalue if the first operand is an lvalue. diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/p6-data-member-of-rvalue-is-xvalue.cpp b/tests/std/expr/expr.compound/expr.mptr.oper/p6-data-member-of-rvalue-is-xvalue.cpp index 9cf2d636d5..5f76b1b90f 100644 --- a/tests/std/expr/expr.compound/expr.mptr.oper/p6-data-member-of-rvalue-is-xvalue.cpp +++ b/tests/std/expr/expr.compound/expr.mptr.oper/p6-data-member-of-rvalue-is-xvalue.cpp @@ -1,4 +1,3 @@ -// translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [expr.mptr.oper]/6: the result of .* with a pointer to data member is // an lvalue if the first operand is an lvalue and an xvalue otherwise. diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/p6-null-pointer-to-data-member.cpp b/tests/std/expr/expr.compound/expr.mptr.oper/p6-null-pointer-to-data-member.cpp index 6fb2193672..0429af16ac 100644 --- a/tests/std/expr/expr.compound/expr.mptr.oper/p6-null-pointer-to-data-member.cpp +++ b/tests/std/expr/expr.compound/expr.mptr.oper/p6-null-pointer-to-data-member.cpp @@ -1,4 +1,3 @@ -// translation-fail: refcount, unsafe // panic-ub: refcount // nondet-result: unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 diff --git a/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/out/unsafe/p10-null-converts-to-null.rs b/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/out/unsafe/p10-null-converts-to-null.rs new file mode 100644 index 0000000000..9f05d142aa --- /dev/null +++ b/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/out/unsafe/p10-null-converts-to-null.rs @@ -0,0 +1,33 @@ +extern crate libc; +use libc::*; +extern crate libcc2rs; +use libcc2rs::*; +use std::collections::BTreeMap; +use std::io::{Read, Seek, Write}; +use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; +use std::rc::Rc; +#[repr(C)] +#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] +pub struct HasTwoInts { + pub first: i32, + pub second: i32, +} +#[repr(C)] +#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] +pub struct HasChar { + pub character: libc::c_char, +} +pub fn main() { + unsafe { + __cpp2rust_init_globals(); + std::process::exit(main_0() as i32); + } +} +unsafe fn main_0() -> i32 { + let mut pm: MemberPtrUnsafe = >::default(); + let mut converted: MemberPtrUnsafe = + >::cast_from(pm); + assert!((converted).is_null()); + return 0; +} +pub unsafe fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/out/unsafe/p10-result-is-unspecified.rs b/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/out/unsafe/p10-result-is-unspecified.rs new file mode 100644 index 0000000000..f910f3a849 --- /dev/null +++ b/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/out/unsafe/p10-result-is-unspecified.rs @@ -0,0 +1,40 @@ +extern crate libc; +use libc::*; +extern crate libcc2rs; +use libcc2rs::*; +use std::collections::BTreeMap; +use std::io::{Read, Seek, Write}; +use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; +use std::rc::Rc; +#[repr(C)] +#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] +pub struct HasTwoInts { + pub first: i32, + pub second: i32, +} +#[repr(C)] +#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] +pub struct AlsoHasTwoInts { + pub first: i32, + pub second: i32, +} +pub fn main() { + unsafe { + __cpp2rust_init_globals(); + std::process::exit(main_0() as i32); + } +} +unsafe fn main_0() -> i32 { + let mut converted: MemberPtrUnsafe = + >::cast_from( + >::from_offset(::std::mem::offset_of!( + HasTwoInts, second + )), + ); + return (((converted) + == (>::from_offset(::std::mem::offset_of!( + AlsoHasTwoInts, + second + )))) as i32); +} +pub unsafe fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/out/unsafe/p10.2-data-member-round-trip.rs b/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/out/unsafe/p10.2-data-member-round-trip.rs new file mode 100644 index 0000000000..7be913ac2f --- /dev/null +++ b/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/out/unsafe/p10.2-data-member-round-trip.rs @@ -0,0 +1,48 @@ +extern crate libc; +use libc::*; +extern crate libcc2rs; +use libcc2rs::*; +use std::collections::BTreeMap; +use std::io::{Read, Seek, Write}; +use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; +use std::rc::Rc; +#[repr(C)] +#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] +pub struct HasTwoInts { + pub first: i32, + pub second: i32, +} +#[repr(C)] +#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] +pub struct HasChar { + pub character: libc::c_char, +} +pub fn main() { + unsafe { + __cpp2rust_init_globals(); + std::process::exit(main_0() as i32); + } +} +unsafe fn main_0() -> i32 { + let mut converted: MemberPtrUnsafe = + >::cast_from( + >::from_offset(::std::mem::offset_of!( + HasTwoInts, second + )), + ); + let mut back: MemberPtrUnsafe = + >::cast_from(converted); + assert!( + ((back) + == (>::from_offset(::std::mem::offset_of!( + HasTwoInts, second + )))) + ); + let mut obj: HasTwoInts = HasTwoInts { + first: 3, + second: 4, + }; + assert!(((*(&mut obj as *mut HasTwoInts).member(back)) == (4))); + return 0; +} +pub unsafe fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/p10-null-converts-to-null.cpp b/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/p10-null-converts-to-null.cpp index 0569858cb6..0e25e92190 100644 --- a/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/p10-null-converts-to-null.cpp +++ b/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/p10-null-converts-to-null.cpp @@ -1,4 +1,3 @@ -// translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [expr.reinterpret.cast]/10: the null member pointer value is converted // to the null member pointer value of the destination type. diff --git a/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/p10-result-is-unspecified.cpp b/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/p10-result-is-unspecified.cpp index f126bd9363..93a1076f81 100644 --- a/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/p10-result-is-unspecified.cpp +++ b/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/p10-result-is-unspecified.cpp @@ -1,4 +1,3 @@ -// translation-fail: refcount, unsafe // nondet-result // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [expr.reinterpret.cast]/10: the result of converting a pointer to diff --git a/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/p10.2-data-member-round-trip.cpp b/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/p10.2-data-member-round-trip.cpp index d7302ed5b3..c81149f721 100644 --- a/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/p10.2-data-member-round-trip.cpp +++ b/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/p10.2-data-member-round-trip.cpp @@ -1,4 +1,3 @@ -// translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [expr.reinterpret.cast]/10.2: converting "pointer to data member of X // of type T1" to "pointer to data member of Y of type T2" (T2 no more strictly diff --git a/tests/std/expr/expr.compound/expr.unary/expr.unary.op/out/refcount/p3.1-member-named-through-derived-class.rs b/tests/std/expr/expr.compound/expr.unary/expr.unary.op/out/refcount/p3.1-member-named-through-derived-class.rs new file mode 100644 index 0000000000..0f9324a7df --- /dev/null +++ b/tests/std/expr/expr.compound/expr.unary/expr.unary.op/out/refcount/p3.1-member-named-through-derived-class.rs @@ -0,0 +1,35 @@ +extern crate libcc2rs; +use libcc2rs::*; +use std::cell::RefCell; +use std::collections::BTreeMap; +use std::io::prelude::*; +use std::io::{Read, Seek, Write}; +use std::os::fd::AsFd; +use std::rc::{Rc, Weak}; +#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] +#[byte_size(4)] +pub struct DeclaresValue { + #[offset(0)] + pub value: i32, +} +#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] +#[byte_size(8)] +pub struct InheritsValue { + #[offset(4)] + pub own: i32, +} +pub fn main() { + __cpp2rust_init_globals(); + std::process::exit(main_0()); +} +fn main_0() -> i32 { + let mut pm: MemberPtr = member_ptr!(DeclaresValue, value); + let base: Value = Rc::new(RefCell::new(DeclaresValue { value: 3 })); + assert!((((base.as_pointer()).member(pm).read()) == 3)); + let derived: Value = Rc::new(RefCell::new(InheritsValue { + own: DeclaresValue { value: 4 }, + })); + assert!((((derived.as_pointer()).member(pm).read()) == 4)); + return 0; +} +pub fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/expr.compound/expr.unary/expr.unary.op/out/unsafe/p3.1-member-named-through-derived-class.rs b/tests/std/expr/expr.compound/expr.unary/expr.unary.op/out/unsafe/p3.1-member-named-through-derived-class.rs new file mode 100644 index 0000000000..f98656d82d --- /dev/null +++ b/tests/std/expr/expr.compound/expr.unary/expr.unary.op/out/unsafe/p3.1-member-named-through-derived-class.rs @@ -0,0 +1,36 @@ +extern crate libc; +use libc::*; +extern crate libcc2rs; +use libcc2rs::*; +use std::collections::BTreeMap; +use std::io::{Read, Seek, Write}; +use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; +use std::rc::Rc; +#[repr(C)] +#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] +pub struct DeclaresValue { + pub value: i32, +} +#[repr(C)] +#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] +pub struct InheritsValue { + pub own: i32, +} +pub fn main() { + unsafe { + __cpp2rust_init_globals(); + std::process::exit(main_0() as i32); + } +} +unsafe fn main_0() -> i32 { + let mut pm: MemberPtr = + >::from_offset(::std::mem::offset_of!(DeclaresValue, value)); + let mut base: DeclaresValue = DeclaresValue { value: 3 }; + assert!(((*(&mut base as *mut DeclaresValue).member(pm)) == (3))); + let mut derived: InheritsValue = InheritsValue { + own: DeclaresValue { value: 4 }, + }; + assert!(((*(&mut derived as *mut DeclaresValue).member(pm)) == (4))); + return 0; +} +pub unsafe fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/expr.compound/expr.unary/expr.unary.op/p3.1-anonymous-union-member.cpp b/tests/std/expr/expr.compound/expr.unary/expr.unary.op/p3.1-anonymous-union-member.cpp index a472196d4e..5b7c95dab7 100644 --- a/tests/std/expr/expr.compound/expr.unary/expr.unary.op/p3.1-anonymous-union-member.cpp +++ b/tests/std/expr/expr.compound/expr.unary/expr.unary.op/p3.1-anonymous-union-member.cpp @@ -1,4 +1,3 @@ -// translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [expr.unary.op]/3.1: a qualified-id naming a variant member of some // class C yields a pointer to member of class C. diff --git a/tests/std/expr/expr.compound/expr.unary/expr.unary.op/p3.1-member-named-through-derived-class.cpp b/tests/std/expr/expr.compound/expr.unary/expr.unary.op/p3.1-member-named-through-derived-class.cpp index 4ce1eb21f5..5082576eb2 100644 --- a/tests/std/expr/expr.compound/expr.unary/expr.unary.op/p3.1-member-named-through-derived-class.cpp +++ b/tests/std/expr/expr.compound/expr.unary/expr.unary.op/p3.1-member-named-through-derived-class.cpp @@ -1,4 +1,4 @@ -// translation-fail: refcount, unsafe +// no-compile: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [expr.unary.op]/3.1: for a qualified-id naming a non-static member m // of some class C, the result has type "pointer to member of class C" and diff --git a/tests/std/temp/temp.type/out/refcount/p2.6-pointer-to-member-argument.rs b/tests/std/temp/temp.type/out/refcount/p2.6-pointer-to-member-argument.rs new file mode 100644 index 0000000000..d95a5b7b9e --- /dev/null +++ b/tests/std/temp/temp.type/out/refcount/p2.6-pointer-to-member-argument.rs @@ -0,0 +1,58 @@ +extern crate libcc2rs; +use libcc2rs::*; +use std::cell::RefCell; +use std::collections::BTreeMap; +use std::io::prelude::*; +use std::io::{Read, Seek, Write}; +use std::os::fd::AsFd; +use std::rc::{Rc, Weak}; +#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] +#[byte_size(8)] +pub struct HasTwoInts { + #[offset(0)] + pub first: i32, + #[offset(4)] + pub second: i32, +} +thread_local!( + pub static count_0: Value = Rc::new(RefCell::new(0)); +); +#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] +#[byte_size(1)] +pub struct CountsPerMember_refHasTwoInts_first_ {} +thread_local!( + pub static count_1: Value = Rc::new(RefCell::new(0)); +); +#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] +#[byte_size(1)] +pub struct CountsPerMember_refHasTwoInts_second_ {} +thread_local!( + pub static count_2: Value = Rc::new(RefCell::new(0)); +); +#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] +#[byte_size(1)] +pub struct CountsPerMember_nullptr_ {} +pub fn main() { + __cpp2rust_init_globals(); + std::process::exit(main_0()); +} +fn main_0() -> i32 { + (*count_0.with(Value::clone).borrow_mut()).prefix_inc(); + assert!((count_0.with(|rc| *rc.borrow()) == 1)); + assert!((count_1.with(|rc| *rc.borrow()) == 0)); + assert!((count_2.with(|rc| *rc.borrow()) == 0)); + count_1.with(|rc| *rc.borrow_mut() += 2); + assert!((count_0.with(|rc| *rc.borrow()) == 1)); + assert!((count_1.with(|rc| *rc.borrow()) == 2)); + assert!((count_2.with(|rc| *rc.borrow()) == 0)); + count_2.with(|rc| *rc.borrow_mut() += 3); + assert!((count_0.with(|rc| *rc.borrow()) == 1)); + assert!((count_1.with(|rc| *rc.borrow()) == 2)); + assert!((count_2.with(|rc| *rc.borrow()) == 3)); + return 0; +} +pub fn __cpp2rust_init_globals() { + let _ = count_0.with(|_| ()); + let _ = count_1.with(|_| ()); + let _ = count_2.with(|_| ()); +} diff --git a/tests/std/temp/temp.type/out/unsafe/p2.6-pointer-to-member-argument.rs b/tests/std/temp/temp.type/out/unsafe/p2.6-pointer-to-member-argument.rs new file mode 100644 index 0000000000..b8768d486a --- /dev/null +++ b/tests/std/temp/temp.type/out/unsafe/p2.6-pointer-to-member-argument.rs @@ -0,0 +1,52 @@ +extern crate libc; +use libc::*; +extern crate libcc2rs; +use libcc2rs::*; +use std::collections::BTreeMap; +use std::io::{Read, Seek, Write}; +use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; +use std::rc::Rc; +#[repr(C)] +#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] +pub struct HasTwoInts { + pub first: i32, + pub second: i32, +} +pub static mut count_0: std::cell::LazyCell = std::cell::LazyCell::new(|| unsafe { 0 }); +#[repr(C)] +#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] +pub struct CountsPerMember_refHasTwoInts_first_ {} +pub static mut count_1: std::cell::LazyCell = std::cell::LazyCell::new(|| unsafe { 0 }); +#[repr(C)] +#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] +pub struct CountsPerMember_refHasTwoInts_second_ {} +pub static mut count_2: std::cell::LazyCell = std::cell::LazyCell::new(|| unsafe { 0 }); +#[repr(C)] +#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] +pub struct CountsPerMember_nullptr_ {} +pub fn main() { + unsafe { + __cpp2rust_init_globals(); + std::process::exit(main_0() as i32); + } +} +unsafe fn main_0() -> i32 { + (*std::cell::LazyCell::force_mut(&mut *&raw mut count_0)).prefix_inc(); + assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut count_0)) == (1))); + assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut count_1)) == (0))); + assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut count_2)) == (0))); + (*std::cell::LazyCell::force_mut(&mut *&raw mut count_1)) += 2; + assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut count_0)) == (1))); + assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut count_1)) == (2))); + assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut count_2)) == (0))); + (*std::cell::LazyCell::force_mut(&mut *&raw mut count_2)) += 3; + assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut count_0)) == (1))); + assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut count_1)) == (2))); + assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut count_2)) == (3))); + return 0; +} +pub unsafe fn __cpp2rust_init_globals() { + std::cell::LazyCell::force(&*&raw const count_0); + std::cell::LazyCell::force(&*&raw const count_1); + std::cell::LazyCell::force(&*&raw const count_2); +} diff --git a/tests/std/temp/temp.type/p2.6-pointer-to-member-argument.cpp b/tests/std/temp/temp.type/p2.6-pointer-to-member-argument.cpp index c691c1c862..6c41ec8c6a 100644 --- a/tests/std/temp/temp.type/p2.6-pointer-to-member-argument.cpp +++ b/tests/std/temp/temp.type/p2.6-pointer-to-member-argument.cpp @@ -1,4 +1,3 @@ -// translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [temp.type]/2.6: two values of pointer-to-member type are // template-argument-equivalent if they refer to the same class member or are diff --git a/tests/std/utilities/function.objects/func.require/out/refcount/p1.4-data-member-with-object.rs b/tests/std/utilities/function.objects/func.require/out/refcount/p1.4-data-member-with-object.rs new file mode 100644 index 0000000000..707998585a --- /dev/null +++ b/tests/std/utilities/function.objects/func.require/out/refcount/p1.4-data-member-with-object.rs @@ -0,0 +1,39 @@ +extern crate libcc2rs; +use libcc2rs::*; +use std::cell::RefCell; +use std::collections::BTreeMap; +use std::io::prelude::*; +use std::io::{Read, Seek, Write}; +use std::os::fd::AsFd; +use std::rc::{Rc, Weak}; +#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] +#[byte_size(8)] +pub struct HasTwoInts { + #[offset(0)] + pub first: i32, + #[offset(4)] + pub second: i32, +} +#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] +#[byte_size(8)] +pub struct InheritsTwoInts {} +pub fn main() { + __cpp2rust_init_globals(); + std::process::exit(main_0()); +} +fn main_0() -> i32 { + let pm: Value> = + Rc::new(RefCell::new(member_ptr!(HasTwoInts, second))); + let obj: Value = Rc::new(RefCell::new(HasTwoInts { + first: 3, + second: 4, + })); + assert!(((({ invoke_0(pm.as_pointer(), obj.as_pointer(),) }).read()) == 4)); + ({ invoke_0(pm.as_pointer(), obj.as_pointer()) }).write(5); + assert!(({ ({ (*obj.borrow()).second } == 5) })); + assert!(({ ({ (*obj.borrow()).first } == 3) })); + let derived: Value = Rc::new(RefCell::new(InheritsTwoInts {})); + assert!(((({ invoke_1(pm.as_pointer(), derived.as_pointer(),) }).read()) == 7)); + return 0; +} +pub fn __cpp2rust_init_globals() {} diff --git a/tests/std/utilities/function.objects/func.require/out/refcount/p1.5-data-member-with-reference-wrapper.rs b/tests/std/utilities/function.objects/func.require/out/refcount/p1.5-data-member-with-reference-wrapper.rs new file mode 100644 index 0000000000..12497c37ba --- /dev/null +++ b/tests/std/utilities/function.objects/func.require/out/refcount/p1.5-data-member-with-reference-wrapper.rs @@ -0,0 +1,49 @@ +extern crate libcc2rs; +use libcc2rs::*; +use std::cell::RefCell; +use std::collections::BTreeMap; +use std::io::prelude::*; +use std::io::{Read, Seek, Write}; +use std::os::fd::AsFd; +use std::rc::{Rc, Weak}; +#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] +#[byte_size(8)] +pub struct HasTwoInts { + #[offset(0)] + pub first: i32, + #[offset(4)] + pub second: i32, +} +#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] +#[byte_size(8)] +pub struct InheritsTwoInts {} +pub fn main() { + __cpp2rust_init_globals(); + std::process::exit(main_0()); +} +fn main_0() -> i32 { + let pm: Value> = + Rc::new(RefCell::new(member_ptr!(HasTwoInts, second))); + let obj: Value = Rc::new(RefCell::new(HasTwoInts { + first: 3, + second: 4, + })); + assert!( + ((({ + let ___args: Value> = + Rc::new(RefCell::new(({ ref_0(obj.as_pointer()) }))); + invoke_1(pm.as_pointer(), ___args.as_pointer()) + }) + .read()) + == 4) + ); + ({ + let ___args: Value> = Rc::new(RefCell::new(({ ref_0(obj.as_pointer()) }))); + invoke_1(pm.as_pointer(), ___args.as_pointer()) + }) + .write(5); + assert!(({ ({ (*obj.borrow()).second } == 5) })); + assert!(({ ({ (*obj.borrow()).first } == 3) })); + return 0; +} +pub fn __cpp2rust_init_globals() {} diff --git a/tests/std/utilities/function.objects/func.require/out/refcount/p1.6-data-member-with-pointer.rs b/tests/std/utilities/function.objects/func.require/out/refcount/p1.6-data-member-with-pointer.rs new file mode 100644 index 0000000000..96296b89ea --- /dev/null +++ b/tests/std/utilities/function.objects/func.require/out/refcount/p1.6-data-member-with-pointer.rs @@ -0,0 +1,48 @@ +extern crate libcc2rs; +use libcc2rs::*; +use std::cell::RefCell; +use std::collections::BTreeMap; +use std::io::prelude::*; +use std::io::{Read, Seek, Write}; +use std::os::fd::AsFd; +use std::rc::{Rc, Weak}; +#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] +#[byte_size(8)] +pub struct HasTwoInts { + #[offset(0)] + pub first: i32, + #[offset(4)] + pub second: i32, +} +#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] +#[byte_size(8)] +pub struct InheritsTwoInts {} +pub fn main() { + __cpp2rust_init_globals(); + std::process::exit(main_0()); +} +fn main_0() -> i32 { + let pm: Value> = + Rc::new(RefCell::new(member_ptr!(HasTwoInts, second))); + let obj: Value = Rc::new(RefCell::new(HasTwoInts { + first: 3, + second: 4, + })); + assert!( + ((({ + let ___args: Value> = Rc::new(RefCell::new((obj.as_pointer()))); + invoke_0(pm.as_pointer(), ___args.as_pointer()) + }) + .read()) + == 4) + ); + ({ + let ___args: Value> = Rc::new(RefCell::new((obj.as_pointer()))); + invoke_0(pm.as_pointer(), ___args.as_pointer()) + }) + .write(5); + assert!(({ ({ (*obj.borrow()).second } == 5) })); + assert!(({ ({ (*obj.borrow()).first } == 3) })); + return 0; +} +pub fn __cpp2rust_init_globals() {} diff --git a/tests/std/utilities/function.objects/func.require/out/unsafe/p1.4-data-member-with-object.rs b/tests/std/utilities/function.objects/func.require/out/unsafe/p1.4-data-member-with-object.rs new file mode 100644 index 0000000000..8b20395fd8 --- /dev/null +++ b/tests/std/utilities/function.objects/func.require/out/unsafe/p1.4-data-member-with-object.rs @@ -0,0 +1,39 @@ +extern crate libc; +use libc::*; +extern crate libcc2rs; +use libcc2rs::*; +use std::collections::BTreeMap; +use std::io::{Read, Seek, Write}; +use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; +use std::rc::Rc; +#[repr(C)] +#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] +pub struct HasTwoInts { + pub first: i32, + pub second: i32, +} +#[repr(C)] +#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] +pub struct InheritsTwoInts {} +pub fn main() { + unsafe { + __cpp2rust_init_globals(); + std::process::exit(main_0() as i32); + } +} +unsafe fn main_0() -> i32 { + let mut pm: MemberPtrUnsafe = + >::from_offset(::std::mem::offset_of!(HasTwoInts, second)); + let mut obj: HasTwoInts = HasTwoInts { + first: 3, + second: 4, + }; + assert!(((*(unsafe { invoke_0(&mut pm, &mut obj,) })) == (4))); + (*(unsafe { invoke_0(&mut pm, &mut obj) })) = 5; + assert!(((obj.second) == (5))); + assert!(((obj.first) == (3))); + let mut derived: InheritsTwoInts = InheritsTwoInts {}; + assert!(((*(unsafe { invoke_1(&mut pm, &mut derived,) })) == (7))); + return 0; +} +pub unsafe fn __cpp2rust_init_globals() {} diff --git a/tests/std/utilities/function.objects/func.require/out/unsafe/p1.5-data-member-with-reference-wrapper.rs b/tests/std/utilities/function.objects/func.require/out/unsafe/p1.5-data-member-with-reference-wrapper.rs new file mode 100644 index 0000000000..09c9a36a8c --- /dev/null +++ b/tests/std/utilities/function.objects/func.require/out/unsafe/p1.5-data-member-with-reference-wrapper.rs @@ -0,0 +1,45 @@ +extern crate libc; +use libc::*; +extern crate libcc2rs; +use libcc2rs::*; +use std::collections::BTreeMap; +use std::io::{Read, Seek, Write}; +use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; +use std::rc::Rc; +#[repr(C)] +#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] +pub struct HasTwoInts { + pub first: i32, + pub second: i32, +} +#[repr(C)] +#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] +pub struct InheritsTwoInts {} +pub fn main() { + unsafe { + __cpp2rust_init_globals(); + std::process::exit(main_0() as i32); + } +} +unsafe fn main_0() -> i32 { + let mut pm: MemberPtrUnsafe = + >::from_offset(::std::mem::offset_of!(HasTwoInts, second)); + let mut obj: HasTwoInts = HasTwoInts { + first: 3, + second: 4, + }; + assert!( + ((*(unsafe { + let mut ___args: *mut HasTwoInts = (unsafe { ref_0(&mut obj) }); + invoke_1(&mut pm, &mut ___args) + })) == (4)) + ); + (*(unsafe { + let mut ___args: *mut HasTwoInts = (unsafe { ref_0(&mut obj) }); + invoke_1(&mut pm, &mut ___args) + })) = 5; + assert!(((obj.second) == (5))); + assert!(((obj.first) == (3))); + return 0; +} +pub unsafe fn __cpp2rust_init_globals() {} diff --git a/tests/std/utilities/function.objects/func.require/out/unsafe/p1.6-data-member-with-pointer.rs b/tests/std/utilities/function.objects/func.require/out/unsafe/p1.6-data-member-with-pointer.rs new file mode 100644 index 0000000000..72401dec55 --- /dev/null +++ b/tests/std/utilities/function.objects/func.require/out/unsafe/p1.6-data-member-with-pointer.rs @@ -0,0 +1,45 @@ +extern crate libc; +use libc::*; +extern crate libcc2rs; +use libcc2rs::*; +use std::collections::BTreeMap; +use std::io::{Read, Seek, Write}; +use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; +use std::rc::Rc; +#[repr(C)] +#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] +pub struct HasTwoInts { + pub first: i32, + pub second: i32, +} +#[repr(C)] +#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] +pub struct InheritsTwoInts {} +pub fn main() { + unsafe { + __cpp2rust_init_globals(); + std::process::exit(main_0() as i32); + } +} +unsafe fn main_0() -> i32 { + let mut pm: MemberPtrUnsafe = + >::from_offset(::std::mem::offset_of!(HasTwoInts, second)); + let mut obj: HasTwoInts = HasTwoInts { + first: 3, + second: 4, + }; + assert!( + ((*(unsafe { + let mut ___args: *mut HasTwoInts = (&mut obj as *mut HasTwoInts); + invoke_0(&mut pm, &mut ___args) + })) == (4)) + ); + (*(unsafe { + let mut ___args: *mut HasTwoInts = (&mut obj as *mut HasTwoInts); + invoke_0(&mut pm, &mut ___args) + })) = 5; + assert!(((obj.second) == (5))); + assert!(((obj.first) == (3))); + return 0; +} +pub unsafe fn __cpp2rust_init_globals() {} diff --git a/tests/std/utilities/function.objects/func.require/p1.4-data-member-with-object.cpp b/tests/std/utilities/function.objects/func.require/p1.4-data-member-with-object.cpp index 1185ea172c..0cd1dd5a59 100644 --- a/tests/std/utilities/function.objects/func.require/p1.4-data-member-with-object.cpp +++ b/tests/std/utilities/function.objects/func.require/p1.4-data-member-with-object.cpp @@ -1,4 +1,3 @@ -// translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [func.require]/1.4: INVOKE(f, t1) is t1.*f when f is a pointer to data // member of a class T and t1 is a T or derived from T. diff --git a/tests/std/utilities/function.objects/func.require/p1.5-data-member-with-reference-wrapper.cpp b/tests/std/utilities/function.objects/func.require/p1.5-data-member-with-reference-wrapper.cpp index bf8b0f60d0..7ce2df28c1 100644 --- a/tests/std/utilities/function.objects/func.require/p1.5-data-member-with-reference-wrapper.cpp +++ b/tests/std/utilities/function.objects/func.require/p1.5-data-member-with-reference-wrapper.cpp @@ -1,4 +1,3 @@ -// translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [func.require]/1.5: INVOKE(f, t1) is t1.get().*f when f is a pointer // to data member and t1 is a reference_wrapper. diff --git a/tests/std/utilities/function.objects/func.require/p1.6-data-member-with-pointer.cpp b/tests/std/utilities/function.objects/func.require/p1.6-data-member-with-pointer.cpp index ef9111380e..ab364b05c4 100644 --- a/tests/std/utilities/function.objects/func.require/p1.6-data-member-with-pointer.cpp +++ b/tests/std/utilities/function.objects/func.require/p1.6-data-member-with-pointer.cpp @@ -1,4 +1,3 @@ -// translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [func.require]/1.6: INVOKE(f, t1) is (*t1).*f when f is a pointer to // data member and t1 is neither a T nor a reference_wrapper. From fc9e4a1b84a7bf0697294ce761bffba4c5593b62 Mon Sep 17 00:00:00 2001 From: Lucian Popescu Date: Mon, 16 Nov 2026 14:02:30 +0000 Subject: [PATCH 04/15] Mark as expectedly failing the invoke, ref, and anonymous union tests --- .../expr/expr.compound/expr.eq/p4.5-members-of-same-union.cpp | 1 + .../expr.compound/expr.mptr.oper/p4-object-type-not-similar.cpp | 2 ++ .../expr.unary/expr.unary.op/p3.1-anonymous-union-member.cpp | 1 + .../func.require/p1.4-data-member-with-object.cpp | 1 + .../func.require/p1.5-data-member-with-reference-wrapper.cpp | 1 + .../func.require/p1.6-data-member-with-pointer.cpp | 1 + 6 files changed, 7 insertions(+) diff --git a/tests/std/expr/expr.compound/expr.eq/p4.5-members-of-same-union.cpp b/tests/std/expr/expr.compound/expr.eq/p4.5-members-of-same-union.cpp index e74fd2b756..178903740f 100644 --- a/tests/std/expr/expr.compound/expr.eq/p4.5-members-of-same-union.cpp +++ b/tests/std/expr/expr.compound/expr.eq/p4.5-members-of-same-union.cpp @@ -1,3 +1,4 @@ +// translation-fail: refcount // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [expr.eq]/4.5: pointers to (possibly different) members of the same // union compare equal. diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/p4-object-type-not-similar.cpp b/tests/std/expr/expr.compound/expr.mptr.oper/p4-object-type-not-similar.cpp index a5e9643f8b..087ab06d4b 100644 --- a/tests/std/expr/expr.compound/expr.mptr.oper/p4-object-type-not-similar.cpp +++ b/tests/std/expr/expr.compound/expr.mptr.oper/p4-object-type-not-similar.cpp @@ -1,3 +1,5 @@ +// translation-fail: refcount +// no-compile: unsafe // panic-ub: refcount // nondet-result: unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 diff --git a/tests/std/expr/expr.compound/expr.unary/expr.unary.op/p3.1-anonymous-union-member.cpp b/tests/std/expr/expr.compound/expr.unary/expr.unary.op/p3.1-anonymous-union-member.cpp index 5b7c95dab7..a472196d4e 100644 --- a/tests/std/expr/expr.compound/expr.unary/expr.unary.op/p3.1-anonymous-union-member.cpp +++ b/tests/std/expr/expr.compound/expr.unary/expr.unary.op/p3.1-anonymous-union-member.cpp @@ -1,3 +1,4 @@ +// translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [expr.unary.op]/3.1: a qualified-id naming a variant member of some // class C yields a pointer to member of class C. diff --git a/tests/std/utilities/function.objects/func.require/p1.4-data-member-with-object.cpp b/tests/std/utilities/function.objects/func.require/p1.4-data-member-with-object.cpp index 0cd1dd5a59..df2c7e2eba 100644 --- a/tests/std/utilities/function.objects/func.require/p1.4-data-member-with-object.cpp +++ b/tests/std/utilities/function.objects/func.require/p1.4-data-member-with-object.cpp @@ -1,3 +1,4 @@ +// no-compile: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [func.require]/1.4: INVOKE(f, t1) is t1.*f when f is a pointer to data // member of a class T and t1 is a T or derived from T. diff --git a/tests/std/utilities/function.objects/func.require/p1.5-data-member-with-reference-wrapper.cpp b/tests/std/utilities/function.objects/func.require/p1.5-data-member-with-reference-wrapper.cpp index 7ce2df28c1..ed736b8459 100644 --- a/tests/std/utilities/function.objects/func.require/p1.5-data-member-with-reference-wrapper.cpp +++ b/tests/std/utilities/function.objects/func.require/p1.5-data-member-with-reference-wrapper.cpp @@ -1,3 +1,4 @@ +// no-compile: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [func.require]/1.5: INVOKE(f, t1) is t1.get().*f when f is a pointer // to data member and t1 is a reference_wrapper. diff --git a/tests/std/utilities/function.objects/func.require/p1.6-data-member-with-pointer.cpp b/tests/std/utilities/function.objects/func.require/p1.6-data-member-with-pointer.cpp index ab364b05c4..487f4547ed 100644 --- a/tests/std/utilities/function.objects/func.require/p1.6-data-member-with-pointer.cpp +++ b/tests/std/utilities/function.objects/func.require/p1.6-data-member-with-pointer.cpp @@ -1,3 +1,4 @@ +// no-compile: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [func.require]/1.6: INVOKE(f, t1) is (*t1).*f when f is a pointer to // data member and t1 is neither a T nor a reference_wrapper. From 789581b8f667458dcc21bfd2d0a339303195dd60 Mon Sep 17 00:00:00 2001 From: Lucian Popescu Date: Mon, 16 Nov 2026 14:06:14 +0000 Subject: [PATCH 05/15] Update tests --- .../out/refcount/p10-null-converts-to-null.rs | 33 ++++++++++++++++ .../out/refcount/p10-result-is-unspecified.rs | 34 ++++++++++++++++ .../refcount/p10.2-data-member-round-trip.rs | 39 +++++++++++++++++++ 3 files changed, 106 insertions(+) create mode 100644 tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/out/refcount/p10-null-converts-to-null.rs create mode 100644 tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/out/refcount/p10-result-is-unspecified.rs create mode 100644 tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/out/refcount/p10.2-data-member-round-trip.rs diff --git a/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/out/refcount/p10-null-converts-to-null.rs b/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/out/refcount/p10-null-converts-to-null.rs new file mode 100644 index 0000000000..275f7abaac --- /dev/null +++ b/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/out/refcount/p10-null-converts-to-null.rs @@ -0,0 +1,33 @@ +extern crate libcc2rs; +use libcc2rs::*; +use std::cell::RefCell; +use std::collections::BTreeMap; +use std::io::prelude::*; +use std::io::{Read, Seek, Write}; +use std::os::fd::AsFd; +use std::rc::{Rc, Weak}; +#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] +#[byte_size(8)] +pub struct HasTwoInts { + #[offset(0)] + pub first: i32, + #[offset(4)] + pub second: i32, +} +#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] +#[byte_size(1)] +pub struct HasChar { + #[offset(0)] + pub character: i8, +} +pub fn main() { + __cpp2rust_init_globals(); + std::process::exit(main_0()); +} +fn main_0() -> i32 { + let mut pm: MemberPtr = >::default(); + let mut converted: MemberPtr = >::cast_from(pm); + assert!((converted).is_null()); + return 0; +} +pub fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/out/refcount/p10-result-is-unspecified.rs b/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/out/refcount/p10-result-is-unspecified.rs new file mode 100644 index 0000000000..b7294c4226 --- /dev/null +++ b/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/out/refcount/p10-result-is-unspecified.rs @@ -0,0 +1,34 @@ +extern crate libcc2rs; +use libcc2rs::*; +use std::cell::RefCell; +use std::collections::BTreeMap; +use std::io::prelude::*; +use std::io::{Read, Seek, Write}; +use std::os::fd::AsFd; +use std::rc::{Rc, Weak}; +#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] +#[byte_size(8)] +pub struct HasTwoInts { + #[offset(0)] + pub first: i32, + #[offset(4)] + pub second: i32, +} +#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] +#[byte_size(8)] +pub struct AlsoHasTwoInts { + #[offset(0)] + pub first: i32, + #[offset(4)] + pub second: i32, +} +pub fn main() { + __cpp2rust_init_globals(); + std::process::exit(main_0()); +} +fn main_0() -> i32 { + let mut converted: MemberPtr = + >::cast_from(member_ptr!(HasTwoInts, second)); + return ((converted == member_ptr!(AlsoHasTwoInts, second)) as i32); +} +pub fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/out/refcount/p10.2-data-member-round-trip.rs b/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/out/refcount/p10.2-data-member-round-trip.rs new file mode 100644 index 0000000000..7aefbb9def --- /dev/null +++ b/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/out/refcount/p10.2-data-member-round-trip.rs @@ -0,0 +1,39 @@ +extern crate libcc2rs; +use libcc2rs::*; +use std::cell::RefCell; +use std::collections::BTreeMap; +use std::io::prelude::*; +use std::io::{Read, Seek, Write}; +use std::os::fd::AsFd; +use std::rc::{Rc, Weak}; +#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] +#[byte_size(8)] +pub struct HasTwoInts { + #[offset(0)] + pub first: i32, + #[offset(4)] + pub second: i32, +} +#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] +#[byte_size(1)] +pub struct HasChar { + #[offset(0)] + pub character: i8, +} +pub fn main() { + __cpp2rust_init_globals(); + std::process::exit(main_0()); +} +fn main_0() -> i32 { + let mut converted: MemberPtr = + >::cast_from(member_ptr!(HasTwoInts, second)); + let mut back: MemberPtr = >::cast_from(converted); + assert!((back == member_ptr!(HasTwoInts, second))); + let obj: Value = Rc::new(RefCell::new(HasTwoInts { + first: 3, + second: 4, + })); + assert!((((obj.as_pointer()).member(back).read()) == 4)); + return 0; +} +pub fn __cpp2rust_init_globals() {} From a1df84f8d7f6c4b1ed461144b746ee8513eae008 Mon Sep 17 00:00:00 2001 From: Lucian Popescu Date: Mon, 16 Nov 2026 14:09:03 +0000 Subject: [PATCH 06/15] Mark the ODR mptr as expectedly failing --- tests/std/basic/basic.def.odr/p3.5-pointer-to-member.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/tests/std/basic/basic.def.odr/p3.5-pointer-to-member.cpp b/tests/std/basic/basic.def.odr/p3.5-pointer-to-member.cpp index db4bc07e36..627b5464d0 100644 --- a/tests/std/basic/basic.def.odr/p3.5-pointer-to-member.cpp +++ b/tests/std/basic/basic.def.odr/p3.5-pointer-to-member.cpp @@ -1,3 +1,4 @@ +// no-compile: refcount // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [basic.def.odr]/3.5: the potential results of E1.*E2 are those of E1. // Reading k.*pm does not odr-use k, so [=] does not capture it. From 1b311c925a264b52e9470e8c7ef4331385e7c816 Mon Sep 17 00:00:00 2001 From: Lucian Popescu Date: Mon, 16 Nov 2026 16:36:26 +0000 Subject: [PATCH 07/15] Translate member pointer as isize in unsafe --- .../out/unsafe/p3.5-pointer-to-member.rs | 15 +--- ...pointer-to-data-member-bytes-round-trip.rs | 77 +++++++------------ ...ata-member-bytes-copied-to-other-object.rs | 42 +++++----- ...p6.1-zero-initialized-pointer-to-member.rs | 40 ++++------ .../p6-array-of-pointers-to-data-members.rs | 66 ++++++++++------ .../out/unsafe/p2-pointer-to-array-member.rs | 24 ++++-- .../out/unsafe/p2-pointer-to-data-member.rs | 28 +++++-- ...2-pointer-to-member-of-incomplete-class.rs | 13 ++-- ...ter-to-member-of-pointer-to-member-type.rs | 37 +++++---- .../p1-null-distinct-from-first-member.rs | 9 +-- .../unsafe/p7.4-pointer-to-member-and-null.rs | 19 +++-- .../expr.eq/out/unsafe/p4.1-both-null.rs | 6 +- .../expr.eq/out/unsafe/p4.2-one-null.rs | 6 +- .../out/unsafe/p4.5-members-of-same-union.rs | 6 +- .../expr.eq/out/unsafe/p4.6-data-members.rs | 9 +-- .../out/unsafe/p3-arrow-star.rs | 13 ++-- .../p4-object-expression-sequenced-first.rs | 11 ++- .../p6-data-member-of-lvalue-is-lvalue.rs | 11 ++- .../p6-data-member-of-rvalue-is-xvalue.rs | 20 ++--- .../unsafe/p6-null-pointer-to-data-member.rs | 6 +- .../out/unsafe/p10-null-converts-to-null.rs | 7 +- .../out/unsafe/p10-result-is-unspecified.rs | 13 +--- .../unsafe/p10.2-data-member-round-trip.rs | 24 +++--- 23 files changed, 246 insertions(+), 256 deletions(-) diff --git a/tests/std/basic/basic.def.odr/out/unsafe/p3.5-pointer-to-member.rs b/tests/std/basic/basic.def.odr/out/unsafe/p3.5-pointer-to-member.rs index fbeaccc27a..f44eb37c7e 100644 --- a/tests/std/basic/basic.def.odr/out/unsafe/p3.5-pointer-to-member.rs +++ b/tests/std/basic/basic.def.odr/out/unsafe/p3.5-pointer-to-member.rs @@ -41,19 +41,12 @@ pub fn main() { } unsafe fn main_0() -> i32 { let k: HasConstexprCtor = HasConstexprCtor::new({ 5 }); - let pm: MemberPtrUnsafe = - >::from_offset(::std::mem::offset_of!( - HasConstexprCtor, - m - )); + let pm: isize = (::std::mem::offset_of!(HasConstexprCtor, m) as isize); let mut f: FnPtr i32> = FnPtr:: i32>::new(|| -> i32 { unsafe { - return (*(&HasConstexprCtor::new({ 5 }) as *const HasConstexprCtor).member( - >::from_offset(::std::mem::offset_of!( - HasConstexprCtor, - m - )), - )); + return (*(&HasConstexprCtor::new({ 5 }) as *const HasConstexprCtor) + .wrapping_byte_offset((::std::mem::offset_of!(HasConstexprCtor, m) as isize)) + .cast::()); } }); assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut copyCount_0)) == (0))); diff --git a/tests/std/basic/basic.types/basic.types.general/out/unsafe/p2-pointer-to-data-member-bytes-round-trip.rs b/tests/std/basic/basic.types/basic.types.general/out/unsafe/p2-pointer-to-data-member-bytes-round-trip.rs index ecb5473b65..9d628a91db 100644 --- a/tests/std/basic/basic.types/basic.types.general/out/unsafe/p2-pointer-to-data-member-bytes-round-trip.rs +++ b/tests/std/basic/basic.types/basic.types.general/out/unsafe/p2-pointer-to-data-member-bytes-round-trip.rs @@ -19,84 +19,63 @@ pub fn main() { } } unsafe fn main_0() -> i32 { - let mut pm: MemberPtrUnsafe = - >::from_offset(::std::mem::offset_of!(HasTwoInts, second)); + let mut pm: isize = (::std::mem::offset_of!(HasTwoInts, second) as isize); let mut bytes: [u8; 8] = [0_u8; 8]; match ({ (bytes.as_mut_ptr() as *mut ::libc::c_void) }, { - ((&mut pm as *mut MemberPtrUnsafe) as *const ::libc::c_void) + ((&mut pm as *mut isize) as *const ::libc::c_void) }) { (mut __tmp_0, mut __tmp_1) => { - if ::std::mem::size_of::>() != 0 { - ::std::ptr::copy_nonoverlapping( - __tmp_1, - __tmp_0, - ::std::mem::size_of::>(), - ) + if ::std::mem::size_of::() != 0 { + ::std::ptr::copy_nonoverlapping(__tmp_1, __tmp_0, ::std::mem::size_of::()) } __tmp_0 } }; - pm = >::from_offset(::std::mem::offset_of!(HasTwoInts, first)); - match ( - { ((&mut pm as *mut MemberPtrUnsafe) as *mut ::libc::c_void) }, - { (bytes.as_mut_ptr() as *const ::libc::c_void) }, - ) { + pm = (::std::mem::offset_of!(HasTwoInts, first) as isize); + match ({ ((&mut pm as *mut isize) as *mut ::libc::c_void) }, { + (bytes.as_mut_ptr() as *const ::libc::c_void) + }) { (mut __tmp_2, mut __tmp_3) => { - if ::std::mem::size_of::>() != 0 { - ::std::ptr::copy_nonoverlapping( - __tmp_3, - __tmp_2, - ::std::mem::size_of::>(), - ) + if ::std::mem::size_of::() != 0 { + ::std::ptr::copy_nonoverlapping(__tmp_3, __tmp_2, ::std::mem::size_of::()) } __tmp_2 } }; - assert!( - ((pm) - == (>::from_offset(::std::mem::offset_of!( - HasTwoInts, second - )))) - ); + assert!(((pm) == (::std::mem::offset_of!(HasTwoInts, second) as isize))); let mut obj: HasTwoInts = HasTwoInts { first: 3, second: 4, }; - assert!(((*(&mut obj as *mut HasTwoInts).member(pm)) == (4))); - let mut null_pm: MemberPtrUnsafe = - >::default(); + assert!( + ((*(&mut obj as *mut HasTwoInts) + .wrapping_byte_offset(pm) + .cast::()) + == (4)) + ); + let mut null_pm: isize = -1_isize; match ({ (bytes.as_mut_ptr() as *mut ::libc::c_void) }, { - ((&mut null_pm as *mut MemberPtrUnsafe) as *const ::libc::c_void) + ((&mut null_pm as *mut isize) as *const ::libc::c_void) }) { (mut __tmp_4, mut __tmp_5) => { - if ::std::mem::size_of::>() != 0 { - ::std::ptr::copy_nonoverlapping( - __tmp_5, - __tmp_4, - ::std::mem::size_of::>(), - ) + if ::std::mem::size_of::() != 0 { + ::std::ptr::copy_nonoverlapping(__tmp_5, __tmp_4, ::std::mem::size_of::()) } __tmp_4 } }; - null_pm = - >::from_offset(::std::mem::offset_of!(HasTwoInts, first)); - match ( - { ((&mut null_pm as *mut MemberPtrUnsafe) as *mut ::libc::c_void) }, - { (bytes.as_mut_ptr() as *const ::libc::c_void) }, - ) { + null_pm = (::std::mem::offset_of!(HasTwoInts, first) as isize); + match ({ ((&mut null_pm as *mut isize) as *mut ::libc::c_void) }, { + (bytes.as_mut_ptr() as *const ::libc::c_void) + }) { (mut __tmp_6, mut __tmp_7) => { - if ::std::mem::size_of::>() != 0 { - ::std::ptr::copy_nonoverlapping( - __tmp_7, - __tmp_6, - ::std::mem::size_of::>(), - ) + if ::std::mem::size_of::() != 0 { + ::std::ptr::copy_nonoverlapping(__tmp_7, __tmp_6, ::std::mem::size_of::()) } __tmp_6 } }; - assert!((null_pm).is_null()); + assert!(((null_pm) == -1_isize)); return 0; } pub unsafe fn __cpp2rust_init_globals() {} diff --git a/tests/std/basic/basic.types/basic.types.general/out/unsafe/p3-pointer-to-data-member-bytes-copied-to-other-object.rs b/tests/std/basic/basic.types/basic.types.general/out/unsafe/p3-pointer-to-data-member-bytes-copied-to-other-object.rs index aaf8f0ea69..e88d4392be 100644 --- a/tests/std/basic/basic.types/basic.types.general/out/unsafe/p3-pointer-to-data-member-bytes-copied-to-other-object.rs +++ b/tests/std/basic/basic.types/basic.types.general/out/unsafe/p3-pointer-to-data-member-bytes-copied-to-other-object.rs @@ -19,21 +19,15 @@ pub fn main() { } } unsafe fn main_0() -> i32 { - let mut source: MemberPtrUnsafe = - >::from_offset(::std::mem::offset_of!(HasTwoInts, second)); - let mut destination: MemberPtrUnsafe = - >::from_offset(::std::mem::offset_of!(HasTwoInts, first)); + let mut source: isize = (::std::mem::offset_of!(HasTwoInts, second) as isize); + let mut destination: isize = (::std::mem::offset_of!(HasTwoInts, first) as isize); match ( - { ((&mut destination as *mut MemberPtrUnsafe) as *mut ::libc::c_void) }, - { ((&mut source as *mut MemberPtrUnsafe) as *const ::libc::c_void) }, + { ((&mut destination as *mut isize) as *mut ::libc::c_void) }, + { ((&mut source as *mut isize) as *const ::libc::c_void) }, ) { (mut __tmp_0, mut __tmp_1) => { - if ::std::mem::size_of::>() != 0 { - ::std::ptr::copy_nonoverlapping( - __tmp_1, - __tmp_0, - ::std::mem::size_of::>(), - ) + if ::std::mem::size_of::() != 0 { + ::std::ptr::copy_nonoverlapping(__tmp_1, __tmp_0, ::std::mem::size_of::()) } __tmp_0 } @@ -43,25 +37,25 @@ unsafe fn main_0() -> i32 { first: 3, second: 4, }; - assert!(((*(&mut obj as *mut HasTwoInts).member(destination)) == (4))); - let mut null_source: MemberPtrUnsafe = - >::default(); + assert!( + ((*(&mut obj as *mut HasTwoInts) + .wrapping_byte_offset(destination) + .cast::()) + == (4)) + ); + let mut null_source: isize = -1_isize; match ( - { ((&mut destination as *mut MemberPtrUnsafe) as *mut ::libc::c_void) }, - { ((&mut null_source as *mut MemberPtrUnsafe) as *const ::libc::c_void) }, + { ((&mut destination as *mut isize) as *mut ::libc::c_void) }, + { ((&mut null_source as *mut isize) as *const ::libc::c_void) }, ) { (mut __tmp_2, mut __tmp_3) => { - if ::std::mem::size_of::>() != 0 { - ::std::ptr::copy_nonoverlapping( - __tmp_3, - __tmp_2, - ::std::mem::size_of::>(), - ) + if ::std::mem::size_of::() != 0 { + ::std::ptr::copy_nonoverlapping(__tmp_3, __tmp_2, ::std::mem::size_of::()) } __tmp_2 } }; - assert!((destination).is_null()); + assert!(((destination) == -1_isize)); return 0; } pub unsafe fn __cpp2rust_init_globals() {} diff --git a/tests/std/dcl.dcl/dcl.decl/dcl.init/dcl.init.general/out/unsafe/p6.1-zero-initialized-pointer-to-member.rs b/tests/std/dcl.dcl/dcl.decl/dcl.init/dcl.init.general/out/unsafe/p6.1-zero-initialized-pointer-to-member.rs index 4b157f423e..a5d3ec9033 100644 --- a/tests/std/dcl.dcl/dcl.decl/dcl.init/dcl.init.general/out/unsafe/p6.1-zero-initialized-pointer-to-member.rs +++ b/tests/std/dcl.dcl/dcl.decl/dcl.init/dcl.init.general/out/unsafe/p6.1-zero-initialized-pointer-to-member.rs @@ -13,12 +13,17 @@ pub struct HasTwoInts { pub second: i32, } #[repr(C)] -#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] +#[derive(Copy, Clone, VaArg, FnPtrArg)] pub struct HoldsSelector { - pub selector: MemberPtrUnsafe, + pub selector: isize, +} +impl Default for HoldsSelector { + fn default() -> Self { + unsafe { HoldsSelector { selector: -1_isize } } + } } -pub static mut static_pm_0: std::cell::LazyCell> = - std::cell::LazyCell::new(|| unsafe { >::default() }); +pub static mut static_pm_0: std::cell::LazyCell = + std::cell::LazyCell::new(|| unsafe { -1_isize }); pub fn main() { unsafe { __cpp2rust_init_globals(); @@ -26,30 +31,17 @@ pub fn main() { } } unsafe fn main_0() -> i32 { - assert!((*std::cell::LazyCell::force_mut(&mut *&raw mut static_pm_0)).is_null()); + assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut static_pm_0)) == -1_isize)); assert!( ((*std::cell::LazyCell::force_mut(&mut *&raw mut static_pm_0)) - != (>::from_offset(::std::mem::offset_of!( - HasTwoInts, first - )))) - ); - let mut value_initialized: MemberPtrUnsafe = - >::default(); - assert!((value_initialized).is_null()); - assert!( - ((value_initialized) - != (>::from_offset(::std::mem::offset_of!( - HasTwoInts, first - )))) + != (::std::mem::offset_of!(HasTwoInts, first) as isize)) ); + let mut value_initialized: isize = -1_isize; + assert!(((value_initialized) == -1_isize)); + assert!(((value_initialized) != (::std::mem::offset_of!(HasTwoInts, first) as isize))); let mut holder: HoldsSelector = ::default(); - assert!((holder.selector).is_null()); - assert!( - ((holder.selector) - != (>::from_offset(::std::mem::offset_of!( - HasTwoInts, first - )))) - ); + assert!(((holder.selector) == -1_isize)); + assert!(((holder.selector) != (::std::mem::offset_of!(HasTwoInts, first) as isize))); return 0; } pub unsafe fn __cpp2rust_init_globals() { diff --git a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.array/out/unsafe/p6-array-of-pointers-to-data-members.rs b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.array/out/unsafe/p6-array-of-pointers-to-data-members.rs index 2e5b2c7a47..de1dded858 100644 --- a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.array/out/unsafe/p6-array-of-pointers-to-data-members.rs +++ b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.array/out/unsafe/p6-array-of-pointers-to-data-members.rs @@ -20,42 +20,58 @@ pub fn main() { } } unsafe fn main_0() -> i32 { - let mut members: [MemberPtrUnsafe; 3] = [ - >::from_offset(::std::mem::offset_of!( - HasThreeInts, - third - )), - >::from_offset(::std::mem::offset_of!( - HasThreeInts, - first - )), - >::from_offset(::std::mem::offset_of!( - HasThreeInts, - second - )), + let mut members: [isize; 3] = [ + (::std::mem::offset_of!(HasThreeInts, third) as isize), + (::std::mem::offset_of!(HasThreeInts, first) as isize), + (::std::mem::offset_of!(HasThreeInts, second) as isize), ]; let mut obj: HasThreeInts = HasThreeInts { first: 4, second: 5, third: 6, }; - assert!(((*(&mut obj as *mut HasThreeInts).member(members[(0) as usize])) == (6))); - assert!(((*(&mut obj as *mut HasThreeInts).member(members[(1) as usize])) == (4))); - assert!(((*(&mut obj as *mut HasThreeInts).member(members[(2) as usize])) == (5))); - let mut element: *mut MemberPtrUnsafe = members.as_mut_ptr(); assert!( - ((element.offset((1) as isize)) - == (&mut members[(1) as usize] as *mut MemberPtrUnsafe)) + ((*(&mut obj as *mut HasThreeInts) + .wrapping_byte_offset(members[(0) as usize]) + .cast::()) + == (6)) + ); + assert!( + ((*(&mut obj as *mut HasThreeInts) + .wrapping_byte_offset(members[(1) as usize]) + .cast::()) + == (4)) + ); + assert!( + ((*(&mut obj as *mut HasThreeInts) + .wrapping_byte_offset(members[(2) as usize]) + .cast::()) + == (5)) + ); + let mut element: *mut isize = members.as_mut_ptr(); + assert!(((element.offset((1) as isize)) == (&mut members[(1) as usize] as *mut isize))); + assert!( + ((*(&mut obj as *mut HasThreeInts) + .wrapping_byte_offset((*element.offset((1) as isize))) + .cast::()) + == (4)) ); - assert!(((*(&mut obj as *mut HasThreeInts).member((*element.offset((1) as isize)))) == (4))); element.prefix_inc(); element.prefix_inc(); - assert!(((element) == (&mut members[(2) as usize] as *mut MemberPtrUnsafe))); - assert!(((*(&mut obj as *mut HasThreeInts).member((*element))) == (5))); - members[(2) as usize] = >::from_offset( - ::std::mem::offset_of!(HasThreeInts, third), + assert!(((element) == (&mut members[(2) as usize] as *mut isize))); + assert!( + ((*(&mut obj as *mut HasThreeInts) + .wrapping_byte_offset((*element)) + .cast::()) + == (5)) + ); + members[(2) as usize] = (::std::mem::offset_of!(HasThreeInts, third) as isize); + assert!( + ((*(&mut obj as *mut HasThreeInts) + .wrapping_byte_offset((*element)) + .cast::()) + == (6)) ); - assert!(((*(&mut obj as *mut HasThreeInts).member((*element))) == (6))); return 0; } pub unsafe fn __cpp2rust_init_globals() {} diff --git a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/unsafe/p2-pointer-to-array-member.rs b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/unsafe/p2-pointer-to-array-member.rs index 9038f09fec..b81daaa6fd 100644 --- a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/unsafe/p2-pointer-to-array-member.rs +++ b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/unsafe/p2-pointer-to-array-member.rs @@ -19,18 +19,26 @@ pub fn main() { } } unsafe fn main_0() -> i32 { - let mut pm: MemberPtrUnsafe = - >::from_offset(::std::mem::offset_of!( - HasIntArray, - elements - )); + let mut pm: isize = (::std::mem::offset_of!(HasIntArray, elements) as isize); let mut obj: HasIntArray = HasIntArray { before: 1, elements: [2, 3, 4], }; - assert!((((*(&mut obj as *mut HasIntArray).member(pm))[(0) as usize]) == (2))); - assert!((((*(&mut obj as *mut HasIntArray).member(pm))[(2) as usize]) == (4))); - (*(&mut obj as *mut HasIntArray).member(pm))[(1) as usize] = 7; + assert!( + (((*(&mut obj as *mut HasIntArray) + .wrapping_byte_offset(pm) + .cast::<[i32; 3]>())[(0) as usize]) + == (2)) + ); + assert!( + (((*(&mut obj as *mut HasIntArray) + .wrapping_byte_offset(pm) + .cast::<[i32; 3]>())[(2) as usize]) + == (4)) + ); + (*(&mut obj as *mut HasIntArray) + .wrapping_byte_offset(pm) + .cast::<[i32; 3]>())[(1) as usize] = 7; assert!(((obj.elements[(1) as usize]) == (7))); assert!(((obj.before) == (1))); return 0; diff --git a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/unsafe/p2-pointer-to-data-member.rs b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/unsafe/p2-pointer-to-data-member.rs index 5f30cd39a0..512dd89360 100644 --- a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/unsafe/p2-pointer-to-data-member.rs +++ b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/unsafe/p2-pointer-to-data-member.rs @@ -19,20 +19,32 @@ pub fn main() { } } unsafe fn main_0() -> i32 { - let mut pm: MemberPtrUnsafe = - >::from_offset(::std::mem::offset_of!(HasTwoInts, first)); + let mut pm: isize = (::std::mem::offset_of!(HasTwoInts, first) as isize); let mut obj: HasTwoInts = HasTwoInts { first: 3, second: 4, }; - assert!(((*(&mut obj as *mut HasTwoInts).member(pm)) == (3))); - (*(&mut obj as *mut HasTwoInts).member(pm)) = 5; + assert!( + ((*(&mut obj as *mut HasTwoInts) + .wrapping_byte_offset(pm) + .cast::()) + == (3)) + ); + (*(&mut obj as *mut HasTwoInts) + .wrapping_byte_offset(pm) + .cast::()) = 5; assert!(((obj.first) == (5))); assert!(((obj.second) == (4))); - pm = - >::from_offset(::std::mem::offset_of!(HasTwoInts, second)); - assert!(((*(&mut obj as *mut HasTwoInts).member(pm)) == (4))); - (*(&mut obj as *mut HasTwoInts).member(pm)) = 6; + pm = (::std::mem::offset_of!(HasTwoInts, second) as isize); + assert!( + ((*(&mut obj as *mut HasTwoInts) + .wrapping_byte_offset(pm) + .cast::()) + == (4)) + ); + (*(&mut obj as *mut HasTwoInts) + .wrapping_byte_offset(pm) + .cast::()) = 6; assert!(((obj.first) == (5))); assert!(((obj.second) == (6))); return 0; diff --git a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/unsafe/p2-pointer-to-member-of-incomplete-class.rs b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/unsafe/p2-pointer-to-member-of-incomplete-class.rs index 3538fd7b83..b7350ca2de 100644 --- a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/unsafe/p2-pointer-to-member-of-incomplete-class.rs +++ b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/unsafe/p2-pointer-to-member-of-incomplete-class.rs @@ -6,8 +6,7 @@ use std::collections::BTreeMap; use std::io::{Read, Seek, Write}; use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; use std::rc::Rc; -pub static mut pm_0: std::cell::LazyCell> = - std::cell::LazyCell::new(|| unsafe { >::default() }); +pub static mut pm_0: std::cell::LazyCell = std::cell::LazyCell::new(|| unsafe { -1_isize }); #[repr(C)] #[derive(Copy, Clone, VaArg, FnPtrArg, Default)] pub struct CompletedLater { @@ -21,19 +20,17 @@ pub fn main() { } } unsafe fn main_0() -> i32 { - assert!((*std::cell::LazyCell::force_mut(&mut *&raw mut pm_0)).is_null()); + assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut pm_0)) == -1_isize)); (*std::cell::LazyCell::force_mut(&mut *&raw mut pm_0)) = - >::from_offset(::std::mem::offset_of!( - CompletedLater, - second - )); + (::std::mem::offset_of!(CompletedLater, second) as isize); let mut obj: CompletedLater = CompletedLater { first: 3, second: 4, }; assert!( ((*(&mut obj as *mut CompletedLater) - .member((*std::cell::LazyCell::force_mut(&mut *&raw mut pm_0)))) + .wrapping_byte_offset((*std::cell::LazyCell::force_mut(&mut *&raw mut pm_0))) + .cast::()) == (4)) ); return 0; diff --git a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/unsafe/p2-pointer-to-member-of-pointer-to-member-type.rs b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/unsafe/p2-pointer-to-member-of-pointer-to-member-type.rs index 98beae3bf0..d026756339 100644 --- a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/unsafe/p2-pointer-to-member-of-pointer-to-member-type.rs +++ b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/unsafe/p2-pointer-to-member-of-pointer-to-member-type.rs @@ -13,9 +13,14 @@ pub struct HasTwoInts { pub second: i32, } #[repr(C)] -#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] +#[derive(Copy, Clone, VaArg, FnPtrArg)] pub struct HoldsSelector { - pub selector: MemberPtrUnsafe, + pub selector: isize, +} +impl Default for HoldsSelector { + fn default() -> Self { + unsafe { HoldsSelector { selector: -1_isize } } + } } pub fn main() { unsafe { @@ -24,14 +29,9 @@ pub fn main() { } } unsafe fn main_0() -> i32 { - let mut pm: MemberPtrUnsafe> = - >>::from_offset( - ::std::mem::offset_of!(HoldsSelector, selector), - ); + let mut pm: isize = (::std::mem::offset_of!(HoldsSelector, selector) as isize); let mut holder: HoldsSelector = HoldsSelector { - selector: >::from_offset(::std::mem::offset_of!( - HasTwoInts, second - )), + selector: (::std::mem::offset_of!(HasTwoInts, second) as isize), }; let mut obj: HasTwoInts = HasTwoInts { first: 3, @@ -39,12 +39,23 @@ unsafe fn main_0() -> i32 { }; assert!( ((*(&mut obj as *mut HasTwoInts) - .member((*(&mut holder as *mut HoldsSelector).member(pm)))) + .wrapping_byte_offset( + (*(&mut holder as *mut HoldsSelector) + .wrapping_byte_offset(pm) + .cast::()) + ) + .cast::()) == (4)) ); - (*(&mut holder as *mut HoldsSelector).member(pm)) = - >::from_offset(::std::mem::offset_of!(HasTwoInts, first)); - assert!(((*(&mut obj as *mut HasTwoInts).member((holder.selector))) == (3))); + (*(&mut holder as *mut HoldsSelector) + .wrapping_byte_offset(pm) + .cast::()) = (::std::mem::offset_of!(HasTwoInts, first) as isize); + assert!( + ((*(&mut obj as *mut HasTwoInts) + .wrapping_byte_offset((holder.selector)) + .cast::()) + == (3)) + ); return 0; } pub unsafe fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/conv/conv.mem/out/unsafe/p1-null-distinct-from-first-member.rs b/tests/std/expr/conv/conv.mem/out/unsafe/p1-null-distinct-from-first-member.rs index 540884aabb..cf13313d37 100644 --- a/tests/std/expr/conv/conv.mem/out/unsafe/p1-null-distinct-from-first-member.rs +++ b/tests/std/expr/conv/conv.mem/out/unsafe/p1-null-distinct-from-first-member.rs @@ -19,12 +19,9 @@ pub fn main() { } } unsafe fn main_0() -> i32 { - let mut null_pm: MemberPtrUnsafe = - >::default(); - let mut first_pm: MemberPtrUnsafe = - >::from_offset(::std::mem::offset_of!(HasTwoInts, first)); - let mut second_pm: MemberPtrUnsafe = - >::from_offset(::std::mem::offset_of!(HasTwoInts, second)); + let mut null_pm: isize = -1_isize; + let mut first_pm: isize = (::std::mem::offset_of!(HasTwoInts, first) as isize); + let mut second_pm: isize = (::std::mem::offset_of!(HasTwoInts, second) as isize); assert!(((first_pm) != (null_pm))); assert!(((second_pm) != (null_pm))); return 0; diff --git a/tests/std/expr/expr.compound/expr.cond/out/unsafe/p7.4-pointer-to-member-and-null.rs b/tests/std/expr/expr.compound/expr.cond/out/unsafe/p7.4-pointer-to-member-and-null.rs index bea466c4a0..34b07edcc3 100644 --- a/tests/std/expr/expr.compound/expr.cond/out/unsafe/p7.4-pointer-to-member-and-null.rs +++ b/tests/std/expr/expr.compound/expr.cond/out/unsafe/p7.4-pointer-to-member-and-null.rs @@ -12,11 +12,11 @@ pub struct HasTwoInts { pub first: i32, pub second: i32, } -pub unsafe fn second_or_null_0(mut choose_second: bool) -> MemberPtrUnsafe { +pub unsafe fn second_or_null_0(mut choose_second: bool) -> isize { return if choose_second { - >::from_offset(::std::mem::offset_of!(HasTwoInts, second)) + (::std::mem::offset_of!(HasTwoInts, second) as isize) } else { - >::default() + -1_isize }; } pub fn main() { @@ -30,14 +30,17 @@ unsafe fn main_0() -> i32 { first: 3, second: 4, }; - assert!((unsafe { second_or_null_0(false,) }).is_null()); + assert!(((unsafe { second_or_null_0(false,) }) == -1_isize)); assert!( ((unsafe { second_or_null_0(true,) }) - == (>::from_offset(::std::mem::offset_of!( - HasTwoInts, second - )))) + == (::std::mem::offset_of!(HasTwoInts, second) as isize)) + ); + assert!( + ((*(&mut obj as *mut HasTwoInts) + .wrapping_byte_offset((unsafe { second_or_null_0(true,) })) + .cast::()) + == (4)) ); - assert!(((*(&mut obj as *mut HasTwoInts).member((unsafe { second_or_null_0(true,) }))) == (4))); return 0; } pub unsafe fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/expr.compound/expr.eq/out/unsafe/p4.1-both-null.rs b/tests/std/expr/expr.compound/expr.eq/out/unsafe/p4.1-both-null.rs index 169c2c6c13..39ee015834 100644 --- a/tests/std/expr/expr.compound/expr.eq/out/unsafe/p4.1-both-null.rs +++ b/tests/std/expr/expr.compound/expr.eq/out/unsafe/p4.1-both-null.rs @@ -19,10 +19,8 @@ pub fn main() { } } unsafe fn main_0() -> i32 { - let mut first_null: MemberPtrUnsafe = - >::default(); - let mut second_null: MemberPtrUnsafe = - >::default(); + let mut first_null: isize = -1_isize; + let mut second_null: isize = -1_isize; assert!(((first_null) == (second_null))); assert!(!((first_null) != (second_null))); return 0; diff --git a/tests/std/expr/expr.compound/expr.eq/out/unsafe/p4.2-one-null.rs b/tests/std/expr/expr.compound/expr.eq/out/unsafe/p4.2-one-null.rs index 012f881f45..b05050afba 100644 --- a/tests/std/expr/expr.compound/expr.eq/out/unsafe/p4.2-one-null.rs +++ b/tests/std/expr/expr.compound/expr.eq/out/unsafe/p4.2-one-null.rs @@ -19,10 +19,8 @@ pub fn main() { } } unsafe fn main_0() -> i32 { - let mut null_pm: MemberPtrUnsafe = - >::default(); - let mut first_pm: MemberPtrUnsafe = - >::from_offset(::std::mem::offset_of!(HasTwoInts, first)); + let mut null_pm: isize = -1_isize; + let mut first_pm: isize = (::std::mem::offset_of!(HasTwoInts, first) as isize); assert!(((first_pm) != (null_pm))); assert!(!((first_pm) == (null_pm))); assert!(((null_pm) != (first_pm))); diff --git a/tests/std/expr/expr.compound/expr.eq/out/unsafe/p4.5-members-of-same-union.rs b/tests/std/expr/expr.compound/expr.eq/out/unsafe/p4.5-members-of-same-union.rs index a16cf56afc..8e0c27c1ae 100644 --- a/tests/std/expr/expr.compound/expr.eq/out/unsafe/p4.5-members-of-same-union.rs +++ b/tests/std/expr/expr.compound/expr.eq/out/unsafe/p4.5-members-of-same-union.rs @@ -24,10 +24,8 @@ pub fn main() { } } unsafe fn main_0() -> i32 { - let mut first_pm: MemberPtrUnsafe = - >::from_offset(0); - let mut second_pm: MemberPtrUnsafe = - >::from_offset(0); + let mut first_pm: isize = 0_isize; + let mut second_pm: isize = 0_isize; assert!(((first_pm) == (second_pm))); assert!(!((first_pm) != (second_pm))); return 0; diff --git a/tests/std/expr/expr.compound/expr.eq/out/unsafe/p4.6-data-members.rs b/tests/std/expr/expr.compound/expr.eq/out/unsafe/p4.6-data-members.rs index f320aa6d12..1d6d711a59 100644 --- a/tests/std/expr/expr.compound/expr.eq/out/unsafe/p4.6-data-members.rs +++ b/tests/std/expr/expr.compound/expr.eq/out/unsafe/p4.6-data-members.rs @@ -19,12 +19,9 @@ pub fn main() { } } unsafe fn main_0() -> i32 { - let mut first_pm: MemberPtrUnsafe = - >::from_offset(::std::mem::offset_of!(HasTwoInts, first)); - let mut also_first_pm: MemberPtrUnsafe = - >::from_offset(::std::mem::offset_of!(HasTwoInts, first)); - let mut second_pm: MemberPtrUnsafe = - >::from_offset(::std::mem::offset_of!(HasTwoInts, second)); + let mut first_pm: isize = (::std::mem::offset_of!(HasTwoInts, first) as isize); + let mut also_first_pm: isize = (::std::mem::offset_of!(HasTwoInts, first) as isize); + let mut second_pm: isize = (::std::mem::offset_of!(HasTwoInts, second) as isize); assert!(((first_pm) == (also_first_pm))); assert!(!((first_pm) != (also_first_pm))); assert!(((first_pm) != (second_pm))); diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p3-arrow-star.rs b/tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p3-arrow-star.rs index b174fd9c24..9ac139c174 100644 --- a/tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p3-arrow-star.rs +++ b/tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p3-arrow-star.rs @@ -19,20 +19,21 @@ pub fn main() { } } unsafe fn main_0() -> i32 { - let mut pm: MemberPtrUnsafe = - >::from_offset(::std::mem::offset_of!(HasTwoInts, second)); + let mut pm: isize = (::std::mem::offset_of!(HasTwoInts, second) as isize); let mut obj: HasTwoInts = HasTwoInts { first: 3, second: 4, }; let mut p: *mut HasTwoInts = (&mut obj as *mut HasTwoInts); - assert!(((*(p).member(pm)) == (4))); - (*(p).member(pm)) = 5; + assert!(((*(p).wrapping_byte_offset(pm).cast::()) == (4))); + (*(p).wrapping_byte_offset(pm).cast::()) = 5; assert!(((obj.second) == (5))); assert!(((obj.first) == (3))); assert!( - ((&mut (*(p).member(pm)) as *mut i32) - == (&mut (*(&mut (*p) as *mut HasTwoInts).member(pm)) as *mut i32)) + ((&mut (*(p).wrapping_byte_offset(pm).cast::()) as *mut i32) + == (&mut (*(&mut (*p) as *mut HasTwoInts) + .wrapping_byte_offset(pm) + .cast::()) as *mut i32)) ); return 0; } diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p4-object-expression-sequenced-first.rs b/tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p4-object-expression-sequenced-first.rs index 72ee744095..05d3d0b7c9 100644 --- a/tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p4-object-expression-sequenced-first.rs +++ b/tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p4-object-expression-sequenced-first.rs @@ -23,10 +23,10 @@ pub unsafe fn select_object_4() -> *mut HasValue { (*std::cell::LazyCell::force_mut(&mut *&raw mut sequence_0)).prefix_inc(); return &mut (*std::cell::LazyCell::force_mut(&mut *&raw mut object_3)); } -pub unsafe fn select_member_5() -> MemberPtrUnsafe { +pub unsafe fn select_member_5() -> isize { (*std::cell::LazyCell::force_mut(&mut *&raw mut member_stamp_2)) = (*std::cell::LazyCell::force_mut(&mut *&raw mut sequence_0)).prefix_inc(); - return >::from_offset(::std::mem::offset_of!(HasValue, value)); + return (::std::mem::offset_of!(HasValue, value) as isize); } pub fn main() { unsafe { @@ -35,7 +35,12 @@ pub fn main() { } } unsafe fn main_0() -> i32 { - assert!(((*(unsafe { select_object_4() }).member((unsafe { select_member_5() }))) == (7))); + assert!( + ((*(unsafe { select_object_4() }) + .wrapping_byte_offset((unsafe { select_member_5() })) + .cast::()) + == (7)) + ); assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut object_stamp_1)) == (1))); assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut member_stamp_2)) == (2))); return 0; diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p6-data-member-of-lvalue-is-lvalue.rs b/tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p6-data-member-of-lvalue-is-lvalue.rs index 7a7bf49cd4..061647cca2 100644 --- a/tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p6-data-member-of-lvalue-is-lvalue.rs +++ b/tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p6-data-member-of-lvalue-is-lvalue.rs @@ -19,17 +19,20 @@ pub fn main() { } } unsafe fn main_0() -> i32 { - let mut pm: MemberPtrUnsafe = - >::from_offset(::std::mem::offset_of!(HasTwoInts, second)); + let mut pm: isize = (::std::mem::offset_of!(HasTwoInts, second) as isize); let mut obj: HasTwoInts = HasTwoInts { first: 3, second: 4, }; assert!( - ((&mut (*(&mut obj as *mut HasTwoInts).member(pm)) as *mut i32) + ((&mut (*(&mut obj as *mut HasTwoInts) + .wrapping_byte_offset(pm) + .cast::()) as *mut i32) == (&mut obj.second as *mut i32)) ); - let ref_: *mut i32 = &mut (*(&mut obj as *mut HasTwoInts).member(pm)); + let ref_: *mut i32 = &mut (*(&mut obj as *mut HasTwoInts) + .wrapping_byte_offset(pm) + .cast::()); (*ref_) = 5; assert!(((obj.second) == (5))); assert!(((obj.first) == (3))); diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p6-data-member-of-rvalue-is-xvalue.rs b/tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p6-data-member-of-rvalue-is-xvalue.rs index 4087c54ed8..06500e5461 100644 --- a/tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p6-data-member-of-rvalue-is-xvalue.rs +++ b/tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p6-data-member-of-rvalue-is-xvalue.rs @@ -48,18 +48,20 @@ pub fn main() { } } unsafe fn main_0() -> i32 { - let mut pm: MemberPtrUnsafe = - >::from_offset(::std::mem::offset_of!( - HoldsCounted, - member - )); + let mut pm: isize = (::std::mem::offset_of!(HoldsCounted, member) as isize); let mut holder: HoldsCounted = ::default(); - let mut from_lvalue: CountsCopiesAndMoves = - CountsCopiesAndMoves::copy_from({ &(*(&mut holder as *mut HoldsCounted).member(pm)) }); + let mut from_lvalue: CountsCopiesAndMoves = CountsCopiesAndMoves::copy_from({ + &(*(&mut holder as *mut HoldsCounted) + .wrapping_byte_offset(pm) + .cast::()) + }); assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut copyCount_0)) == (1))); assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut moveCount_1)) == (0))); - let mut from_xvalue: CountsCopiesAndMoves = - CountsCopiesAndMoves::move_from({ &mut (*(&mut holder as *mut HoldsCounted).member(pm)) }); + let mut from_xvalue: CountsCopiesAndMoves = CountsCopiesAndMoves::move_from({ + &mut (*(&mut holder as *mut HoldsCounted) + .wrapping_byte_offset(pm) + .cast::()) + }); assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut copyCount_0)) == (1))); assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut moveCount_1)) == (1))); return 0; diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p6-null-pointer-to-data-member.rs b/tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p6-null-pointer-to-data-member.rs index f7455947ff..7fd683370a 100644 --- a/tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p6-null-pointer-to-data-member.rs +++ b/tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p6-null-pointer-to-data-member.rs @@ -19,11 +19,13 @@ pub fn main() { } } unsafe fn main_0() -> i32 { - let mut pm: MemberPtrUnsafe = >::default(); + let mut pm: isize = -1_isize; let mut obj: HasTwoInts = HasTwoInts { first: 3, second: 4, }; - return (*(&mut obj as *mut HasTwoInts).member(pm)); + return (*(&mut obj as *mut HasTwoInts) + .wrapping_byte_offset(pm) + .cast::()); } pub unsafe fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/out/unsafe/p10-null-converts-to-null.rs b/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/out/unsafe/p10-null-converts-to-null.rs index 9f05d142aa..b1773eeb67 100644 --- a/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/out/unsafe/p10-null-converts-to-null.rs +++ b/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/out/unsafe/p10-null-converts-to-null.rs @@ -24,10 +24,9 @@ pub fn main() { } } unsafe fn main_0() -> i32 { - let mut pm: MemberPtrUnsafe = >::default(); - let mut converted: MemberPtrUnsafe = - >::cast_from(pm); - assert!((converted).is_null()); + let mut pm: isize = -1_isize; + let mut converted: isize = pm; + assert!(((converted) == -1_isize)); return 0; } pub unsafe fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/out/unsafe/p10-result-is-unspecified.rs b/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/out/unsafe/p10-result-is-unspecified.rs index f910f3a849..67fb4e03fa 100644 --- a/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/out/unsafe/p10-result-is-unspecified.rs +++ b/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/out/unsafe/p10-result-is-unspecified.rs @@ -25,16 +25,7 @@ pub fn main() { } } unsafe fn main_0() -> i32 { - let mut converted: MemberPtrUnsafe = - >::cast_from( - >::from_offset(::std::mem::offset_of!( - HasTwoInts, second - )), - ); - return (((converted) - == (>::from_offset(::std::mem::offset_of!( - AlsoHasTwoInts, - second - )))) as i32); + let mut converted: isize = (::std::mem::offset_of!(HasTwoInts, second) as isize); + return (((converted) == (::std::mem::offset_of!(AlsoHasTwoInts, second) as isize)) as i32); } pub unsafe fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/out/unsafe/p10.2-data-member-round-trip.rs b/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/out/unsafe/p10.2-data-member-round-trip.rs index 7be913ac2f..8b3fc92e6e 100644 --- a/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/out/unsafe/p10.2-data-member-round-trip.rs +++ b/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/out/unsafe/p10.2-data-member-round-trip.rs @@ -24,25 +24,19 @@ pub fn main() { } } unsafe fn main_0() -> i32 { - let mut converted: MemberPtrUnsafe = - >::cast_from( - >::from_offset(::std::mem::offset_of!( - HasTwoInts, second - )), - ); - let mut back: MemberPtrUnsafe = - >::cast_from(converted); - assert!( - ((back) - == (>::from_offset(::std::mem::offset_of!( - HasTwoInts, second - )))) - ); + let mut converted: isize = (::std::mem::offset_of!(HasTwoInts, second) as isize); + let mut back: isize = converted; + assert!(((back) == (::std::mem::offset_of!(HasTwoInts, second) as isize))); let mut obj: HasTwoInts = HasTwoInts { first: 3, second: 4, }; - assert!(((*(&mut obj as *mut HasTwoInts).member(back)) == (4))); + assert!( + ((*(&mut obj as *mut HasTwoInts) + .wrapping_byte_offset(back) + .cast::()) + == (4)) + ); return 0; } pub unsafe fn __cpp2rust_init_globals() {} From 51b6c5184f4ee71bb359d3919c680158944f09d6 Mon Sep 17 00:00:00 2001 From: Lucian Popescu Date: Mon, 16 Nov 2026 16:45:43 +0000 Subject: [PATCH 08/15] Use isize in refcount too --- ...pointer-to-data-member-bytes-round-trip.rs | 29 +++++++++------- ...ata-member-bytes-copied-to-other-object.rs | 34 +++++++++++++------ ...p6.1-zero-initialized-pointer-to-member.rs | 28 +++++++++------ .../p6-array-of-pointers-to-data-members.rs | 29 +++++++++------- .../refcount/p2-pointer-to-array-member.rs | 8 ++--- .../out/refcount/p2-pointer-to-data-member.rs | 12 +++---- ...2-pointer-to-member-of-incomplete-class.rs | 9 +++-- ...ter-to-member-of-pointer-to-member-type.rs | 22 +++++++----- .../p1-null-distinct-from-first-member.rs | 6 ++-- .../p7.4-pointer-to-member-and-null.rs | 12 +++---- .../expr.eq/out/refcount/p4.1-both-null.rs | 4 +-- .../expr.eq/out/refcount/p4.2-one-null.rs | 4 +-- .../expr.eq/out/refcount/p4.6-data-members.rs | 6 ++-- .../out/refcount/p3-arrow-star.rs | 8 ++--- .../p4-object-expression-sequenced-first.rs | 6 ++-- .../p6-data-member-of-lvalue-is-lvalue.rs | 6 ++-- .../p6-data-member-of-rvalue-is-xvalue.rs | 12 ++++--- .../p6-null-pointer-to-data-member.rs | 4 +-- .../out/refcount/p10-null-converts-to-null.rs | 6 ++-- .../out/refcount/p10-result-is-unspecified.rs | 5 ++- .../refcount/p10.2-data-member-round-trip.rs | 9 +++-- 21 files changed, 145 insertions(+), 114 deletions(-) diff --git a/tests/std/basic/basic.types/basic.types.general/out/refcount/p2-pointer-to-data-member-bytes-round-trip.rs b/tests/std/basic/basic.types/basic.types.general/out/refcount/p2-pointer-to-data-member-bytes-round-trip.rs index bfb8cbe495..ecaf43fe57 100644 --- a/tests/std/basic/basic.types/basic.types.general/out/refcount/p2-pointer-to-data-member-bytes-round-trip.rs +++ b/tests/std/basic/basic.types/basic.types.general/out/refcount/p2-pointer-to-data-member-bytes-round-trip.rs @@ -19,45 +19,48 @@ pub fn main() { std::process::exit(main_0()); } fn main_0() -> i32 { - let pm: Value> = - Rc::new(RefCell::new(member_ptr!(HasTwoInts, second))); + let pm: Value = Rc::new(RefCell::new( + (::OFFSETS.second as isize), + )); let bytes: Value> = Rc::new(RefCell::new((0..8).map(|_| 0_u8).collect::>())); match ({ (bytes.decay()).to_any() },) { (mut __tmp_0,) => { - __tmp_0.memcpy(&(pm.as_pointer()).to_any(), 8usize); + __tmp_0.memcpy(&(pm.as_pointer()).to_any(), ::std::mem::size_of::()); (__tmp_0).clone() } }; - (*pm.borrow_mut()) = member_ptr!(HasTwoInts, first); + (*pm.borrow_mut()) = (::OFFSETS.first as isize); match ({ (pm.as_pointer()).to_any() },) { (mut __tmp_1,) => { - __tmp_1.memcpy(&(bytes.decay()).to_any(), 8usize); + __tmp_1.memcpy(&(bytes.decay()).to_any(), ::std::mem::size_of::()); (__tmp_1).clone() } }; - assert!(({ ((*pm.borrow()) == member_ptr!(HasTwoInts, second)) })); + assert!(({ ((*pm.borrow()) == (::OFFSETS.second as isize)) })); let obj: Value = Rc::new(RefCell::new(HasTwoInts { first: 3, second: 4, })); - assert!(({ (((obj.as_pointer()).member((*pm.borrow())).read()) == 4) })); - let null_pm: Value> = - Rc::new(RefCell::new(>::default())); + assert!(({ (((obj.as_pointer()).member::((*pm.borrow())).read()) == 4) })); + let null_pm: Value = Rc::new(RefCell::new(-1_isize)); match ({ (bytes.decay()).to_any() },) { (mut __tmp_2,) => { - __tmp_2.memcpy(&(null_pm.as_pointer()).to_any(), 8usize); + __tmp_2.memcpy( + &(null_pm.as_pointer()).to_any(), + ::std::mem::size_of::(), + ); (__tmp_2).clone() } }; - (*null_pm.borrow_mut()) = member_ptr!(HasTwoInts, first); + (*null_pm.borrow_mut()) = (::OFFSETS.first as isize); match ({ (null_pm.as_pointer()).to_any() },) { (mut __tmp_3,) => { - __tmp_3.memcpy(&(bytes.decay()).to_any(), 8usize); + __tmp_3.memcpy(&(bytes.decay()).to_any(), ::std::mem::size_of::()); (__tmp_3).clone() } }; - assert!(({ (*null_pm.borrow()).is_null() })); + assert!(({ ((*null_pm.borrow()) == -1_isize) })); return 0; } pub fn __cpp2rust_init_globals() {} diff --git a/tests/std/basic/basic.types/basic.types.general/out/refcount/p3-pointer-to-data-member-bytes-copied-to-other-object.rs b/tests/std/basic/basic.types/basic.types.general/out/refcount/p3-pointer-to-data-member-bytes-copied-to-other-object.rs index 4626321138..a0213284ad 100644 --- a/tests/std/basic/basic.types/basic.types.general/out/refcount/p3-pointer-to-data-member-bytes-copied-to-other-object.rs +++ b/tests/std/basic/basic.types/basic.types.general/out/refcount/p3-pointer-to-data-member-bytes-copied-to-other-object.rs @@ -19,13 +19,18 @@ pub fn main() { std::process::exit(main_0()); } fn main_0() -> i32 { - let source: Value> = - Rc::new(RefCell::new(member_ptr!(HasTwoInts, second))); - let destination: Value> = - Rc::new(RefCell::new(member_ptr!(HasTwoInts, first))); + let source: Value = Rc::new(RefCell::new( + (::OFFSETS.second as isize), + )); + let destination: Value = Rc::new(RefCell::new( + (::OFFSETS.first as isize), + )); match ({ (destination.as_pointer()).to_any() },) { (mut __tmp_0,) => { - __tmp_0.memcpy(&(source.as_pointer()).to_any(), 8usize); + __tmp_0.memcpy( + &(source.as_pointer()).to_any(), + ::std::mem::size_of::(), + ); (__tmp_0).clone() } }; @@ -34,16 +39,25 @@ fn main_0() -> i32 { first: 3, second: 4, })); - assert!(({ (((obj.as_pointer()).member((*destination.borrow())).read()) == 4) })); - let null_source: Value> = - Rc::new(RefCell::new(>::default())); + assert!( + ({ + (((obj.as_pointer()) + .member::((*destination.borrow())) + .read()) + == 4) + }) + ); + let null_source: Value = Rc::new(RefCell::new(-1_isize)); match ({ (destination.as_pointer()).to_any() },) { (mut __tmp_1,) => { - __tmp_1.memcpy(&(null_source.as_pointer()).to_any(), 8usize); + __tmp_1.memcpy( + &(null_source.as_pointer()).to_any(), + ::std::mem::size_of::(), + ); (__tmp_1).clone() } }; - assert!(({ (*destination.borrow()).is_null() })); + assert!(({ ((*destination.borrow()) == -1_isize) })); return 0; } pub fn __cpp2rust_init_globals() {} diff --git a/tests/std/dcl.dcl/dcl.decl/dcl.init/dcl.init.general/out/refcount/p6.1-zero-initialized-pointer-to-member.rs b/tests/std/dcl.dcl/dcl.decl/dcl.init/dcl.init.general/out/refcount/p6.1-zero-initialized-pointer-to-member.rs index 40990591b6..a8c6c7d45b 100644 --- a/tests/std/dcl.dcl/dcl.decl/dcl.init/dcl.init.general/out/refcount/p6.1-zero-initialized-pointer-to-member.rs +++ b/tests/std/dcl.dcl/dcl.decl/dcl.init/dcl.init.general/out/refcount/p6.1-zero-initialized-pointer-to-member.rs @@ -14,30 +14,36 @@ pub struct HasTwoInts { #[offset(4)] pub second: i32, } -#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] +#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg)] #[byte_size(8)] pub struct HoldsSelector { #[offset(0)] #[byte_size(8)] - pub selector: MemberPtr, + pub selector: isize, +} +impl Default for HoldsSelector { + fn default() -> Self { + { HoldsSelector { selector: -1_isize } } + } } thread_local!( - pub static static_pm_0: Value> = - >>::default(); + pub static static_pm_0: Value = Rc::new(RefCell::new(-1_isize)); ); pub fn main() { __cpp2rust_init_globals(); std::process::exit(main_0()); } fn main_0() -> i32 { - assert!((static_pm_0.with(|rc| *rc.borrow())).is_null()); - assert!((static_pm_0.with(|rc| *rc.borrow()) != member_ptr!(HasTwoInts, first))); - let mut value_initialized: MemberPtr = >::default(); - assert!((value_initialized).is_null()); - assert!((value_initialized != member_ptr!(HasTwoInts, first))); + assert!(((static_pm_0.with(|rc| *rc.borrow())) == -1_isize)); + assert!( + (static_pm_0.with(|rc| *rc.borrow()) != (::OFFSETS.first as isize)) + ); + let mut value_initialized: isize = -1_isize; + assert!(((value_initialized) == -1_isize)); + assert!((value_initialized != (::OFFSETS.first as isize))); let mut holder: HoldsSelector = ::default(); - assert!((holder.selector).is_null()); - assert!((holder.selector != member_ptr!(HasTwoInts, first))); + assert!(((holder.selector) == -1_isize)); + assert!((holder.selector != (::OFFSETS.first as isize))); return 0; } pub fn __cpp2rust_init_globals() { diff --git a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.array/out/refcount/p6-array-of-pointers-to-data-members.rs b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.array/out/refcount/p6-array-of-pointers-to-data-members.rs index f1ade7c9fe..e0c12c1072 100644 --- a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.array/out/refcount/p6-array-of-pointers-to-data-members.rs +++ b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.array/out/refcount/p6-array-of-pointers-to-data-members.rs @@ -21,10 +21,10 @@ pub fn main() { std::process::exit(main_0()); } fn main_0() -> i32 { - let members: Value]>> = Rc::new(RefCell::new(Box::new([ - member_ptr!(HasThreeInts, third), - member_ptr!(HasThreeInts, first), - member_ptr!(HasThreeInts, second), + let members: Value> = Rc::new(RefCell::new(Box::new([ + (::OFFSETS.third as isize), + (::OFFSETS.first as isize), + (::OFFSETS.second as isize), ]))); let obj: Value = Rc::new(RefCell::new(HasThreeInts { first: 4, @@ -34,7 +34,7 @@ fn main_0() -> i32 { assert!( ({ (((obj.as_pointer()) - .member((*members.borrow())[(0) as usize]) + .member::((*members.borrow())[(0) as usize]) .read()) == 6) }) @@ -42,7 +42,7 @@ fn main_0() -> i32 { assert!( ({ (((obj.as_pointer()) - .member((*members.borrow())[(1) as usize]) + .member::((*members.borrow())[(1) as usize]) .read()) == 4) }) @@ -50,20 +50,25 @@ fn main_0() -> i32 { assert!( ({ (((obj.as_pointer()) - .member((*members.borrow())[(2) as usize]) + .member::((*members.borrow())[(2) as usize]) .read()) == 5) }) ); - let mut element: Ptr> = members.decay(); + let mut element: Ptr = members.decay(); assert!(({ element.offset((1) as isize) } == { (members.decay().offset(1)) })); - assert!((((obj.as_pointer()).member((elem!(element, 1).read())).read()) == 4)); + assert!( + (((obj.as_pointer()) + .member::((elem!(element, 1).read())) + .read()) + == 4) + ); element.prefix_inc(); element.prefix_inc(); assert!(({ (element).clone() } == { (members.decay().offset(2)) })); - assert!((((obj.as_pointer()).member((element.read())).read()) == 5)); - (*members.borrow_mut())[(2) as usize] = member_ptr!(HasThreeInts, third); - assert!((((obj.as_pointer()).member((element.read())).read()) == 6)); + assert!((((obj.as_pointer()).member::((element.read())).read()) == 5)); + (*members.borrow_mut())[(2) as usize] = (::OFFSETS.third as isize); + assert!((((obj.as_pointer()).member::((element.read())).read()) == 6)); return 0; } pub fn __cpp2rust_init_globals() {} diff --git a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/refcount/p2-pointer-to-array-member.rs b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/refcount/p2-pointer-to-array-member.rs index 6e3ecd70ef..c711c862ae 100644 --- a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/refcount/p2-pointer-to-array-member.rs +++ b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/refcount/p2-pointer-to-array-member.rs @@ -30,14 +30,14 @@ pub fn main() { std::process::exit(main_0()); } fn main_0() -> i32 { - let mut pm: MemberPtr> = member_ptr!(HasIntArray, elements); + let mut pm: isize = (::OFFSETS.elements as isize); let obj: Value = Rc::new(RefCell::new(HasIntArray { before: 1, elements: Box::new([2, 3, 4]), })); - assert!((((obj.as_pointer()).member(pm).read())[(0) as usize] == 2)); - assert!((((obj.as_pointer()).member(pm).read())[(2) as usize] == 4)); - index!((obj.as_pointer()).member(pm), 1).write(7); + assert!((((obj.as_pointer()).member::>(pm).read())[(0) as usize] == 2)); + assert!((((obj.as_pointer()).member::>(pm).read())[(2) as usize] == 4)); + index!((obj.as_pointer()).member::>(pm), 1).write(7); assert!(((array_elem!(obj.as_pointer(), elements, 1).read()) == 7)); assert!(({ ({ (*obj.borrow()).before } == 1) })); return 0; diff --git a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/refcount/p2-pointer-to-data-member.rs b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/refcount/p2-pointer-to-data-member.rs index bce9afa21d..5afa29a59c 100644 --- a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/refcount/p2-pointer-to-data-member.rs +++ b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/refcount/p2-pointer-to-data-member.rs @@ -19,18 +19,18 @@ pub fn main() { std::process::exit(main_0()); } fn main_0() -> i32 { - let mut pm: MemberPtr = member_ptr!(HasTwoInts, first); + let mut pm: isize = (::OFFSETS.first as isize); let obj: Value = Rc::new(RefCell::new(HasTwoInts { first: 3, second: 4, })); - assert!((((obj.as_pointer()).member(pm).read()) == 3)); - (obj.as_pointer()).member(pm).write(5); + assert!((((obj.as_pointer()).member::(pm).read()) == 3)); + (obj.as_pointer()).member::(pm).write(5); assert!(({ ({ (*obj.borrow()).first } == 5) })); assert!(({ ({ (*obj.borrow()).second } == 4) })); - pm = member_ptr!(HasTwoInts, second); - assert!((((obj.as_pointer()).member(pm).read()) == 4)); - (obj.as_pointer()).member(pm).write(6); + pm = (::OFFSETS.second as isize); + assert!((((obj.as_pointer()).member::(pm).read()) == 4)); + (obj.as_pointer()).member::(pm).write(6); assert!(({ ({ (*obj.borrow()).first } == 5) })); assert!(({ ({ (*obj.borrow()).second } == 6) })); return 0; diff --git a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/refcount/p2-pointer-to-member-of-incomplete-class.rs b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/refcount/p2-pointer-to-member-of-incomplete-class.rs index 4b4b74a167..6d94933c88 100644 --- a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/refcount/p2-pointer-to-member-of-incomplete-class.rs +++ b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/refcount/p2-pointer-to-member-of-incomplete-class.rs @@ -7,8 +7,7 @@ use std::io::{Read, Seek, Write}; use std::os::fd::AsFd; use std::rc::{Rc, Weak}; thread_local!( - pub static pm_0: Value> = - Rc::new(RefCell::new(>::default())); + pub static pm_0: Value = Rc::new(RefCell::new(-1_isize)); ); #[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] #[byte_size(8)] @@ -23,15 +22,15 @@ pub fn main() { std::process::exit(main_0()); } fn main_0() -> i32 { - assert!((pm_0.with(|rc| *rc.borrow())).is_null()); - pm_0.with(|rc| *rc.borrow_mut() = member_ptr!(CompletedLater, second)); + assert!(((pm_0.with(|rc| *rc.borrow())) == -1_isize)); + pm_0.with(|rc| *rc.borrow_mut() = (::OFFSETS.second as isize)); let obj: Value = Rc::new(RefCell::new(CompletedLater { first: 3, second: 4, })); assert!( (((obj.as_pointer()) - .member(pm_0.with(|rc| *rc.borrow())) + .member::(pm_0.with(|rc| *rc.borrow())) .read()) == 4) ); diff --git a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/refcount/p2-pointer-to-member-of-pointer-to-member-type.rs b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/refcount/p2-pointer-to-member-of-pointer-to-member-type.rs index f6692e90da..4c31e8ab2f 100644 --- a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/refcount/p2-pointer-to-member-of-pointer-to-member-type.rs +++ b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/refcount/p2-pointer-to-member-of-pointer-to-member-type.rs @@ -14,22 +14,26 @@ pub struct HasTwoInts { #[offset(4)] pub second: i32, } -#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] +#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg)] #[byte_size(8)] pub struct HoldsSelector { #[offset(0)] #[byte_size(8)] - pub selector: MemberPtr, + pub selector: isize, +} +impl Default for HoldsSelector { + fn default() -> Self { + { HoldsSelector { selector: -1_isize } } + } } pub fn main() { __cpp2rust_init_globals(); std::process::exit(main_0()); } fn main_0() -> i32 { - let mut pm: MemberPtr> = - member_ptr!(HoldsSelector, selector); + let mut pm: isize = (::OFFSETS.selector as isize); let holder: Value = Rc::new(RefCell::new(HoldsSelector { - selector: member_ptr!(HasTwoInts, second), + selector: (::OFFSETS.second as isize), })); let obj: Value = Rc::new(RefCell::new(HasTwoInts { first: 3, @@ -37,17 +41,17 @@ fn main_0() -> i32 { })); assert!( (((obj.as_pointer()) - .member(((holder.as_pointer()).member(pm).read())) + .member::(((holder.as_pointer()).member::(pm).read())) .read()) == 4) ); (holder.as_pointer()) - .member(pm) - .write(member_ptr!(HasTwoInts, first)); + .member::(pm) + .write((::OFFSETS.first as isize)); assert!( ({ (((obj.as_pointer()) - .member(({ (*holder.borrow()).selector })) + .member::(({ (*holder.borrow()).selector })) .read()) == 3) }) diff --git a/tests/std/expr/conv/conv.mem/out/refcount/p1-null-distinct-from-first-member.rs b/tests/std/expr/conv/conv.mem/out/refcount/p1-null-distinct-from-first-member.rs index dad1e505cc..4bcabd8ac0 100644 --- a/tests/std/expr/conv/conv.mem/out/refcount/p1-null-distinct-from-first-member.rs +++ b/tests/std/expr/conv/conv.mem/out/refcount/p1-null-distinct-from-first-member.rs @@ -19,9 +19,9 @@ pub fn main() { std::process::exit(main_0()); } fn main_0() -> i32 { - let mut null_pm: MemberPtr = >::default(); - let mut first_pm: MemberPtr = member_ptr!(HasTwoInts, first); - let mut second_pm: MemberPtr = member_ptr!(HasTwoInts, second); + let mut null_pm: isize = -1_isize; + let mut first_pm: isize = (::OFFSETS.first as isize); + let mut second_pm: isize = (::OFFSETS.second as isize); assert!((first_pm != null_pm)); assert!((second_pm != null_pm)); return 0; diff --git a/tests/std/expr/expr.compound/expr.cond/out/refcount/p7.4-pointer-to-member-and-null.rs b/tests/std/expr/expr.compound/expr.cond/out/refcount/p7.4-pointer-to-member-and-null.rs index 6223b58d15..3b241f9054 100644 --- a/tests/std/expr/expr.compound/expr.cond/out/refcount/p7.4-pointer-to-member-and-null.rs +++ b/tests/std/expr/expr.compound/expr.cond/out/refcount/p7.4-pointer-to-member-and-null.rs @@ -14,11 +14,11 @@ pub struct HasTwoInts { #[offset(4)] pub second: i32, } -pub fn second_or_null_0(mut choose_second: bool) -> MemberPtr { +pub fn second_or_null_0(mut choose_second: bool) -> isize { return if choose_second { - member_ptr!(HasTwoInts, second) + (::OFFSETS.second as isize) } else { - >::default() + -1_isize }; } pub fn main() { @@ -30,11 +30,11 @@ fn main_0() -> i32 { first: 3, second: 4, })); - assert!(({ second_or_null_0(false,) }).is_null()); - assert!((({ second_or_null_0(true,) }) == member_ptr!(HasTwoInts, second))); + assert!((({ second_or_null_0(false,) }) == -1_isize)); + assert!((({ second_or_null_0(true,) }) == (::OFFSETS.second as isize))); assert!( (((obj.as_pointer()) - .member(({ second_or_null_0(true,) })) + .member::(({ second_or_null_0(true,) })) .read()) == 4) ); diff --git a/tests/std/expr/expr.compound/expr.eq/out/refcount/p4.1-both-null.rs b/tests/std/expr/expr.compound/expr.eq/out/refcount/p4.1-both-null.rs index 1a0a6ea210..d7c0353e6a 100644 --- a/tests/std/expr/expr.compound/expr.eq/out/refcount/p4.1-both-null.rs +++ b/tests/std/expr/expr.compound/expr.eq/out/refcount/p4.1-both-null.rs @@ -19,8 +19,8 @@ pub fn main() { std::process::exit(main_0()); } fn main_0() -> i32 { - let mut first_null: MemberPtr = >::default(); - let mut second_null: MemberPtr = >::default(); + let mut first_null: isize = -1_isize; + let mut second_null: isize = -1_isize; assert!((first_null == second_null)); assert!(!(first_null != second_null)); return 0; diff --git a/tests/std/expr/expr.compound/expr.eq/out/refcount/p4.2-one-null.rs b/tests/std/expr/expr.compound/expr.eq/out/refcount/p4.2-one-null.rs index d9f772998a..8b7e638ed7 100644 --- a/tests/std/expr/expr.compound/expr.eq/out/refcount/p4.2-one-null.rs +++ b/tests/std/expr/expr.compound/expr.eq/out/refcount/p4.2-one-null.rs @@ -19,8 +19,8 @@ pub fn main() { std::process::exit(main_0()); } fn main_0() -> i32 { - let mut null_pm: MemberPtr = >::default(); - let mut first_pm: MemberPtr = member_ptr!(HasTwoInts, first); + let mut null_pm: isize = -1_isize; + let mut first_pm: isize = (::OFFSETS.first as isize); assert!((first_pm != null_pm)); assert!(!(first_pm == null_pm)); assert!((null_pm != first_pm)); diff --git a/tests/std/expr/expr.compound/expr.eq/out/refcount/p4.6-data-members.rs b/tests/std/expr/expr.compound/expr.eq/out/refcount/p4.6-data-members.rs index e1a1ca0147..7eece39c53 100644 --- a/tests/std/expr/expr.compound/expr.eq/out/refcount/p4.6-data-members.rs +++ b/tests/std/expr/expr.compound/expr.eq/out/refcount/p4.6-data-members.rs @@ -19,9 +19,9 @@ pub fn main() { std::process::exit(main_0()); } fn main_0() -> i32 { - let mut first_pm: MemberPtr = member_ptr!(HasTwoInts, first); - let mut also_first_pm: MemberPtr = member_ptr!(HasTwoInts, first); - let mut second_pm: MemberPtr = member_ptr!(HasTwoInts, second); + let mut first_pm: isize = (::OFFSETS.first as isize); + let mut also_first_pm: isize = (::OFFSETS.first as isize); + let mut second_pm: isize = (::OFFSETS.second as isize); assert!((first_pm == also_first_pm)); assert!(!(first_pm != also_first_pm)); assert!((first_pm != second_pm)); diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p3-arrow-star.rs b/tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p3-arrow-star.rs index 4eafcc79d7..e6e793dd23 100644 --- a/tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p3-arrow-star.rs +++ b/tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p3-arrow-star.rs @@ -19,17 +19,17 @@ pub fn main() { std::process::exit(main_0()); } fn main_0() -> i32 { - let mut pm: MemberPtr = member_ptr!(HasTwoInts, second); + let mut pm: isize = (::OFFSETS.second as isize); let obj: Value = Rc::new(RefCell::new(HasTwoInts { first: 3, second: 4, })); let mut p: Ptr = (obj.as_pointer()); - assert!((((p).member(pm).read()) == 4)); - (p).member(pm).write(5); + assert!((((p).member::(pm).read()) == 4)); + (p).member::(pm).write(5); assert!(({ ({ (*obj.borrow()).second } == 5) })); assert!(({ ({ (*obj.borrow()).first } == 3) })); - assert!((((p).member(pm)) == ((p).member(pm)))); + assert!((((p).member::(pm)) == ((p).member::(pm)))); return 0; } pub fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p4-object-expression-sequenced-first.rs b/tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p4-object-expression-sequenced-first.rs index 891b967771..48f1062ae9 100644 --- a/tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p4-object-expression-sequenced-first.rs +++ b/tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p4-object-expression-sequenced-first.rs @@ -29,10 +29,10 @@ pub fn select_object_4() -> Ptr { .with(|rc| *rc.borrow_mut() = (*sequence_0.with(Value::clone).borrow_mut()).prefix_inc()); return object_3.with(|v| v.as_pointer()); } -pub fn select_member_5() -> MemberPtr { +pub fn select_member_5() -> isize { member_stamp_2 .with(|rc| *rc.borrow_mut() = (*sequence_0.with(Value::clone).borrow_mut()).prefix_inc()); - return member_ptr!(HasValue, value); + return (::OFFSETS.value as isize); } pub fn main() { __cpp2rust_init_globals(); @@ -41,7 +41,7 @@ pub fn main() { fn main_0() -> i32 { assert!( ((({ select_object_4() }) - .member(({ select_member_5() })) + .member::(({ select_member_5() })) .read()) == 7) ); diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p6-data-member-of-lvalue-is-lvalue.rs b/tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p6-data-member-of-lvalue-is-lvalue.rs index 7b5ac59a35..a41629c6b6 100644 --- a/tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p6-data-member-of-lvalue-is-lvalue.rs +++ b/tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p6-data-member-of-lvalue-is-lvalue.rs @@ -19,13 +19,13 @@ pub fn main() { std::process::exit(main_0()); } fn main_0() -> i32 { - let mut pm: MemberPtr = member_ptr!(HasTwoInts, second); + let mut pm: isize = (::OFFSETS.second as isize); let obj: Value = Rc::new(RefCell::new(HasTwoInts { first: 3, second: 4, })); - assert!((((obj.as_pointer()).member(pm)) == (field_ptr!(obj.as_pointer(), second)))); - let ref_: Ptr = (obj.as_pointer()).member(pm); + assert!((((obj.as_pointer()).member::(pm)) == (field_ptr!(obj.as_pointer(), second)))); + let ref_: Ptr = (obj.as_pointer()).member::(pm); ref_.write(5); assert!(({ ({ (*obj.borrow()).second } == 5) })); assert!(({ ({ (*obj.borrow()).first } == 3) })); diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p6-data-member-of-rvalue-is-xvalue.rs b/tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p6-data-member-of-rvalue-is-xvalue.rs index 17da7ba7ac..f203b47017 100644 --- a/tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p6-data-member-of-rvalue-is-xvalue.rs +++ b/tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p6-data-member-of-rvalue-is-xvalue.rs @@ -52,14 +52,16 @@ pub fn main() { std::process::exit(main_0()); } fn main_0() -> i32 { - let mut pm: MemberPtr = member_ptr!(HoldsCounted, member); + let mut pm: isize = (::OFFSETS.member as isize); let holder: Value = Rc::new(RefCell::new(::default())); - let mut from_lvalue: CountsCopiesAndMoves = - CountsCopiesAndMoves::copy_from({ (holder.as_pointer()).member(pm) }); + let mut from_lvalue: CountsCopiesAndMoves = CountsCopiesAndMoves::copy_from({ + (holder.as_pointer()).member::(pm) + }); assert!((copyCount_0.with(|rc| *rc.borrow()) == 1)); assert!((moveCount_1.with(|rc| *rc.borrow()) == 0)); - let mut from_xvalue: CountsCopiesAndMoves = - CountsCopiesAndMoves::move_from({ (holder.as_pointer()).member(pm) }); + let mut from_xvalue: CountsCopiesAndMoves = CountsCopiesAndMoves::move_from({ + (holder.as_pointer()).member::(pm) + }); assert!((copyCount_0.with(|rc| *rc.borrow()) == 1)); assert!((moveCount_1.with(|rc| *rc.borrow()) == 1)); return 0; diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p6-null-pointer-to-data-member.rs b/tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p6-null-pointer-to-data-member.rs index aff9b95623..f580b9bf45 100644 --- a/tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p6-null-pointer-to-data-member.rs +++ b/tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p6-null-pointer-to-data-member.rs @@ -19,11 +19,11 @@ pub fn main() { std::process::exit(main_0()); } fn main_0() -> i32 { - let mut pm: MemberPtr = >::default(); + let mut pm: isize = -1_isize; let obj: Value = Rc::new(RefCell::new(HasTwoInts { first: 3, second: 4, })); - return ((obj.as_pointer()).member(pm).read()); + return ((obj.as_pointer()).member::(pm).read()); } pub fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/out/refcount/p10-null-converts-to-null.rs b/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/out/refcount/p10-null-converts-to-null.rs index 275f7abaac..f423c8bc8f 100644 --- a/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/out/refcount/p10-null-converts-to-null.rs +++ b/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/out/refcount/p10-null-converts-to-null.rs @@ -25,9 +25,9 @@ pub fn main() { std::process::exit(main_0()); } fn main_0() -> i32 { - let mut pm: MemberPtr = >::default(); - let mut converted: MemberPtr = >::cast_from(pm); - assert!((converted).is_null()); + let mut pm: isize = -1_isize; + let mut converted: isize = pm; + assert!(((converted) == -1_isize)); return 0; } pub fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/out/refcount/p10-result-is-unspecified.rs b/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/out/refcount/p10-result-is-unspecified.rs index b7294c4226..b13c20a0c4 100644 --- a/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/out/refcount/p10-result-is-unspecified.rs +++ b/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/out/refcount/p10-result-is-unspecified.rs @@ -27,8 +27,7 @@ pub fn main() { std::process::exit(main_0()); } fn main_0() -> i32 { - let mut converted: MemberPtr = - >::cast_from(member_ptr!(HasTwoInts, second)); - return ((converted == member_ptr!(AlsoHasTwoInts, second)) as i32); + let mut converted: isize = (::OFFSETS.second as isize); + return ((converted == (::OFFSETS.second as isize)) as i32); } pub fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/out/refcount/p10.2-data-member-round-trip.rs b/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/out/refcount/p10.2-data-member-round-trip.rs index 7aefbb9def..d451052256 100644 --- a/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/out/refcount/p10.2-data-member-round-trip.rs +++ b/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/out/refcount/p10.2-data-member-round-trip.rs @@ -25,15 +25,14 @@ pub fn main() { std::process::exit(main_0()); } fn main_0() -> i32 { - let mut converted: MemberPtr = - >::cast_from(member_ptr!(HasTwoInts, second)); - let mut back: MemberPtr = >::cast_from(converted); - assert!((back == member_ptr!(HasTwoInts, second))); + let mut converted: isize = (::OFFSETS.second as isize); + let mut back: isize = converted; + assert!((back == (::OFFSETS.second as isize))); let obj: Value = Rc::new(RefCell::new(HasTwoInts { first: 3, second: 4, })); - assert!((((obj.as_pointer()).member(back).read()) == 4)); + assert!((((obj.as_pointer()).member::(back).read()) == 4)); return 0; } pub fn __cpp2rust_init_globals() {} From 659617efe540b96c335f04e4e7139d77037f73c6 Mon Sep 17 00:00:00 2001 From: Lucian Popescu Date: Mon, 16 Nov 2026 16:51:22 +0000 Subject: [PATCH 09/15] Add converter and libcc2rs support for pointer to data member --- cpp2rust/converter/converter.cpp | 124 +++++++++++++++++- cpp2rust/converter/converter.h | 20 ++- .../converter/models/converter_refcount.cpp | 42 ++++++ .../converter/models/converter_refcount.h | 10 ++ cpp2rust/converter/rules/rules_loader.cpp | 4 + libcc2rs/src/field.rs | 63 +++++---- libcc2rs/src/lib.rs | 2 + libcc2rs/src/member_ptr.rs | 39 ++++++ 8 files changed, 276 insertions(+), 28 deletions(-) create mode 100644 libcc2rs/src/member_ptr.rs diff --git a/cpp2rust/converter/converter.cpp b/cpp2rust/converter/converter.cpp index ed3c5db8fb..4a529b2372 100644 --- a/cpp2rust/converter/converter.cpp +++ b/cpp2rust/converter/converter.cpp @@ -353,6 +353,14 @@ bool Converter::VisitPointerType(clang::PointerType *type) { return Convert(pointee_type); } +bool Converter::VisitMemberPointerType(clang::MemberPointerType *type) { + if (type->isMemberFunctionPointer()) { + llvm::report_fatal_error("pointers to member functions are not supported"); + } + StrCat("isize"); + return false; +} + bool Converter::VisitDecayedType(clang::DecayedType *type) { return Convert(type->getDecayedType()); } @@ -715,7 +723,7 @@ bool Converter::TypeDerivesDefault(clang::QualType qual_type) { return array_type->getSize().ule(32) && TypeDerivesDefault(array_type->getElementType()); } - if (qual_type->isArrayType()) { + if (qual_type->isArrayType() || qual_type->isMemberPointerType()) { return false; } @@ -2595,6 +2603,18 @@ bool Converter::VisitImplicitCastExpr(clang::ImplicitCastExpr *expr) { case clang::CastKind::CK_NullToPointer: EmitFresh(GetDefaultAsString(type)); break; + case clang::CastKind::CK_NullToMemberPointer: + EmitFresh(GetUnboxedDefaultAsString(type)); + break; + case clang::CastKind::CK_MemberPointerToBoolean: + StrCat(token::kNot); + ConvertEqualsNullPtr(sub_expr); + break; + case clang::CastKind::CK_BaseToDerivedMemberPointer: + case clang::CastKind::CK_DerivedToBaseMemberPointer: + llvm::report_fatal_error( + "conversions of pointers to members between classes are not " + "supported"); default: // Before clang 24, a case value is a literal in a ConstantExpr. auto *value = sub_expr; @@ -2662,6 +2682,25 @@ bool Converter::VisitExplicitCastExpr(clang::ExplicitCastExpr *expr) { ConvertIntegerToEnumeralCast(expr, sub_expr); return false; } + switch (expr->getCastKind()) { + case clang::CastKind::CK_NullToMemberPointer: + EmitFresh(GetUnboxedDefaultAsString(type)); + return false; + case clang::CastKind::CK_MemberPointerToBoolean: + StrCat(token::kNot); + ConvertEqualsNullPtr(sub_expr); + return false; + case clang::CastKind::CK_ReinterpretMemberPointer: + Convert(sub_expr); + return false; + case clang::CastKind::CK_BaseToDerivedMemberPointer: + case clang::CastKind::CK_DerivedToBaseMemberPointer: + llvm::report_fatal_error( + "conversions of pointers to members between classes are not " + "supported"); + default: + break; + } switch (expr->getStmtClass()) { case clang::Stmt::CXXFunctionalCastExprClass: Convert(sub_expr, type); @@ -2710,6 +2749,10 @@ bool Converter::VisitCXXRewrittenBinaryOperator( } bool Converter::VisitBinaryOperator(clang::BinaryOperator *expr) { + if (expr->isPtrMemOp()) { + ConvertMemberPtrAccess(expr); + return false; + } if (expr->getOpcode() == clang::BO_Cmp) { EmitFresh(std::format("std::cmp::Ord::cmp(&({}), &({}))", ConvertRValue(expr->getLHS()), @@ -2934,6 +2977,10 @@ bool Converter::VisitUnaryOperator(clang::UnaryOperator *expr) { Convert(sub_expr); break; case clang::UO_AddrOf: { + if (expr->getType()->isMemberPointerType()) { + ConvertMemberPtr(expr); + break; + } PushParen paren(*this); ConvertAddrOf(sub_expr, expr->getType()); break; @@ -3996,6 +4043,9 @@ bool Converter::VisitImplicitValueInitExpr(clang::ImplicitValueInitExpr *expr) { auto elem_ty = arr_ty->getElementType(); if (elem_ty->isIntegerType() && !elem_ty->isEnumeralType()) { StrCat(std::format("[0; {}]", arr_ty->getSize().getZExtValue())); + } else if (elem_ty->isMemberDataPointerType()) { + StrCat(std::format("[{}; {}]", GetDefaultAsString(elem_ty), + arr_ty->getSize().getZExtValue())); } else { StrCat( std::format("std::array::from_fn::<_, {}, _>(|_| Default::default())", @@ -4171,6 +4221,10 @@ std::string Converter::GetDefaultAsString(clang::QualType qual_type) { return init; } + if (qual_type->isMemberDataPointerType()) { + return "-1_isize"; + } + if (qual_type->isPointerType()) { auto pointee = qual_type->getPointeeType(); if (pointee->isFunctionType()) { @@ -4359,6 +4413,15 @@ void Converter::ConvertUnsignedArithOperand(clang::Expr *expr, } void Converter::ConvertEqualsNullPtr(clang::Expr *expr) { + if (expr->getType()->isMemberPointerType()) { + PushParen outer(*this); + { + PushParen inner(*this); + Convert(expr); + } + EmitFresh("== -1_isize"); + return; + } StrCat('('); Convert(expr); EmitFresh(expr->getType()->isFunctionPointerType() ? ").is_none()" @@ -4932,6 +4995,65 @@ void Converter::ConvertAddrOf(clang::Expr *expr, clang::QualType pointer_type) { } } +void Converter::ConvertMemberPtr(clang::UnaryOperator *expr) { + auto type = expr->getType(); + if (!type->isMemberDataPointerType()) { + llvm::report_fatal_error("pointers to member functions are not supported"); + } + auto *ref = clang::cast(expr->getSubExpr()); + auto *field = clang::dyn_cast(ref->getDecl()); + if (!field) { + llvm::report_fatal_error( + "pointers to members of anonymous unions are not supported"); + } + EmitFresh(GetMemberPtrAsString(field->getParent(), field)); +} + +std::string Converter::GetMemberPtrAsString(const clang::RecordDecl *record, + const clang::FieldDecl *field) { + if (record->isUnion()) { + return "0_isize"; + } + return std::format("(::std::mem::offset_of!({}, {}) as isize)", + GetRecordName(record), GetNamedDeclAsString(field)); +} + +void Converter::ConvertMemberPtrAccess(clang::BinaryOperator *expr) { + auto object = ConvertMemberPtrObject(expr); + auto member = ConvertRValue(expr->getRHS()); + auto ptr = GetMemberOfObjectAsString(std::move(object), std::move(member), + expr->getType()); + if (isAddrOf()) { + EmitFresh(ptr); + return; + } + EmitMemberPtrPointee(std::move(ptr), expr->getType()); +} + +std::string Converter::ConvertMemberPtrObject(clang::BinaryOperator *expr) { + auto *object = expr->getLHS(); + if (expr->getOpcode() == clang::BO_PtrMemI) { + return std::format("({})", ConvertRValue(object)); + } + Buffer buf(*this); + { + PushParen paren(*this); + ConvertAddrOf(object, ctx_.getPointerType(object->getType())); + } + return std::move(buf).str(); +} + +std::string Converter::GetMemberOfObjectAsString(std::string object, + std::string member, + clang::QualType type) { + return std::format("{}.wrapping_byte_offset({}).cast::<{}>()", object, member, + ToString(type)); +} + +void Converter::EmitMemberPtrPointee(std::string ptr, clang::QualType type) { + EmitDeref(std::move(ptr), type); +} + void Converter::EmitDeref(std::string inner, clang::QualType pointee_type) { auto wrap = std::exchange(autoref_mut_, std::nullopt); PushParen outer(*this, wrap.has_value()); diff --git a/cpp2rust/converter/converter.h b/cpp2rust/converter/converter.h index ec49e3712e..dd67d539bb 100644 --- a/cpp2rust/converter/converter.h +++ b/cpp2rust/converter/converter.h @@ -119,6 +119,8 @@ class Converter : public clang::RecursiveASTVisitor { virtual bool VisitPointerType(clang::PointerType *type); + bool VisitMemberPointerType(clang::MemberPointerType *type); + virtual std::string ConvertFunctionPointerType(const clang::FunctionProtoType *proto); @@ -462,7 +464,8 @@ class Converter : public clang::RecursiveASTVisitor { if (ty->isFunctionPointerType() || ty->isFunctionType()) { return FunctionPointerImplementsCopy(); } - if (ty->isBuiltinType() || ty->isEnumeralType()) { + if (ty->isBuiltinType() || ty->isEnumeralType() || + ty->isMemberDataPointerType()) { return true; } if (ty->getAsRecordDecl()) { @@ -857,6 +860,21 @@ class Converter : public clang::RecursiveASTVisitor { virtual void ConvertAddrOf(clang::Expr *expr, clang::QualType pointer_type); + void ConvertMemberPtr(clang::UnaryOperator *expr); + + virtual std::string GetMemberPtrAsString(const clang::RecordDecl *record, + const clang::FieldDecl *field); + + void ConvertMemberPtrAccess(clang::BinaryOperator *expr); + + virtual std::string ConvertMemberPtrObject(clang::BinaryOperator *expr); + + virtual std::string GetMemberOfObjectAsString(std::string object, + std::string member, + clang::QualType type); + + virtual void EmitMemberPtrPointee(std::string ptr, clang::QualType type); + virtual void ConvertDeref(clang::Expr *expr); void EmitDeref(std::string inner, clang::QualType pointee_type); diff --git a/cpp2rust/converter/models/converter_refcount.cpp b/cpp2rust/converter/models/converter_refcount.cpp index d6c1eeabd5..ef93b18f2c 100644 --- a/cpp2rust/converter/models/converter_refcount.cpp +++ b/cpp2rust/converter/models/converter_refcount.cpp @@ -1427,6 +1427,10 @@ std::string ConverterRefCount::ConvertFnPtrPlaceholder(clang::Expr *arg) { } void ConverterRefCount::ConvertEqualsNullPtr(clang::Expr *expr) { + if (expr->getType()->isMemberPointerType()) { + Converter::ConvertEqualsNullPtr(expr); + return; + } StrCat('('); Convert(expr); EmitFresh(").is_null()"); @@ -1499,6 +1503,9 @@ bool ConverterRefCount::VisitExplicitCastExpr(clang::ExplicitCastExpr *expr) { MarkFresh(); return false; } + if (expr->getCastKind() == clang::CK_ReinterpretMemberPointer) { + return Converter::VisitExplicitCastExpr(expr); + } switch (expr->getStmtClass()) { case clang::Stmt::CXXReinterpretCastExprClass: assert(expr->getType()->isPointerType() && @@ -2228,6 +2235,10 @@ std::string ConverterRefCount::GetDefaultAsString(clang::QualType qual_type) { return BoxValue(std::move(init)); } + if (qual_type->isMemberDataPointerType()) { + return BoxValue("-1_isize"); + } + if (!qual_type->isPointerType()) { return Converter::GetDefaultAsString(qual_type); } @@ -2866,6 +2877,37 @@ void ConverterRefCount::ConvertAddrOf(clang::Expr *expr, StrCat(ConvertPointer(expr)); } +std::string +ConverterRefCount::GetMemberPtrAsString(const clang::RecordDecl *record, + const clang::FieldDecl *field) { + if (record->isUnion()) { + llvm::report_fatal_error("pointers to members of unions are not supported"); + } + return std::format("(<{} as Record>::OFFSETS.{} as isize)", + GetRecordName(record), GetNamedDeclAsString(field)); +} + +std::string ConverterRefCount::GetMemberOfObjectAsString(std::string object, + std::string member, + clang::QualType type) { + PushConversionKind push(*this, ConversionKind::Pointee); + return std::format("{}.member::<{}>({})", object, ToString(type), member); +} + +std::string +ConverterRefCount::ConvertMemberPtrObject(clang::BinaryOperator *expr) { + auto *object = expr->getLHS(); + if (expr->getOpcode() == clang::BO_PtrMemI) { + return std::format("({})", ConvertRValue(object)); + } + return std::format("({})", ConvertPointer(object)); +} + +void ConverterRefCount::EmitMemberPtrPointee(std::string ptr, + clang::QualType type) { + EmitPointee(std::move(ptr), type, /*fresh=*/true); +} + void ConverterRefCount::ConvertDeref(clang::Expr *expr) { auto pointee_type = expr->getType()->getPointeeType(); diff --git a/cpp2rust/converter/models/converter_refcount.h b/cpp2rust/converter/models/converter_refcount.h index 2026cad9c9..0dfe9815b1 100644 --- a/cpp2rust/converter/models/converter_refcount.h +++ b/cpp2rust/converter/models/converter_refcount.h @@ -316,6 +316,16 @@ class ConverterRefCount final : public Converter { void ConvertAddrOf(clang::Expr *expr, clang::QualType pointer_type) override; + std::string GetMemberPtrAsString(const clang::RecordDecl *record, + const clang::FieldDecl *field) override; + + std::string ConvertMemberPtrObject(clang::BinaryOperator *expr) override; + + std::string GetMemberOfObjectAsString(std::string object, std::string member, + clang::QualType type) override; + + void EmitMemberPtrPointee(std::string ptr, clang::QualType type) override; + void ConvertDeref(clang::Expr *expr) override; void ConvertArrow(clang::Expr *expr) override; diff --git a/cpp2rust/converter/rules/rules_loader.cpp b/cpp2rust/converter/rules/rules_loader.cpp index f8e0c96342..f969e9168f 100644 --- a/cpp2rust/converter/rules/rules_loader.cpp +++ b/cpp2rust/converter/rules/rules_loader.cpp @@ -180,6 +180,10 @@ class RuleUsageCollector if (type->isPointerType() || type->isReferenceType()) { return AddType(type->getPointeeType()); } + if (const auto *member = type->getAs()) { + AddType(ctx_.getCanonicalTagType(member->getMostRecentCXXRecordDecl())); + return AddType(member->getPointeeType()); + } if (const auto *array = ctx_.getAsArrayType(type)) { return AddType(array->getElementType()); } diff --git a/libcc2rs/src/field.rs b/libcc2rs/src/field.rs index 3ad420ed4e..1f5f2ff9fb 100644 --- a/libcc2rs/src/field.rs +++ b/libcc2rs/src/field.rs @@ -236,7 +236,43 @@ impl FieldPtr for Ptr { G: Fn(&S) -> &T + Copy + 'static, M: Fn(&mut S) -> &mut T + Copy + 'static, { - let offset = offset(&S::OFFSETS); + self.field_ptr_at(get, get_mut, offset(&S::OFFSETS)) + } + + #[inline] + fn array_field_ptr( + &self, + get: G, + get_mut: M, + offset: fn(&S::Offsets) -> usize, + ) -> Ptr + where + T: ByteRepr, + G: Fn(&S) -> &Box<[T]> + Copy + 'static, + M: Fn(&mut S) -> &mut Box<[T]> + Copy + 'static, + { + match &self.kind { + PtrKind::Reinterpreted(_) => { + let (alloc, byte_offset) = self.original_alloc().unwrap(); + Ptr::from_original_alloc(alloc, byte_offset.wrapping_add(offset(&S::OFFSETS))) + } + PtrKind::Field(_, _, FieldShape::Single) => { + self.field_ptr(get, get_mut, offset).decay() + } + PtrKind::Address(_) => Ptr::from_int(self.offset.wrapping_add(offset(&S::OFFSETS))), + _ => self.elems_of(get, get_mut, offset(&S::OFFSETS)), + } + } +} + +impl Ptr { + #[inline] + pub(crate) fn field_ptr_at(&self, get: G, get_mut: M, offset: usize) -> Ptr + where + T: ByteRepr, + G: Fn(&S) -> &T + Copy + 'static, + M: Fn(&mut S) -> &mut T + Copy + 'static, + { // The byte offset of the struct in its allocation. let start = || self.offset.wrapping_mul(S::byte_size()); let (root, start): (Weak, usize) = match &self.kind { @@ -270,31 +306,6 @@ impl FieldPtr for Ptr { kind: PtrKind::Field(root, 0, FieldShape::Single), } } - - #[inline] - fn array_field_ptr( - &self, - get: G, - get_mut: M, - offset: fn(&S::Offsets) -> usize, - ) -> Ptr - where - T: ByteRepr, - G: Fn(&S) -> &Box<[T]> + Copy + 'static, - M: Fn(&mut S) -> &mut Box<[T]> + Copy + 'static, - { - match &self.kind { - PtrKind::Reinterpreted(_) => { - let (alloc, byte_offset) = self.original_alloc().unwrap(); - Ptr::from_original_alloc(alloc, byte_offset.wrapping_add(offset(&S::OFFSETS))) - } - PtrKind::Field(_, _, FieldShape::Single) => { - self.field_ptr(get, get_mut, offset).decay() - } - PtrKind::Address(_) => Ptr::from_int(self.offset.wrapping_add(offset(&S::OFFSETS))), - _ => self.elems_of(get, get_mut, offset(&S::OFFSETS)), - } - } } impl FieldPtr for Value { diff --git a/libcc2rs/src/lib.rs b/libcc2rs/src/lib.rs index dba659bc65..f88239ce92 100644 --- a/libcc2rs/src/lib.rs +++ b/libcc2rs/src/lib.rs @@ -22,6 +22,8 @@ pub mod __field { }; } +mod member_ptr; + mod cstr; pub use cstr::CChar; diff --git a/libcc2rs/src/member_ptr.rs b/libcc2rs/src/member_ptr.rs new file mode 100644 index 0000000000..4c7f4347ca --- /dev/null +++ b/libcc2rs/src/member_ptr.rs @@ -0,0 +1,39 @@ +// Copyright (c) 2022-present INESC-ID. +// Distributed under the MIT license that can be found in the LICENSE file. + +use std::any::TypeId; + +use crate::Record; +use crate::rc::Ptr; +use crate::reinterpret::ByteRepr; + +const NULL: isize = -1; + +fn member_of(object: &C, offset: usize) -> &T { + object + .locate(offset, TypeId::of::()) + .and_then(|member| member.downcast_ref::()) + .unwrap_or_else(|| panic!("ub: invalid member pointer")) +} + +fn member_of_mut(object: &mut C, offset: usize) -> &mut T { + object + .locate_mut(offset, TypeId::of::()) + .and_then(|member| member.downcast_mut::()) + .unwrap_or_else(|| panic!("ub: invalid member pointer")) +} + +impl Ptr { + #[inline] + pub fn member(&self, member: isize) -> Ptr { + if member == NULL { + panic!("ub: null member pointer"); + } + let offset = member as usize; + self.field_ptr_at( + move |object| member_of(object, offset), + move |object| member_of_mut(object, offset), + offset, + ) + } +} From 779d4d3ffd8855fd75b69a5f9815f329c245bdc8 Mon Sep 17 00:00:00 2001 From: Lucian Popescu Date: Mon, 16 Nov 2026 17:15:37 +0000 Subject: [PATCH 10/15] Support member pointer into anonymous struct/union --- cpp2rust/converter/converter.cpp | 41 +++++++++----- cpp2rust/converter/converter.h | 5 +- cpp2rust/converter/converter_lib.cpp | 13 +++++ cpp2rust/converter/converter_lib.h | 3 + .../converter/models/converter_refcount.cpp | 11 ++-- .../converter/models/converter_refcount.h | 3 +- .../refcount/p4.5-members-of-same-union.rs | 42 ++++++++++++++ .../expr.eq/p4.5-members-of-same-union.cpp | 1 - .../refcount/p3.1-anonymous-union-member.rs | 55 +++++++++++++++++++ .../out/unsafe/p3.1-anonymous-union-member.rs | 50 +++++++++++++++++ .../p3.1-anonymous-union-member.cpp | 2 +- 11 files changed, 200 insertions(+), 26 deletions(-) create mode 100644 tests/std/expr/expr.compound/expr.eq/out/refcount/p4.5-members-of-same-union.rs create mode 100644 tests/std/expr/expr.compound/expr.unary/expr.unary.op/out/refcount/p3.1-anonymous-union-member.rs create mode 100644 tests/std/expr/expr.compound/expr.unary/expr.unary.op/out/unsafe/p3.1-anonymous-union-member.rs diff --git a/cpp2rust/converter/converter.cpp b/cpp2rust/converter/converter.cpp index cd4c7731fc..6f50a1ca49 100644 --- a/cpp2rust/converter/converter.cpp +++ b/cpp2rust/converter/converter.cpp @@ -5150,26 +5150,41 @@ void Converter::ConvertAddrOf(clang::Expr *expr, clang::QualType pointer_type) { } void Converter::ConvertMemberPtr(clang::UnaryOperator *expr) { - auto type = expr->getType(); - if (!type->isMemberDataPointerType()) { + if (!expr->getType()->isMemberDataPointerType()) { llvm::report_fatal_error("pointers to member functions are not supported"); } auto *ref = clang::cast(expr->getSubExpr()); - auto *field = clang::dyn_cast(ref->getDecl()); - if (!field) { - llvm::report_fatal_error( - "pointers to members of anonymous unions are not supported"); - } - EmitFresh(GetMemberPtrAsString(field->getParent(), field)); + EmitFresh(GetMemberPtrAsString(ref->getDecl())); } -std::string Converter::GetMemberPtrAsString(const clang::RecordDecl *record, - const clang::FieldDecl *field) { - if (record->isUnion()) { +std::string Converter::GetMemberPtrAsString(const clang::ValueDecl *member) { + std::vector offsets; + for (auto *field : GetFieldPath(member)) { + if (field->getParent()->isUnion()) { + continue; + } + offsets.push_back(GetFieldOffsetAsString(field)); + } + if (offsets.empty()) { return "0_isize"; } - return std::format("(::std::mem::offset_of!({}, {}) as isize)", - GetRecordName(record), GetNamedDeclAsString(field)); + if (offsets.size() == 1) { + return std::format("({} as isize)", offsets.front()); + } + std::string sum; + for (const auto &offset : offsets) { + if (!sum.empty()) { + sum += " + "; + } + sum += offset; + } + return std::format("(({}) as isize)", sum); +} + +std::string Converter::GetFieldOffsetAsString(const clang::FieldDecl *field) { + return std::format("::std::mem::offset_of!({}, {})", + GetRecordName(field->getParent()), + GetNamedDeclAsString(field)); } void Converter::ConvertMemberPtrAccess(clang::BinaryOperator *expr) { diff --git a/cpp2rust/converter/converter.h b/cpp2rust/converter/converter.h index ba5eb07044..36510a0480 100644 --- a/cpp2rust/converter/converter.h +++ b/cpp2rust/converter/converter.h @@ -868,8 +868,9 @@ class Converter : public clang::RecursiveASTVisitor { void ConvertMemberPtr(clang::UnaryOperator *expr); - virtual std::string GetMemberPtrAsString(const clang::RecordDecl *record, - const clang::FieldDecl *field); + std::string GetMemberPtrAsString(const clang::ValueDecl *member); + + virtual std::string GetFieldOffsetAsString(const clang::FieldDecl *field); void ConvertMemberPtrAccess(clang::BinaryOperator *expr); diff --git a/cpp2rust/converter/converter_lib.cpp b/cpp2rust/converter/converter_lib.cpp index 083fa6ba96..362561cc37 100644 --- a/cpp2rust/converter/converter_lib.cpp +++ b/cpp2rust/converter/converter_lib.cpp @@ -374,6 +374,19 @@ bool RustSizeDivergesFromC(clang::QualType qt) { return false; } +std::vector +GetFieldPath(const clang::ValueDecl *member) { + std::vector path; + if (auto *indirect = clang::dyn_cast(member)) { + for (auto *link : indirect->chain()) { + path.push_back(clang::cast(link)); + } + } else { + path.push_back(clang::cast(member)); + } + return path; +} + bool IsMutatingCall(const clang::CallExpr *expr) { if (auto *callee = expr->getDirectCallee()) { if (auto *method = clang::dyn_cast(callee)) { diff --git a/cpp2rust/converter/converter_lib.h b/cpp2rust/converter/converter_lib.h index 6690962efb..acdb97eccb 100644 --- a/cpp2rust/converter/converter_lib.h +++ b/cpp2rust/converter/converter_lib.h @@ -70,6 +70,9 @@ bool IsMut(clang::QualType qual_type); bool RustSizeDivergesFromC(clang::QualType qt); +std::vector +GetFieldPath(const clang::ValueDecl *member); + bool IsMutatingCall(const clang::CallExpr *expr); // The method of a prefix or postfix increment or decrement, or nullptr if diff --git a/cpp2rust/converter/models/converter_refcount.cpp b/cpp2rust/converter/models/converter_refcount.cpp index df75b041d3..c69800e574 100644 --- a/cpp2rust/converter/models/converter_refcount.cpp +++ b/cpp2rust/converter/models/converter_refcount.cpp @@ -2918,13 +2918,10 @@ void ConverterRefCount::ConvertAddrOf(clang::Expr *expr, } std::string -ConverterRefCount::GetMemberPtrAsString(const clang::RecordDecl *record, - const clang::FieldDecl *field) { - if (record->isUnion()) { - llvm::report_fatal_error("pointers to members of unions are not supported"); - } - return std::format("(<{} as Record>::OFFSETS.{} as isize)", - GetRecordName(record), GetNamedDeclAsString(field)); +ConverterRefCount::GetFieldOffsetAsString(const clang::FieldDecl *field) { + return std::format("<{} as Record>::OFFSETS.{}", + GetRecordName(field->getParent()), + GetNamedDeclAsString(field)); } std::string ConverterRefCount::GetMemberOfObjectAsString(std::string object, diff --git a/cpp2rust/converter/models/converter_refcount.h b/cpp2rust/converter/models/converter_refcount.h index 09820ac35a..e9fda29a46 100644 --- a/cpp2rust/converter/models/converter_refcount.h +++ b/cpp2rust/converter/models/converter_refcount.h @@ -318,8 +318,7 @@ class ConverterRefCount final : public Converter { void ConvertAddrOf(clang::Expr *expr, clang::QualType pointer_type) override; - std::string GetMemberPtrAsString(const clang::RecordDecl *record, - const clang::FieldDecl *field) override; + std::string GetFieldOffsetAsString(const clang::FieldDecl *field) override; std::string ConvertMemberPtrObject(clang::BinaryOperator *expr) override; diff --git a/tests/std/expr/expr.compound/expr.eq/out/refcount/p4.5-members-of-same-union.rs b/tests/std/expr/expr.compound/expr.eq/out/refcount/p4.5-members-of-same-union.rs new file mode 100644 index 0000000000..963b86e0a5 --- /dev/null +++ b/tests/std/expr/expr.compound/expr.eq/out/refcount/p4.5-members-of-same-union.rs @@ -0,0 +1,42 @@ +extern crate libcc2rs; +use libcc2rs::*; +use std::cell::RefCell; +use std::collections::BTreeMap; +use std::io::prelude::*; +use std::io::{Read, Seek, Write}; +use std::os::fd::AsFd; +use std::rc::{Rc, Weak}; +#[derive(VaArg, FnPtrArg, ByteRepr, Clone)] +#[byte_size(4)] +pub struct HasTwoIntMembers { + #[offset(0)] + #[byte_size(4)] + __bytes: Box<[u8]>, +} +impl HasTwoIntMembers { + pub fn first(this: Ptr) -> Ptr { + this.reinterpret_cast() + } + pub fn second(this: Ptr) -> Ptr { + this.reinterpret_cast() + } +} +impl Default for HasTwoIntMembers { + fn default() -> Self { + HasTwoIntMembers { + __bytes: Box::from([0u8; 4]), + } + } +} +pub fn main() { + __cpp2rust_init_globals(); + std::process::exit(main_0()); +} +fn main_0() -> i32 { + let mut first_pm: isize = 0_isize; + let mut second_pm: isize = 0_isize; + assert!((first_pm == second_pm)); + assert!(!(first_pm != second_pm)); + return 0; +} +pub fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/expr.compound/expr.eq/p4.5-members-of-same-union.cpp b/tests/std/expr/expr.compound/expr.eq/p4.5-members-of-same-union.cpp index 178903740f..e74fd2b756 100644 --- a/tests/std/expr/expr.compound/expr.eq/p4.5-members-of-same-union.cpp +++ b/tests/std/expr/expr.compound/expr.eq/p4.5-members-of-same-union.cpp @@ -1,4 +1,3 @@ -// translation-fail: refcount // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [expr.eq]/4.5: pointers to (possibly different) members of the same // union compare equal. diff --git a/tests/std/expr/expr.compound/expr.unary/expr.unary.op/out/refcount/p3.1-anonymous-union-member.rs b/tests/std/expr/expr.compound/expr.unary/expr.unary.op/out/refcount/p3.1-anonymous-union-member.rs new file mode 100644 index 0000000000..2b9d0c3e9d --- /dev/null +++ b/tests/std/expr/expr.compound/expr.unary/expr.unary.op/out/refcount/p3.1-anonymous-union-member.rs @@ -0,0 +1,55 @@ +extern crate libcc2rs; +use libcc2rs::*; +use std::cell::RefCell; +use std::collections::BTreeMap; +use std::io::prelude::*; +use std::io::{Read, Seek, Write}; +use std::os::fd::AsFd; +use std::rc::{Rc, Weak}; +#[derive(VaArg, FnPtrArg, ByteRepr, Clone)] +#[byte_size(4)] +pub struct anon_0 { + #[offset(0)] + #[byte_size(4)] + __bytes: Box<[u8]>, +} +impl anon_0 { + pub fn as_int(this: Ptr) -> Ptr { + this.reinterpret_cast() + } + pub fn as_unsigned(this: Ptr) -> Ptr { + this.reinterpret_cast() + } +} +impl Default for anon_0 { + fn default() -> Self { + anon_0 { + __bytes: Box::from([0u8; 4]), + } + } +} +#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] +#[byte_size(8)] +pub struct HasAnonymousUnion { + #[offset(0)] + pub before: i32, + #[offset(4)] + #[byte_size(4)] + pub anon_0: anon_0, +} +pub fn main() { + __cpp2rust_init_globals(); + std::process::exit(main_0()); +} +fn main_0() -> i32 { + let mut pm: isize = (::OFFSETS.anon_0 as isize); + let obj: Value = Rc::new(RefCell::new(::default())); + (*obj.borrow_mut()).before = 1; + anon_0::as_int(field_ptr!(obj.as_pointer(), anon_0)).write(2); + assert!((((obj.as_pointer()).member::(pm).read()) == 2)); + (obj.as_pointer()).member::(pm).write(3); + assert!(((anon_0::as_int(field_ptr!(obj.as_pointer(), anon_0)).read()) == 3)); + assert!(({ ({ (*obj.borrow()).before } == 1) })); + return 0; +} +pub fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/expr.compound/expr.unary/expr.unary.op/out/unsafe/p3.1-anonymous-union-member.rs b/tests/std/expr/expr.compound/expr.unary/expr.unary.op/out/unsafe/p3.1-anonymous-union-member.rs new file mode 100644 index 0000000000..c4a027e65e --- /dev/null +++ b/tests/std/expr/expr.compound/expr.unary/expr.unary.op/out/unsafe/p3.1-anonymous-union-member.rs @@ -0,0 +1,50 @@ +extern crate libc; +use libc::*; +extern crate libcc2rs; +use libcc2rs::*; +use std::collections::BTreeMap; +use std::io::{Read, Seek, Write}; +use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; +use std::rc::Rc; +#[repr(C)] +#[derive(Copy, Clone, FnPtrArg, VaArg)] +pub union anon_0 { + pub as_int: i32, + pub as_unsigned: u32, +} +impl Default for anon_0 { + fn default() -> Self { + unsafe { std::mem::zeroed() } + } +} +#[repr(C)] +#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] +pub struct HasAnonymousUnion { + pub before: i32, + pub anon_0: anon_0, +} +pub fn main() { + unsafe { + __cpp2rust_init_globals(); + std::process::exit(main_0() as i32); + } +} +unsafe fn main_0() -> i32 { + let mut pm: isize = (::std::mem::offset_of!(HasAnonymousUnion, anon_0) as isize); + let mut obj: HasAnonymousUnion = ::default(); + obj.before = 1; + obj.anon_0.as_int = 2; + assert!( + ((*(&mut obj as *mut HasAnonymousUnion) + .wrapping_byte_offset(pm) + .cast::()) + == (2)) + ); + (*(&mut obj as *mut HasAnonymousUnion) + .wrapping_byte_offset(pm) + .cast::()) = 3; + assert!(((obj.anon_0.as_int) == (3))); + assert!(((obj.before) == (1))); + return 0; +} +pub unsafe fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/expr.compound/expr.unary/expr.unary.op/p3.1-anonymous-union-member.cpp b/tests/std/expr/expr.compound/expr.unary/expr.unary.op/p3.1-anonymous-union-member.cpp index a472196d4e..927ea7c259 100644 --- a/tests/std/expr/expr.compound/expr.unary/expr.unary.op/p3.1-anonymous-union-member.cpp +++ b/tests/std/expr/expr.compound/expr.unary/expr.unary.op/p3.1-anonymous-union-member.cpp @@ -1,4 +1,4 @@ -// translation-fail: refcount, unsafe +// panic: refcount // ADDITIONAL_COMPILE_FLAGS: -std=c++23 // N4950 [expr.unary.op]/3.1: a qualified-id naming a variant member of some // class C yields a pointer to member of class C. From 34f1bde7ea60b3ca7bc4ec455dfc91aa99e00108 Mon Sep 17 00:00:00 2001 From: Lucian Popescu Date: Mon, 16 Nov 2026 17:16:36 +0000 Subject: [PATCH 11/15] format --- .../dcl.array/p6-array-of-pointers-to-member-functions.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.array/p6-array-of-pointers-to-member-functions.cpp b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.array/p6-array-of-pointers-to-member-functions.cpp index 8bff99f21c..8482e262c8 100644 --- a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.array/p6-array-of-pointers-to-member-functions.cpp +++ b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.array/p6-array-of-pointers-to-member-functions.cpp @@ -22,7 +22,7 @@ int main() { assert(obj.first_calls == 0); assert(obj.second_calls == 0); assert(obj.third_calls == 1); - void (HasThreeMemberFunctions::**element)() = functions; + void (HasThreeMemberFunctions::* * element)() = functions; ++element; assert(element == &functions[1]); (obj.**element)(); From 472311f60bbfe5c81f7020a8fadeb1bf1a0b17c0 Mon Sep 17 00:00:00 2001 From: Lucian Popescu Date: Mon, 16 Nov 2026 17:20:00 +0000 Subject: [PATCH 12/15] Delete output of failing tests --- .../out/refcount/p3.5-pointer-to-member.rs | 69 ------- .../p4.1-pure-virtual-qualified-call.rs | 48 ----- .../p5.3-discarded-value-in-lambda.rs | 150 -------------- .../p6-evaluated-binding-is-captured.rs | 191 ------------------ .../p4.1-pure-virtual-qualified-call.rs | 48 ----- .../unsafe/p5.3-discarded-value-in-lambda.rs | 116 ----------- .../p6-evaluated-binding-is-captured.rs | 150 -------------- ...inline-function-reads-per-file-constant.rs | 40 ---- .../refcount/p2-object-of-derived-class.rs | 44 ---- .../p3-arrow-star-pointer-to-derived-class.rs | 45 ----- .../out/unsafe/p2-object-of-derived-class.rs | 44 ---- .../p3-arrow-star-pointer-to-derived-class.rs | 45 ----- .../out/unsafe/p4-object-type-not-similar.rs | 36 ---- ...p3.1-member-named-through-derived-class.rs | 35 ---- ...p3.1-member-named-through-derived-class.rs | 36 ---- .../refcount/p1.4-data-member-with-object.rs | 39 ---- ...p1.5-data-member-with-reference-wrapper.rs | 49 ----- .../refcount/p1.6-data-member-with-pointer.rs | 48 ----- .../unsafe/p1.4-data-member-with-object.rs | 39 ---- ...p1.5-data-member-with-reference-wrapper.rs | 45 ----- .../unsafe/p1.6-data-member-with-pointer.rs | 45 ----- 21 files changed, 1362 deletions(-) delete mode 100644 tests/std/basic/basic.def.odr/out/refcount/p3.5-pointer-to-member.rs delete mode 100644 tests/std/basic/basic.def.odr/out/refcount/p4.1-pure-virtual-qualified-call.rs delete mode 100644 tests/std/basic/basic.def.odr/out/refcount/p5.3-discarded-value-in-lambda.rs delete mode 100644 tests/std/basic/basic.def.odr/out/refcount/p6-evaluated-binding-is-captured.rs delete mode 100644 tests/std/basic/basic.def.odr/out/unsafe/p4.1-pure-virtual-qualified-call.rs delete mode 100644 tests/std/basic/basic.def.odr/out/unsafe/p5.3-discarded-value-in-lambda.rs delete mode 100644 tests/std/basic/basic.def.odr/out/unsafe/p6-evaluated-binding-is-captured.rs delete mode 100644 tests/std/basic/basic.def.odr/p14.5.1-inline-function-reads-per-file-constant/out/unsafe/p14.5.1-inline-function-reads-per-file-constant.rs delete mode 100644 tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p2-object-of-derived-class.rs delete mode 100644 tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p3-arrow-star-pointer-to-derived-class.rs delete mode 100644 tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p2-object-of-derived-class.rs delete mode 100644 tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p3-arrow-star-pointer-to-derived-class.rs delete mode 100644 tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p4-object-type-not-similar.rs delete mode 100644 tests/std/expr/expr.compound/expr.unary/expr.unary.op/out/refcount/p3.1-member-named-through-derived-class.rs delete mode 100644 tests/std/expr/expr.compound/expr.unary/expr.unary.op/out/unsafe/p3.1-member-named-through-derived-class.rs delete mode 100644 tests/std/utilities/function.objects/func.require/out/refcount/p1.4-data-member-with-object.rs delete mode 100644 tests/std/utilities/function.objects/func.require/out/refcount/p1.5-data-member-with-reference-wrapper.rs delete mode 100644 tests/std/utilities/function.objects/func.require/out/refcount/p1.6-data-member-with-pointer.rs delete mode 100644 tests/std/utilities/function.objects/func.require/out/unsafe/p1.4-data-member-with-object.rs delete mode 100644 tests/std/utilities/function.objects/func.require/out/unsafe/p1.5-data-member-with-reference-wrapper.rs delete mode 100644 tests/std/utilities/function.objects/func.require/out/unsafe/p1.6-data-member-with-pointer.rs diff --git a/tests/std/basic/basic.def.odr/out/refcount/p3.5-pointer-to-member.rs b/tests/std/basic/basic.def.odr/out/refcount/p3.5-pointer-to-member.rs deleted file mode 100644 index b156bd0113..0000000000 --- a/tests/std/basic/basic.def.odr/out/refcount/p3.5-pointer-to-member.rs +++ /dev/null @@ -1,69 +0,0 @@ -extern crate libcc2rs; -use libcc2rs::*; -use std::cell::RefCell; -use std::collections::BTreeMap; -use std::io::prelude::*; -use std::io::{Read, Seek, Write}; -use std::os::fd::AsFd; -use std::rc::{Rc, Weak}; -thread_local!( - pub static copyCount_0: Value = Rc::new(RefCell::new(0)); -); -#[derive(Record, ByteRepr, VaArg, FnPtrArg, CppFrom, CopyAssign, Default)] -#[cpp_from(i32, new, value)] -#[byte_size(4)] -pub struct HasConstexprCtor { - #[offset(0)] - pub m: i32, -} -impl HasConstexprCtor { - pub fn new(mut v: i32) -> Self { - Self { m: v } - } - pub fn copy_from(o: Ptr) -> Self { - let __this: HasConstexprCtor = Self { - m: o.with(|__s| __s.m), - }; - (*copyCount_0.with(Value::clone).borrow_mut()).prefix_inc(); - __this - } -} -impl Clone for HasConstexprCtor { - fn clone(&self) -> Self { - let __src: Value = - Rc::new(RefCell::new(HasConstexprCtor { m: self.m.clone() })); - HasConstexprCtor::copy_from(__src.as_pointer()) - } -} -pub fn main() { - __cpp2rust_init_globals(); - std::process::exit(main_0()); -} -fn main_0() -> i32 { - let k: Value = Rc::new(RefCell::new(HasConstexprCtor::new({ 5 }))); - let mut pm: MemberPtr = member_ptr!(HasConstexprCtor, m); - let f: Value i32>> = - Rc::new(RefCell::new(FnPtr:: i32>::new(|| -> i32 { - { - return ((HasConstexprCtor::new({ 5 })) - .member(member_ptr!(HasConstexprCtor, m)) - .read()); - } - }))); - assert!((copyCount_0.with(|rc| *rc.borrow()) == 0)); - assert!(({ (({ (*f.borrow()).call() }) == 5) })); - assert!((copyCount_0.with(|rc| *rc.borrow()) == 0)); - return 0; -} -pub trait HasConstexprCtorImpl { - fn copy_assign(&self, _a0: Ptr) -> Ptr; -} -impl HasConstexprCtorImpl for Ptr { - fn copy_assign(&self, _a0: Ptr) -> Ptr { - field!((*self), m).write({ _a0.with(|__s| __s.m) }); - return (*self).clone(); - } -} -pub fn __cpp2rust_init_globals() { - let _ = copyCount_0.with(|_| ()); -} diff --git a/tests/std/basic/basic.def.odr/out/refcount/p4.1-pure-virtual-qualified-call.rs b/tests/std/basic/basic.def.odr/out/refcount/p4.1-pure-virtual-qualified-call.rs deleted file mode 100644 index 75c8783930..0000000000 --- a/tests/std/basic/basic.def.odr/out/refcount/p4.1-pure-virtual-qualified-call.rs +++ /dev/null @@ -1,48 +0,0 @@ -extern crate libcc2rs; -use libcc2rs::*; -use std::cell::RefCell; -use std::collections::BTreeMap; -use std::io::prelude::*; -use std::io::{Read, Seek, Write}; -use std::os::fd::AsFd; -use std::rc::{Rc, Weak}; -thread_local!( - pub static base_calls_0: Value = Rc::new(RefCell::new(0_i32)); -); -thread_local!( - pub static derived_calls_1: Value = Rc::new(RefCell::new(0_i32)); -); -pub trait HasPureVirtual { - fn f(&mut self); -} -impl HasPureVirtual { - fn f(&mut self); -} -#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] -#[byte_size(8)] -pub struct OverridesPureVirtual {} -pub fn main() { - __cpp2rust_init_globals(); - std::process::exit(main_0()); -} -fn main_0() -> i32 { - let d: Value = Rc::new(RefCell::new(::default())); - let mut p: PtrDyn = (d.as_pointer()).to_dyn::(|w| w); - ({ (*p.upgrade().deref_mut()).f() }); - assert!((derived_calls_1.with(|rc| *rc.borrow()) == 1)); - assert!((base_calls_0.with(|rc| *rc.borrow()) == 1)); - ({ ((*d.borrow_mut()) as HasPureVirtual).f() }); - assert!((derived_calls_1.with(|rc| *rc.borrow()) == 1)); - assert!((base_calls_0.with(|rc| *rc.borrow()) == 2)); - return 0; -} -impl HasPureVirtual for OverridesPureVirtual { - fn f(&mut self) { - (*derived_calls_1.with(Value::clone).borrow_mut()).prefix_inc(); - ({ self.f() }); - } -} -pub fn __cpp2rust_init_globals() { - let _ = base_calls_0.with(|_| ()); - let _ = derived_calls_1.with(|_| ()); -} diff --git a/tests/std/basic/basic.def.odr/out/refcount/p5.3-discarded-value-in-lambda.rs b/tests/std/basic/basic.def.odr/out/refcount/p5.3-discarded-value-in-lambda.rs deleted file mode 100644 index 8f6aa1e0df..0000000000 --- a/tests/std/basic/basic.def.odr/out/refcount/p5.3-discarded-value-in-lambda.rs +++ /dev/null @@ -1,150 +0,0 @@ -extern crate libcc2rs; -use libcc2rs::*; -use std::cell::RefCell; -use std::collections::BTreeMap; -use std::io::prelude::*; -use std::io::{Read, Seek, Write}; -use std::os::fd::AsFd; -use std::rc::{Rc, Weak}; -thread_local!( - pub static ctorCount_0: Value = Rc::new(RefCell::new(0)); -); -thread_local!( - pub static copyCount_1: Value = Rc::new(RefCell::new(0)); -); -thread_local!( - pub static dtorCount_2: Value = Rc::new(RefCell::new(0)); -); -thread_local!( - pub static useCount_3: Value = Rc::new(RefCell::new(0)); -); -#[derive(Record, ByteRepr, VaArg, FnPtrArg, CopyAssign, Destructor)] -#[byte_size(4)] -pub struct LifetimeTracked { - #[offset(0)] - pub uses: i32, -} -impl LifetimeTracked { - pub fn new() -> Self { - let __this: LifetimeTracked = Self { uses: 0 }; - (*ctorCount_0.with(Value::clone).borrow_mut()).prefix_inc(); - __this - } - pub fn copy_from(_a0: Ptr) -> Self { - let __this: LifetimeTracked = Self { uses: 0 }; - (*copyCount_1.with(Value::clone).borrow_mut()).prefix_inc(); - __this - } -} -impl Clone for LifetimeTracked { - fn clone(&self) -> Self { - let __src: Value = Rc::new(RefCell::new(LifetimeTracked { - uses: self.uses.clone(), - })); - LifetimeTracked::copy_from(__src.as_pointer()) - } -} -impl Default for LifetimeTracked { - fn default() -> Self { - { LifetimeTracked::new() } - } -} -thread_local!( - pub static copyCount_4: Value = Rc::new(RefCell::new(0)); -); -#[derive(Record, ByteRepr, VaArg, FnPtrArg, CppFrom, CopyAssign, Default)] -#[cpp_from(i32, new, value)] -#[byte_size(4)] -pub struct HasConstexprCtor { - #[offset(0)] - pub m: i32, -} -impl HasConstexprCtor { - pub fn new(mut v: i32) -> Self { - Self { m: v } - } - pub fn copy_from(o: Ptr) -> Self { - let __this: HasConstexprCtor = Self { - m: o.with(|__s| __s.m), - }; - (*copyCount_4.with(Value::clone).borrow_mut()).prefix_inc(); - __this - } -} -impl Clone for HasConstexprCtor { - fn clone(&self) -> Self { - let __src: Value = - Rc::new(RefCell::new(HasConstexprCtor { m: self.m.clone() })); - HasConstexprCtor::copy_from(__src.as_pointer()) - } -} -#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Destructor, Default)] -#[byte_size(4)] -pub struct AssertsDtorCountAtExit { - #[offset(0)] - pub expected: i32, -} -pub fn main() { - __cpp2rust_init_globals(); - std::process::exit(main_0()); -} -fn main_0() -> i32 { - let t: Value = Rc::new(RefCell::new(LifetimeTracked::new())); - let _dtor_t = std::mem::DropGuard::new(t.clone(), |__p| __p.as_pointer().destructor()); - let f: Value> = Rc::new(RefCell::new(lambda!( - { - let t: Value = - Rc::new(RefCell::new(LifetimeTracked::copy_from({ t.as_pointer() }))); - }, - || {} - ))); - let _dtor_f = - std::mem::DropGuard::new(f.clone(), |__p| __p.as_pointer().with(|__f| __f.destroy())); - assert!((copyCount_1.with(|rc| *rc.borrow()) == 0)); - ({ (*f.borrow()).call() }); - assert!((copyCount_1.with(|rc| *rc.borrow()) == 0)); - assert!((ctorCount_0.with(|rc| *rc.borrow()) == 1)); - return 0; -} -pub trait AssertsDtorCountAtExitImpl { - fn destructor(&self); -} -impl AssertsDtorCountAtExitImpl for Ptr { - fn destructor(&self) { - assert!((dtorCount_2.with(|rc| *rc.borrow()) == (*self).with(|__s| __s.expected))); - } -} -pub trait HasConstexprCtorImpl { - fn copy_assign(&self, _a0: Ptr) -> Ptr; -} -impl HasConstexprCtorImpl for Ptr { - fn copy_assign(&self, _a0: Ptr) -> Ptr { - field!((*self), m).write({ _a0.with(|__s| __s.m) }); - return (*self).clone(); - } -} -pub trait LifetimeTrackedImpl { - fn destructor(&self); - fn use_(&self); - fn copy_assign(&self, _a0: Ptr) -> Ptr; -} -impl LifetimeTrackedImpl for Ptr { - fn destructor(&self) { - (*dtorCount_2.with(Value::clone).borrow_mut()).prefix_inc(); - } - fn use_(&self) { - field!((*self), uses).with_mut(|__v| __v.prefix_inc()); - (*useCount_3.with(Value::clone).borrow_mut()).prefix_inc(); - } - fn copy_assign(&self, _a0: Ptr) -> Ptr { - field!((*self), uses).write({ _a0.with(|__s| __s.uses) }); - return (*self).clone(); - } -} -pub fn __cpp2rust_init_globals() { - let _ = ctorCount_0.with(|_| ()); - let _ = copyCount_1.with(|_| ()); - let _ = dtorCount_2.with(|_| ()); - let _ = useCount_3.with(|_| ()); - let _ = copyCount_4.with(|_| ()); -} diff --git a/tests/std/basic/basic.def.odr/out/refcount/p6-evaluated-binding-is-captured.rs b/tests/std/basic/basic.def.odr/out/refcount/p6-evaluated-binding-is-captured.rs deleted file mode 100644 index 5bb4361fc1..0000000000 --- a/tests/std/basic/basic.def.odr/out/refcount/p6-evaluated-binding-is-captured.rs +++ /dev/null @@ -1,191 +0,0 @@ -extern crate libcc2rs; -use libcc2rs::*; -use std::cell::RefCell; -use std::collections::BTreeMap; -use std::io::prelude::*; -use std::io::{Read, Seek, Write}; -use std::os::fd::AsFd; -use std::rc::{Rc, Weak}; -thread_local!( - pub static ctorCount_0: Value = Rc::new(RefCell::new(0)); -); -thread_local!( - pub static copyCount_1: Value = Rc::new(RefCell::new(0)); -); -thread_local!( - pub static dtorCount_2: Value = Rc::new(RefCell::new(0)); -); -thread_local!( - pub static useCount_3: Value = Rc::new(RefCell::new(0)); -); -#[derive(Record, ByteRepr, VaArg, FnPtrArg, CopyAssign, Destructor)] -#[byte_size(4)] -pub struct LifetimeTracked { - #[offset(0)] - pub uses: i32, -} -impl LifetimeTracked { - pub fn new() -> Self { - let __this: LifetimeTracked = Self { uses: 0 }; - (*ctorCount_0.with(Value::clone).borrow_mut()).prefix_inc(); - __this - } - pub fn copy_from(_a0: Ptr) -> Self { - let __this: LifetimeTracked = Self { uses: 0 }; - (*copyCount_1.with(Value::clone).borrow_mut()).prefix_inc(); - __this - } -} -impl Clone for LifetimeTracked { - fn clone(&self) -> Self { - let __src: Value = Rc::new(RefCell::new(LifetimeTracked { - uses: self.uses.clone(), - })); - LifetimeTracked::copy_from(__src.as_pointer()) - } -} -impl Default for LifetimeTracked { - fn default() -> Self { - { LifetimeTracked::new() } - } -} -thread_local!( - pub static copyCount_4: Value = Rc::new(RefCell::new(0)); -); -#[derive(Record, ByteRepr, VaArg, FnPtrArg, CppFrom, CopyAssign, Default)] -#[cpp_from(i32, new, value)] -#[byte_size(4)] -pub struct HasConstexprCtor { - #[offset(0)] - pub m: i32, -} -impl HasConstexprCtor { - pub fn new(mut v: i32) -> Self { - Self { m: v } - } - pub fn copy_from(o: Ptr) -> Self { - let __this: HasConstexprCtor = Self { - m: o.with(|__s| __s.m), - }; - (*copyCount_4.with(Value::clone).borrow_mut()).prefix_inc(); - __this - } -} -impl Clone for HasConstexprCtor { - fn clone(&self) -> Self { - let __src: Value = - Rc::new(RefCell::new(HasConstexprCtor { m: self.m.clone() })); - HasConstexprCtor::copy_from(__src.as_pointer()) - } -} -#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Destructor, Default)] -#[byte_size(4)] -pub struct AssertsDtorCountAtExit { - #[offset(0)] - pub expected: i32, -} -#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, CopyAssign, Destructor, Default)] -#[byte_size(8)] -pub struct HasTwoMembers { - #[offset(0)] - #[byte_size(4)] - pub a: LifetimeTracked, - #[offset(4)] - #[byte_size(4)] - pub b: LifetimeTracked, -} -pub fn main() { - __cpp2rust_init_globals(); - std::process::exit(main_0()); -} -fn main_0() -> i32 { - let p: Value = Rc::new(RefCell::new(HasTwoMembers { - a: LifetimeTracked::new(), - b: LifetimeTracked::new(), - })); - let _dtor_p = std::mem::DropGuard::new(p.clone(), |__p| __p.as_pointer().destructor()); - assert!((ctorCount_0.with(|rc| *rc.borrow()) == 2)); - let __decomp_5: Ptr = p.as_pointer(); - assert!((copyCount_1.with(|rc| *rc.borrow()) == 0)); - let f: Value> = Rc::new(RefCell::new(lambda!( - { - let a: Value = Rc::new(RefCell::new(LifetimeTracked::copy_from({ - field_ptr!(__decomp_5, a) - }))); - }, - || { - ({ LifetimeTrackedImpl::use_(&field_ptr!(__decomp_5, a)) }); - } - ))); - let _dtor_f = - std::mem::DropGuard::new(f.clone(), |__p| __p.as_pointer().with(|__f| __f.destroy())); - assert!((copyCount_1.with(|rc| *rc.borrow()) == 1)); - ({ (*f.borrow()).call() }); - assert!((copyCount_1.with(|rc| *rc.borrow()) == 1)); - assert!((useCount_3.with(|rc| *rc.borrow()) == 1)); - assert!(({ ({ (*p.borrow()).a.uses } == 0) })); - return 0; -} -pub trait AssertsDtorCountAtExitImpl { - fn destructor(&self); -} -impl AssertsDtorCountAtExitImpl for Ptr { - fn destructor(&self) { - assert!((dtorCount_2.with(|rc| *rc.borrow()) == (*self).with(|__s| __s.expected))); - } -} -pub trait HasConstexprCtorImpl { - fn copy_assign(&self, _a0: Ptr) -> Ptr; -} -impl HasConstexprCtorImpl for Ptr { - fn copy_assign(&self, _a0: Ptr) -> Ptr { - field!((*self), m).write({ _a0.with(|__s| __s.m) }); - return (*self).clone(); - } -} -pub trait HasTwoMembersImpl { - fn copy_assign(&self, _a0: Ptr) -> Ptr; - fn destructor(&self); -} -impl HasTwoMembersImpl for Ptr { - fn copy_assign(&self, _a0: Ptr) -> Ptr { - ({ - let _arg0: Ptr = field_ptr!(_a0, a); - LifetimeTrackedImpl::copy_assign(&field_ptr!((*self), a), _arg0) - }); - ({ - let _arg0: Ptr = field_ptr!(_a0, b); - LifetimeTrackedImpl::copy_assign(&field_ptr!((*self), b), _arg0) - }); - return (*self).clone(); - } - fn destructor(&self) { - field_ptr!(self, b).destructor(); - field_ptr!(self, a).destructor(); - } -} -pub trait LifetimeTrackedImpl { - fn destructor(&self); - fn use_(&self); - fn copy_assign(&self, _a0: Ptr) -> Ptr; -} -impl LifetimeTrackedImpl for Ptr { - fn destructor(&self) { - (*dtorCount_2.with(Value::clone).borrow_mut()).prefix_inc(); - } - fn use_(&self) { - field!((*self), uses).with_mut(|__v| __v.prefix_inc()); - (*useCount_3.with(Value::clone).borrow_mut()).prefix_inc(); - } - fn copy_assign(&self, _a0: Ptr) -> Ptr { - field!((*self), uses).write({ _a0.with(|__s| __s.uses) }); - return (*self).clone(); - } -} -pub fn __cpp2rust_init_globals() { - let _ = ctorCount_0.with(|_| ()); - let _ = copyCount_1.with(|_| ()); - let _ = dtorCount_2.with(|_| ()); - let _ = useCount_3.with(|_| ()); - let _ = copyCount_4.with(|_| ()); -} diff --git a/tests/std/basic/basic.def.odr/out/unsafe/p4.1-pure-virtual-qualified-call.rs b/tests/std/basic/basic.def.odr/out/unsafe/p4.1-pure-virtual-qualified-call.rs deleted file mode 100644 index a6989bf591..0000000000 --- a/tests/std/basic/basic.def.odr/out/unsafe/p4.1-pure-virtual-qualified-call.rs +++ /dev/null @@ -1,48 +0,0 @@ -extern crate libc; -use libc::*; -extern crate libcc2rs; -use libcc2rs::*; -use std::collections::BTreeMap; -use std::io::{Read, Seek, Write}; -use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; -use std::rc::Rc; -pub static mut base_calls_0: std::cell::LazyCell = - std::cell::LazyCell::new(|| unsafe { 0_i32 }); -pub static mut derived_calls_1: std::cell::LazyCell = - std::cell::LazyCell::new(|| unsafe { 0_i32 }); -pub unsafe trait HasPureVirtual { - unsafe fn f(&mut self); -} -impl HasPureVirtual { - unsafe fn f(&mut self); -} -#[repr(C)] -#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] -pub struct OverridesPureVirtual {} -pub fn main() { - unsafe { - __cpp2rust_init_globals(); - std::process::exit(main_0() as i32); - } -} -unsafe fn main_0() -> i32 { - let mut d: OverridesPureVirtual = ::default(); - let mut p: *mut dyn HasPureVirtual = (&mut d as *mut OverridesPureVirtual); - (unsafe { (*p).f() }); - assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut derived_calls_1)) == (1))); - assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut base_calls_0)) == (1))); - (unsafe { (d as HasPureVirtual).f() }); - assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut derived_calls_1)) == (1))); - assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut base_calls_0)) == (2))); - return 0; -} -unsafe impl HasPureVirtual for OverridesPureVirtual { - unsafe fn f(&mut self) { - (*std::cell::LazyCell::force_mut(&mut *&raw mut derived_calls_1)).prefix_inc(); - (unsafe { self.f() }); - } -} -pub unsafe fn __cpp2rust_init_globals() { - std::cell::LazyCell::force(&*&raw const base_calls_0); - std::cell::LazyCell::force(&*&raw const derived_calls_1); -} diff --git a/tests/std/basic/basic.def.odr/out/unsafe/p5.3-discarded-value-in-lambda.rs b/tests/std/basic/basic.def.odr/out/unsafe/p5.3-discarded-value-in-lambda.rs deleted file mode 100644 index 1c13438d11..0000000000 --- a/tests/std/basic/basic.def.odr/out/unsafe/p5.3-discarded-value-in-lambda.rs +++ /dev/null @@ -1,116 +0,0 @@ -extern crate libc; -use libc::*; -extern crate libcc2rs; -use libcc2rs::*; -use std::collections::BTreeMap; -use std::io::{Read, Seek, Write}; -use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; -use std::rc::Rc; -pub static mut ctorCount_0: std::cell::LazyCell = std::cell::LazyCell::new(|| unsafe { 0 }); -pub static mut copyCount_1: std::cell::LazyCell = std::cell::LazyCell::new(|| unsafe { 0 }); -pub static mut dtorCount_2: std::cell::LazyCell = std::cell::LazyCell::new(|| unsafe { 0 }); -pub static mut useCount_3: std::cell::LazyCell = std::cell::LazyCell::new(|| unsafe { 0 }); -#[repr(C)] -#[derive(VaArg, FnPtrArg, CopyAssignUnsafe, DestructorUnsafe)] -pub struct LifetimeTracked { - pub uses: i32, -} -impl LifetimeTracked { - pub unsafe fn new() -> Self { - let mut this = Self { uses: 0 }; - (*std::cell::LazyCell::force_mut(&mut *&raw mut ctorCount_0)).prefix_inc(); - this - } - pub unsafe fn copy_from(_a0: *const LifetimeTracked) -> Self { - let mut this = Self { uses: 0 }; - (*std::cell::LazyCell::force_mut(&mut *&raw mut copyCount_1)).prefix_inc(); - this - } - pub unsafe fn destructor(&mut self) { - (*std::cell::LazyCell::force_mut(&mut *&raw mut dtorCount_2)).prefix_inc(); - } - pub unsafe fn use_(&self) { - (*(&raw const self.uses).cast_mut()).prefix_inc(); - (*std::cell::LazyCell::force_mut(&mut *&raw mut useCount_3)).prefix_inc(); - } - pub unsafe fn copy_assign(&mut self, _a0: *const LifetimeTracked) -> *mut LifetimeTracked { - self.uses = (*_a0).uses; - return &mut (*(self as *mut LifetimeTracked)); - } -} -impl Clone for LifetimeTracked { - fn clone(&self) -> Self { - unsafe { LifetimeTracked::copy_from(self as *const LifetimeTracked) } - } -} -impl Default for LifetimeTracked { - fn default() -> Self { - unsafe { LifetimeTracked::new() } - } -} -pub static mut copyCount_4: std::cell::LazyCell = std::cell::LazyCell::new(|| unsafe { 0 }); -#[repr(C)] -#[derive(VaArg, FnPtrArg, CppFromUnsafe, CopyAssignUnsafe, Default)] -#[cpp_from(i32, new, value)] -pub struct HasConstexprCtor { - pub m: i32, -} -impl HasConstexprCtor { - pub unsafe fn new(mut v: i32) -> Self { - let mut this = Self { m: v }; - this - } - pub unsafe fn copy_from(o: *const HasConstexprCtor) -> Self { - let mut this = Self { m: (*o).m }; - (*std::cell::LazyCell::force_mut(&mut *&raw mut copyCount_4)).prefix_inc(); - this - } - pub unsafe fn copy_assign(&mut self, _a0: *const HasConstexprCtor) -> *mut HasConstexprCtor { - self.m = (*_a0).m; - return &mut (*(self as *mut HasConstexprCtor)); - } -} -impl Clone for HasConstexprCtor { - fn clone(&self) -> Self { - unsafe { HasConstexprCtor::copy_from(self as *const HasConstexprCtor) } - } -} -#[repr(C)] -#[derive(Clone, VaArg, FnPtrArg, DestructorUnsafe, Default)] -pub struct AssertsDtorCountAtExit { - pub expected: i32, -} -impl AssertsDtorCountAtExit { - pub unsafe fn destructor(&mut self) { - assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut dtorCount_2)) == (self.expected))); - } -} -pub fn main() { - unsafe { - __cpp2rust_init_globals(); - std::process::exit(main_0() as i32); - } -} -unsafe fn main_0() -> i32 { - let mut t: LifetimeTracked = LifetimeTracked::new(); - let _dtor_t = std::mem::DropGuard::new(&raw mut t, |__p| unsafe { (*__p).destructor() }); - let mut f: FnPtr = lambda_unsafe!( - { - let t: LifetimeTracked = LifetimeTracked::copy_from({ &t }); - }, - || {} - ); - let _dtor_f = std::mem::DropGuard::new(&raw mut f, |__p| unsafe { (*__p).destroy() }); - assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut copyCount_1)) == (0))); - (unsafe { f.call() }); - assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut copyCount_1)) == (0))); - assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut ctorCount_0)) == (1))); - return 0; -} -pub unsafe fn __cpp2rust_init_globals() { - std::cell::LazyCell::force(&*&raw const ctorCount_0); - std::cell::LazyCell::force(&*&raw const copyCount_1); - std::cell::LazyCell::force(&*&raw const dtorCount_2); - std::cell::LazyCell::force(&*&raw const useCount_3); - std::cell::LazyCell::force(&*&raw const copyCount_4); -} diff --git a/tests/std/basic/basic.def.odr/out/unsafe/p6-evaluated-binding-is-captured.rs b/tests/std/basic/basic.def.odr/out/unsafe/p6-evaluated-binding-is-captured.rs deleted file mode 100644 index 547b680d00..0000000000 --- a/tests/std/basic/basic.def.odr/out/unsafe/p6-evaluated-binding-is-captured.rs +++ /dev/null @@ -1,150 +0,0 @@ -extern crate libc; -use libc::*; -extern crate libcc2rs; -use libcc2rs::*; -use std::collections::BTreeMap; -use std::io::{Read, Seek, Write}; -use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; -use std::rc::Rc; -pub static mut ctorCount_0: std::cell::LazyCell = std::cell::LazyCell::new(|| unsafe { 0 }); -pub static mut copyCount_1: std::cell::LazyCell = std::cell::LazyCell::new(|| unsafe { 0 }); -pub static mut dtorCount_2: std::cell::LazyCell = std::cell::LazyCell::new(|| unsafe { 0 }); -pub static mut useCount_3: std::cell::LazyCell = std::cell::LazyCell::new(|| unsafe { 0 }); -#[repr(C)] -#[derive(VaArg, FnPtrArg, CopyAssignUnsafe, DestructorUnsafe)] -pub struct LifetimeTracked { - pub uses: i32, -} -impl LifetimeTracked { - pub unsafe fn new() -> Self { - let mut this = Self { uses: 0 }; - (*std::cell::LazyCell::force_mut(&mut *&raw mut ctorCount_0)).prefix_inc(); - this - } - pub unsafe fn copy_from(_a0: *const LifetimeTracked) -> Self { - let mut this = Self { uses: 0 }; - (*std::cell::LazyCell::force_mut(&mut *&raw mut copyCount_1)).prefix_inc(); - this - } - pub unsafe fn destructor(&mut self) { - (*std::cell::LazyCell::force_mut(&mut *&raw mut dtorCount_2)).prefix_inc(); - } - pub unsafe fn use_(&self) { - (*(&raw const self.uses).cast_mut()).prefix_inc(); - (*std::cell::LazyCell::force_mut(&mut *&raw mut useCount_3)).prefix_inc(); - } - pub unsafe fn copy_assign(&mut self, _a0: *const LifetimeTracked) -> *mut LifetimeTracked { - self.uses = (*_a0).uses; - return &mut (*(self as *mut LifetimeTracked)); - } -} -impl Clone for LifetimeTracked { - fn clone(&self) -> Self { - unsafe { LifetimeTracked::copy_from(self as *const LifetimeTracked) } - } -} -impl Default for LifetimeTracked { - fn default() -> Self { - unsafe { LifetimeTracked::new() } - } -} -pub static mut copyCount_4: std::cell::LazyCell = std::cell::LazyCell::new(|| unsafe { 0 }); -#[repr(C)] -#[derive(VaArg, FnPtrArg, CppFromUnsafe, CopyAssignUnsafe, Default)] -#[cpp_from(i32, new, value)] -pub struct HasConstexprCtor { - pub m: i32, -} -impl HasConstexprCtor { - pub unsafe fn new(mut v: i32) -> Self { - let mut this = Self { m: v }; - this - } - pub unsafe fn copy_from(o: *const HasConstexprCtor) -> Self { - let mut this = Self { m: (*o).m }; - (*std::cell::LazyCell::force_mut(&mut *&raw mut copyCount_4)).prefix_inc(); - this - } - pub unsafe fn copy_assign(&mut self, _a0: *const HasConstexprCtor) -> *mut HasConstexprCtor { - self.m = (*_a0).m; - return &mut (*(self as *mut HasConstexprCtor)); - } -} -impl Clone for HasConstexprCtor { - fn clone(&self) -> Self { - unsafe { HasConstexprCtor::copy_from(self as *const HasConstexprCtor) } - } -} -#[repr(C)] -#[derive(Clone, VaArg, FnPtrArg, DestructorUnsafe, Default)] -pub struct AssertsDtorCountAtExit { - pub expected: i32, -} -impl AssertsDtorCountAtExit { - pub unsafe fn destructor(&mut self) { - assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut dtorCount_2)) == (self.expected))); - } -} -#[repr(C)] -#[derive(Clone, VaArg, FnPtrArg, CopyAssignUnsafe, DestructorUnsafe, Default)] -pub struct HasTwoMembers { - pub a: LifetimeTracked, - pub b: LifetimeTracked, -} -impl HasTwoMembers { - pub unsafe fn copy_assign(&mut self, _a0: *const HasTwoMembers) -> *mut HasTwoMembers { - (unsafe { - let _arg0: *const LifetimeTracked = &(*_a0).a; - LifetimeTracked::copy_assign(&mut self.a, _arg0) - }); - (unsafe { - let _arg0: *const LifetimeTracked = &(*_a0).b; - LifetimeTracked::copy_assign(&mut self.b, _arg0) - }); - return &mut (*(self as *mut HasTwoMembers)); - } -} -impl HasTwoMembers { - pub unsafe fn destructor(&mut self) { - LifetimeTracked::destructor(&mut self.b); - LifetimeTracked::destructor(&mut self.a); - } -} -pub fn main() { - unsafe { - __cpp2rust_init_globals(); - std::process::exit(main_0() as i32); - } -} -unsafe fn main_0() -> i32 { - let mut p: HasTwoMembers = HasTwoMembers { - a: LifetimeTracked::new(), - b: LifetimeTracked::new(), - }; - let _dtor_p = std::mem::DropGuard::new(&raw mut p, |__p| unsafe { (*__p).destructor() }); - assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut ctorCount_0)) == (2))); - let __decomp_5: *mut HasTwoMembers = &mut p; - assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut copyCount_1)) == (0))); - let mut f: FnPtr = lambda_unsafe!( - { - let a: LifetimeTracked = LifetimeTracked::copy_from({ &(*__decomp_5).a }); - }, - || { - (unsafe { LifetimeTracked::use_(&(*__decomp_5).a) }); - } - ); - let _dtor_f = std::mem::DropGuard::new(&raw mut f, |__p| unsafe { (*__p).destroy() }); - assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut copyCount_1)) == (1))); - (unsafe { f.call() }); - assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut copyCount_1)) == (1))); - assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut useCount_3)) == (1))); - assert!(((p.a.uses) == (0))); - return 0; -} -pub unsafe fn __cpp2rust_init_globals() { - std::cell::LazyCell::force(&*&raw const ctorCount_0); - std::cell::LazyCell::force(&*&raw const copyCount_1); - std::cell::LazyCell::force(&*&raw const dtorCount_2); - std::cell::LazyCell::force(&*&raw const useCount_3); - std::cell::LazyCell::force(&*&raw const copyCount_4); -} diff --git a/tests/std/basic/basic.def.odr/p14.5.1-inline-function-reads-per-file-constant/out/unsafe/p14.5.1-inline-function-reads-per-file-constant.rs b/tests/std/basic/basic.def.odr/p14.5.1-inline-function-reads-per-file-constant/out/unsafe/p14.5.1-inline-function-reads-per-file-constant.rs deleted file mode 100644 index 044ff38d0b..0000000000 --- a/tests/std/basic/basic.def.odr/p14.5.1-inline-function-reads-per-file-constant/out/unsafe/p14.5.1-inline-function-reads-per-file-constant.rs +++ /dev/null @@ -1,40 +0,0 @@ -extern crate libc; -use libc::*; -extern crate libcc2rs; -use libcc2rs::*; -use std::collections::BTreeMap; -use std::io::{Read, Seek, Write}; -use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; -use std::rc::Rc; -pub static mut factor_0: std::cell::LazyCell = std::cell::LazyCell::new(|| unsafe { 3 }); -pub unsafe fn scaled_1(mut v: i32) -> i32 { - return ((v) * (*std::cell::LazyCell::force_mut(&mut *&raw mut factor_0))); -} -pub fn main() { - unsafe { - __cpp2rust_init_globals(); - std::process::exit(main_0() as i32); - } -} -unsafe fn main_0() -> i32 { - assert!( - ((&raw const (*std::cell::LazyCell::force_mut(&mut *&raw mut factor_0)) as *const i32) - != (unsafe { b_factor_address_2() })) - ); - assert!(((Some(scaled_1)) == (unsafe { b_scaled_address_3() }))); - assert!(((unsafe { scaled_1(2,) }) == (6))); - assert!(((unsafe { b_scaled_4(2,) }) == (6))); - return 0; -} -pub unsafe fn b_factor_address_2() -> *const i32 { - return (&raw const (*std::cell::LazyCell::force_mut(&mut *&raw mut factor_0)) as *const i32); -} -pub unsafe fn b_scaled_address_3() -> Option i32> { - return (Some(scaled_1)); -} -pub unsafe fn b_scaled_4(mut v: i32) -> i32 { - return (unsafe { scaled_1(v) }); -} -pub unsafe fn __cpp2rust_init_globals() { - std::cell::LazyCell::force(&*&raw const factor_0); -} diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p2-object-of-derived-class.rs b/tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p2-object-of-derived-class.rs deleted file mode 100644 index 72643b6338..0000000000 --- a/tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p2-object-of-derived-class.rs +++ /dev/null @@ -1,44 +0,0 @@ -extern crate libcc2rs; -use libcc2rs::*; -use std::cell::RefCell; -use std::collections::BTreeMap; -use std::io::prelude::*; -use std::io::{Read, Seek, Write}; -use std::os::fd::AsFd; -use std::rc::{Rc, Weak}; -#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] -#[byte_size(4)] -pub struct Precedes { - #[offset(0)] - pub preceding: i32, -} -#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] -#[byte_size(4)] -pub struct DeclaresValue { - #[offset(0)] - pub value: i32, -} -#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] -#[byte_size(12)] -pub struct InheritsValue { - #[offset(8)] - pub own: i32, -} -pub fn main() { - __cpp2rust_init_globals(); - std::process::exit(main_0()); -} -fn main_0() -> i32 { - let mut pm: MemberPtr = member_ptr!(DeclaresValue, value); - let obj: Value = Rc::new(RefCell::new(::default())); - ((*obj.borrow_mut()) as Precedes).preceding = 1; - ((*obj.borrow_mut()) as DeclaresValue).value = 2; - (*obj.borrow_mut()).own = 3; - assert!((((obj.as_pointer()).member(pm).read()) == 2)); - (obj.as_pointer()).member(pm).write(4); - assert!(({ ({ ((*obj.borrow()) as DeclaresValue).value } == 4) })); - assert!(({ ({ ((*obj.borrow()) as Precedes).preceding } == 1) })); - assert!(({ ({ (*obj.borrow()).own } == 3) })); - return 0; -} -pub fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p3-arrow-star-pointer-to-derived-class.rs b/tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p3-arrow-star-pointer-to-derived-class.rs deleted file mode 100644 index 142ec20c97..0000000000 --- a/tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p3-arrow-star-pointer-to-derived-class.rs +++ /dev/null @@ -1,45 +0,0 @@ -extern crate libcc2rs; -use libcc2rs::*; -use std::cell::RefCell; -use std::collections::BTreeMap; -use std::io::prelude::*; -use std::io::{Read, Seek, Write}; -use std::os::fd::AsFd; -use std::rc::{Rc, Weak}; -#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] -#[byte_size(4)] -pub struct Precedes { - #[offset(0)] - pub preceding: i32, -} -#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] -#[byte_size(4)] -pub struct DeclaresValue { - #[offset(0)] - pub value: i32, -} -#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] -#[byte_size(12)] -pub struct InheritsValue { - #[offset(8)] - pub own: i32, -} -pub fn main() { - __cpp2rust_init_globals(); - std::process::exit(main_0()); -} -fn main_0() -> i32 { - let mut pm: MemberPtr = member_ptr!(DeclaresValue, value); - let obj: Value = Rc::new(RefCell::new(::default())); - ((*obj.borrow_mut()) as Precedes).preceding = 1; - ((*obj.borrow_mut()) as DeclaresValue).value = 2; - (*obj.borrow_mut()).own = 3; - let mut p: Ptr = (obj.as_pointer()); - assert!((((p).member(pm).read()) == 2)); - (p).member(pm).write(4); - assert!(({ ({ ((*obj.borrow()) as DeclaresValue).value } == 4) })); - assert!(({ ({ ((*obj.borrow()) as Precedes).preceding } == 1) })); - assert!(({ ({ (*obj.borrow()).own } == 3) })); - return 0; -} -pub fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p2-object-of-derived-class.rs b/tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p2-object-of-derived-class.rs deleted file mode 100644 index feb9de323c..0000000000 --- a/tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p2-object-of-derived-class.rs +++ /dev/null @@ -1,44 +0,0 @@ -extern crate libc; -use libc::*; -extern crate libcc2rs; -use libcc2rs::*; -use std::collections::BTreeMap; -use std::io::{Read, Seek, Write}; -use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; -use std::rc::Rc; -#[repr(C)] -#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] -pub struct Precedes { - pub preceding: i32, -} -#[repr(C)] -#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] -pub struct DeclaresValue { - pub value: i32, -} -#[repr(C)] -#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] -pub struct InheritsValue { - pub own: i32, -} -pub fn main() { - unsafe { - __cpp2rust_init_globals(); - std::process::exit(main_0() as i32); - } -} -unsafe fn main_0() -> i32 { - let mut pm: MemberPtr = - >::from_offset(::std::mem::offset_of!(DeclaresValue, value)); - let mut obj: InheritsValue = ::default(); - (obj as Precedes).preceding = 1; - (obj as DeclaresValue).value = 2; - obj.own = 3; - assert!(((*(&mut obj as *mut DeclaresValue).member(pm)) == (2))); - (*(&mut obj as *mut DeclaresValue).member(pm)) = 4; - assert!((((obj as DeclaresValue).value) == (4))); - assert!((((obj as Precedes).preceding) == (1))); - assert!(((obj.own) == (3))); - return 0; -} -pub unsafe fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p3-arrow-star-pointer-to-derived-class.rs b/tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p3-arrow-star-pointer-to-derived-class.rs deleted file mode 100644 index a9ed48054a..0000000000 --- a/tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p3-arrow-star-pointer-to-derived-class.rs +++ /dev/null @@ -1,45 +0,0 @@ -extern crate libc; -use libc::*; -extern crate libcc2rs; -use libcc2rs::*; -use std::collections::BTreeMap; -use std::io::{Read, Seek, Write}; -use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; -use std::rc::Rc; -#[repr(C)] -#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] -pub struct Precedes { - pub preceding: i32, -} -#[repr(C)] -#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] -pub struct DeclaresValue { - pub value: i32, -} -#[repr(C)] -#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] -pub struct InheritsValue { - pub own: i32, -} -pub fn main() { - unsafe { - __cpp2rust_init_globals(); - std::process::exit(main_0() as i32); - } -} -unsafe fn main_0() -> i32 { - let mut pm: MemberPtr = - >::from_offset(::std::mem::offset_of!(DeclaresValue, value)); - let mut obj: InheritsValue = ::default(); - (obj as Precedes).preceding = 1; - (obj as DeclaresValue).value = 2; - obj.own = 3; - let mut p: *mut InheritsValue = (&mut obj as *mut InheritsValue); - assert!(((*(p).member(pm)) == (2))); - (*(p).member(pm)) = 4; - assert!((((obj as DeclaresValue).value) == (4))); - assert!((((obj as Precedes).preceding) == (1))); - assert!(((obj.own) == (3))); - return 0; -} -pub unsafe fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p4-object-type-not-similar.rs b/tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p4-object-type-not-similar.rs deleted file mode 100644 index e4fec1b297..0000000000 --- a/tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p4-object-type-not-similar.rs +++ /dev/null @@ -1,36 +0,0 @@ -extern crate libc; -use libc::*; -extern crate libcc2rs; -use libcc2rs::*; -use std::collections::BTreeMap; -use std::io::{Read, Seek, Write}; -use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; -use std::rc::Rc; -#[repr(C)] -#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] -pub struct HasTwoInts { - pub first: i32, - pub second: i32, -} -#[repr(C)] -#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] -pub struct HasTwoShorts { - pub first: i16, - pub second: i16, -} -pub fn main() { - unsafe { - __cpp2rust_init_globals(); - std::process::exit(main_0() as i32); - } -} -unsafe fn main_0() -> i32 { - let mut pm: MemberPtrUnsafe = - >::from_offset(::std::mem::offset_of!(HasTwoInts, second)); - let mut obj: HasTwoShorts = HasTwoShorts { - first: 3_i16, - second: 4_i16, - }; - return (*(&mut obj as *mut HasTwoInts).member(pm)); -} -pub unsafe fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/expr.compound/expr.unary/expr.unary.op/out/refcount/p3.1-member-named-through-derived-class.rs b/tests/std/expr/expr.compound/expr.unary/expr.unary.op/out/refcount/p3.1-member-named-through-derived-class.rs deleted file mode 100644 index 0f9324a7df..0000000000 --- a/tests/std/expr/expr.compound/expr.unary/expr.unary.op/out/refcount/p3.1-member-named-through-derived-class.rs +++ /dev/null @@ -1,35 +0,0 @@ -extern crate libcc2rs; -use libcc2rs::*; -use std::cell::RefCell; -use std::collections::BTreeMap; -use std::io::prelude::*; -use std::io::{Read, Seek, Write}; -use std::os::fd::AsFd; -use std::rc::{Rc, Weak}; -#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] -#[byte_size(4)] -pub struct DeclaresValue { - #[offset(0)] - pub value: i32, -} -#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] -#[byte_size(8)] -pub struct InheritsValue { - #[offset(4)] - pub own: i32, -} -pub fn main() { - __cpp2rust_init_globals(); - std::process::exit(main_0()); -} -fn main_0() -> i32 { - let mut pm: MemberPtr = member_ptr!(DeclaresValue, value); - let base: Value = Rc::new(RefCell::new(DeclaresValue { value: 3 })); - assert!((((base.as_pointer()).member(pm).read()) == 3)); - let derived: Value = Rc::new(RefCell::new(InheritsValue { - own: DeclaresValue { value: 4 }, - })); - assert!((((derived.as_pointer()).member(pm).read()) == 4)); - return 0; -} -pub fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/expr.compound/expr.unary/expr.unary.op/out/unsafe/p3.1-member-named-through-derived-class.rs b/tests/std/expr/expr.compound/expr.unary/expr.unary.op/out/unsafe/p3.1-member-named-through-derived-class.rs deleted file mode 100644 index f98656d82d..0000000000 --- a/tests/std/expr/expr.compound/expr.unary/expr.unary.op/out/unsafe/p3.1-member-named-through-derived-class.rs +++ /dev/null @@ -1,36 +0,0 @@ -extern crate libc; -use libc::*; -extern crate libcc2rs; -use libcc2rs::*; -use std::collections::BTreeMap; -use std::io::{Read, Seek, Write}; -use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; -use std::rc::Rc; -#[repr(C)] -#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] -pub struct DeclaresValue { - pub value: i32, -} -#[repr(C)] -#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] -pub struct InheritsValue { - pub own: i32, -} -pub fn main() { - unsafe { - __cpp2rust_init_globals(); - std::process::exit(main_0() as i32); - } -} -unsafe fn main_0() -> i32 { - let mut pm: MemberPtr = - >::from_offset(::std::mem::offset_of!(DeclaresValue, value)); - let mut base: DeclaresValue = DeclaresValue { value: 3 }; - assert!(((*(&mut base as *mut DeclaresValue).member(pm)) == (3))); - let mut derived: InheritsValue = InheritsValue { - own: DeclaresValue { value: 4 }, - }; - assert!(((*(&mut derived as *mut DeclaresValue).member(pm)) == (4))); - return 0; -} -pub unsafe fn __cpp2rust_init_globals() {} diff --git a/tests/std/utilities/function.objects/func.require/out/refcount/p1.4-data-member-with-object.rs b/tests/std/utilities/function.objects/func.require/out/refcount/p1.4-data-member-with-object.rs deleted file mode 100644 index 707998585a..0000000000 --- a/tests/std/utilities/function.objects/func.require/out/refcount/p1.4-data-member-with-object.rs +++ /dev/null @@ -1,39 +0,0 @@ -extern crate libcc2rs; -use libcc2rs::*; -use std::cell::RefCell; -use std::collections::BTreeMap; -use std::io::prelude::*; -use std::io::{Read, Seek, Write}; -use std::os::fd::AsFd; -use std::rc::{Rc, Weak}; -#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] -#[byte_size(8)] -pub struct HasTwoInts { - #[offset(0)] - pub first: i32, - #[offset(4)] - pub second: i32, -} -#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] -#[byte_size(8)] -pub struct InheritsTwoInts {} -pub fn main() { - __cpp2rust_init_globals(); - std::process::exit(main_0()); -} -fn main_0() -> i32 { - let pm: Value> = - Rc::new(RefCell::new(member_ptr!(HasTwoInts, second))); - let obj: Value = Rc::new(RefCell::new(HasTwoInts { - first: 3, - second: 4, - })); - assert!(((({ invoke_0(pm.as_pointer(), obj.as_pointer(),) }).read()) == 4)); - ({ invoke_0(pm.as_pointer(), obj.as_pointer()) }).write(5); - assert!(({ ({ (*obj.borrow()).second } == 5) })); - assert!(({ ({ (*obj.borrow()).first } == 3) })); - let derived: Value = Rc::new(RefCell::new(InheritsTwoInts {})); - assert!(((({ invoke_1(pm.as_pointer(), derived.as_pointer(),) }).read()) == 7)); - return 0; -} -pub fn __cpp2rust_init_globals() {} diff --git a/tests/std/utilities/function.objects/func.require/out/refcount/p1.5-data-member-with-reference-wrapper.rs b/tests/std/utilities/function.objects/func.require/out/refcount/p1.5-data-member-with-reference-wrapper.rs deleted file mode 100644 index 12497c37ba..0000000000 --- a/tests/std/utilities/function.objects/func.require/out/refcount/p1.5-data-member-with-reference-wrapper.rs +++ /dev/null @@ -1,49 +0,0 @@ -extern crate libcc2rs; -use libcc2rs::*; -use std::cell::RefCell; -use std::collections::BTreeMap; -use std::io::prelude::*; -use std::io::{Read, Seek, Write}; -use std::os::fd::AsFd; -use std::rc::{Rc, Weak}; -#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] -#[byte_size(8)] -pub struct HasTwoInts { - #[offset(0)] - pub first: i32, - #[offset(4)] - pub second: i32, -} -#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] -#[byte_size(8)] -pub struct InheritsTwoInts {} -pub fn main() { - __cpp2rust_init_globals(); - std::process::exit(main_0()); -} -fn main_0() -> i32 { - let pm: Value> = - Rc::new(RefCell::new(member_ptr!(HasTwoInts, second))); - let obj: Value = Rc::new(RefCell::new(HasTwoInts { - first: 3, - second: 4, - })); - assert!( - ((({ - let ___args: Value> = - Rc::new(RefCell::new(({ ref_0(obj.as_pointer()) }))); - invoke_1(pm.as_pointer(), ___args.as_pointer()) - }) - .read()) - == 4) - ); - ({ - let ___args: Value> = Rc::new(RefCell::new(({ ref_0(obj.as_pointer()) }))); - invoke_1(pm.as_pointer(), ___args.as_pointer()) - }) - .write(5); - assert!(({ ({ (*obj.borrow()).second } == 5) })); - assert!(({ ({ (*obj.borrow()).first } == 3) })); - return 0; -} -pub fn __cpp2rust_init_globals() {} diff --git a/tests/std/utilities/function.objects/func.require/out/refcount/p1.6-data-member-with-pointer.rs b/tests/std/utilities/function.objects/func.require/out/refcount/p1.6-data-member-with-pointer.rs deleted file mode 100644 index 96296b89ea..0000000000 --- a/tests/std/utilities/function.objects/func.require/out/refcount/p1.6-data-member-with-pointer.rs +++ /dev/null @@ -1,48 +0,0 @@ -extern crate libcc2rs; -use libcc2rs::*; -use std::cell::RefCell; -use std::collections::BTreeMap; -use std::io::prelude::*; -use std::io::{Read, Seek, Write}; -use std::os::fd::AsFd; -use std::rc::{Rc, Weak}; -#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] -#[byte_size(8)] -pub struct HasTwoInts { - #[offset(0)] - pub first: i32, - #[offset(4)] - pub second: i32, -} -#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] -#[byte_size(8)] -pub struct InheritsTwoInts {} -pub fn main() { - __cpp2rust_init_globals(); - std::process::exit(main_0()); -} -fn main_0() -> i32 { - let pm: Value> = - Rc::new(RefCell::new(member_ptr!(HasTwoInts, second))); - let obj: Value = Rc::new(RefCell::new(HasTwoInts { - first: 3, - second: 4, - })); - assert!( - ((({ - let ___args: Value> = Rc::new(RefCell::new((obj.as_pointer()))); - invoke_0(pm.as_pointer(), ___args.as_pointer()) - }) - .read()) - == 4) - ); - ({ - let ___args: Value> = Rc::new(RefCell::new((obj.as_pointer()))); - invoke_0(pm.as_pointer(), ___args.as_pointer()) - }) - .write(5); - assert!(({ ({ (*obj.borrow()).second } == 5) })); - assert!(({ ({ (*obj.borrow()).first } == 3) })); - return 0; -} -pub fn __cpp2rust_init_globals() {} diff --git a/tests/std/utilities/function.objects/func.require/out/unsafe/p1.4-data-member-with-object.rs b/tests/std/utilities/function.objects/func.require/out/unsafe/p1.4-data-member-with-object.rs deleted file mode 100644 index 8b20395fd8..0000000000 --- a/tests/std/utilities/function.objects/func.require/out/unsafe/p1.4-data-member-with-object.rs +++ /dev/null @@ -1,39 +0,0 @@ -extern crate libc; -use libc::*; -extern crate libcc2rs; -use libcc2rs::*; -use std::collections::BTreeMap; -use std::io::{Read, Seek, Write}; -use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; -use std::rc::Rc; -#[repr(C)] -#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] -pub struct HasTwoInts { - pub first: i32, - pub second: i32, -} -#[repr(C)] -#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] -pub struct InheritsTwoInts {} -pub fn main() { - unsafe { - __cpp2rust_init_globals(); - std::process::exit(main_0() as i32); - } -} -unsafe fn main_0() -> i32 { - let mut pm: MemberPtrUnsafe = - >::from_offset(::std::mem::offset_of!(HasTwoInts, second)); - let mut obj: HasTwoInts = HasTwoInts { - first: 3, - second: 4, - }; - assert!(((*(unsafe { invoke_0(&mut pm, &mut obj,) })) == (4))); - (*(unsafe { invoke_0(&mut pm, &mut obj) })) = 5; - assert!(((obj.second) == (5))); - assert!(((obj.first) == (3))); - let mut derived: InheritsTwoInts = InheritsTwoInts {}; - assert!(((*(unsafe { invoke_1(&mut pm, &mut derived,) })) == (7))); - return 0; -} -pub unsafe fn __cpp2rust_init_globals() {} diff --git a/tests/std/utilities/function.objects/func.require/out/unsafe/p1.5-data-member-with-reference-wrapper.rs b/tests/std/utilities/function.objects/func.require/out/unsafe/p1.5-data-member-with-reference-wrapper.rs deleted file mode 100644 index 09c9a36a8c..0000000000 --- a/tests/std/utilities/function.objects/func.require/out/unsafe/p1.5-data-member-with-reference-wrapper.rs +++ /dev/null @@ -1,45 +0,0 @@ -extern crate libc; -use libc::*; -extern crate libcc2rs; -use libcc2rs::*; -use std::collections::BTreeMap; -use std::io::{Read, Seek, Write}; -use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; -use std::rc::Rc; -#[repr(C)] -#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] -pub struct HasTwoInts { - pub first: i32, - pub second: i32, -} -#[repr(C)] -#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] -pub struct InheritsTwoInts {} -pub fn main() { - unsafe { - __cpp2rust_init_globals(); - std::process::exit(main_0() as i32); - } -} -unsafe fn main_0() -> i32 { - let mut pm: MemberPtrUnsafe = - >::from_offset(::std::mem::offset_of!(HasTwoInts, second)); - let mut obj: HasTwoInts = HasTwoInts { - first: 3, - second: 4, - }; - assert!( - ((*(unsafe { - let mut ___args: *mut HasTwoInts = (unsafe { ref_0(&mut obj) }); - invoke_1(&mut pm, &mut ___args) - })) == (4)) - ); - (*(unsafe { - let mut ___args: *mut HasTwoInts = (unsafe { ref_0(&mut obj) }); - invoke_1(&mut pm, &mut ___args) - })) = 5; - assert!(((obj.second) == (5))); - assert!(((obj.first) == (3))); - return 0; -} -pub unsafe fn __cpp2rust_init_globals() {} diff --git a/tests/std/utilities/function.objects/func.require/out/unsafe/p1.6-data-member-with-pointer.rs b/tests/std/utilities/function.objects/func.require/out/unsafe/p1.6-data-member-with-pointer.rs deleted file mode 100644 index 72401dec55..0000000000 --- a/tests/std/utilities/function.objects/func.require/out/unsafe/p1.6-data-member-with-pointer.rs +++ /dev/null @@ -1,45 +0,0 @@ -extern crate libc; -use libc::*; -extern crate libcc2rs; -use libcc2rs::*; -use std::collections::BTreeMap; -use std::io::{Read, Seek, Write}; -use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; -use std::rc::Rc; -#[repr(C)] -#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] -pub struct HasTwoInts { - pub first: i32, - pub second: i32, -} -#[repr(C)] -#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] -pub struct InheritsTwoInts {} -pub fn main() { - unsafe { - __cpp2rust_init_globals(); - std::process::exit(main_0() as i32); - } -} -unsafe fn main_0() -> i32 { - let mut pm: MemberPtrUnsafe = - >::from_offset(::std::mem::offset_of!(HasTwoInts, second)); - let mut obj: HasTwoInts = HasTwoInts { - first: 3, - second: 4, - }; - assert!( - ((*(unsafe { - let mut ___args: *mut HasTwoInts = (&mut obj as *mut HasTwoInts); - invoke_0(&mut pm, &mut ___args) - })) == (4)) - ); - (*(unsafe { - let mut ___args: *mut HasTwoInts = (&mut obj as *mut HasTwoInts); - invoke_0(&mut pm, &mut ___args) - })) = 5; - assert!(((obj.second) == (5))); - assert!(((obj.first) == (3))); - return 0; -} -pub unsafe fn __cpp2rust_init_globals() {} From 02bc92a1f5d313f8fa3bcc6d9915a0905ea5941a Mon Sep 17 00:00:00 2001 From: Lucian Popescu Date: Mon, 16 Nov 2026 19:53:51 +0000 Subject: [PATCH 13/15] Hide field offset behind a macro --- cpp2rust/converter/models/converter_refcount.cpp | 2 +- libcc2rs/src/field.rs | 7 +++++++ 2 files changed, 8 insertions(+), 1 deletion(-) diff --git a/cpp2rust/converter/models/converter_refcount.cpp b/cpp2rust/converter/models/converter_refcount.cpp index c69800e574..64a3f8ed38 100644 --- a/cpp2rust/converter/models/converter_refcount.cpp +++ b/cpp2rust/converter/models/converter_refcount.cpp @@ -2919,7 +2919,7 @@ void ConverterRefCount::ConvertAddrOf(clang::Expr *expr, std::string ConverterRefCount::GetFieldOffsetAsString(const clang::FieldDecl *field) { - return std::format("<{} as Record>::OFFSETS.{}", + return std::format("offset_of_field!({}, {})", GetRecordName(field->getParent()), GetNamedDeclAsString(field)); } diff --git a/libcc2rs/src/field.rs b/libcc2rs/src/field.rs index 1f5f2ff9fb..349f6a0ce7 100644 --- a/libcc2rs/src/field.rs +++ b/libcc2rs/src/field.rs @@ -742,6 +742,13 @@ macro_rules! size_of_field { }; } +#[macro_export] +macro_rules! offset_of_field { + ($ty:ty, $field:ident) => { + <$ty as $crate::Record>::OFFSETS.$field + }; +} + // The size of the type that `f` gives a reference to. pub const fn size_of_pointee(_f: fn(&S) -> &T) -> usize { std::mem::size_of::() From 8fc50a38c321c2ff71a536c701f5701f303e9709 Mon Sep 17 00:00:00 2001 From: Lucian Popescu Date: Mon, 16 Nov 2026 19:55:21 +0000 Subject: [PATCH 14/15] Update tests --- .../p2-pointer-to-data-member-bytes-round-trip.rs | 8 ++++---- ...pointer-to-data-member-bytes-copied-to-other-object.rs | 7 +++---- .../refcount/p6.1-zero-initialized-pointer-to-member.rs | 6 +++--- .../out/refcount/p6-array-of-pointers-to-data-members.rs | 8 ++++---- .../dcl.mptr/out/refcount/p2-pointer-to-array-member.rs | 2 +- .../dcl.mptr/out/refcount/p2-pointer-to-data-member.rs | 4 ++-- .../refcount/p2-pointer-to-member-of-incomplete-class.rs | 2 +- .../p2-pointer-to-member-of-pointer-to-member-type.rs | 6 +++--- .../out/refcount/p1-null-distinct-from-first-member.rs | 4 ++-- .../out/refcount/p7.4-pointer-to-member-and-null.rs | 4 ++-- .../expr.compound/expr.eq/out/refcount/p4.2-one-null.rs | 2 +- .../expr.eq/out/refcount/p4.6-data-members.rs | 6 +++--- .../expr.mptr.oper/out/refcount/p3-arrow-star.rs | 2 +- .../out/refcount/p4-object-expression-sequenced-first.rs | 2 +- .../out/refcount/p6-data-member-of-lvalue-is-lvalue.rs | 2 +- .../out/refcount/p6-data-member-of-rvalue-is-xvalue.rs | 2 +- .../out/refcount/p10-result-is-unspecified.rs | 4 ++-- .../out/refcount/p10.2-data-member-round-trip.rs | 4 ++-- .../out/refcount/p3.1-anonymous-union-member.rs | 2 +- 19 files changed, 38 insertions(+), 39 deletions(-) diff --git a/tests/std/basic/basic.types/basic.types.general/out/refcount/p2-pointer-to-data-member-bytes-round-trip.rs b/tests/std/basic/basic.types/basic.types.general/out/refcount/p2-pointer-to-data-member-bytes-round-trip.rs index ecaf43fe57..144425921b 100644 --- a/tests/std/basic/basic.types/basic.types.general/out/refcount/p2-pointer-to-data-member-bytes-round-trip.rs +++ b/tests/std/basic/basic.types/basic.types.general/out/refcount/p2-pointer-to-data-member-bytes-round-trip.rs @@ -20,7 +20,7 @@ pub fn main() { } fn main_0() -> i32 { let pm: Value = Rc::new(RefCell::new( - (::OFFSETS.second as isize), + (offset_of_field!(HasTwoInts, second) as isize), )); let bytes: Value> = Rc::new(RefCell::new((0..8).map(|_| 0_u8).collect::>())); @@ -30,14 +30,14 @@ fn main_0() -> i32 { (__tmp_0).clone() } }; - (*pm.borrow_mut()) = (::OFFSETS.first as isize); + (*pm.borrow_mut()) = (offset_of_field!(HasTwoInts, first) as isize); match ({ (pm.as_pointer()).to_any() },) { (mut __tmp_1,) => { __tmp_1.memcpy(&(bytes.decay()).to_any(), ::std::mem::size_of::()); (__tmp_1).clone() } }; - assert!(({ ((*pm.borrow()) == (::OFFSETS.second as isize)) })); + assert!(({ ((*pm.borrow()) == (offset_of_field!(HasTwoInts, second) as isize)) })); let obj: Value = Rc::new(RefCell::new(HasTwoInts { first: 3, second: 4, @@ -53,7 +53,7 @@ fn main_0() -> i32 { (__tmp_2).clone() } }; - (*null_pm.borrow_mut()) = (::OFFSETS.first as isize); + (*null_pm.borrow_mut()) = (offset_of_field!(HasTwoInts, first) as isize); match ({ (null_pm.as_pointer()).to_any() },) { (mut __tmp_3,) => { __tmp_3.memcpy(&(bytes.decay()).to_any(), ::std::mem::size_of::()); diff --git a/tests/std/basic/basic.types/basic.types.general/out/refcount/p3-pointer-to-data-member-bytes-copied-to-other-object.rs b/tests/std/basic/basic.types/basic.types.general/out/refcount/p3-pointer-to-data-member-bytes-copied-to-other-object.rs index a0213284ad..3c0bb02175 100644 --- a/tests/std/basic/basic.types/basic.types.general/out/refcount/p3-pointer-to-data-member-bytes-copied-to-other-object.rs +++ b/tests/std/basic/basic.types/basic.types.general/out/refcount/p3-pointer-to-data-member-bytes-copied-to-other-object.rs @@ -20,11 +20,10 @@ pub fn main() { } fn main_0() -> i32 { let source: Value = Rc::new(RefCell::new( - (::OFFSETS.second as isize), - )); - let destination: Value = Rc::new(RefCell::new( - (::OFFSETS.first as isize), + (offset_of_field!(HasTwoInts, second) as isize), )); + let destination: Value = + Rc::new(RefCell::new((offset_of_field!(HasTwoInts, first) as isize))); match ({ (destination.as_pointer()).to_any() },) { (mut __tmp_0,) => { __tmp_0.memcpy( diff --git a/tests/std/dcl.dcl/dcl.decl/dcl.init/dcl.init.general/out/refcount/p6.1-zero-initialized-pointer-to-member.rs b/tests/std/dcl.dcl/dcl.decl/dcl.init/dcl.init.general/out/refcount/p6.1-zero-initialized-pointer-to-member.rs index a8c6c7d45b..03c70f2106 100644 --- a/tests/std/dcl.dcl/dcl.decl/dcl.init/dcl.init.general/out/refcount/p6.1-zero-initialized-pointer-to-member.rs +++ b/tests/std/dcl.dcl/dcl.decl/dcl.init/dcl.init.general/out/refcount/p6.1-zero-initialized-pointer-to-member.rs @@ -36,14 +36,14 @@ pub fn main() { fn main_0() -> i32 { assert!(((static_pm_0.with(|rc| *rc.borrow())) == -1_isize)); assert!( - (static_pm_0.with(|rc| *rc.borrow()) != (::OFFSETS.first as isize)) + (static_pm_0.with(|rc| *rc.borrow()) != (offset_of_field!(HasTwoInts, first) as isize)) ); let mut value_initialized: isize = -1_isize; assert!(((value_initialized) == -1_isize)); - assert!((value_initialized != (::OFFSETS.first as isize))); + assert!((value_initialized != (offset_of_field!(HasTwoInts, first) as isize))); let mut holder: HoldsSelector = ::default(); assert!(((holder.selector) == -1_isize)); - assert!((holder.selector != (::OFFSETS.first as isize))); + assert!((holder.selector != (offset_of_field!(HasTwoInts, first) as isize))); return 0; } pub fn __cpp2rust_init_globals() { diff --git a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.array/out/refcount/p6-array-of-pointers-to-data-members.rs b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.array/out/refcount/p6-array-of-pointers-to-data-members.rs index e0c12c1072..ec2d5a7ea3 100644 --- a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.array/out/refcount/p6-array-of-pointers-to-data-members.rs +++ b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.array/out/refcount/p6-array-of-pointers-to-data-members.rs @@ -22,9 +22,9 @@ pub fn main() { } fn main_0() -> i32 { let members: Value> = Rc::new(RefCell::new(Box::new([ - (::OFFSETS.third as isize), - (::OFFSETS.first as isize), - (::OFFSETS.second as isize), + (offset_of_field!(HasThreeInts, third) as isize), + (offset_of_field!(HasThreeInts, first) as isize), + (offset_of_field!(HasThreeInts, second) as isize), ]))); let obj: Value = Rc::new(RefCell::new(HasThreeInts { first: 4, @@ -67,7 +67,7 @@ fn main_0() -> i32 { element.prefix_inc(); assert!(({ (element).clone() } == { (members.decay().offset(2)) })); assert!((((obj.as_pointer()).member::((element.read())).read()) == 5)); - (*members.borrow_mut())[(2) as usize] = (::OFFSETS.third as isize); + (*members.borrow_mut())[(2) as usize] = (offset_of_field!(HasThreeInts, third) as isize); assert!((((obj.as_pointer()).member::((element.read())).read()) == 6)); return 0; } diff --git a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/refcount/p2-pointer-to-array-member.rs b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/refcount/p2-pointer-to-array-member.rs index c711c862ae..b607988c25 100644 --- a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/refcount/p2-pointer-to-array-member.rs +++ b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/refcount/p2-pointer-to-array-member.rs @@ -30,7 +30,7 @@ pub fn main() { std::process::exit(main_0()); } fn main_0() -> i32 { - let mut pm: isize = (::OFFSETS.elements as isize); + let mut pm: isize = (offset_of_field!(HasIntArray, elements) as isize); let obj: Value = Rc::new(RefCell::new(HasIntArray { before: 1, elements: Box::new([2, 3, 4]), diff --git a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/refcount/p2-pointer-to-data-member.rs b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/refcount/p2-pointer-to-data-member.rs index 5afa29a59c..6fcd39ade3 100644 --- a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/refcount/p2-pointer-to-data-member.rs +++ b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/refcount/p2-pointer-to-data-member.rs @@ -19,7 +19,7 @@ pub fn main() { std::process::exit(main_0()); } fn main_0() -> i32 { - let mut pm: isize = (::OFFSETS.first as isize); + let mut pm: isize = (offset_of_field!(HasTwoInts, first) as isize); let obj: Value = Rc::new(RefCell::new(HasTwoInts { first: 3, second: 4, @@ -28,7 +28,7 @@ fn main_0() -> i32 { (obj.as_pointer()).member::(pm).write(5); assert!(({ ({ (*obj.borrow()).first } == 5) })); assert!(({ ({ (*obj.borrow()).second } == 4) })); - pm = (::OFFSETS.second as isize); + pm = (offset_of_field!(HasTwoInts, second) as isize); assert!((((obj.as_pointer()).member::(pm).read()) == 4)); (obj.as_pointer()).member::(pm).write(6); assert!(({ ({ (*obj.borrow()).first } == 5) })); diff --git a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/refcount/p2-pointer-to-member-of-incomplete-class.rs b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/refcount/p2-pointer-to-member-of-incomplete-class.rs index 6d94933c88..415d653106 100644 --- a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/refcount/p2-pointer-to-member-of-incomplete-class.rs +++ b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/refcount/p2-pointer-to-member-of-incomplete-class.rs @@ -23,7 +23,7 @@ pub fn main() { } fn main_0() -> i32 { assert!(((pm_0.with(|rc| *rc.borrow())) == -1_isize)); - pm_0.with(|rc| *rc.borrow_mut() = (::OFFSETS.second as isize)); + pm_0.with(|rc| *rc.borrow_mut() = (offset_of_field!(CompletedLater, second) as isize)); let obj: Value = Rc::new(RefCell::new(CompletedLater { first: 3, second: 4, diff --git a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/refcount/p2-pointer-to-member-of-pointer-to-member-type.rs b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/refcount/p2-pointer-to-member-of-pointer-to-member-type.rs index 4c31e8ab2f..ebebb124e6 100644 --- a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/refcount/p2-pointer-to-member-of-pointer-to-member-type.rs +++ b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/refcount/p2-pointer-to-member-of-pointer-to-member-type.rs @@ -31,9 +31,9 @@ pub fn main() { std::process::exit(main_0()); } fn main_0() -> i32 { - let mut pm: isize = (::OFFSETS.selector as isize); + let mut pm: isize = (offset_of_field!(HoldsSelector, selector) as isize); let holder: Value = Rc::new(RefCell::new(HoldsSelector { - selector: (::OFFSETS.second as isize), + selector: (offset_of_field!(HasTwoInts, second) as isize), })); let obj: Value = Rc::new(RefCell::new(HasTwoInts { first: 3, @@ -47,7 +47,7 @@ fn main_0() -> i32 { ); (holder.as_pointer()) .member::(pm) - .write((::OFFSETS.first as isize)); + .write((offset_of_field!(HasTwoInts, first) as isize)); assert!( ({ (((obj.as_pointer()) diff --git a/tests/std/expr/conv/conv.mem/out/refcount/p1-null-distinct-from-first-member.rs b/tests/std/expr/conv/conv.mem/out/refcount/p1-null-distinct-from-first-member.rs index 4bcabd8ac0..ee0da09cf4 100644 --- a/tests/std/expr/conv/conv.mem/out/refcount/p1-null-distinct-from-first-member.rs +++ b/tests/std/expr/conv/conv.mem/out/refcount/p1-null-distinct-from-first-member.rs @@ -20,8 +20,8 @@ pub fn main() { } fn main_0() -> i32 { let mut null_pm: isize = -1_isize; - let mut first_pm: isize = (::OFFSETS.first as isize); - let mut second_pm: isize = (::OFFSETS.second as isize); + let mut first_pm: isize = (offset_of_field!(HasTwoInts, first) as isize); + let mut second_pm: isize = (offset_of_field!(HasTwoInts, second) as isize); assert!((first_pm != null_pm)); assert!((second_pm != null_pm)); return 0; diff --git a/tests/std/expr/expr.compound/expr.cond/out/refcount/p7.4-pointer-to-member-and-null.rs b/tests/std/expr/expr.compound/expr.cond/out/refcount/p7.4-pointer-to-member-and-null.rs index 3b241f9054..f2456e545c 100644 --- a/tests/std/expr/expr.compound/expr.cond/out/refcount/p7.4-pointer-to-member-and-null.rs +++ b/tests/std/expr/expr.compound/expr.cond/out/refcount/p7.4-pointer-to-member-and-null.rs @@ -16,7 +16,7 @@ pub struct HasTwoInts { } pub fn second_or_null_0(mut choose_second: bool) -> isize { return if choose_second { - (::OFFSETS.second as isize) + (offset_of_field!(HasTwoInts, second) as isize) } else { -1_isize }; @@ -31,7 +31,7 @@ fn main_0() -> i32 { second: 4, })); assert!((({ second_or_null_0(false,) }) == -1_isize)); - assert!((({ second_or_null_0(true,) }) == (::OFFSETS.second as isize))); + assert!((({ second_or_null_0(true,) }) == (offset_of_field!(HasTwoInts, second) as isize))); assert!( (((obj.as_pointer()) .member::(({ second_or_null_0(true,) })) diff --git a/tests/std/expr/expr.compound/expr.eq/out/refcount/p4.2-one-null.rs b/tests/std/expr/expr.compound/expr.eq/out/refcount/p4.2-one-null.rs index 8b7e638ed7..b018abcf9a 100644 --- a/tests/std/expr/expr.compound/expr.eq/out/refcount/p4.2-one-null.rs +++ b/tests/std/expr/expr.compound/expr.eq/out/refcount/p4.2-one-null.rs @@ -20,7 +20,7 @@ pub fn main() { } fn main_0() -> i32 { let mut null_pm: isize = -1_isize; - let mut first_pm: isize = (::OFFSETS.first as isize); + let mut first_pm: isize = (offset_of_field!(HasTwoInts, first) as isize); assert!((first_pm != null_pm)); assert!(!(first_pm == null_pm)); assert!((null_pm != first_pm)); diff --git a/tests/std/expr/expr.compound/expr.eq/out/refcount/p4.6-data-members.rs b/tests/std/expr/expr.compound/expr.eq/out/refcount/p4.6-data-members.rs index 7eece39c53..2801de00fd 100644 --- a/tests/std/expr/expr.compound/expr.eq/out/refcount/p4.6-data-members.rs +++ b/tests/std/expr/expr.compound/expr.eq/out/refcount/p4.6-data-members.rs @@ -19,9 +19,9 @@ pub fn main() { std::process::exit(main_0()); } fn main_0() -> i32 { - let mut first_pm: isize = (::OFFSETS.first as isize); - let mut also_first_pm: isize = (::OFFSETS.first as isize); - let mut second_pm: isize = (::OFFSETS.second as isize); + let mut first_pm: isize = (offset_of_field!(HasTwoInts, first) as isize); + let mut also_first_pm: isize = (offset_of_field!(HasTwoInts, first) as isize); + let mut second_pm: isize = (offset_of_field!(HasTwoInts, second) as isize); assert!((first_pm == also_first_pm)); assert!(!(first_pm != also_first_pm)); assert!((first_pm != second_pm)); diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p3-arrow-star.rs b/tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p3-arrow-star.rs index e6e793dd23..de03789803 100644 --- a/tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p3-arrow-star.rs +++ b/tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p3-arrow-star.rs @@ -19,7 +19,7 @@ pub fn main() { std::process::exit(main_0()); } fn main_0() -> i32 { - let mut pm: isize = (::OFFSETS.second as isize); + let mut pm: isize = (offset_of_field!(HasTwoInts, second) as isize); let obj: Value = Rc::new(RefCell::new(HasTwoInts { first: 3, second: 4, diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p4-object-expression-sequenced-first.rs b/tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p4-object-expression-sequenced-first.rs index 48f1062ae9..d87a482be0 100644 --- a/tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p4-object-expression-sequenced-first.rs +++ b/tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p4-object-expression-sequenced-first.rs @@ -32,7 +32,7 @@ pub fn select_object_4() -> Ptr { pub fn select_member_5() -> isize { member_stamp_2 .with(|rc| *rc.borrow_mut() = (*sequence_0.with(Value::clone).borrow_mut()).prefix_inc()); - return (::OFFSETS.value as isize); + return (offset_of_field!(HasValue, value) as isize); } pub fn main() { __cpp2rust_init_globals(); diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p6-data-member-of-lvalue-is-lvalue.rs b/tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p6-data-member-of-lvalue-is-lvalue.rs index a41629c6b6..c0723e25b8 100644 --- a/tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p6-data-member-of-lvalue-is-lvalue.rs +++ b/tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p6-data-member-of-lvalue-is-lvalue.rs @@ -19,7 +19,7 @@ pub fn main() { std::process::exit(main_0()); } fn main_0() -> i32 { - let mut pm: isize = (::OFFSETS.second as isize); + let mut pm: isize = (offset_of_field!(HasTwoInts, second) as isize); let obj: Value = Rc::new(RefCell::new(HasTwoInts { first: 3, second: 4, diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p6-data-member-of-rvalue-is-xvalue.rs b/tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p6-data-member-of-rvalue-is-xvalue.rs index f203b47017..cb4248b7f0 100644 --- a/tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p6-data-member-of-rvalue-is-xvalue.rs +++ b/tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p6-data-member-of-rvalue-is-xvalue.rs @@ -52,7 +52,7 @@ pub fn main() { std::process::exit(main_0()); } fn main_0() -> i32 { - let mut pm: isize = (::OFFSETS.member as isize); + let mut pm: isize = (offset_of_field!(HoldsCounted, member) as isize); let holder: Value = Rc::new(RefCell::new(::default())); let mut from_lvalue: CountsCopiesAndMoves = CountsCopiesAndMoves::copy_from({ (holder.as_pointer()).member::(pm) diff --git a/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/out/refcount/p10-result-is-unspecified.rs b/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/out/refcount/p10-result-is-unspecified.rs index b13c20a0c4..2acb388099 100644 --- a/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/out/refcount/p10-result-is-unspecified.rs +++ b/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/out/refcount/p10-result-is-unspecified.rs @@ -27,7 +27,7 @@ pub fn main() { std::process::exit(main_0()); } fn main_0() -> i32 { - let mut converted: isize = (::OFFSETS.second as isize); - return ((converted == (::OFFSETS.second as isize)) as i32); + let mut converted: isize = (offset_of_field!(HasTwoInts, second) as isize); + return ((converted == (offset_of_field!(AlsoHasTwoInts, second) as isize)) as i32); } pub fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/out/refcount/p10.2-data-member-round-trip.rs b/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/out/refcount/p10.2-data-member-round-trip.rs index d451052256..027757226c 100644 --- a/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/out/refcount/p10.2-data-member-round-trip.rs +++ b/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/out/refcount/p10.2-data-member-round-trip.rs @@ -25,9 +25,9 @@ pub fn main() { std::process::exit(main_0()); } fn main_0() -> i32 { - let mut converted: isize = (::OFFSETS.second as isize); + let mut converted: isize = (offset_of_field!(HasTwoInts, second) as isize); let mut back: isize = converted; - assert!((back == (::OFFSETS.second as isize))); + assert!((back == (offset_of_field!(HasTwoInts, second) as isize))); let obj: Value = Rc::new(RefCell::new(HasTwoInts { first: 3, second: 4, diff --git a/tests/std/expr/expr.compound/expr.unary/expr.unary.op/out/refcount/p3.1-anonymous-union-member.rs b/tests/std/expr/expr.compound/expr.unary/expr.unary.op/out/refcount/p3.1-anonymous-union-member.rs index 2b9d0c3e9d..6032fc6601 100644 --- a/tests/std/expr/expr.compound/expr.unary/expr.unary.op/out/refcount/p3.1-anonymous-union-member.rs +++ b/tests/std/expr/expr.compound/expr.unary/expr.unary.op/out/refcount/p3.1-anonymous-union-member.rs @@ -42,7 +42,7 @@ pub fn main() { std::process::exit(main_0()); } fn main_0() -> i32 { - let mut pm: isize = (::OFFSETS.anon_0 as isize); + let mut pm: isize = (offset_of_field!(HasAnonymousUnion, anon_0) as isize); let obj: Value = Rc::new(RefCell::new(::default())); (*obj.borrow_mut()).before = 1; anon_0::as_int(field_ptr!(obj.as_pointer(), anon_0)).write(2); From 7acd5ee53b673f8b94183ea2c974073cfb9efd99 Mon Sep 17 00:00:00 2001 From: Lucian Popescu Date: Mon, 16 Nov 2026 21:30:41 +0000 Subject: [PATCH 15/15] Merge tests --- .../basic.types.general-unsupported.cpp | 127 ++++++++++++ .../basic/basic.types/basic.types.general.cpp | 58 ++++++ ...pointer-to-data-member-bytes-round-trip.rs | 66 ------- ...ata-member-bytes-copied-to-other-object.rs | 62 ------ ...pointer-to-data-member-bytes-round-trip.rs | 81 -------- ...ata-member-bytes-copied-to-other-object.rs | 61 ------ ...ointer-to-data-member-bytes-round-trip.cpp | 29 --- ...er-to-member-function-bytes-round-trip.cpp | 34 ---- ...rtual-member-function-bytes-round-trip.cpp | 33 ---- ...lding-pointers-to-members-bytes-copied.cpp | 31 --- ...ta-member-bytes-copied-to-other-object.cpp | 24 --- ...-function-bytes-copied-to-other-object.cpp | 29 --- .../out/refcount/basic.types.general.rs | 143 ++++++++++++++ .../out/unsafe/basic.types.general.rs | 149 ++++++++++++++ ...ter-to-member.cpp => dcl.init.general.cpp} | 12 +- .../refcount/dcl.init.general.rs} | 40 ++-- .../unsafe/dcl.init.general.rs} | 43 +++-- ...unctions.cpp => dcl.array-unsupported.cpp} | 12 +- ...ters-to-data-members.cpp => dcl.array.cpp} | 12 +- ...-function.cpp => dcl.mptr-unsupported.cpp} | 12 +- .../dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr.cpp | 94 +++++++++ .../refcount/p2-pointer-to-array-member.rs | 45 ----- .../out/refcount/p2-pointer-to-data-member.rs | 38 ---- ...2-pointer-to-member-of-incomplete-class.rs | 41 ---- ...ter-to-member-of-pointer-to-member-type.rs | 61 ------ .../out/unsafe/p2-pointer-to-array-member.rs | 46 ----- .../out/unsafe/p2-pointer-to-data-member.rs | 52 ----- ...2-pointer-to-member-of-incomplete-class.rs | 40 ---- ...ter-to-member-of-pointer-to-member-type.rs | 61 ------ .../dcl.mptr/p2-pointer-to-array-member.cpp | 20 -- .../dcl.mptr/p2-pointer-to-data-member.cpp | 24 --- ...-pointer-to-member-of-incomplete-class.cpp | 21 -- ...er-to-member-of-pointer-to-member-type.cpp | 23 --- .../refcount/dcl.array.rs} | 36 ++-- .../dcl.meaning/out/refcount/dcl.mptr.rs | 173 +++++++++++++++++ .../unsafe/dcl.array.rs} | 52 ++--- .../dcl.meaning/out/unsafe/dcl.mptr.rs | 176 +++++++++++++++++ ...o-member.cpp => conv.bool-unsupported.cpp} | 12 +- ...nction.cpp => conv.fctptr-unsupported.cpp} | 12 +- tests/std/expr/conv/conv.mem-unsupported.cpp | 136 +++++++++++++ ...nct-from-first-member.cpp => conv.mem.cpp} | 12 +- .../p1-null-distinct-from-member-function.cpp | 21 -- .../conv.mem/p1-null-values-compare-equal.cpp | 21 -- .../p2-base-to-derived-data-member.cpp | 33 ---- .../p2-base-to-derived-member-function.cpp | 33 ---- .../conv.mem/p2-null-converts-to-null.cpp | 26 --- .../refcount/conv.mem.rs} | 17 +- .../unsafe/conv.mem.rs} | 17 +- ...o-member.cpp => expr.cond-unsupported.cpp} | 12 +- ...r-to-member-and-null.cpp => expr.cond.cpp} | 12 +- ....3-pointer-to-virtual-member-function.cpp} | 0 ....eq-p4.4-members-of-unrelated-classes.cpp} | 0 .../expr.compound/expr.eq-unsupported.cpp | 98 ++++++++++ tests/std/expr/expr.compound/expr.eq.cpp | 80 ++++++++ .../expr.eq/out/refcount/p4.1-both-null.rs | 28 --- .../expr.eq/out/refcount/p4.2-one-null.rs | 30 --- .../refcount/p4.5-members-of-same-union.rs | 42 ---- .../expr.eq/out/refcount/p4.6-data-members.rs | 31 --- .../expr.eq/out/unsafe/p4.1-both-null.rs | 28 --- .../expr.eq/out/unsafe/p4.2-one-null.rs | 30 --- .../out/unsafe/p4.5-members-of-same-union.rs | 33 ---- .../expr.eq/out/unsafe/p4.6-data-members.rs | 31 --- .../expr.compound/expr.eq/p4.1-both-null.cpp | 17 -- .../expr.compound/expr.eq/p4.2-one-null.cpp | 19 -- .../expr.eq/p4.5-members-of-same-union.cpp | 17 -- .../p4.6-data-member-of-repeated-base.cpp | 33 ---- .../expr.eq/p4.6-data-members.cpp | 21 -- .../p4.6-member-function-of-repeated-base.cpp | 38 ---- .../expr.eq/p4.6-member-functions.cpp | 23 --- ...ptr.oper-p4-dynamic-type-lacks-member.cpp} | 0 ....mptr.oper-p4-object-type-not-similar.cpp} | 0 ...r.oper-p6-null-pointer-to-data-member.cpp} | 0 ...er-p6-null-pointer-to-member-function.cpp} | 0 .../expr.mptr.oper-unsupported.cpp | 124 ++++++++++++ .../std/expr/expr.compound/expr.mptr.oper.cpp | 105 ++++++++++ .../out/refcount/p3-arrow-star.rs | 35 ---- .../p4-object-expression-sequenced-first.rs | 57 ------ .../p6-data-member-of-lvalue-is-lvalue.rs | 34 ---- .../p6-data-member-of-rvalue-is-xvalue.rs | 72 ------- .../out/unsafe/p3-arrow-star.rs | 40 ---- .../p4-object-expression-sequenced-first.rs | 53 ----- .../p6-data-member-of-lvalue-is-lvalue.rs | 41 ---- .../p6-data-member-of-rvalue-is-xvalue.rs | 72 ------- .../p2-object-of-derived-class.cpp | 31 --- ...p3-arrow-star-pointer-to-derived-class.cpp | 32 ---- .../expr.mptr.oper/p3-arrow-star.cpp | 20 -- .../p4-object-expression-sequenced-first.cpp | 29 --- .../p6-data-member-of-lvalue-is-lvalue.cpp | 20 -- .../p6-data-member-of-rvalue-is-xvalue.cpp | 30 --- .../p6-member-function-call.cpp | 27 --- .../p6-pointer-to-virtual-member-function.cpp | 30 --- ...erpret.cast-p10-result-is-unspecified.cpp} | 0 ... => expr.reinterpret.cast-unsupported.cpp} | 12 +- ...und-trip.cpp => expr.reinterpret.cast.cpp} | 32 +++- .../out/refcount/p10-null-converts-to-null.rs | 33 ---- .../refcount/p10.2-data-member-round-trip.rs | 38 ---- .../out/unsafe/p10-null-converts-to-null.rs | 32 ---- .../unsafe/p10.2-data-member-round-trip.rs | 42 ---- .../p10-null-converts-to-null.cpp | 20 -- ...st-p13-base-unrelated-to-member-class.cpp} | 0 .../expr.static.cast-unsupported.cpp | 104 ++++++++++ .../p13-derived-to-base-data-member.cpp | 27 --- .../p13-derived-to-base-member-function.cpp | 28 --- .../p13-null-converts-to-null.cpp | 22 --- .../p13-round-trip-yields-original.cpp | 24 --- ...terpret.cast-p10-result-is-unspecified.rs} | 0 .../out/refcount/expr.reinterpret.cast.rs | 63 ++++++ ...terpret.cast-p10-result-is-unspecified.rs} | 0 .../out/unsafe/expr.reinterpret.cast.rs | 67 +++++++ .../expr.unary/expr.unary.op-unsupported.cpp | 54 ++++++ .../expr.unary/expr.unary.op.cpp | 54 ++++++ .../refcount/p3.1-anonymous-union-member.rs | 55 ------ .../p3.2-static-member-is-ordinary-pointer.rs | 40 ---- ...thesized-qualified-id-is-object-pointer.rs | 48 ----- .../out/unsafe/p3.1-anonymous-union-member.rs | 50 ----- .../p3.2-static-member-is-ordinary-pointer.rs | 39 ---- ...thesized-qualified-id-is-object-pointer.rs | 43 ----- .../p3.1-anonymous-union-member.cpp | 25 --- ...3.1-member-named-through-derived-class.cpp | 23 --- ...p3.2-static-member-is-ordinary-pointer.cpp | 22 --- ...hesized-qualified-id-is-object-pointer.cpp | 26 --- .../expr.unary/out/refcount/expr.unary.op.rs | 93 +++++++++ .../expr.unary/out/unsafe/expr.unary.op.rs | 81 ++++++++ .../refcount/expr.cond.rs} | 31 +-- .../expr.compound/out/refcount/expr.eq.rs | 95 +++++++++ ...tr.oper-p6-null-pointer-to-data-member.rs} | 0 .../out/refcount/expr.mptr.oper.rs | 177 +++++++++++++++++ .../unsafe/expr.cond.rs} | 35 ++-- .../expr/expr.compound/out/unsafe/expr.eq.rs | 83 ++++++++ ...tr.oper-p6-null-pointer-to-data-member.rs} | 0 .../out/unsafe/expr.mptr.oper.rs | 181 ++++++++++++++++++ .../refcount/temp.type.rs} | 23 ++- .../unsafe/temp.type.rs} | 27 +-- ...r-to-member-argument.cpp => temp.type.cpp} | 12 +- .../func.require-unsupported.cpp | 144 ++++++++++++++ .../p1.1-member-function-with-object.cpp | 28 --- ...member-function-with-reference-wrapper.cpp | 24 --- .../p1.3-member-function-with-pointer.cpp | 24 --- .../p1.4-data-member-with-object.cpp | 25 --- ...1.5-data-member-with-reference-wrapper.cpp | 23 --- .../p1.6-data-member-with-pointer.cpp | 23 --- 141 files changed, 2983 insertions(+), 3045 deletions(-) create mode 100644 tests/std/basic/basic.types/basic.types.general-unsupported.cpp create mode 100644 tests/std/basic/basic.types/basic.types.general.cpp delete mode 100644 tests/std/basic/basic.types/basic.types.general/out/refcount/p2-pointer-to-data-member-bytes-round-trip.rs delete mode 100644 tests/std/basic/basic.types/basic.types.general/out/refcount/p3-pointer-to-data-member-bytes-copied-to-other-object.rs delete mode 100644 tests/std/basic/basic.types/basic.types.general/out/unsafe/p2-pointer-to-data-member-bytes-round-trip.rs delete mode 100644 tests/std/basic/basic.types/basic.types.general/out/unsafe/p3-pointer-to-data-member-bytes-copied-to-other-object.rs delete mode 100644 tests/std/basic/basic.types/basic.types.general/p2-pointer-to-data-member-bytes-round-trip.cpp delete mode 100644 tests/std/basic/basic.types/basic.types.general/p2-pointer-to-member-function-bytes-round-trip.cpp delete mode 100644 tests/std/basic/basic.types/basic.types.general/p2-pointer-to-virtual-member-function-bytes-round-trip.cpp delete mode 100644 tests/std/basic/basic.types/basic.types.general/p3-class-holding-pointers-to-members-bytes-copied.cpp delete mode 100644 tests/std/basic/basic.types/basic.types.general/p3-pointer-to-data-member-bytes-copied-to-other-object.cpp delete mode 100644 tests/std/basic/basic.types/basic.types.general/p3-pointer-to-member-function-bytes-copied-to-other-object.cpp create mode 100644 tests/std/basic/basic.types/out/refcount/basic.types.general.rs create mode 100644 tests/std/basic/basic.types/out/unsafe/basic.types.general.rs rename tests/std/dcl.dcl/dcl.decl/dcl.init/{dcl.init.general/p6.1-zero-initialized-pointer-to-member.cpp => dcl.init.general.cpp} (80%) rename tests/std/dcl.dcl/dcl.decl/dcl.init/{dcl.init.general/out/refcount/p6.1-zero-initialized-pointer-to-member.rs => out/refcount/dcl.init.general.rs} (51%) rename tests/std/dcl.dcl/dcl.decl/dcl.init/{dcl.init.general/out/unsafe/p6.1-zero-initialized-pointer-to-member.rs => out/unsafe/dcl.init.general.rs} (53%) rename tests/std/dcl.dcl/dcl.decl/dcl.meaning/{dcl.array/p6-array-of-pointers-to-member-functions.cpp => dcl.array-unsupported.cpp} (86%) rename tests/std/dcl.dcl/dcl.decl/dcl.meaning/{dcl.array/p6-array-of-pointers-to-data-members.cpp => dcl.array.cpp} (83%) rename tests/std/dcl.dcl/dcl.decl/dcl.meaning/{dcl.mptr/p2-pointer-to-member-function.cpp => dcl.mptr-unsupported.cpp} (83%) create mode 100644 tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr.cpp delete mode 100644 tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/refcount/p2-pointer-to-array-member.rs delete mode 100644 tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/refcount/p2-pointer-to-data-member.rs delete mode 100644 tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/refcount/p2-pointer-to-member-of-incomplete-class.rs delete mode 100644 tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/refcount/p2-pointer-to-member-of-pointer-to-member-type.rs delete mode 100644 tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/unsafe/p2-pointer-to-array-member.rs delete mode 100644 tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/unsafe/p2-pointer-to-data-member.rs delete mode 100644 tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/unsafe/p2-pointer-to-member-of-incomplete-class.rs delete mode 100644 tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/unsafe/p2-pointer-to-member-of-pointer-to-member-type.rs delete mode 100644 tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/p2-pointer-to-array-member.cpp delete mode 100644 tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/p2-pointer-to-data-member.cpp delete mode 100644 tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/p2-pointer-to-member-of-incomplete-class.cpp delete mode 100644 tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/p2-pointer-to-member-of-pointer-to-member-type.cpp rename tests/std/dcl.dcl/dcl.decl/dcl.meaning/{dcl.array/out/refcount/p6-array-of-pointers-to-data-members.rs => out/refcount/dcl.array.rs} (69%) create mode 100644 tests/std/dcl.dcl/dcl.decl/dcl.meaning/out/refcount/dcl.mptr.rs rename tests/std/dcl.dcl/dcl.decl/dcl.meaning/{dcl.array/out/unsafe/p6-array-of-pointers-to-data-members.rs => out/unsafe/dcl.array.rs} (55%) create mode 100644 tests/std/dcl.dcl/dcl.decl/dcl.meaning/out/unsafe/dcl.mptr.rs rename tests/std/expr/conv/{conv.bool/p1-pointer-to-member.cpp => conv.bool-unsupported.cpp} (89%) rename tests/std/expr/conv/{conv.fctptr/p1-pointer-to-noexcept-member-function.cpp => conv.fctptr-unsupported.cpp} (77%) create mode 100644 tests/std/expr/conv/conv.mem-unsupported.cpp rename tests/std/expr/conv/{conv.mem/p1-null-distinct-from-first-member.cpp => conv.mem.cpp} (75%) delete mode 100644 tests/std/expr/conv/conv.mem/p1-null-distinct-from-member-function.cpp delete mode 100644 tests/std/expr/conv/conv.mem/p1-null-values-compare-equal.cpp delete mode 100644 tests/std/expr/conv/conv.mem/p2-base-to-derived-data-member.cpp delete mode 100644 tests/std/expr/conv/conv.mem/p2-base-to-derived-member-function.cpp delete mode 100644 tests/std/expr/conv/conv.mem/p2-null-converts-to-null.cpp rename tests/std/expr/conv/{conv.mem/out/refcount/p1-null-distinct-from-first-member.rs => out/refcount/conv.mem.rs} (64%) rename tests/std/expr/conv/{conv.mem/out/unsafe/p1-null-distinct-from-first-member.rs => out/unsafe/conv.mem.rs} (63%) rename tests/std/expr/expr.compound/{expr.cond/p7.4-base-and-derived-pointer-to-member.cpp => expr.cond-unsupported.cpp} (82%) rename tests/std/expr/expr.compound/{expr.cond/p7.4-pointer-to-member-and-null.cpp => expr.cond.cpp} (79%) rename tests/std/expr/expr.compound/{expr.eq/p4.3-pointer-to-virtual-member-function.cpp => expr.eq-p4.3-pointer-to-virtual-member-function.cpp} (100%) rename tests/std/expr/expr.compound/{expr.eq/p4.4-members-of-unrelated-classes.cpp => expr.eq-p4.4-members-of-unrelated-classes.cpp} (100%) create mode 100644 tests/std/expr/expr.compound/expr.eq-unsupported.cpp create mode 100644 tests/std/expr/expr.compound/expr.eq.cpp delete mode 100644 tests/std/expr/expr.compound/expr.eq/out/refcount/p4.1-both-null.rs delete mode 100644 tests/std/expr/expr.compound/expr.eq/out/refcount/p4.2-one-null.rs delete mode 100644 tests/std/expr/expr.compound/expr.eq/out/refcount/p4.5-members-of-same-union.rs delete mode 100644 tests/std/expr/expr.compound/expr.eq/out/refcount/p4.6-data-members.rs delete mode 100644 tests/std/expr/expr.compound/expr.eq/out/unsafe/p4.1-both-null.rs delete mode 100644 tests/std/expr/expr.compound/expr.eq/out/unsafe/p4.2-one-null.rs delete mode 100644 tests/std/expr/expr.compound/expr.eq/out/unsafe/p4.5-members-of-same-union.rs delete mode 100644 tests/std/expr/expr.compound/expr.eq/out/unsafe/p4.6-data-members.rs delete mode 100644 tests/std/expr/expr.compound/expr.eq/p4.1-both-null.cpp delete mode 100644 tests/std/expr/expr.compound/expr.eq/p4.2-one-null.cpp delete mode 100644 tests/std/expr/expr.compound/expr.eq/p4.5-members-of-same-union.cpp delete mode 100644 tests/std/expr/expr.compound/expr.eq/p4.6-data-member-of-repeated-base.cpp delete mode 100644 tests/std/expr/expr.compound/expr.eq/p4.6-data-members.cpp delete mode 100644 tests/std/expr/expr.compound/expr.eq/p4.6-member-function-of-repeated-base.cpp delete mode 100644 tests/std/expr/expr.compound/expr.eq/p4.6-member-functions.cpp rename tests/std/expr/expr.compound/{expr.mptr.oper/p4-dynamic-type-lacks-member.cpp => expr.mptr.oper-p4-dynamic-type-lacks-member.cpp} (100%) rename tests/std/expr/expr.compound/{expr.mptr.oper/p4-object-type-not-similar.cpp => expr.mptr.oper-p4-object-type-not-similar.cpp} (100%) rename tests/std/expr/expr.compound/{expr.mptr.oper/p6-null-pointer-to-data-member.cpp => expr.mptr.oper-p6-null-pointer-to-data-member.cpp} (100%) rename tests/std/expr/expr.compound/{expr.mptr.oper/p6-null-pointer-to-member-function.cpp => expr.mptr.oper-p6-null-pointer-to-member-function.cpp} (100%) create mode 100644 tests/std/expr/expr.compound/expr.mptr.oper-unsupported.cpp create mode 100644 tests/std/expr/expr.compound/expr.mptr.oper.cpp delete mode 100644 tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p3-arrow-star.rs delete mode 100644 tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p4-object-expression-sequenced-first.rs delete mode 100644 tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p6-data-member-of-lvalue-is-lvalue.rs delete mode 100644 tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p6-data-member-of-rvalue-is-xvalue.rs delete mode 100644 tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p3-arrow-star.rs delete mode 100644 tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p4-object-expression-sequenced-first.rs delete mode 100644 tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p6-data-member-of-lvalue-is-lvalue.rs delete mode 100644 tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p6-data-member-of-rvalue-is-xvalue.rs delete mode 100644 tests/std/expr/expr.compound/expr.mptr.oper/p2-object-of-derived-class.cpp delete mode 100644 tests/std/expr/expr.compound/expr.mptr.oper/p3-arrow-star-pointer-to-derived-class.cpp delete mode 100644 tests/std/expr/expr.compound/expr.mptr.oper/p3-arrow-star.cpp delete mode 100644 tests/std/expr/expr.compound/expr.mptr.oper/p4-object-expression-sequenced-first.cpp delete mode 100644 tests/std/expr/expr.compound/expr.mptr.oper/p6-data-member-of-lvalue-is-lvalue.cpp delete mode 100644 tests/std/expr/expr.compound/expr.mptr.oper/p6-data-member-of-rvalue-is-xvalue.cpp delete mode 100644 tests/std/expr/expr.compound/expr.mptr.oper/p6-member-function-call.cpp delete mode 100644 tests/std/expr/expr.compound/expr.mptr.oper/p6-pointer-to-virtual-member-function.cpp rename tests/std/expr/expr.compound/expr.post/{expr.reinterpret.cast/p10-result-is-unspecified.cpp => expr.reinterpret.cast-p10-result-is-unspecified.cpp} (100%) rename tests/std/expr/expr.compound/expr.post/{expr.reinterpret.cast/p10.1-member-function-round-trip.cpp => expr.reinterpret.cast-unsupported.cpp} (81%) rename tests/std/expr/expr.compound/expr.post/{expr.reinterpret.cast/p10.2-data-member-round-trip.cpp => expr.reinterpret.cast.cpp} (50%) delete mode 100644 tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/out/refcount/p10-null-converts-to-null.rs delete mode 100644 tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/out/refcount/p10.2-data-member-round-trip.rs delete mode 100644 tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/out/unsafe/p10-null-converts-to-null.rs delete mode 100644 tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/out/unsafe/p10.2-data-member-round-trip.rs delete mode 100644 tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/p10-null-converts-to-null.cpp rename tests/std/expr/expr.compound/expr.post/{expr.static.cast/p13-base-unrelated-to-member-class.cpp => expr.static.cast-p13-base-unrelated-to-member-class.cpp} (100%) create mode 100644 tests/std/expr/expr.compound/expr.post/expr.static.cast-unsupported.cpp delete mode 100644 tests/std/expr/expr.compound/expr.post/expr.static.cast/p13-derived-to-base-data-member.cpp delete mode 100644 tests/std/expr/expr.compound/expr.post/expr.static.cast/p13-derived-to-base-member-function.cpp delete mode 100644 tests/std/expr/expr.compound/expr.post/expr.static.cast/p13-null-converts-to-null.cpp delete mode 100644 tests/std/expr/expr.compound/expr.post/expr.static.cast/p13-round-trip-yields-original.cpp rename tests/std/expr/expr.compound/expr.post/{expr.reinterpret.cast/out/refcount/p10-result-is-unspecified.rs => out/refcount/expr.reinterpret.cast-p10-result-is-unspecified.rs} (100%) create mode 100644 tests/std/expr/expr.compound/expr.post/out/refcount/expr.reinterpret.cast.rs rename tests/std/expr/expr.compound/expr.post/{expr.reinterpret.cast/out/unsafe/p10-result-is-unspecified.rs => out/unsafe/expr.reinterpret.cast-p10-result-is-unspecified.rs} (100%) create mode 100644 tests/std/expr/expr.compound/expr.post/out/unsafe/expr.reinterpret.cast.rs create mode 100644 tests/std/expr/expr.compound/expr.unary/expr.unary.op-unsupported.cpp create mode 100644 tests/std/expr/expr.compound/expr.unary/expr.unary.op.cpp delete mode 100644 tests/std/expr/expr.compound/expr.unary/expr.unary.op/out/refcount/p3.1-anonymous-union-member.rs delete mode 100644 tests/std/expr/expr.compound/expr.unary/expr.unary.op/out/refcount/p3.2-static-member-is-ordinary-pointer.rs delete mode 100644 tests/std/expr/expr.compound/expr.unary/expr.unary.op/out/refcount/p4-parenthesized-qualified-id-is-object-pointer.rs delete mode 100644 tests/std/expr/expr.compound/expr.unary/expr.unary.op/out/unsafe/p3.1-anonymous-union-member.rs delete mode 100644 tests/std/expr/expr.compound/expr.unary/expr.unary.op/out/unsafe/p3.2-static-member-is-ordinary-pointer.rs delete mode 100644 tests/std/expr/expr.compound/expr.unary/expr.unary.op/out/unsafe/p4-parenthesized-qualified-id-is-object-pointer.rs delete mode 100644 tests/std/expr/expr.compound/expr.unary/expr.unary.op/p3.1-anonymous-union-member.cpp delete mode 100644 tests/std/expr/expr.compound/expr.unary/expr.unary.op/p3.1-member-named-through-derived-class.cpp delete mode 100644 tests/std/expr/expr.compound/expr.unary/expr.unary.op/p3.2-static-member-is-ordinary-pointer.cpp delete mode 100644 tests/std/expr/expr.compound/expr.unary/expr.unary.op/p4-parenthesized-qualified-id-is-object-pointer.cpp create mode 100644 tests/std/expr/expr.compound/expr.unary/out/refcount/expr.unary.op.rs create mode 100644 tests/std/expr/expr.compound/expr.unary/out/unsafe/expr.unary.op.rs rename tests/std/expr/expr.compound/{expr.cond/out/refcount/p7.4-pointer-to-member-and-null.rs => out/refcount/expr.cond.rs} (61%) create mode 100644 tests/std/expr/expr.compound/out/refcount/expr.eq.rs rename tests/std/expr/expr.compound/{expr.mptr.oper/out/refcount/p6-null-pointer-to-data-member.rs => out/refcount/expr.mptr.oper-p6-null-pointer-to-data-member.rs} (100%) create mode 100644 tests/std/expr/expr.compound/out/refcount/expr.mptr.oper.rs rename tests/std/expr/expr.compound/{expr.cond/out/unsafe/p7.4-pointer-to-member-and-null.rs => out/unsafe/expr.cond.rs} (61%) create mode 100644 tests/std/expr/expr.compound/out/unsafe/expr.eq.rs rename tests/std/expr/expr.compound/{expr.mptr.oper/out/unsafe/p6-null-pointer-to-data-member.rs => out/unsafe/expr.mptr.oper-p6-null-pointer-to-data-member.rs} (100%) create mode 100644 tests/std/expr/expr.compound/out/unsafe/expr.mptr.oper.rs rename tests/std/temp/{temp.type/out/refcount/p2.6-pointer-to-member-argument.rs => out/refcount/temp.type.rs} (81%) rename tests/std/temp/{temp.type/out/unsafe/p2.6-pointer-to-member-argument.rs => out/unsafe/temp.type.rs} (83%) rename tests/std/temp/{temp.type/p2.6-pointer-to-member-argument.cpp => temp.type.cpp} (87%) create mode 100644 tests/std/utilities/function.objects/func.require-unsupported.cpp delete mode 100644 tests/std/utilities/function.objects/func.require/p1.1-member-function-with-object.cpp delete mode 100644 tests/std/utilities/function.objects/func.require/p1.2-member-function-with-reference-wrapper.cpp delete mode 100644 tests/std/utilities/function.objects/func.require/p1.3-member-function-with-pointer.cpp delete mode 100644 tests/std/utilities/function.objects/func.require/p1.4-data-member-with-object.cpp delete mode 100644 tests/std/utilities/function.objects/func.require/p1.5-data-member-with-reference-wrapper.cpp delete mode 100644 tests/std/utilities/function.objects/func.require/p1.6-data-member-with-pointer.cpp diff --git a/tests/std/basic/basic.types/basic.types.general-unsupported.cpp b/tests/std/basic/basic.types/basic.types.general-unsupported.cpp new file mode 100644 index 0000000000..3a5ed04aca --- /dev/null +++ b/tests/std/basic/basic.types/basic.types.general-unsupported.cpp @@ -0,0 +1,127 @@ +// translation-fail: refcount, unsafe +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +#include +#include + +// N4950 [basic.types.general]/2: the underlying bytes of an object of +// trivially copyable type can be copied into an array of unsigned char; if +// they are copied back, the object holds its original value. +namespace p2_pointer_to_member_function_bytes_round_trip { +struct HasTwoMemberFunctions { + int first_calls = 0; + int second_calls = 0; + void first() { ++first_calls; } + void second() { ++second_calls; } +}; + +void test() { + void (HasTwoMemberFunctions::*pmf)() = &HasTwoMemberFunctions::second; + unsigned char bytes[sizeof(pmf)]; + std::memcpy(bytes, &pmf, sizeof(pmf)); + pmf = &HasTwoMemberFunctions::first; + std::memcpy(&pmf, bytes, sizeof(pmf)); + assert(pmf == &HasTwoMemberFunctions::second); + HasTwoMemberFunctions obj; + (obj.*pmf)(); + assert(obj.first_calls == 0); + assert(obj.second_calls == 1); + + void (HasTwoMemberFunctions::*null_pmf)() = nullptr; + std::memcpy(bytes, &null_pmf, sizeof(null_pmf)); + null_pmf = &HasTwoMemberFunctions::first; + std::memcpy(&null_pmf, bytes, sizeof(null_pmf)); + assert(null_pmf == nullptr); +} +} // namespace p2_pointer_to_member_function_bytes_round_trip + +// N4950 [basic.types.general]/2: the underlying bytes of an object of +// trivially copyable type can be copied into an array of unsigned char; if +// they are copied back, the object holds its original value. +namespace p2_pointer_to_virtual_member_function_bytes_round_trip { +static int base_calls; +static int override_calls; + +struct DeclaresVirtual { + virtual void run() { ++base_calls; } + void other() {} +}; + +struct OverridesVirtual : DeclaresVirtual { + void run() override { ++override_calls; } +}; + +void test() { + void (DeclaresVirtual::*pmf)() = &DeclaresVirtual::run; + unsigned char bytes[sizeof(pmf)]; + std::memcpy(bytes, &pmf, sizeof(pmf)); + pmf = &DeclaresVirtual::other; + std::memcpy(&pmf, bytes, sizeof(pmf)); + OverridesVirtual overrider; + DeclaresVirtual &ref = overrider; + (ref.*pmf)(); + assert(base_calls == 0); + assert(override_calls == 1); +} +} // namespace p2_pointer_to_virtual_member_function_bytes_round_trip + +// N4950 [basic.types.general]/3: if the underlying bytes of obj1 of trivially +// copyable type are copied into obj2, obj2 holds the same value as obj1. +namespace p3_class_holding_pointers_to_members_bytes_copied { +struct HasValueAndIncrement { + int padding; + int value; + void increment() { ++value; } +}; + +struct HoldsPointersToMembers { + int HasValueAndIncrement::*data; + void (HasValueAndIncrement::*function)(); +}; + +void test() { + HoldsPointersToMembers source{&HasValueAndIncrement::value, + &HasValueAndIncrement::increment}; + HoldsPointersToMembers destination{nullptr, nullptr}; + std::memcpy(&destination, &source, sizeof(source)); + assert(destination.data == &HasValueAndIncrement::value); + assert(destination.function == &HasValueAndIncrement::increment); + HasValueAndIncrement obj{1, 2}; + (obj.*destination.function)(); + assert(obj.*destination.data == 3); + assert(obj.padding == 1); +} +} // namespace p3_class_holding_pointers_to_members_bytes_copied + +// N4950 [basic.types.general]/3: if the underlying bytes of obj1 of trivially +// copyable type are copied into obj2, obj2 holds the same value as obj1. +namespace p3_pointer_to_member_function_bytes_copied_to_other_object { +struct HasTwoMemberFunctions { + int first_calls = 0; + int second_calls = 0; + void first() { ++first_calls; } + void second() { ++second_calls; } +}; + +void test() { + void (HasTwoMemberFunctions::*source)() = &HasTwoMemberFunctions::second; + void (HasTwoMemberFunctions::*destination)() = &HasTwoMemberFunctions::first; + std::memcpy(&destination, &source, sizeof(source)); + assert(destination == source); + HasTwoMemberFunctions obj; + (obj.*destination)(); + assert(obj.first_calls == 0); + assert(obj.second_calls == 1); + + void (HasTwoMemberFunctions::*null_source)() = nullptr; + std::memcpy(&destination, &null_source, sizeof(null_source)); + assert(destination == nullptr); +} +} // namespace p3_pointer_to_member_function_bytes_copied_to_other_object + +int main() { + p2_pointer_to_member_function_bytes_round_trip::test(); + p2_pointer_to_virtual_member_function_bytes_round_trip::test(); + p3_class_holding_pointers_to_members_bytes_copied::test(); + p3_pointer_to_member_function_bytes_copied_to_other_object::test(); + return 0; +} diff --git a/tests/std/basic/basic.types/basic.types.general.cpp b/tests/std/basic/basic.types/basic.types.general.cpp new file mode 100644 index 0000000000..dca0f15d59 --- /dev/null +++ b/tests/std/basic/basic.types/basic.types.general.cpp @@ -0,0 +1,58 @@ +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +#include +#include + +// N4950 [basic.types.general]/2: the underlying bytes of an object of +// trivially copyable type can be copied into an array of unsigned char; if +// they are copied back, the object holds its original value. +namespace p2_pointer_to_data_member_bytes_round_trip { +struct HasTwoInts { + int first; + int second; +}; + +void test() { + int HasTwoInts::*pm = &HasTwoInts::second; + unsigned char bytes[sizeof(pm)]; + std::memcpy(bytes, &pm, sizeof(pm)); + pm = &HasTwoInts::first; + std::memcpy(&pm, bytes, sizeof(pm)); + assert(pm == &HasTwoInts::second); + HasTwoInts obj{3, 4}; + assert(obj.*pm == 4); + + int HasTwoInts::*null_pm = nullptr; + std::memcpy(bytes, &null_pm, sizeof(null_pm)); + null_pm = &HasTwoInts::first; + std::memcpy(&null_pm, bytes, sizeof(null_pm)); + assert(null_pm == nullptr); +} +} // namespace p2_pointer_to_data_member_bytes_round_trip + +// N4950 [basic.types.general]/3: if the underlying bytes of obj1 of trivially +// copyable type are copied into obj2, obj2 holds the same value as obj1. +namespace p3_pointer_to_data_member_bytes_copied_to_other_object { +struct HasTwoInts { + int first; + int second; +}; + +void test() { + int HasTwoInts::*source = &HasTwoInts::second; + int HasTwoInts::*destination = &HasTwoInts::first; + std::memcpy(&destination, &source, sizeof(source)); + assert(destination == source); + HasTwoInts obj{3, 4}; + assert(obj.*destination == 4); + + int HasTwoInts::*null_source = nullptr; + std::memcpy(&destination, &null_source, sizeof(null_source)); + assert(destination == nullptr); +} +} // namespace p3_pointer_to_data_member_bytes_copied_to_other_object + +int main() { + p2_pointer_to_data_member_bytes_round_trip::test(); + p3_pointer_to_data_member_bytes_copied_to_other_object::test(); + return 0; +} diff --git a/tests/std/basic/basic.types/basic.types.general/out/refcount/p2-pointer-to-data-member-bytes-round-trip.rs b/tests/std/basic/basic.types/basic.types.general/out/refcount/p2-pointer-to-data-member-bytes-round-trip.rs deleted file mode 100644 index 144425921b..0000000000 --- a/tests/std/basic/basic.types/basic.types.general/out/refcount/p2-pointer-to-data-member-bytes-round-trip.rs +++ /dev/null @@ -1,66 +0,0 @@ -extern crate libcc2rs; -use libcc2rs::*; -use std::cell::RefCell; -use std::collections::BTreeMap; -use std::io::prelude::*; -use std::io::{Read, Seek, Write}; -use std::os::fd::AsFd; -use std::rc::{Rc, Weak}; -#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] -#[byte_size(8)] -pub struct HasTwoInts { - #[offset(0)] - pub first: i32, - #[offset(4)] - pub second: i32, -} -pub fn main() { - __cpp2rust_init_globals(); - std::process::exit(main_0()); -} -fn main_0() -> i32 { - let pm: Value = Rc::new(RefCell::new( - (offset_of_field!(HasTwoInts, second) as isize), - )); - let bytes: Value> = - Rc::new(RefCell::new((0..8).map(|_| 0_u8).collect::>())); - match ({ (bytes.decay()).to_any() },) { - (mut __tmp_0,) => { - __tmp_0.memcpy(&(pm.as_pointer()).to_any(), ::std::mem::size_of::()); - (__tmp_0).clone() - } - }; - (*pm.borrow_mut()) = (offset_of_field!(HasTwoInts, first) as isize); - match ({ (pm.as_pointer()).to_any() },) { - (mut __tmp_1,) => { - __tmp_1.memcpy(&(bytes.decay()).to_any(), ::std::mem::size_of::()); - (__tmp_1).clone() - } - }; - assert!(({ ((*pm.borrow()) == (offset_of_field!(HasTwoInts, second) as isize)) })); - let obj: Value = Rc::new(RefCell::new(HasTwoInts { - first: 3, - second: 4, - })); - assert!(({ (((obj.as_pointer()).member::((*pm.borrow())).read()) == 4) })); - let null_pm: Value = Rc::new(RefCell::new(-1_isize)); - match ({ (bytes.decay()).to_any() },) { - (mut __tmp_2,) => { - __tmp_2.memcpy( - &(null_pm.as_pointer()).to_any(), - ::std::mem::size_of::(), - ); - (__tmp_2).clone() - } - }; - (*null_pm.borrow_mut()) = (offset_of_field!(HasTwoInts, first) as isize); - match ({ (null_pm.as_pointer()).to_any() },) { - (mut __tmp_3,) => { - __tmp_3.memcpy(&(bytes.decay()).to_any(), ::std::mem::size_of::()); - (__tmp_3).clone() - } - }; - assert!(({ ((*null_pm.borrow()) == -1_isize) })); - return 0; -} -pub fn __cpp2rust_init_globals() {} diff --git a/tests/std/basic/basic.types/basic.types.general/out/refcount/p3-pointer-to-data-member-bytes-copied-to-other-object.rs b/tests/std/basic/basic.types/basic.types.general/out/refcount/p3-pointer-to-data-member-bytes-copied-to-other-object.rs deleted file mode 100644 index 3c0bb02175..0000000000 --- a/tests/std/basic/basic.types/basic.types.general/out/refcount/p3-pointer-to-data-member-bytes-copied-to-other-object.rs +++ /dev/null @@ -1,62 +0,0 @@ -extern crate libcc2rs; -use libcc2rs::*; -use std::cell::RefCell; -use std::collections::BTreeMap; -use std::io::prelude::*; -use std::io::{Read, Seek, Write}; -use std::os::fd::AsFd; -use std::rc::{Rc, Weak}; -#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] -#[byte_size(8)] -pub struct HasTwoInts { - #[offset(0)] - pub first: i32, - #[offset(4)] - pub second: i32, -} -pub fn main() { - __cpp2rust_init_globals(); - std::process::exit(main_0()); -} -fn main_0() -> i32 { - let source: Value = Rc::new(RefCell::new( - (offset_of_field!(HasTwoInts, second) as isize), - )); - let destination: Value = - Rc::new(RefCell::new((offset_of_field!(HasTwoInts, first) as isize))); - match ({ (destination.as_pointer()).to_any() },) { - (mut __tmp_0,) => { - __tmp_0.memcpy( - &(source.as_pointer()).to_any(), - ::std::mem::size_of::(), - ); - (__tmp_0).clone() - } - }; - assert!(({ ((*destination.borrow()) == (*source.borrow())) })); - let obj: Value = Rc::new(RefCell::new(HasTwoInts { - first: 3, - second: 4, - })); - assert!( - ({ - (((obj.as_pointer()) - .member::((*destination.borrow())) - .read()) - == 4) - }) - ); - let null_source: Value = Rc::new(RefCell::new(-1_isize)); - match ({ (destination.as_pointer()).to_any() },) { - (mut __tmp_1,) => { - __tmp_1.memcpy( - &(null_source.as_pointer()).to_any(), - ::std::mem::size_of::(), - ); - (__tmp_1).clone() - } - }; - assert!(({ ((*destination.borrow()) == -1_isize) })); - return 0; -} -pub fn __cpp2rust_init_globals() {} diff --git a/tests/std/basic/basic.types/basic.types.general/out/unsafe/p2-pointer-to-data-member-bytes-round-trip.rs b/tests/std/basic/basic.types/basic.types.general/out/unsafe/p2-pointer-to-data-member-bytes-round-trip.rs deleted file mode 100644 index 9d628a91db..0000000000 --- a/tests/std/basic/basic.types/basic.types.general/out/unsafe/p2-pointer-to-data-member-bytes-round-trip.rs +++ /dev/null @@ -1,81 +0,0 @@ -extern crate libc; -use libc::*; -extern crate libcc2rs; -use libcc2rs::*; -use std::collections::BTreeMap; -use std::io::{Read, Seek, Write}; -use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; -use std::rc::Rc; -#[repr(C)] -#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] -pub struct HasTwoInts { - pub first: i32, - pub second: i32, -} -pub fn main() { - unsafe { - __cpp2rust_init_globals(); - std::process::exit(main_0() as i32); - } -} -unsafe fn main_0() -> i32 { - let mut pm: isize = (::std::mem::offset_of!(HasTwoInts, second) as isize); - let mut bytes: [u8; 8] = [0_u8; 8]; - match ({ (bytes.as_mut_ptr() as *mut ::libc::c_void) }, { - ((&mut pm as *mut isize) as *const ::libc::c_void) - }) { - (mut __tmp_0, mut __tmp_1) => { - if ::std::mem::size_of::() != 0 { - ::std::ptr::copy_nonoverlapping(__tmp_1, __tmp_0, ::std::mem::size_of::()) - } - __tmp_0 - } - }; - pm = (::std::mem::offset_of!(HasTwoInts, first) as isize); - match ({ ((&mut pm as *mut isize) as *mut ::libc::c_void) }, { - (bytes.as_mut_ptr() as *const ::libc::c_void) - }) { - (mut __tmp_2, mut __tmp_3) => { - if ::std::mem::size_of::() != 0 { - ::std::ptr::copy_nonoverlapping(__tmp_3, __tmp_2, ::std::mem::size_of::()) - } - __tmp_2 - } - }; - assert!(((pm) == (::std::mem::offset_of!(HasTwoInts, second) as isize))); - let mut obj: HasTwoInts = HasTwoInts { - first: 3, - second: 4, - }; - assert!( - ((*(&mut obj as *mut HasTwoInts) - .wrapping_byte_offset(pm) - .cast::()) - == (4)) - ); - let mut null_pm: isize = -1_isize; - match ({ (bytes.as_mut_ptr() as *mut ::libc::c_void) }, { - ((&mut null_pm as *mut isize) as *const ::libc::c_void) - }) { - (mut __tmp_4, mut __tmp_5) => { - if ::std::mem::size_of::() != 0 { - ::std::ptr::copy_nonoverlapping(__tmp_5, __tmp_4, ::std::mem::size_of::()) - } - __tmp_4 - } - }; - null_pm = (::std::mem::offset_of!(HasTwoInts, first) as isize); - match ({ ((&mut null_pm as *mut isize) as *mut ::libc::c_void) }, { - (bytes.as_mut_ptr() as *const ::libc::c_void) - }) { - (mut __tmp_6, mut __tmp_7) => { - if ::std::mem::size_of::() != 0 { - ::std::ptr::copy_nonoverlapping(__tmp_7, __tmp_6, ::std::mem::size_of::()) - } - __tmp_6 - } - }; - assert!(((null_pm) == -1_isize)); - return 0; -} -pub unsafe fn __cpp2rust_init_globals() {} diff --git a/tests/std/basic/basic.types/basic.types.general/out/unsafe/p3-pointer-to-data-member-bytes-copied-to-other-object.rs b/tests/std/basic/basic.types/basic.types.general/out/unsafe/p3-pointer-to-data-member-bytes-copied-to-other-object.rs deleted file mode 100644 index e88d4392be..0000000000 --- a/tests/std/basic/basic.types/basic.types.general/out/unsafe/p3-pointer-to-data-member-bytes-copied-to-other-object.rs +++ /dev/null @@ -1,61 +0,0 @@ -extern crate libc; -use libc::*; -extern crate libcc2rs; -use libcc2rs::*; -use std::collections::BTreeMap; -use std::io::{Read, Seek, Write}; -use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; -use std::rc::Rc; -#[repr(C)] -#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] -pub struct HasTwoInts { - pub first: i32, - pub second: i32, -} -pub fn main() { - unsafe { - __cpp2rust_init_globals(); - std::process::exit(main_0() as i32); - } -} -unsafe fn main_0() -> i32 { - let mut source: isize = (::std::mem::offset_of!(HasTwoInts, second) as isize); - let mut destination: isize = (::std::mem::offset_of!(HasTwoInts, first) as isize); - match ( - { ((&mut destination as *mut isize) as *mut ::libc::c_void) }, - { ((&mut source as *mut isize) as *const ::libc::c_void) }, - ) { - (mut __tmp_0, mut __tmp_1) => { - if ::std::mem::size_of::() != 0 { - ::std::ptr::copy_nonoverlapping(__tmp_1, __tmp_0, ::std::mem::size_of::()) - } - __tmp_0 - } - }; - assert!(((destination) == (source))); - let mut obj: HasTwoInts = HasTwoInts { - first: 3, - second: 4, - }; - assert!( - ((*(&mut obj as *mut HasTwoInts) - .wrapping_byte_offset(destination) - .cast::()) - == (4)) - ); - let mut null_source: isize = -1_isize; - match ( - { ((&mut destination as *mut isize) as *mut ::libc::c_void) }, - { ((&mut null_source as *mut isize) as *const ::libc::c_void) }, - ) { - (mut __tmp_2, mut __tmp_3) => { - if ::std::mem::size_of::() != 0 { - ::std::ptr::copy_nonoverlapping(__tmp_3, __tmp_2, ::std::mem::size_of::()) - } - __tmp_2 - } - }; - assert!(((destination) == -1_isize)); - return 0; -} -pub unsafe fn __cpp2rust_init_globals() {} diff --git a/tests/std/basic/basic.types/basic.types.general/p2-pointer-to-data-member-bytes-round-trip.cpp b/tests/std/basic/basic.types/basic.types.general/p2-pointer-to-data-member-bytes-round-trip.cpp deleted file mode 100644 index 4bf5c849ad..0000000000 --- a/tests/std/basic/basic.types/basic.types.general/p2-pointer-to-data-member-bytes-round-trip.cpp +++ /dev/null @@ -1,29 +0,0 @@ -// ADDITIONAL_COMPILE_FLAGS: -std=c++23 -// N4950 [basic.types.general]/2: the underlying bytes of an object of -// trivially copyable type can be copied into an array of unsigned char; if -// they are copied back, the object holds its original value. -#include -#include - -struct HasTwoInts { - int first; - int second; -}; - -int main() { - int HasTwoInts::*pm = &HasTwoInts::second; - unsigned char bytes[sizeof(pm)]; - std::memcpy(bytes, &pm, sizeof(pm)); - pm = &HasTwoInts::first; - std::memcpy(&pm, bytes, sizeof(pm)); - assert(pm == &HasTwoInts::second); - HasTwoInts obj{3, 4}; - assert(obj.*pm == 4); - - int HasTwoInts::*null_pm = nullptr; - std::memcpy(bytes, &null_pm, sizeof(null_pm)); - null_pm = &HasTwoInts::first; - std::memcpy(&null_pm, bytes, sizeof(null_pm)); - assert(null_pm == nullptr); - return 0; -} diff --git a/tests/std/basic/basic.types/basic.types.general/p2-pointer-to-member-function-bytes-round-trip.cpp b/tests/std/basic/basic.types/basic.types.general/p2-pointer-to-member-function-bytes-round-trip.cpp deleted file mode 100644 index 4ac7c9ae0a..0000000000 --- a/tests/std/basic/basic.types/basic.types.general/p2-pointer-to-member-function-bytes-round-trip.cpp +++ /dev/null @@ -1,34 +0,0 @@ -// translation-fail: refcount, unsafe -// ADDITIONAL_COMPILE_FLAGS: -std=c++23 -// N4950 [basic.types.general]/2: the underlying bytes of an object of -// trivially copyable type can be copied into an array of unsigned char; if -// they are copied back, the object holds its original value. -#include -#include - -struct HasTwoMemberFunctions { - int first_calls = 0; - int second_calls = 0; - void first() { ++first_calls; } - void second() { ++second_calls; } -}; - -int main() { - void (HasTwoMemberFunctions::*pmf)() = &HasTwoMemberFunctions::second; - unsigned char bytes[sizeof(pmf)]; - std::memcpy(bytes, &pmf, sizeof(pmf)); - pmf = &HasTwoMemberFunctions::first; - std::memcpy(&pmf, bytes, sizeof(pmf)); - assert(pmf == &HasTwoMemberFunctions::second); - HasTwoMemberFunctions obj; - (obj.*pmf)(); - assert(obj.first_calls == 0); - assert(obj.second_calls == 1); - - void (HasTwoMemberFunctions::*null_pmf)() = nullptr; - std::memcpy(bytes, &null_pmf, sizeof(null_pmf)); - null_pmf = &HasTwoMemberFunctions::first; - std::memcpy(&null_pmf, bytes, sizeof(null_pmf)); - assert(null_pmf == nullptr); - return 0; -} diff --git a/tests/std/basic/basic.types/basic.types.general/p2-pointer-to-virtual-member-function-bytes-round-trip.cpp b/tests/std/basic/basic.types/basic.types.general/p2-pointer-to-virtual-member-function-bytes-round-trip.cpp deleted file mode 100644 index 56c4cfce3f..0000000000 --- a/tests/std/basic/basic.types/basic.types.general/p2-pointer-to-virtual-member-function-bytes-round-trip.cpp +++ /dev/null @@ -1,33 +0,0 @@ -// translation-fail: refcount, unsafe -// ADDITIONAL_COMPILE_FLAGS: -std=c++23 -// N4950 [basic.types.general]/2: the underlying bytes of an object of -// trivially copyable type can be copied into an array of unsigned char; if -// they are copied back, the object holds its original value. -#include -#include - -static int base_calls; -static int override_calls; - -struct DeclaresVirtual { - virtual void run() { ++base_calls; } - void other() {} -}; - -struct OverridesVirtual : DeclaresVirtual { - void run() override { ++override_calls; } -}; - -int main() { - void (DeclaresVirtual::*pmf)() = &DeclaresVirtual::run; - unsigned char bytes[sizeof(pmf)]; - std::memcpy(bytes, &pmf, sizeof(pmf)); - pmf = &DeclaresVirtual::other; - std::memcpy(&pmf, bytes, sizeof(pmf)); - OverridesVirtual overrider; - DeclaresVirtual &ref = overrider; - (ref.*pmf)(); - assert(base_calls == 0); - assert(override_calls == 1); - return 0; -} diff --git a/tests/std/basic/basic.types/basic.types.general/p3-class-holding-pointers-to-members-bytes-copied.cpp b/tests/std/basic/basic.types/basic.types.general/p3-class-holding-pointers-to-members-bytes-copied.cpp deleted file mode 100644 index 9eacb358bb..0000000000 --- a/tests/std/basic/basic.types/basic.types.general/p3-class-holding-pointers-to-members-bytes-copied.cpp +++ /dev/null @@ -1,31 +0,0 @@ -// translation-fail: refcount, unsafe -// ADDITIONAL_COMPILE_FLAGS: -std=c++23 -// N4950 [basic.types.general]/3: if the underlying bytes of obj1 of trivially -// copyable type are copied into obj2, obj2 holds the same value as obj1. -#include -#include - -struct HasValueAndIncrement { - int padding; - int value; - void increment() { ++value; } -}; - -struct HoldsPointersToMembers { - int HasValueAndIncrement::*data; - void (HasValueAndIncrement::*function)(); -}; - -int main() { - HoldsPointersToMembers source{&HasValueAndIncrement::value, - &HasValueAndIncrement::increment}; - HoldsPointersToMembers destination{nullptr, nullptr}; - std::memcpy(&destination, &source, sizeof(source)); - assert(destination.data == &HasValueAndIncrement::value); - assert(destination.function == &HasValueAndIncrement::increment); - HasValueAndIncrement obj{1, 2}; - (obj.*destination.function)(); - assert(obj.*destination.data == 3); - assert(obj.padding == 1); - return 0; -} diff --git a/tests/std/basic/basic.types/basic.types.general/p3-pointer-to-data-member-bytes-copied-to-other-object.cpp b/tests/std/basic/basic.types/basic.types.general/p3-pointer-to-data-member-bytes-copied-to-other-object.cpp deleted file mode 100644 index 4053e89f44..0000000000 --- a/tests/std/basic/basic.types/basic.types.general/p3-pointer-to-data-member-bytes-copied-to-other-object.cpp +++ /dev/null @@ -1,24 +0,0 @@ -// ADDITIONAL_COMPILE_FLAGS: -std=c++23 -// N4950 [basic.types.general]/3: if the underlying bytes of obj1 of trivially -// copyable type are copied into obj2, obj2 holds the same value as obj1. -#include -#include - -struct HasTwoInts { - int first; - int second; -}; - -int main() { - int HasTwoInts::*source = &HasTwoInts::second; - int HasTwoInts::*destination = &HasTwoInts::first; - std::memcpy(&destination, &source, sizeof(source)); - assert(destination == source); - HasTwoInts obj{3, 4}; - assert(obj.*destination == 4); - - int HasTwoInts::*null_source = nullptr; - std::memcpy(&destination, &null_source, sizeof(null_source)); - assert(destination == nullptr); - return 0; -} diff --git a/tests/std/basic/basic.types/basic.types.general/p3-pointer-to-member-function-bytes-copied-to-other-object.cpp b/tests/std/basic/basic.types/basic.types.general/p3-pointer-to-member-function-bytes-copied-to-other-object.cpp deleted file mode 100644 index 3a87d53028..0000000000 --- a/tests/std/basic/basic.types/basic.types.general/p3-pointer-to-member-function-bytes-copied-to-other-object.cpp +++ /dev/null @@ -1,29 +0,0 @@ -// translation-fail: refcount, unsafe -// ADDITIONAL_COMPILE_FLAGS: -std=c++23 -// N4950 [basic.types.general]/3: if the underlying bytes of obj1 of trivially -// copyable type are copied into obj2, obj2 holds the same value as obj1. -#include -#include - -struct HasTwoMemberFunctions { - int first_calls = 0; - int second_calls = 0; - void first() { ++first_calls; } - void second() { ++second_calls; } -}; - -int main() { - void (HasTwoMemberFunctions::*source)() = &HasTwoMemberFunctions::second; - void (HasTwoMemberFunctions::*destination)() = &HasTwoMemberFunctions::first; - std::memcpy(&destination, &source, sizeof(source)); - assert(destination == source); - HasTwoMemberFunctions obj; - (obj.*destination)(); - assert(obj.first_calls == 0); - assert(obj.second_calls == 1); - - void (HasTwoMemberFunctions::*null_source)() = nullptr; - std::memcpy(&destination, &null_source, sizeof(null_source)); - assert(destination == nullptr); - return 0; -} diff --git a/tests/std/basic/basic.types/out/refcount/basic.types.general.rs b/tests/std/basic/basic.types/out/refcount/basic.types.general.rs new file mode 100644 index 0000000000..485e7f73e8 --- /dev/null +++ b/tests/std/basic/basic.types/out/refcount/basic.types.general.rs @@ -0,0 +1,143 @@ +extern crate libcc2rs; +use libcc2rs::*; +use std::cell::RefCell; +use std::collections::BTreeMap; +use std::io::prelude::*; +use std::io::{Read, Seek, Write}; +use std::os::fd::AsFd; +use std::rc::{Rc, Weak}; +#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] +#[byte_size(8)] +pub struct p2_pointer_to_data_member_bytes_round_trip_HasTwoInts { + #[offset(0)] + pub first: i32, + #[offset(4)] + pub second: i32, +} +pub fn test_0() { + let pm: Value = Rc::new(RefCell::new( + (offset_of_field!( + p2_pointer_to_data_member_bytes_round_trip_HasTwoInts, + second + ) as isize), + )); + let bytes: Value> = + Rc::new(RefCell::new((0..8).map(|_| 0_u8).collect::>())); + match ({ (bytes.decay()).to_any() },) { + (mut __tmp_0,) => { + __tmp_0.memcpy(&(pm.as_pointer()).to_any(), ::std::mem::size_of::()); + (__tmp_0).clone() + } + }; + (*pm.borrow_mut()) = + (offset_of_field!(p2_pointer_to_data_member_bytes_round_trip_HasTwoInts, first) as isize); + match ({ (pm.as_pointer()).to_any() },) { + (mut __tmp_1,) => { + __tmp_1.memcpy(&(bytes.decay()).to_any(), ::std::mem::size_of::()); + (__tmp_1).clone() + } + }; + assert!( + ({ + ((*pm.borrow()) + == (offset_of_field!( + p2_pointer_to_data_member_bytes_round_trip_HasTwoInts, + second + ) as isize)) + }) + ); + let obj: Value = Rc::new(RefCell::new( + p2_pointer_to_data_member_bytes_round_trip_HasTwoInts { + first: 3, + second: 4, + }, + )); + assert!(({ (((obj.as_pointer()).member::((*pm.borrow())).read()) == 4) })); + let null_pm: Value = Rc::new(RefCell::new(-1_isize)); + match ({ (bytes.decay()).to_any() },) { + (mut __tmp_2,) => { + __tmp_2.memcpy( + &(null_pm.as_pointer()).to_any(), + ::std::mem::size_of::(), + ); + (__tmp_2).clone() + } + }; + (*null_pm.borrow_mut()) = + (offset_of_field!(p2_pointer_to_data_member_bytes_round_trip_HasTwoInts, first) as isize); + match ({ (null_pm.as_pointer()).to_any() },) { + (mut __tmp_3,) => { + __tmp_3.memcpy(&(bytes.decay()).to_any(), ::std::mem::size_of::()); + (__tmp_3).clone() + } + }; + assert!(({ ((*null_pm.borrow()) == -1_isize) })); +} +#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] +#[byte_size(8)] +pub struct p3_pointer_to_data_member_bytes_copied_to_other_object_HasTwoInts { + #[offset(0)] + pub first: i32, + #[offset(4)] + pub second: i32, +} +pub fn test_1() { + let source: Value = Rc::new(RefCell::new( + (offset_of_field!( + p3_pointer_to_data_member_bytes_copied_to_other_object_HasTwoInts, + second + ) as isize), + )); + let destination: Value = Rc::new(RefCell::new( + (offset_of_field!( + p3_pointer_to_data_member_bytes_copied_to_other_object_HasTwoInts, + first + ) as isize), + )); + match ({ (destination.as_pointer()).to_any() },) { + (mut __tmp_4,) => { + __tmp_4.memcpy( + &(source.as_pointer()).to_any(), + ::std::mem::size_of::(), + ); + (__tmp_4).clone() + } + }; + assert!(({ ((*destination.borrow()) == (*source.borrow())) })); + let obj: Value = + Rc::new(RefCell::new( + p3_pointer_to_data_member_bytes_copied_to_other_object_HasTwoInts { + first: 3, + second: 4, + }, + )); + assert!( + ({ + (((obj.as_pointer()) + .member::((*destination.borrow())) + .read()) + == 4) + }) + ); + let null_source: Value = Rc::new(RefCell::new(-1_isize)); + match ({ (destination.as_pointer()).to_any() },) { + (mut __tmp_5,) => { + __tmp_5.memcpy( + &(null_source.as_pointer()).to_any(), + ::std::mem::size_of::(), + ); + (__tmp_5).clone() + } + }; + assert!(({ ((*destination.borrow()) == -1_isize) })); +} +pub fn main() { + __cpp2rust_init_globals(); + std::process::exit(main_0()); +} +fn main_0() -> i32 { + ({ test_0() }); + ({ test_1() }); + return 0; +} +pub fn __cpp2rust_init_globals() {} diff --git a/tests/std/basic/basic.types/out/unsafe/basic.types.general.rs b/tests/std/basic/basic.types/out/unsafe/basic.types.general.rs new file mode 100644 index 0000000000..8c0537fa1e --- /dev/null +++ b/tests/std/basic/basic.types/out/unsafe/basic.types.general.rs @@ -0,0 +1,149 @@ +extern crate libc; +use libc::*; +extern crate libcc2rs; +use libcc2rs::*; +use std::collections::BTreeMap; +use std::io::{Read, Seek, Write}; +use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; +use std::rc::Rc; +#[repr(C)] +#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] +pub struct p2_pointer_to_data_member_bytes_round_trip_HasTwoInts { + pub first: i32, + pub second: i32, +} +pub unsafe fn test_0() { + let mut pm: isize = (::std::mem::offset_of!( + p2_pointer_to_data_member_bytes_round_trip_HasTwoInts, + second + ) as isize); + let mut bytes: [u8; 8] = [0_u8; 8]; + match ({ (bytes.as_mut_ptr() as *mut ::libc::c_void) }, { + ((&mut pm as *mut isize) as *const ::libc::c_void) + }) { + (mut __tmp_0, mut __tmp_1) => { + if ::std::mem::size_of::() != 0 { + ::std::ptr::copy_nonoverlapping(__tmp_1, __tmp_0, ::std::mem::size_of::()) + } + __tmp_0 + } + }; + pm = (::std::mem::offset_of!(p2_pointer_to_data_member_bytes_round_trip_HasTwoInts, first) + as isize); + match ({ ((&mut pm as *mut isize) as *mut ::libc::c_void) }, { + (bytes.as_mut_ptr() as *const ::libc::c_void) + }) { + (mut __tmp_2, mut __tmp_3) => { + if ::std::mem::size_of::() != 0 { + ::std::ptr::copy_nonoverlapping(__tmp_3, __tmp_2, ::std::mem::size_of::()) + } + __tmp_2 + } + }; + assert!( + ((pm) + == (::std::mem::offset_of!( + p2_pointer_to_data_member_bytes_round_trip_HasTwoInts, + second + ) as isize)) + ); + let mut obj: p2_pointer_to_data_member_bytes_round_trip_HasTwoInts = + p2_pointer_to_data_member_bytes_round_trip_HasTwoInts { + first: 3, + second: 4, + }; + assert!( + ((*(&mut obj as *mut p2_pointer_to_data_member_bytes_round_trip_HasTwoInts) + .wrapping_byte_offset(pm) + .cast::()) + == (4)) + ); + let mut null_pm: isize = -1_isize; + match ({ (bytes.as_mut_ptr() as *mut ::libc::c_void) }, { + ((&mut null_pm as *mut isize) as *const ::libc::c_void) + }) { + (mut __tmp_4, mut __tmp_5) => { + if ::std::mem::size_of::() != 0 { + ::std::ptr::copy_nonoverlapping(__tmp_5, __tmp_4, ::std::mem::size_of::()) + } + __tmp_4 + } + }; + null_pm = (::std::mem::offset_of!(p2_pointer_to_data_member_bytes_round_trip_HasTwoInts, first) + as isize); + match ({ ((&mut null_pm as *mut isize) as *mut ::libc::c_void) }, { + (bytes.as_mut_ptr() as *const ::libc::c_void) + }) { + (mut __tmp_6, mut __tmp_7) => { + if ::std::mem::size_of::() != 0 { + ::std::ptr::copy_nonoverlapping(__tmp_7, __tmp_6, ::std::mem::size_of::()) + } + __tmp_6 + } + }; + assert!(((null_pm) == -1_isize)); +} +#[repr(C)] +#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] +pub struct p3_pointer_to_data_member_bytes_copied_to_other_object_HasTwoInts { + pub first: i32, + pub second: i32, +} +pub unsafe fn test_1() { + let mut source: isize = (::std::mem::offset_of!( + p3_pointer_to_data_member_bytes_copied_to_other_object_HasTwoInts, + second + ) as isize); + let mut destination: isize = (::std::mem::offset_of!( + p3_pointer_to_data_member_bytes_copied_to_other_object_HasTwoInts, + first + ) as isize); + match ( + { ((&mut destination as *mut isize) as *mut ::libc::c_void) }, + { ((&mut source as *mut isize) as *const ::libc::c_void) }, + ) { + (mut __tmp_8, mut __tmp_9) => { + if ::std::mem::size_of::() != 0 { + ::std::ptr::copy_nonoverlapping(__tmp_9, __tmp_8, ::std::mem::size_of::()) + } + __tmp_8 + } + }; + assert!(((destination) == (source))); + let mut obj: p3_pointer_to_data_member_bytes_copied_to_other_object_HasTwoInts = + p3_pointer_to_data_member_bytes_copied_to_other_object_HasTwoInts { + first: 3, + second: 4, + }; + assert!( + ((*(&mut obj as *mut p3_pointer_to_data_member_bytes_copied_to_other_object_HasTwoInts) + .wrapping_byte_offset(destination) + .cast::()) + == (4)) + ); + let mut null_source: isize = -1_isize; + match ( + { ((&mut destination as *mut isize) as *mut ::libc::c_void) }, + { ((&mut null_source as *mut isize) as *const ::libc::c_void) }, + ) { + (mut __tmp_10, mut __tmp_11) => { + if ::std::mem::size_of::() != 0 { + ::std::ptr::copy_nonoverlapping(__tmp_11, __tmp_10, ::std::mem::size_of::()) + } + __tmp_10 + } + }; + assert!(((destination) == -1_isize)); +} +pub fn main() { + unsafe { + __cpp2rust_init_globals(); + std::process::exit(main_0() as i32); + } +} +unsafe fn main_0() -> i32 { + (unsafe { test_0() }); + (unsafe { test_1() }); + return 0; +} +pub unsafe fn __cpp2rust_init_globals() {} diff --git a/tests/std/dcl.dcl/dcl.decl/dcl.init/dcl.init.general/p6.1-zero-initialized-pointer-to-member.cpp b/tests/std/dcl.dcl/dcl.decl/dcl.init/dcl.init.general.cpp similarity index 80% rename from tests/std/dcl.dcl/dcl.decl/dcl.init/dcl.init.general/p6.1-zero-initialized-pointer-to-member.cpp rename to tests/std/dcl.dcl/dcl.decl/dcl.init/dcl.init.general.cpp index 60ab37f3b2..ff328142c6 100644 --- a/tests/std/dcl.dcl/dcl.decl/dcl.init/dcl.init.general/p6.1-zero-initialized-pointer-to-member.cpp +++ b/tests/std/dcl.dcl/dcl.decl/dcl.init/dcl.init.general.cpp @@ -1,9 +1,10 @@ // ADDITIONAL_COMPILE_FLAGS: -std=c++23 +#include + // N4950 [dcl.init.general]/6.1: zero-initializing a scalar converts the // integer literal 0 to its type; for a pointer to member that is the null // member pointer value. -#include - +namespace p6_1_zero_initialized_pointer_to_member { struct HasTwoInts { int first; int second; @@ -15,7 +16,7 @@ struct HoldsSelector { static int HasTwoInts::*static_pm; -int main() { +void test() { assert(static_pm == nullptr); assert(static_pm != &HasTwoInts::first); int HasTwoInts::*value_initialized{}; @@ -24,5 +25,10 @@ int main() { HoldsSelector holder{}; assert(holder.selector == nullptr); assert(holder.selector != &HasTwoInts::first); +} +} // namespace p6_1_zero_initialized_pointer_to_member + +int main() { + p6_1_zero_initialized_pointer_to_member::test(); return 0; } diff --git a/tests/std/dcl.dcl/dcl.decl/dcl.init/dcl.init.general/out/refcount/p6.1-zero-initialized-pointer-to-member.rs b/tests/std/dcl.dcl/dcl.decl/dcl.init/out/refcount/dcl.init.general.rs similarity index 51% rename from tests/std/dcl.dcl/dcl.decl/dcl.init/dcl.init.general/out/refcount/p6.1-zero-initialized-pointer-to-member.rs rename to tests/std/dcl.dcl/dcl.decl/dcl.init/out/refcount/dcl.init.general.rs index 03c70f2106..fe8062d4e0 100644 --- a/tests/std/dcl.dcl/dcl.decl/dcl.init/dcl.init.general/out/refcount/p6.1-zero-initialized-pointer-to-member.rs +++ b/tests/std/dcl.dcl/dcl.decl/dcl.init/out/refcount/dcl.init.general.rs @@ -8,7 +8,7 @@ use std::os::fd::AsFd; use std::rc::{Rc, Weak}; #[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] #[byte_size(8)] -pub struct HasTwoInts { +pub struct p6_1_zero_initialized_pointer_to_member_HasTwoInts { #[offset(0)] pub first: i32, #[offset(4)] @@ -16,34 +16,48 @@ pub struct HasTwoInts { } #[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg)] #[byte_size(8)] -pub struct HoldsSelector { +pub struct p6_1_zero_initialized_pointer_to_member_HoldsSelector { #[offset(0)] #[byte_size(8)] pub selector: isize, } -impl Default for HoldsSelector { +impl Default for p6_1_zero_initialized_pointer_to_member_HoldsSelector { fn default() -> Self { - { HoldsSelector { selector: -1_isize } } + { p6_1_zero_initialized_pointer_to_member_HoldsSelector { selector: -1_isize } } } } thread_local!( pub static static_pm_0: Value = Rc::new(RefCell::new(-1_isize)); ); -pub fn main() { - __cpp2rust_init_globals(); - std::process::exit(main_0()); -} -fn main_0() -> i32 { +pub fn test_1() { assert!(((static_pm_0.with(|rc| *rc.borrow())) == -1_isize)); assert!( - (static_pm_0.with(|rc| *rc.borrow()) != (offset_of_field!(HasTwoInts, first) as isize)) + (static_pm_0.with(|rc| *rc.borrow()) + != (offset_of_field!(p6_1_zero_initialized_pointer_to_member_HasTwoInts, first) + as isize)) ); let mut value_initialized: isize = -1_isize; assert!(((value_initialized) == -1_isize)); - assert!((value_initialized != (offset_of_field!(HasTwoInts, first) as isize))); - let mut holder: HoldsSelector = ::default(); + assert!( + (value_initialized + != (offset_of_field!(p6_1_zero_initialized_pointer_to_member_HasTwoInts, first) + as isize)) + ); + let mut holder: p6_1_zero_initialized_pointer_to_member_HoldsSelector = + ::default(); assert!(((holder.selector) == -1_isize)); - assert!((holder.selector != (offset_of_field!(HasTwoInts, first) as isize))); + assert!( + (holder.selector + != (offset_of_field!(p6_1_zero_initialized_pointer_to_member_HasTwoInts, first) + as isize)) + ); +} +pub fn main() { + __cpp2rust_init_globals(); + std::process::exit(main_0()); +} +fn main_0() -> i32 { + ({ test_1() }); return 0; } pub fn __cpp2rust_init_globals() { diff --git a/tests/std/dcl.dcl/dcl.decl/dcl.init/dcl.init.general/out/unsafe/p6.1-zero-initialized-pointer-to-member.rs b/tests/std/dcl.dcl/dcl.decl/dcl.init/out/unsafe/dcl.init.general.rs similarity index 53% rename from tests/std/dcl.dcl/dcl.decl/dcl.init/dcl.init.general/out/unsafe/p6.1-zero-initialized-pointer-to-member.rs rename to tests/std/dcl.dcl/dcl.decl/dcl.init/out/unsafe/dcl.init.general.rs index a5d3ec9033..b8b369db6c 100644 --- a/tests/std/dcl.dcl/dcl.decl/dcl.init/dcl.init.general/out/unsafe/p6.1-zero-initialized-pointer-to-member.rs +++ b/tests/std/dcl.dcl/dcl.decl/dcl.init/out/unsafe/dcl.init.general.rs @@ -8,40 +8,53 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; use std::rc::Rc; #[repr(C)] #[derive(Copy, Clone, VaArg, FnPtrArg, Default)] -pub struct HasTwoInts { +pub struct p6_1_zero_initialized_pointer_to_member_HasTwoInts { pub first: i32, pub second: i32, } #[repr(C)] #[derive(Copy, Clone, VaArg, FnPtrArg)] -pub struct HoldsSelector { +pub struct p6_1_zero_initialized_pointer_to_member_HoldsSelector { pub selector: isize, } -impl Default for HoldsSelector { +impl Default for p6_1_zero_initialized_pointer_to_member_HoldsSelector { fn default() -> Self { - unsafe { HoldsSelector { selector: -1_isize } } + unsafe { p6_1_zero_initialized_pointer_to_member_HoldsSelector { selector: -1_isize } } } } pub static mut static_pm_0: std::cell::LazyCell = std::cell::LazyCell::new(|| unsafe { -1_isize }); -pub fn main() { - unsafe { - __cpp2rust_init_globals(); - std::process::exit(main_0() as i32); - } -} -unsafe fn main_0() -> i32 { +pub unsafe fn test_1() { assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut static_pm_0)) == -1_isize)); assert!( ((*std::cell::LazyCell::force_mut(&mut *&raw mut static_pm_0)) - != (::std::mem::offset_of!(HasTwoInts, first) as isize)) + != (::std::mem::offset_of!(p6_1_zero_initialized_pointer_to_member_HasTwoInts, first) + as isize)) ); let mut value_initialized: isize = -1_isize; assert!(((value_initialized) == -1_isize)); - assert!(((value_initialized) != (::std::mem::offset_of!(HasTwoInts, first) as isize))); - let mut holder: HoldsSelector = ::default(); + assert!( + ((value_initialized) + != (::std::mem::offset_of!(p6_1_zero_initialized_pointer_to_member_HasTwoInts, first) + as isize)) + ); + let mut holder: p6_1_zero_initialized_pointer_to_member_HoldsSelector = + ::default(); assert!(((holder.selector) == -1_isize)); - assert!(((holder.selector) != (::std::mem::offset_of!(HasTwoInts, first) as isize))); + assert!( + ((holder.selector) + != (::std::mem::offset_of!(p6_1_zero_initialized_pointer_to_member_HasTwoInts, first) + as isize)) + ); +} +pub fn main() { + unsafe { + __cpp2rust_init_globals(); + std::process::exit(main_0() as i32); + } +} +unsafe fn main_0() -> i32 { + (unsafe { test_1() }); return 0; } pub unsafe fn __cpp2rust_init_globals() { diff --git a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.array/p6-array-of-pointers-to-member-functions.cpp b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.array-unsupported.cpp similarity index 86% rename from tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.array/p6-array-of-pointers-to-member-functions.cpp rename to tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.array-unsupported.cpp index 8482e262c8..f61beafc94 100644 --- a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.array/p6-array-of-pointers-to-member-functions.cpp +++ b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.array-unsupported.cpp @@ -1,9 +1,10 @@ // translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 -// N4950 [dcl.array]/6: an object of type "array of N U" consists of a -// contiguously allocated set of N subobjects of type U, numbered 0 to N-1. #include +// N4950 [dcl.array]/6: an object of type "array of N U" consists of a +// contiguously allocated set of N subobjects of type U, numbered 0 to N-1. +namespace p6_array_of_pointers_to_member_functions { struct HasThreeMemberFunctions { int first_calls = 0; int second_calls = 0; @@ -13,7 +14,7 @@ struct HasThreeMemberFunctions { void third() { ++third_calls; } }; -int main() { +void test() { void (HasThreeMemberFunctions::*functions[3])() = { &HasThreeMemberFunctions::third, &HasThreeMemberFunctions::first, &HasThreeMemberFunctions::second}; @@ -33,5 +34,10 @@ int main() { assert(obj.first_calls == 1); assert(obj.second_calls == 1); assert(obj.third_calls == 1); +} +} // namespace p6_array_of_pointers_to_member_functions + +int main() { + p6_array_of_pointers_to_member_functions::test(); return 0; } diff --git a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.array/p6-array-of-pointers-to-data-members.cpp b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.array.cpp similarity index 83% rename from tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.array/p6-array-of-pointers-to-data-members.cpp rename to tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.array.cpp index b6c973166d..35e53f7b2b 100644 --- a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.array/p6-array-of-pointers-to-data-members.cpp +++ b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.array.cpp @@ -1,15 +1,16 @@ // ADDITIONAL_COMPILE_FLAGS: -std=c++23 -// N4950 [dcl.array]/6: an object of type "array of N U" consists of a -// contiguously allocated set of N subobjects of type U, numbered 0 to N-1. #include +// N4950 [dcl.array]/6: an object of type "array of N U" consists of a +// contiguously allocated set of N subobjects of type U, numbered 0 to N-1. +namespace p6_array_of_pointers_to_data_members { struct HasThreeInts { int first; int second; int third; }; -int main() { +void test() { int HasThreeInts::*members[3] = {&HasThreeInts::third, &HasThreeInts::first, &HasThreeInts::second}; HasThreeInts obj{4, 5, 6}; @@ -25,5 +26,10 @@ int main() { assert(obj.**element == 5); members[2] = &HasThreeInts::third; assert(obj.**element == 6); +} +} // namespace p6_array_of_pointers_to_data_members + +int main() { + p6_array_of_pointers_to_data_members::test(); return 0; } diff --git a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/p2-pointer-to-member-function.cpp b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr-unsupported.cpp similarity index 83% rename from tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/p2-pointer-to-member-function.cpp rename to tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr-unsupported.cpp index 269b7512f4..6d6a77fc8f 100644 --- a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/p2-pointer-to-member-function.cpp +++ b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr-unsupported.cpp @@ -1,9 +1,10 @@ // translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 -// N4950 [dcl.mptr]/2: "T (C::*)(parameters)" declares a pointer to member of -// class C of function type. #include +// N4950 [dcl.mptr]/2: "T (C::*)(parameters)" declares a pointer to member of +// class C of function type. +namespace p2_pointer_to_member_function { struct HasTwoMemberFunctions { int first_total = 0; int second_total = 0; @@ -11,7 +12,7 @@ struct HasTwoMemberFunctions { void second(int amount) { second_total += amount; } }; -int main() { +void test() { void (HasTwoMemberFunctions::*pmf)(int) = &HasTwoMemberFunctions::first; HasTwoMemberFunctions obj; (obj.*pmf)(3); @@ -21,5 +22,10 @@ int main() { (obj.*pmf)(4); assert(obj.first_total == 3); assert(obj.second_total == 4); +} +} // namespace p2_pointer_to_member_function + +int main() { + p2_pointer_to_member_function::test(); return 0; } diff --git a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr.cpp b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr.cpp new file mode 100644 index 0000000000..1522e49e02 --- /dev/null +++ b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr.cpp @@ -0,0 +1,94 @@ +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +#include + +// N4950 [dcl.mptr]/2: the type is "derived-declarator-type-list pointer to +// member of class C of type T"; T can be an array type. +namespace p2_pointer_to_array_member { +struct HasIntArray { + int before; + int elements[3]; +}; + +void test() { + int (HasIntArray::*pm)[3] = &HasIntArray::elements; + HasIntArray obj{1, {2, 3, 4}}; + assert((obj.*pm)[0] == 2); + assert((obj.*pm)[2] == 4); + (obj.*pm)[1] = 7; + assert(obj.elements[1] == 7); + assert(obj.before == 1); +} +} // namespace p2_pointer_to_array_member + +// N4950 [dcl.mptr]/2: "T C::*" declares a pointer to member of class C of +// type T. +namespace p2_pointer_to_data_member { +struct HasTwoInts { + int first; + int second; +}; + +void test() { + int HasTwoInts::*pm = &HasTwoInts::first; + HasTwoInts obj{3, 4}; + assert(obj.*pm == 3); + obj.*pm = 5; + assert(obj.first == 5); + assert(obj.second == 4); + pm = &HasTwoInts::second; + assert(obj.*pm == 4); + obj.*pm = 6; + assert(obj.first == 5); + assert(obj.second == 6); +} +} // namespace p2_pointer_to_data_member + +// N4950 [dcl.mptr]/2: the nested-name-specifier denotes a class; the class +// need not be complete. +namespace p2_pointer_to_member_of_incomplete_class { +struct CompletedLater; + +static int CompletedLater::*pm = nullptr; + +struct CompletedLater { + int first; + int second; +}; + +void test() { + assert(pm == nullptr); + pm = &CompletedLater::second; + CompletedLater obj{3, 4}; + assert(obj.*pm == 4); +} +} // namespace p2_pointer_to_member_of_incomplete_class + +// N4950 [dcl.mptr]/2: the type is "derived-declarator-type-list pointer to +// member of class C of type T"; T can itself be a pointer-to-member type. +namespace p2_pointer_to_member_of_pointer_to_member_type { +struct HasTwoInts { + int first; + int second; +}; + +struct HoldsSelector { + int HasTwoInts::*selector; +}; + +void test() { + int HasTwoInts::*HoldsSelector::*pm = &HoldsSelector::selector; + HoldsSelector holder{&HasTwoInts::second}; + HasTwoInts obj{3, 4}; + assert(obj.*(holder.*pm) == 4); + holder.*pm = &HasTwoInts::first; + assert(obj.*(holder.selector) == 3); +} +} // namespace p2_pointer_to_member_of_pointer_to_member_type + +int main() { + p2_pointer_to_array_member::test(); + p2_pointer_to_data_member::test(); + p2_pointer_to_member_of_incomplete_class::test(); + p2_pointer_to_member_of_pointer_to_member_type::test(); + return 0; +} diff --git a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/refcount/p2-pointer-to-array-member.rs b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/refcount/p2-pointer-to-array-member.rs deleted file mode 100644 index b607988c25..0000000000 --- a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/refcount/p2-pointer-to-array-member.rs +++ /dev/null @@ -1,45 +0,0 @@ -extern crate libcc2rs; -use libcc2rs::*; -use std::cell::RefCell; -use std::collections::BTreeMap; -use std::io::prelude::*; -use std::io::{Read, Seek, Write}; -use std::os::fd::AsFd; -use std::rc::{Rc, Weak}; -#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg)] -#[byte_size(16)] -pub struct HasIntArray { - #[offset(0)] - pub before: i32, - #[offset(4)] - #[byte_size(12)] - pub elements: Box<[i32]>, -} -impl Default for HasIntArray { - fn default() -> Self { - { - HasIntArray { - before: 0_i32, - elements: (0..3).map(|_| 0_i32).collect::>(), - } - } - } -} -pub fn main() { - __cpp2rust_init_globals(); - std::process::exit(main_0()); -} -fn main_0() -> i32 { - let mut pm: isize = (offset_of_field!(HasIntArray, elements) as isize); - let obj: Value = Rc::new(RefCell::new(HasIntArray { - before: 1, - elements: Box::new([2, 3, 4]), - })); - assert!((((obj.as_pointer()).member::>(pm).read())[(0) as usize] == 2)); - assert!((((obj.as_pointer()).member::>(pm).read())[(2) as usize] == 4)); - index!((obj.as_pointer()).member::>(pm), 1).write(7); - assert!(((array_elem!(obj.as_pointer(), elements, 1).read()) == 7)); - assert!(({ ({ (*obj.borrow()).before } == 1) })); - return 0; -} -pub fn __cpp2rust_init_globals() {} diff --git a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/refcount/p2-pointer-to-data-member.rs b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/refcount/p2-pointer-to-data-member.rs deleted file mode 100644 index 6fcd39ade3..0000000000 --- a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/refcount/p2-pointer-to-data-member.rs +++ /dev/null @@ -1,38 +0,0 @@ -extern crate libcc2rs; -use libcc2rs::*; -use std::cell::RefCell; -use std::collections::BTreeMap; -use std::io::prelude::*; -use std::io::{Read, Seek, Write}; -use std::os::fd::AsFd; -use std::rc::{Rc, Weak}; -#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] -#[byte_size(8)] -pub struct HasTwoInts { - #[offset(0)] - pub first: i32, - #[offset(4)] - pub second: i32, -} -pub fn main() { - __cpp2rust_init_globals(); - std::process::exit(main_0()); -} -fn main_0() -> i32 { - let mut pm: isize = (offset_of_field!(HasTwoInts, first) as isize); - let obj: Value = Rc::new(RefCell::new(HasTwoInts { - first: 3, - second: 4, - })); - assert!((((obj.as_pointer()).member::(pm).read()) == 3)); - (obj.as_pointer()).member::(pm).write(5); - assert!(({ ({ (*obj.borrow()).first } == 5) })); - assert!(({ ({ (*obj.borrow()).second } == 4) })); - pm = (offset_of_field!(HasTwoInts, second) as isize); - assert!((((obj.as_pointer()).member::(pm).read()) == 4)); - (obj.as_pointer()).member::(pm).write(6); - assert!(({ ({ (*obj.borrow()).first } == 5) })); - assert!(({ ({ (*obj.borrow()).second } == 6) })); - return 0; -} -pub fn __cpp2rust_init_globals() {} diff --git a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/refcount/p2-pointer-to-member-of-incomplete-class.rs b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/refcount/p2-pointer-to-member-of-incomplete-class.rs deleted file mode 100644 index 415d653106..0000000000 --- a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/refcount/p2-pointer-to-member-of-incomplete-class.rs +++ /dev/null @@ -1,41 +0,0 @@ -extern crate libcc2rs; -use libcc2rs::*; -use std::cell::RefCell; -use std::collections::BTreeMap; -use std::io::prelude::*; -use std::io::{Read, Seek, Write}; -use std::os::fd::AsFd; -use std::rc::{Rc, Weak}; -thread_local!( - pub static pm_0: Value = Rc::new(RefCell::new(-1_isize)); -); -#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] -#[byte_size(8)] -pub struct CompletedLater { - #[offset(0)] - pub first: i32, - #[offset(4)] - pub second: i32, -} -pub fn main() { - __cpp2rust_init_globals(); - std::process::exit(main_0()); -} -fn main_0() -> i32 { - assert!(((pm_0.with(|rc| *rc.borrow())) == -1_isize)); - pm_0.with(|rc| *rc.borrow_mut() = (offset_of_field!(CompletedLater, second) as isize)); - let obj: Value = Rc::new(RefCell::new(CompletedLater { - first: 3, - second: 4, - })); - assert!( - (((obj.as_pointer()) - .member::(pm_0.with(|rc| *rc.borrow())) - .read()) - == 4) - ); - return 0; -} -pub fn __cpp2rust_init_globals() { - let _ = pm_0.with(|_| ()); -} diff --git a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/refcount/p2-pointer-to-member-of-pointer-to-member-type.rs b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/refcount/p2-pointer-to-member-of-pointer-to-member-type.rs deleted file mode 100644 index ebebb124e6..0000000000 --- a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/refcount/p2-pointer-to-member-of-pointer-to-member-type.rs +++ /dev/null @@ -1,61 +0,0 @@ -extern crate libcc2rs; -use libcc2rs::*; -use std::cell::RefCell; -use std::collections::BTreeMap; -use std::io::prelude::*; -use std::io::{Read, Seek, Write}; -use std::os::fd::AsFd; -use std::rc::{Rc, Weak}; -#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] -#[byte_size(8)] -pub struct HasTwoInts { - #[offset(0)] - pub first: i32, - #[offset(4)] - pub second: i32, -} -#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg)] -#[byte_size(8)] -pub struct HoldsSelector { - #[offset(0)] - #[byte_size(8)] - pub selector: isize, -} -impl Default for HoldsSelector { - fn default() -> Self { - { HoldsSelector { selector: -1_isize } } - } -} -pub fn main() { - __cpp2rust_init_globals(); - std::process::exit(main_0()); -} -fn main_0() -> i32 { - let mut pm: isize = (offset_of_field!(HoldsSelector, selector) as isize); - let holder: Value = Rc::new(RefCell::new(HoldsSelector { - selector: (offset_of_field!(HasTwoInts, second) as isize), - })); - let obj: Value = Rc::new(RefCell::new(HasTwoInts { - first: 3, - second: 4, - })); - assert!( - (((obj.as_pointer()) - .member::(((holder.as_pointer()).member::(pm).read())) - .read()) - == 4) - ); - (holder.as_pointer()) - .member::(pm) - .write((offset_of_field!(HasTwoInts, first) as isize)); - assert!( - ({ - (((obj.as_pointer()) - .member::(({ (*holder.borrow()).selector })) - .read()) - == 3) - }) - ); - return 0; -} -pub fn __cpp2rust_init_globals() {} diff --git a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/unsafe/p2-pointer-to-array-member.rs b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/unsafe/p2-pointer-to-array-member.rs deleted file mode 100644 index b81daaa6fd..0000000000 --- a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/unsafe/p2-pointer-to-array-member.rs +++ /dev/null @@ -1,46 +0,0 @@ -extern crate libc; -use libc::*; -extern crate libcc2rs; -use libcc2rs::*; -use std::collections::BTreeMap; -use std::io::{Read, Seek, Write}; -use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; -use std::rc::Rc; -#[repr(C)] -#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] -pub struct HasIntArray { - pub before: i32, - pub elements: [i32; 3], -} -pub fn main() { - unsafe { - __cpp2rust_init_globals(); - std::process::exit(main_0() as i32); - } -} -unsafe fn main_0() -> i32 { - let mut pm: isize = (::std::mem::offset_of!(HasIntArray, elements) as isize); - let mut obj: HasIntArray = HasIntArray { - before: 1, - elements: [2, 3, 4], - }; - assert!( - (((*(&mut obj as *mut HasIntArray) - .wrapping_byte_offset(pm) - .cast::<[i32; 3]>())[(0) as usize]) - == (2)) - ); - assert!( - (((*(&mut obj as *mut HasIntArray) - .wrapping_byte_offset(pm) - .cast::<[i32; 3]>())[(2) as usize]) - == (4)) - ); - (*(&mut obj as *mut HasIntArray) - .wrapping_byte_offset(pm) - .cast::<[i32; 3]>())[(1) as usize] = 7; - assert!(((obj.elements[(1) as usize]) == (7))); - assert!(((obj.before) == (1))); - return 0; -} -pub unsafe fn __cpp2rust_init_globals() {} diff --git a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/unsafe/p2-pointer-to-data-member.rs b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/unsafe/p2-pointer-to-data-member.rs deleted file mode 100644 index 512dd89360..0000000000 --- a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/unsafe/p2-pointer-to-data-member.rs +++ /dev/null @@ -1,52 +0,0 @@ -extern crate libc; -use libc::*; -extern crate libcc2rs; -use libcc2rs::*; -use std::collections::BTreeMap; -use std::io::{Read, Seek, Write}; -use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; -use std::rc::Rc; -#[repr(C)] -#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] -pub struct HasTwoInts { - pub first: i32, - pub second: i32, -} -pub fn main() { - unsafe { - __cpp2rust_init_globals(); - std::process::exit(main_0() as i32); - } -} -unsafe fn main_0() -> i32 { - let mut pm: isize = (::std::mem::offset_of!(HasTwoInts, first) as isize); - let mut obj: HasTwoInts = HasTwoInts { - first: 3, - second: 4, - }; - assert!( - ((*(&mut obj as *mut HasTwoInts) - .wrapping_byte_offset(pm) - .cast::()) - == (3)) - ); - (*(&mut obj as *mut HasTwoInts) - .wrapping_byte_offset(pm) - .cast::()) = 5; - assert!(((obj.first) == (5))); - assert!(((obj.second) == (4))); - pm = (::std::mem::offset_of!(HasTwoInts, second) as isize); - assert!( - ((*(&mut obj as *mut HasTwoInts) - .wrapping_byte_offset(pm) - .cast::()) - == (4)) - ); - (*(&mut obj as *mut HasTwoInts) - .wrapping_byte_offset(pm) - .cast::()) = 6; - assert!(((obj.first) == (5))); - assert!(((obj.second) == (6))); - return 0; -} -pub unsafe fn __cpp2rust_init_globals() {} diff --git a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/unsafe/p2-pointer-to-member-of-incomplete-class.rs b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/unsafe/p2-pointer-to-member-of-incomplete-class.rs deleted file mode 100644 index b7350ca2de..0000000000 --- a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/unsafe/p2-pointer-to-member-of-incomplete-class.rs +++ /dev/null @@ -1,40 +0,0 @@ -extern crate libc; -use libc::*; -extern crate libcc2rs; -use libcc2rs::*; -use std::collections::BTreeMap; -use std::io::{Read, Seek, Write}; -use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; -use std::rc::Rc; -pub static mut pm_0: std::cell::LazyCell = std::cell::LazyCell::new(|| unsafe { -1_isize }); -#[repr(C)] -#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] -pub struct CompletedLater { - pub first: i32, - pub second: i32, -} -pub fn main() { - unsafe { - __cpp2rust_init_globals(); - std::process::exit(main_0() as i32); - } -} -unsafe fn main_0() -> i32 { - assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut pm_0)) == -1_isize)); - (*std::cell::LazyCell::force_mut(&mut *&raw mut pm_0)) = - (::std::mem::offset_of!(CompletedLater, second) as isize); - let mut obj: CompletedLater = CompletedLater { - first: 3, - second: 4, - }; - assert!( - ((*(&mut obj as *mut CompletedLater) - .wrapping_byte_offset((*std::cell::LazyCell::force_mut(&mut *&raw mut pm_0))) - .cast::()) - == (4)) - ); - return 0; -} -pub unsafe fn __cpp2rust_init_globals() { - std::cell::LazyCell::force(&*&raw const pm_0); -} diff --git a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/unsafe/p2-pointer-to-member-of-pointer-to-member-type.rs b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/unsafe/p2-pointer-to-member-of-pointer-to-member-type.rs deleted file mode 100644 index d026756339..0000000000 --- a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/out/unsafe/p2-pointer-to-member-of-pointer-to-member-type.rs +++ /dev/null @@ -1,61 +0,0 @@ -extern crate libc; -use libc::*; -extern crate libcc2rs; -use libcc2rs::*; -use std::collections::BTreeMap; -use std::io::{Read, Seek, Write}; -use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; -use std::rc::Rc; -#[repr(C)] -#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] -pub struct HasTwoInts { - pub first: i32, - pub second: i32, -} -#[repr(C)] -#[derive(Copy, Clone, VaArg, FnPtrArg)] -pub struct HoldsSelector { - pub selector: isize, -} -impl Default for HoldsSelector { - fn default() -> Self { - unsafe { HoldsSelector { selector: -1_isize } } - } -} -pub fn main() { - unsafe { - __cpp2rust_init_globals(); - std::process::exit(main_0() as i32); - } -} -unsafe fn main_0() -> i32 { - let mut pm: isize = (::std::mem::offset_of!(HoldsSelector, selector) as isize); - let mut holder: HoldsSelector = HoldsSelector { - selector: (::std::mem::offset_of!(HasTwoInts, second) as isize), - }; - let mut obj: HasTwoInts = HasTwoInts { - first: 3, - second: 4, - }; - assert!( - ((*(&mut obj as *mut HasTwoInts) - .wrapping_byte_offset( - (*(&mut holder as *mut HoldsSelector) - .wrapping_byte_offset(pm) - .cast::()) - ) - .cast::()) - == (4)) - ); - (*(&mut holder as *mut HoldsSelector) - .wrapping_byte_offset(pm) - .cast::()) = (::std::mem::offset_of!(HasTwoInts, first) as isize); - assert!( - ((*(&mut obj as *mut HasTwoInts) - .wrapping_byte_offset((holder.selector)) - .cast::()) - == (3)) - ); - return 0; -} -pub unsafe fn __cpp2rust_init_globals() {} diff --git a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/p2-pointer-to-array-member.cpp b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/p2-pointer-to-array-member.cpp deleted file mode 100644 index 6daf337c45..0000000000 --- a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/p2-pointer-to-array-member.cpp +++ /dev/null @@ -1,20 +0,0 @@ -// ADDITIONAL_COMPILE_FLAGS: -std=c++23 -// N4950 [dcl.mptr]/2: the type is "derived-declarator-type-list pointer to -// member of class C of type T"; T can be an array type. -#include - -struct HasIntArray { - int before; - int elements[3]; -}; - -int main() { - int (HasIntArray::*pm)[3] = &HasIntArray::elements; - HasIntArray obj{1, {2, 3, 4}}; - assert((obj.*pm)[0] == 2); - assert((obj.*pm)[2] == 4); - (obj.*pm)[1] = 7; - assert(obj.elements[1] == 7); - assert(obj.before == 1); - return 0; -} diff --git a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/p2-pointer-to-data-member.cpp b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/p2-pointer-to-data-member.cpp deleted file mode 100644 index c4897bca79..0000000000 --- a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/p2-pointer-to-data-member.cpp +++ /dev/null @@ -1,24 +0,0 @@ -// ADDITIONAL_COMPILE_FLAGS: -std=c++23 -// N4950 [dcl.mptr]/2: "T C::*" declares a pointer to member of class C of -// type T. -#include - -struct HasTwoInts { - int first; - int second; -}; - -int main() { - int HasTwoInts::*pm = &HasTwoInts::first; - HasTwoInts obj{3, 4}; - assert(obj.*pm == 3); - obj.*pm = 5; - assert(obj.first == 5); - assert(obj.second == 4); - pm = &HasTwoInts::second; - assert(obj.*pm == 4); - obj.*pm = 6; - assert(obj.first == 5); - assert(obj.second == 6); - return 0; -} diff --git a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/p2-pointer-to-member-of-incomplete-class.cpp b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/p2-pointer-to-member-of-incomplete-class.cpp deleted file mode 100644 index 4f363a15db..0000000000 --- a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/p2-pointer-to-member-of-incomplete-class.cpp +++ /dev/null @@ -1,21 +0,0 @@ -// ADDITIONAL_COMPILE_FLAGS: -std=c++23 -// N4950 [dcl.mptr]/2: the nested-name-specifier denotes a class; the class -// need not be complete. -#include - -struct CompletedLater; - -static int CompletedLater::*pm = nullptr; - -struct CompletedLater { - int first; - int second; -}; - -int main() { - assert(pm == nullptr); - pm = &CompletedLater::second; - CompletedLater obj{3, 4}; - assert(obj.*pm == 4); - return 0; -} diff --git a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/p2-pointer-to-member-of-pointer-to-member-type.cpp b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/p2-pointer-to-member-of-pointer-to-member-type.cpp deleted file mode 100644 index 0106d49f10..0000000000 --- a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr/p2-pointer-to-member-of-pointer-to-member-type.cpp +++ /dev/null @@ -1,23 +0,0 @@ -// ADDITIONAL_COMPILE_FLAGS: -std=c++23 -// N4950 [dcl.mptr]/2: the type is "derived-declarator-type-list pointer to -// member of class C of type T"; T can itself be a pointer-to-member type. -#include - -struct HasTwoInts { - int first; - int second; -}; - -struct HoldsSelector { - int HasTwoInts::*selector; -}; - -int main() { - int HasTwoInts::*HoldsSelector::*pm = &HoldsSelector::selector; - HoldsSelector holder{&HasTwoInts::second}; - HasTwoInts obj{3, 4}; - assert(obj.*(holder.*pm) == 4); - holder.*pm = &HasTwoInts::first; - assert(obj.*(holder.selector) == 3); - return 0; -} diff --git a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.array/out/refcount/p6-array-of-pointers-to-data-members.rs b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/out/refcount/dcl.array.rs similarity index 69% rename from tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.array/out/refcount/p6-array-of-pointers-to-data-members.rs rename to tests/std/dcl.dcl/dcl.decl/dcl.meaning/out/refcount/dcl.array.rs index ec2d5a7ea3..82ad0a61f0 100644 --- a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.array/out/refcount/p6-array-of-pointers-to-data-members.rs +++ b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/out/refcount/dcl.array.rs @@ -8,7 +8,7 @@ use std::os::fd::AsFd; use std::rc::{Rc, Weak}; #[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] #[byte_size(12)] -pub struct HasThreeInts { +pub struct p6_array_of_pointers_to_data_members_HasThreeInts { #[offset(0)] pub first: i32, #[offset(4)] @@ -16,21 +16,19 @@ pub struct HasThreeInts { #[offset(8)] pub third: i32, } -pub fn main() { - __cpp2rust_init_globals(); - std::process::exit(main_0()); -} -fn main_0() -> i32 { +pub fn test_0() { let members: Value> = Rc::new(RefCell::new(Box::new([ - (offset_of_field!(HasThreeInts, third) as isize), - (offset_of_field!(HasThreeInts, first) as isize), - (offset_of_field!(HasThreeInts, second) as isize), + (offset_of_field!(p6_array_of_pointers_to_data_members_HasThreeInts, third) as isize), + (offset_of_field!(p6_array_of_pointers_to_data_members_HasThreeInts, first) as isize), + (offset_of_field!(p6_array_of_pointers_to_data_members_HasThreeInts, second) as isize), ]))); - let obj: Value = Rc::new(RefCell::new(HasThreeInts { - first: 4, - second: 5, - third: 6, - })); + let obj: Value = Rc::new(RefCell::new( + p6_array_of_pointers_to_data_members_HasThreeInts { + first: 4, + second: 5, + third: 6, + }, + )); assert!( ({ (((obj.as_pointer()) @@ -67,8 +65,16 @@ fn main_0() -> i32 { element.prefix_inc(); assert!(({ (element).clone() } == { (members.decay().offset(2)) })); assert!((((obj.as_pointer()).member::((element.read())).read()) == 5)); - (*members.borrow_mut())[(2) as usize] = (offset_of_field!(HasThreeInts, third) as isize); + (*members.borrow_mut())[(2) as usize] = + (offset_of_field!(p6_array_of_pointers_to_data_members_HasThreeInts, third) as isize); assert!((((obj.as_pointer()).member::((element.read())).read()) == 6)); +} +pub fn main() { + __cpp2rust_init_globals(); + std::process::exit(main_0()); +} +fn main_0() -> i32 { + ({ test_0() }); return 0; } pub fn __cpp2rust_init_globals() {} diff --git a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/out/refcount/dcl.mptr.rs b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/out/refcount/dcl.mptr.rs new file mode 100644 index 0000000000..46e82022ef --- /dev/null +++ b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/out/refcount/dcl.mptr.rs @@ -0,0 +1,173 @@ +extern crate libcc2rs; +use libcc2rs::*; +use std::cell::RefCell; +use std::collections::BTreeMap; +use std::io::prelude::*; +use std::io::{Read, Seek, Write}; +use std::os::fd::AsFd; +use std::rc::{Rc, Weak}; +#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg)] +#[byte_size(16)] +pub struct p2_pointer_to_array_member_HasIntArray { + #[offset(0)] + pub before: i32, + #[offset(4)] + #[byte_size(12)] + pub elements: Box<[i32]>, +} +impl Default for p2_pointer_to_array_member_HasIntArray { + fn default() -> Self { + { + p2_pointer_to_array_member_HasIntArray { + before: 0_i32, + elements: (0..3).map(|_| 0_i32).collect::>(), + } + } + } +} +pub fn test_0() { + let mut pm: isize = + (offset_of_field!(p2_pointer_to_array_member_HasIntArray, elements) as isize); + let obj: Value = + Rc::new(RefCell::new(p2_pointer_to_array_member_HasIntArray { + before: 1, + elements: Box::new([2, 3, 4]), + })); + assert!((((obj.as_pointer()).member::>(pm).read())[(0) as usize] == 2)); + assert!((((obj.as_pointer()).member::>(pm).read())[(2) as usize] == 4)); + index!((obj.as_pointer()).member::>(pm), 1).write(7); + assert!(((array_elem!(obj.as_pointer(), elements, 1).read()) == 7)); + assert!(({ ({ (*obj.borrow()).before } == 1) })); +} +#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] +#[byte_size(8)] +pub struct p2_pointer_to_data_member_HasTwoInts { + #[offset(0)] + pub first: i32, + #[offset(4)] + pub second: i32, +} +pub fn test_1() { + let mut pm: isize = (offset_of_field!(p2_pointer_to_data_member_HasTwoInts, first) as isize); + let obj: Value = + Rc::new(RefCell::new(p2_pointer_to_data_member_HasTwoInts { + first: 3, + second: 4, + })); + assert!((((obj.as_pointer()).member::(pm).read()) == 3)); + (obj.as_pointer()).member::(pm).write(5); + assert!(({ ({ (*obj.borrow()).first } == 5) })); + assert!(({ ({ (*obj.borrow()).second } == 4) })); + pm = (offset_of_field!(p2_pointer_to_data_member_HasTwoInts, second) as isize); + assert!((((obj.as_pointer()).member::(pm).read()) == 4)); + (obj.as_pointer()).member::(pm).write(6); + assert!(({ ({ (*obj.borrow()).first } == 5) })); + assert!(({ ({ (*obj.borrow()).second } == 6) })); +} +thread_local!( + pub static pm_2: Value = Rc::new(RefCell::new(-1_isize)); +); +#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] +#[byte_size(8)] +pub struct p2_pointer_to_member_of_incomplete_class_CompletedLater { + #[offset(0)] + pub first: i32, + #[offset(4)] + pub second: i32, +} +pub fn test_3() { + assert!(((pm_2.with(|rc| *rc.borrow())) == -1_isize)); + pm_2.with(|rc| { + *rc.borrow_mut() = (offset_of_field!( + p2_pointer_to_member_of_incomplete_class_CompletedLater, + second + ) as isize) + }); + let obj: Value = Rc::new( + RefCell::new(p2_pointer_to_member_of_incomplete_class_CompletedLater { + first: 3, + second: 4, + }), + ); + assert!( + (((obj.as_pointer()) + .member::(pm_2.with(|rc| *rc.borrow())) + .read()) + == 4) + ); +} +#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] +#[byte_size(8)] +pub struct p2_pointer_to_member_of_pointer_to_member_type_HasTwoInts { + #[offset(0)] + pub first: i32, + #[offset(4)] + pub second: i32, +} +#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg)] +#[byte_size(8)] +pub struct p2_pointer_to_member_of_pointer_to_member_type_HoldsSelector { + #[offset(0)] + #[byte_size(8)] + pub selector: isize, +} +impl Default for p2_pointer_to_member_of_pointer_to_member_type_HoldsSelector { + fn default() -> Self { + { p2_pointer_to_member_of_pointer_to_member_type_HoldsSelector { selector: -1_isize } } + } +} +pub fn test_4() { + let mut pm: isize = (offset_of_field!( + p2_pointer_to_member_of_pointer_to_member_type_HoldsSelector, + selector + ) as isize); + let holder: Value = + Rc::new(RefCell::new( + p2_pointer_to_member_of_pointer_to_member_type_HoldsSelector { + selector: (offset_of_field!( + p2_pointer_to_member_of_pointer_to_member_type_HasTwoInts, + second + ) as isize), + }, + )); + let obj: Value = Rc::new( + RefCell::new(p2_pointer_to_member_of_pointer_to_member_type_HasTwoInts { + first: 3, + second: 4, + }), + ); + assert!( + (((obj.as_pointer()) + .member::(((holder.as_pointer()).member::(pm).read())) + .read()) + == 4) + ); + (holder.as_pointer()).member::(pm).write( + (offset_of_field!( + p2_pointer_to_member_of_pointer_to_member_type_HasTwoInts, + first + ) as isize), + ); + assert!( + ({ + (((obj.as_pointer()) + .member::(({ (*holder.borrow()).selector })) + .read()) + == 3) + }) + ); +} +pub fn main() { + __cpp2rust_init_globals(); + std::process::exit(main_0()); +} +fn main_0() -> i32 { + ({ test_0() }); + ({ test_1() }); + ({ test_3() }); + ({ test_4() }); + return 0; +} +pub fn __cpp2rust_init_globals() { + let _ = pm_2.with(|_| ()); +} diff --git a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.array/out/unsafe/p6-array-of-pointers-to-data-members.rs b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/out/unsafe/dcl.array.rs similarity index 55% rename from tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.array/out/unsafe/p6-array-of-pointers-to-data-members.rs rename to tests/std/dcl.dcl/dcl.decl/dcl.meaning/out/unsafe/dcl.array.rs index de1dded858..f87830d99a 100644 --- a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.array/out/unsafe/p6-array-of-pointers-to-data-members.rs +++ b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/out/unsafe/dcl.array.rs @@ -8,42 +8,38 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; use std::rc::Rc; #[repr(C)] #[derive(Copy, Clone, VaArg, FnPtrArg, Default)] -pub struct HasThreeInts { +pub struct p6_array_of_pointers_to_data_members_HasThreeInts { pub first: i32, pub second: i32, pub third: i32, } -pub fn main() { - unsafe { - __cpp2rust_init_globals(); - std::process::exit(main_0() as i32); - } -} -unsafe fn main_0() -> i32 { +pub unsafe fn test_0() { let mut members: [isize; 3] = [ - (::std::mem::offset_of!(HasThreeInts, third) as isize), - (::std::mem::offset_of!(HasThreeInts, first) as isize), - (::std::mem::offset_of!(HasThreeInts, second) as isize), + (::std::mem::offset_of!(p6_array_of_pointers_to_data_members_HasThreeInts, third) as isize), + (::std::mem::offset_of!(p6_array_of_pointers_to_data_members_HasThreeInts, first) as isize), + (::std::mem::offset_of!(p6_array_of_pointers_to_data_members_HasThreeInts, second) + as isize), ]; - let mut obj: HasThreeInts = HasThreeInts { - first: 4, - second: 5, - third: 6, - }; + let mut obj: p6_array_of_pointers_to_data_members_HasThreeInts = + p6_array_of_pointers_to_data_members_HasThreeInts { + first: 4, + second: 5, + third: 6, + }; assert!( - ((*(&mut obj as *mut HasThreeInts) + ((*(&mut obj as *mut p6_array_of_pointers_to_data_members_HasThreeInts) .wrapping_byte_offset(members[(0) as usize]) .cast::()) == (6)) ); assert!( - ((*(&mut obj as *mut HasThreeInts) + ((*(&mut obj as *mut p6_array_of_pointers_to_data_members_HasThreeInts) .wrapping_byte_offset(members[(1) as usize]) .cast::()) == (4)) ); assert!( - ((*(&mut obj as *mut HasThreeInts) + ((*(&mut obj as *mut p6_array_of_pointers_to_data_members_HasThreeInts) .wrapping_byte_offset(members[(2) as usize]) .cast::()) == (5)) @@ -51,7 +47,7 @@ unsafe fn main_0() -> i32 { let mut element: *mut isize = members.as_mut_ptr(); assert!(((element.offset((1) as isize)) == (&mut members[(1) as usize] as *mut isize))); assert!( - ((*(&mut obj as *mut HasThreeInts) + ((*(&mut obj as *mut p6_array_of_pointers_to_data_members_HasThreeInts) .wrapping_byte_offset((*element.offset((1) as isize))) .cast::()) == (4)) @@ -60,18 +56,28 @@ unsafe fn main_0() -> i32 { element.prefix_inc(); assert!(((element) == (&mut members[(2) as usize] as *mut isize))); assert!( - ((*(&mut obj as *mut HasThreeInts) + ((*(&mut obj as *mut p6_array_of_pointers_to_data_members_HasThreeInts) .wrapping_byte_offset((*element)) .cast::()) == (5)) ); - members[(2) as usize] = (::std::mem::offset_of!(HasThreeInts, third) as isize); + members[(2) as usize] = + (::std::mem::offset_of!(p6_array_of_pointers_to_data_members_HasThreeInts, third) as isize); assert!( - ((*(&mut obj as *mut HasThreeInts) + ((*(&mut obj as *mut p6_array_of_pointers_to_data_members_HasThreeInts) .wrapping_byte_offset((*element)) .cast::()) == (6)) ); +} +pub fn main() { + unsafe { + __cpp2rust_init_globals(); + std::process::exit(main_0() as i32); + } +} +unsafe fn main_0() -> i32 { + (unsafe { test_0() }); return 0; } pub unsafe fn __cpp2rust_init_globals() {} diff --git a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/out/unsafe/dcl.mptr.rs b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/out/unsafe/dcl.mptr.rs new file mode 100644 index 0000000000..d5c79dbb68 --- /dev/null +++ b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/out/unsafe/dcl.mptr.rs @@ -0,0 +1,176 @@ +extern crate libc; +use libc::*; +extern crate libcc2rs; +use libcc2rs::*; +use std::collections::BTreeMap; +use std::io::{Read, Seek, Write}; +use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; +use std::rc::Rc; +#[repr(C)] +#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] +pub struct p2_pointer_to_array_member_HasIntArray { + pub before: i32, + pub elements: [i32; 3], +} +pub unsafe fn test_0() { + let mut pm: isize = + (::std::mem::offset_of!(p2_pointer_to_array_member_HasIntArray, elements) as isize); + let mut obj: p2_pointer_to_array_member_HasIntArray = p2_pointer_to_array_member_HasIntArray { + before: 1, + elements: [2, 3, 4], + }; + assert!( + (((*(&mut obj as *mut p2_pointer_to_array_member_HasIntArray) + .wrapping_byte_offset(pm) + .cast::<[i32; 3]>())[(0) as usize]) + == (2)) + ); + assert!( + (((*(&mut obj as *mut p2_pointer_to_array_member_HasIntArray) + .wrapping_byte_offset(pm) + .cast::<[i32; 3]>())[(2) as usize]) + == (4)) + ); + (*(&mut obj as *mut p2_pointer_to_array_member_HasIntArray) + .wrapping_byte_offset(pm) + .cast::<[i32; 3]>())[(1) as usize] = 7; + assert!(((obj.elements[(1) as usize]) == (7))); + assert!(((obj.before) == (1))); +} +#[repr(C)] +#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] +pub struct p2_pointer_to_data_member_HasTwoInts { + pub first: i32, + pub second: i32, +} +pub unsafe fn test_1() { + let mut pm: isize = + (::std::mem::offset_of!(p2_pointer_to_data_member_HasTwoInts, first) as isize); + let mut obj: p2_pointer_to_data_member_HasTwoInts = p2_pointer_to_data_member_HasTwoInts { + first: 3, + second: 4, + }; + assert!( + ((*(&mut obj as *mut p2_pointer_to_data_member_HasTwoInts) + .wrapping_byte_offset(pm) + .cast::()) + == (3)) + ); + (*(&mut obj as *mut p2_pointer_to_data_member_HasTwoInts) + .wrapping_byte_offset(pm) + .cast::()) = 5; + assert!(((obj.first) == (5))); + assert!(((obj.second) == (4))); + pm = (::std::mem::offset_of!(p2_pointer_to_data_member_HasTwoInts, second) as isize); + assert!( + ((*(&mut obj as *mut p2_pointer_to_data_member_HasTwoInts) + .wrapping_byte_offset(pm) + .cast::()) + == (4)) + ); + (*(&mut obj as *mut p2_pointer_to_data_member_HasTwoInts) + .wrapping_byte_offset(pm) + .cast::()) = 6; + assert!(((obj.first) == (5))); + assert!(((obj.second) == (6))); +} +pub static mut pm_2: std::cell::LazyCell = std::cell::LazyCell::new(|| unsafe { -1_isize }); +#[repr(C)] +#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] +pub struct p2_pointer_to_member_of_incomplete_class_CompletedLater { + pub first: i32, + pub second: i32, +} +pub unsafe fn test_3() { + assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut pm_2)) == -1_isize)); + (*std::cell::LazyCell::force_mut(&mut *&raw mut pm_2)) = (::std::mem::offset_of!( + p2_pointer_to_member_of_incomplete_class_CompletedLater, + second + ) as isize); + let mut obj: p2_pointer_to_member_of_incomplete_class_CompletedLater = + p2_pointer_to_member_of_incomplete_class_CompletedLater { + first: 3, + second: 4, + }; + assert!( + ((*(&mut obj as *mut p2_pointer_to_member_of_incomplete_class_CompletedLater) + .wrapping_byte_offset((*std::cell::LazyCell::force_mut(&mut *&raw mut pm_2))) + .cast::()) + == (4)) + ); +} +#[repr(C)] +#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] +pub struct p2_pointer_to_member_of_pointer_to_member_type_HasTwoInts { + pub first: i32, + pub second: i32, +} +#[repr(C)] +#[derive(Copy, Clone, VaArg, FnPtrArg)] +pub struct p2_pointer_to_member_of_pointer_to_member_type_HoldsSelector { + pub selector: isize, +} +impl Default for p2_pointer_to_member_of_pointer_to_member_type_HoldsSelector { + fn default() -> Self { + unsafe { + p2_pointer_to_member_of_pointer_to_member_type_HoldsSelector { selector: -1_isize } + } + } +} +pub unsafe fn test_4() { + let mut pm: isize = (::std::mem::offset_of!( + p2_pointer_to_member_of_pointer_to_member_type_HoldsSelector, + selector + ) as isize); + let mut holder: p2_pointer_to_member_of_pointer_to_member_type_HoldsSelector = + p2_pointer_to_member_of_pointer_to_member_type_HoldsSelector { + selector: (::std::mem::offset_of!( + p2_pointer_to_member_of_pointer_to_member_type_HasTwoInts, + second + ) as isize), + }; + let mut obj: p2_pointer_to_member_of_pointer_to_member_type_HasTwoInts = + p2_pointer_to_member_of_pointer_to_member_type_HasTwoInts { + first: 3, + second: 4, + }; + assert!( + ((*(&mut obj as *mut p2_pointer_to_member_of_pointer_to_member_type_HasTwoInts) + .wrapping_byte_offset( + (*(&mut holder + as *mut p2_pointer_to_member_of_pointer_to_member_type_HoldsSelector) + .wrapping_byte_offset(pm) + .cast::()) + ) + .cast::()) + == (4)) + ); + (*(&mut holder as *mut p2_pointer_to_member_of_pointer_to_member_type_HoldsSelector) + .wrapping_byte_offset(pm) + .cast::()) = (::std::mem::offset_of!( + p2_pointer_to_member_of_pointer_to_member_type_HasTwoInts, + first + ) as isize); + assert!( + ((*(&mut obj as *mut p2_pointer_to_member_of_pointer_to_member_type_HasTwoInts) + .wrapping_byte_offset((holder.selector)) + .cast::()) + == (3)) + ); +} +pub fn main() { + unsafe { + __cpp2rust_init_globals(); + std::process::exit(main_0() as i32); + } +} +unsafe fn main_0() -> i32 { + (unsafe { test_0() }); + (unsafe { test_1() }); + (unsafe { test_3() }); + (unsafe { test_4() }); + return 0; +} +pub unsafe fn __cpp2rust_init_globals() { + std::cell::LazyCell::force(&*&raw const pm_2); +} diff --git a/tests/std/expr/conv/conv.bool/p1-pointer-to-member.cpp b/tests/std/expr/conv/conv.bool-unsupported.cpp similarity index 89% rename from tests/std/expr/conv/conv.bool/p1-pointer-to-member.cpp rename to tests/std/expr/conv/conv.bool-unsupported.cpp index 9c59757010..553debe0c4 100644 --- a/tests/std/expr/conv/conv.bool/p1-pointer-to-member.cpp +++ b/tests/std/expr/conv/conv.bool-unsupported.cpp @@ -1,16 +1,17 @@ // translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 -// N4950 [conv.bool]/1: a prvalue of pointer-to-member type can be converted to -// bool; the null member pointer value becomes false, any other value true. #include +// N4950 [conv.bool]/1: a prvalue of pointer-to-member type can be converted to +// bool; the null member pointer value becomes false, any other value true. +namespace p1_pointer_to_member { struct HasTwoInts { int first; int second; void run() {} }; -int main() { +void test() { int HasTwoInts::*null_pm = nullptr; int HasTwoInts::*first_pm = &HasTwoInts::first; int HasTwoInts::*second_pm = &HasTwoInts::second; @@ -26,5 +27,10 @@ int main() { assert(!null_function_as_bool); bool run_as_bool = static_cast(run_pmf); assert(run_as_bool); +} +} // namespace p1_pointer_to_member + +int main() { + p1_pointer_to_member::test(); return 0; } diff --git a/tests/std/expr/conv/conv.fctptr/p1-pointer-to-noexcept-member-function.cpp b/tests/std/expr/conv/conv.fctptr-unsupported.cpp similarity index 77% rename from tests/std/expr/conv/conv.fctptr/p1-pointer-to-noexcept-member-function.cpp rename to tests/std/expr/conv/conv.fctptr-unsupported.cpp index 24af176fbc..67c8e74895 100644 --- a/tests/std/expr/conv/conv.fctptr/p1-pointer-to-noexcept-member-function.cpp +++ b/tests/std/expr/conv/conv.fctptr-unsupported.cpp @@ -1,20 +1,26 @@ // translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 +#include + // N4950 [conv.fctptr]/1: "pointer to member of type noexcept function" // converts to "pointer to member of type function"; the result designates the // member function. -#include - +namespace p1_pointer_to_noexcept_member_function { struct HasNoexceptMember { int calls = 0; void run() noexcept { ++calls; } }; -int main() { +void test() { void (HasNoexceptMember::*noexcept_pmf)() noexcept = &HasNoexceptMember::run; void (HasNoexceptMember::*pmf)() = noexcept_pmf; HasNoexceptMember obj; (obj.*pmf)(); assert(obj.calls == 1); +} +} // namespace p1_pointer_to_noexcept_member_function + +int main() { + p1_pointer_to_noexcept_member_function::test(); return 0; } diff --git a/tests/std/expr/conv/conv.mem-unsupported.cpp b/tests/std/expr/conv/conv.mem-unsupported.cpp new file mode 100644 index 0000000000..3b56c773a8 --- /dev/null +++ b/tests/std/expr/conv/conv.mem-unsupported.cpp @@ -0,0 +1,136 @@ +// translation-fail: refcount, unsafe +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +#include + +// N4950 [conv.mem]/1: the null member pointer value is distinguishable from +// any pointer to member not created from a null pointer constant. +namespace p1_null_distinct_from_member_function { +struct HasVirtualAndNonVirtual { + virtual void first_virtual() {} + void non_virtual() {} +}; + +void test() { + void (HasVirtualAndNonVirtual::*null_pmf)() = nullptr; + void (HasVirtualAndNonVirtual::*virtual_pmf)() = + &HasVirtualAndNonVirtual::first_virtual; + void (HasVirtualAndNonVirtual::*non_virtual_pmf)() = + &HasVirtualAndNonVirtual::non_virtual; + assert(virtual_pmf != null_pmf); + assert(non_virtual_pmf != null_pmf); +} +} // namespace p1_null_distinct_from_member_function + +// N4950 [conv.mem]/1: a null pointer constant can be converted to a +// pointer-to-member type; two null member pointer values of the same type +// compare equal. +namespace p1_null_values_compare_equal { +struct HasTwoInts { + int first; + int second; +}; + +void test() { + int HasTwoInts::*from_nullptr = nullptr; + int HasTwoInts::*from_zero = 0; + assert(from_nullptr == from_zero); + void (HasTwoInts::*function_from_nullptr)() = nullptr; + void (HasTwoInts::*function_from_zero)() = 0; + assert(function_from_nullptr == function_from_zero); +} +} // namespace p1_null_values_compare_equal + +// N4950 [conv.mem]/2: "pointer to member of B of type T" converts to "pointer +// to member of D of type T"; the result refers to the member in D's instance +// of B. +namespace p2_base_to_derived_data_member { +struct Precedes { + int preceding; +}; + +struct DeclaresValue { + int value; +}; + +struct InheritsValue : Precedes, DeclaresValue { + int own; +}; + +void test() { + int DeclaresValue::*base_pm = &DeclaresValue::value; + int InheritsValue::*derived_pm = base_pm; + InheritsValue obj; + obj.preceding = 1; + obj.value = 2; + obj.own = 3; + assert(obj.*derived_pm == 2); + obj.*derived_pm = 4; + assert(obj.value == 4); + assert(obj.preceding == 1); + assert(obj.own == 3); +} +} // namespace p2_base_to_derived_data_member + +// N4950 [conv.mem]/2: indirection through the converted pointer with a D +// object is the same as indirecting through the pointer to member of B with +// the B subobject of D. +namespace p2_base_to_derived_member_function { +struct Precedes { + int preceding; +}; + +struct DeclaresIncrement { + int value; + void increment() { ++value; } +}; + +struct InheritsIncrement : Precedes, DeclaresIncrement { + int own; +}; + +void test() { + void (DeclaresIncrement::*base_pmf)() = &DeclaresIncrement::increment; + void (InheritsIncrement::*derived_pmf)() = base_pmf; + InheritsIncrement obj; + obj.preceding = 1; + obj.value = 2; + obj.own = 3; + (obj.*derived_pmf)(); + assert(obj.value == 3); + assert(obj.preceding == 1); + assert(obj.own == 3); +} +} // namespace p2_base_to_derived_member_function + +// N4950 [conv.mem]/2: the null member pointer value is converted to the null +// member pointer value of the destination type. +namespace p2_null_converts_to_null { +struct Precedes { + int preceding; +}; + +struct DeclaresValue { + int value; + void increment() { ++value; } +}; + +struct InheritsValue : Precedes, DeclaresValue {}; + +void test() { + int DeclaresValue::*base_pm = nullptr; + int InheritsValue::*derived_pm = base_pm; + assert(derived_pm == nullptr); + void (DeclaresValue::*base_pmf)() = nullptr; + void (InheritsValue::*derived_pmf)() = base_pmf; + assert(derived_pmf == nullptr); +} +} // namespace p2_null_converts_to_null + +int main() { + p1_null_distinct_from_member_function::test(); + p1_null_values_compare_equal::test(); + p2_base_to_derived_data_member::test(); + p2_base_to_derived_member_function::test(); + p2_null_converts_to_null::test(); + return 0; +} diff --git a/tests/std/expr/conv/conv.mem/p1-null-distinct-from-first-member.cpp b/tests/std/expr/conv/conv.mem.cpp similarity index 75% rename from tests/std/expr/conv/conv.mem/p1-null-distinct-from-first-member.cpp rename to tests/std/expr/conv/conv.mem.cpp index edddb4e6a4..7b53047b50 100644 --- a/tests/std/expr/conv/conv.mem/p1-null-distinct-from-first-member.cpp +++ b/tests/std/expr/conv/conv.mem.cpp @@ -1,18 +1,24 @@ // ADDITIONAL_COMPILE_FLAGS: -std=c++23 -// N4950 [conv.mem]/1: the null member pointer value is distinguishable from -// any pointer to member not created from a null pointer constant. #include +// N4950 [conv.mem]/1: the null member pointer value is distinguishable from +// any pointer to member not created from a null pointer constant. +namespace p1_null_distinct_from_first_member { struct HasTwoInts { int first; int second; }; -int main() { +void test() { int HasTwoInts::*null_pm = nullptr; int HasTwoInts::*first_pm = &HasTwoInts::first; int HasTwoInts::*second_pm = &HasTwoInts::second; assert(first_pm != null_pm); assert(second_pm != null_pm); +} +} // namespace p1_null_distinct_from_first_member + +int main() { + p1_null_distinct_from_first_member::test(); return 0; } diff --git a/tests/std/expr/conv/conv.mem/p1-null-distinct-from-member-function.cpp b/tests/std/expr/conv/conv.mem/p1-null-distinct-from-member-function.cpp deleted file mode 100644 index 79e5b4f9f6..0000000000 --- a/tests/std/expr/conv/conv.mem/p1-null-distinct-from-member-function.cpp +++ /dev/null @@ -1,21 +0,0 @@ -// translation-fail: refcount, unsafe -// ADDITIONAL_COMPILE_FLAGS: -std=c++23 -// N4950 [conv.mem]/1: the null member pointer value is distinguishable from -// any pointer to member not created from a null pointer constant. -#include - -struct HasVirtualAndNonVirtual { - virtual void first_virtual() {} - void non_virtual() {} -}; - -int main() { - void (HasVirtualAndNonVirtual::*null_pmf)() = nullptr; - void (HasVirtualAndNonVirtual::*virtual_pmf)() = - &HasVirtualAndNonVirtual::first_virtual; - void (HasVirtualAndNonVirtual::*non_virtual_pmf)() = - &HasVirtualAndNonVirtual::non_virtual; - assert(virtual_pmf != null_pmf); - assert(non_virtual_pmf != null_pmf); - return 0; -} diff --git a/tests/std/expr/conv/conv.mem/p1-null-values-compare-equal.cpp b/tests/std/expr/conv/conv.mem/p1-null-values-compare-equal.cpp deleted file mode 100644 index fcd7a44087..0000000000 --- a/tests/std/expr/conv/conv.mem/p1-null-values-compare-equal.cpp +++ /dev/null @@ -1,21 +0,0 @@ -// translation-fail: refcount, unsafe -// ADDITIONAL_COMPILE_FLAGS: -std=c++23 -// N4950 [conv.mem]/1: a null pointer constant can be converted to a -// pointer-to-member type; two null member pointer values of the same type -// compare equal. -#include - -struct HasTwoInts { - int first; - int second; -}; - -int main() { - int HasTwoInts::*from_nullptr = nullptr; - int HasTwoInts::*from_zero = 0; - assert(from_nullptr == from_zero); - void (HasTwoInts::*function_from_nullptr)() = nullptr; - void (HasTwoInts::*function_from_zero)() = 0; - assert(function_from_nullptr == function_from_zero); - return 0; -} diff --git a/tests/std/expr/conv/conv.mem/p2-base-to-derived-data-member.cpp b/tests/std/expr/conv/conv.mem/p2-base-to-derived-data-member.cpp deleted file mode 100644 index 5321c9fb95..0000000000 --- a/tests/std/expr/conv/conv.mem/p2-base-to-derived-data-member.cpp +++ /dev/null @@ -1,33 +0,0 @@ -// translation-fail: refcount, unsafe -// ADDITIONAL_COMPILE_FLAGS: -std=c++23 -// N4950 [conv.mem]/2: "pointer to member of B of type T" converts to "pointer -// to member of D of type T"; the result refers to the member in D's instance -// of B. -#include - -struct Precedes { - int preceding; -}; - -struct DeclaresValue { - int value; -}; - -struct InheritsValue : Precedes, DeclaresValue { - int own; -}; - -int main() { - int DeclaresValue::*base_pm = &DeclaresValue::value; - int InheritsValue::*derived_pm = base_pm; - InheritsValue obj; - obj.preceding = 1; - obj.value = 2; - obj.own = 3; - assert(obj.*derived_pm == 2); - obj.*derived_pm = 4; - assert(obj.value == 4); - assert(obj.preceding == 1); - assert(obj.own == 3); - return 0; -} diff --git a/tests/std/expr/conv/conv.mem/p2-base-to-derived-member-function.cpp b/tests/std/expr/conv/conv.mem/p2-base-to-derived-member-function.cpp deleted file mode 100644 index 1510592ab1..0000000000 --- a/tests/std/expr/conv/conv.mem/p2-base-to-derived-member-function.cpp +++ /dev/null @@ -1,33 +0,0 @@ -// translation-fail: refcount, unsafe -// ADDITIONAL_COMPILE_FLAGS: -std=c++23 -// N4950 [conv.mem]/2: indirection through the converted pointer with a D -// object is the same as indirecting through the pointer to member of B with -// the B subobject of D. -#include - -struct Precedes { - int preceding; -}; - -struct DeclaresIncrement { - int value; - void increment() { ++value; } -}; - -struct InheritsIncrement : Precedes, DeclaresIncrement { - int own; -}; - -int main() { - void (DeclaresIncrement::*base_pmf)() = &DeclaresIncrement::increment; - void (InheritsIncrement::*derived_pmf)() = base_pmf; - InheritsIncrement obj; - obj.preceding = 1; - obj.value = 2; - obj.own = 3; - (obj.*derived_pmf)(); - assert(obj.value == 3); - assert(obj.preceding == 1); - assert(obj.own == 3); - return 0; -} diff --git a/tests/std/expr/conv/conv.mem/p2-null-converts-to-null.cpp b/tests/std/expr/conv/conv.mem/p2-null-converts-to-null.cpp deleted file mode 100644 index 483e682adc..0000000000 --- a/tests/std/expr/conv/conv.mem/p2-null-converts-to-null.cpp +++ /dev/null @@ -1,26 +0,0 @@ -// translation-fail: refcount, unsafe -// ADDITIONAL_COMPILE_FLAGS: -std=c++23 -// N4950 [conv.mem]/2: the null member pointer value is converted to the null -// member pointer value of the destination type. -#include - -struct Precedes { - int preceding; -}; - -struct DeclaresValue { - int value; - void increment() { ++value; } -}; - -struct InheritsValue : Precedes, DeclaresValue {}; - -int main() { - int DeclaresValue::*base_pm = nullptr; - int InheritsValue::*derived_pm = base_pm; - assert(derived_pm == nullptr); - void (DeclaresValue::*base_pmf)() = nullptr; - void (InheritsValue::*derived_pmf)() = base_pmf; - assert(derived_pmf == nullptr); - return 0; -} diff --git a/tests/std/expr/conv/conv.mem/out/refcount/p1-null-distinct-from-first-member.rs b/tests/std/expr/conv/out/refcount/conv.mem.rs similarity index 64% rename from tests/std/expr/conv/conv.mem/out/refcount/p1-null-distinct-from-first-member.rs rename to tests/std/expr/conv/out/refcount/conv.mem.rs index ee0da09cf4..d272ef1c0f 100644 --- a/tests/std/expr/conv/conv.mem/out/refcount/p1-null-distinct-from-first-member.rs +++ b/tests/std/expr/conv/out/refcount/conv.mem.rs @@ -8,22 +8,27 @@ use std::os::fd::AsFd; use std::rc::{Rc, Weak}; #[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] #[byte_size(8)] -pub struct HasTwoInts { +pub struct p1_null_distinct_from_first_member_HasTwoInts { #[offset(0)] pub first: i32, #[offset(4)] pub second: i32, } +pub fn test_0() { + let mut null_pm: isize = -1_isize; + let mut first_pm: isize = + (offset_of_field!(p1_null_distinct_from_first_member_HasTwoInts, first) as isize); + let mut second_pm: isize = + (offset_of_field!(p1_null_distinct_from_first_member_HasTwoInts, second) as isize); + assert!((first_pm != null_pm)); + assert!((second_pm != null_pm)); +} pub fn main() { __cpp2rust_init_globals(); std::process::exit(main_0()); } fn main_0() -> i32 { - let mut null_pm: isize = -1_isize; - let mut first_pm: isize = (offset_of_field!(HasTwoInts, first) as isize); - let mut second_pm: isize = (offset_of_field!(HasTwoInts, second) as isize); - assert!((first_pm != null_pm)); - assert!((second_pm != null_pm)); + ({ test_0() }); return 0; } pub fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/conv/conv.mem/out/unsafe/p1-null-distinct-from-first-member.rs b/tests/std/expr/conv/out/unsafe/conv.mem.rs similarity index 63% rename from tests/std/expr/conv/conv.mem/out/unsafe/p1-null-distinct-from-first-member.rs rename to tests/std/expr/conv/out/unsafe/conv.mem.rs index cf13313d37..b87445fc44 100644 --- a/tests/std/expr/conv/conv.mem/out/unsafe/p1-null-distinct-from-first-member.rs +++ b/tests/std/expr/conv/out/unsafe/conv.mem.rs @@ -8,10 +8,19 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; use std::rc::Rc; #[repr(C)] #[derive(Copy, Clone, VaArg, FnPtrArg, Default)] -pub struct HasTwoInts { +pub struct p1_null_distinct_from_first_member_HasTwoInts { pub first: i32, pub second: i32, } +pub unsafe fn test_0() { + let mut null_pm: isize = -1_isize; + let mut first_pm: isize = + (::std::mem::offset_of!(p1_null_distinct_from_first_member_HasTwoInts, first) as isize); + let mut second_pm: isize = + (::std::mem::offset_of!(p1_null_distinct_from_first_member_HasTwoInts, second) as isize); + assert!(((first_pm) != (null_pm))); + assert!(((second_pm) != (null_pm))); +} pub fn main() { unsafe { __cpp2rust_init_globals(); @@ -19,11 +28,7 @@ pub fn main() { } } unsafe fn main_0() -> i32 { - let mut null_pm: isize = -1_isize; - let mut first_pm: isize = (::std::mem::offset_of!(HasTwoInts, first) as isize); - let mut second_pm: isize = (::std::mem::offset_of!(HasTwoInts, second) as isize); - assert!(((first_pm) != (null_pm))); - assert!(((second_pm) != (null_pm))); + (unsafe { test_0() }); return 0; } pub unsafe fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/expr.compound/expr.cond/p7.4-base-and-derived-pointer-to-member.cpp b/tests/std/expr/expr.compound/expr.cond-unsupported.cpp similarity index 82% rename from tests/std/expr/expr.compound/expr.cond/p7.4-base-and-derived-pointer-to-member.cpp rename to tests/std/expr/expr.compound/expr.cond-unsupported.cpp index 9e83e57e18..e19becf301 100644 --- a/tests/std/expr/expr.compound/expr.cond/p7.4-base-and-derived-pointer-to-member.cpp +++ b/tests/std/expr/expr.compound/expr.cond-unsupported.cpp @@ -1,10 +1,11 @@ // translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 +#include + // N4950 [expr.cond]/7.4: if one or both of the second and third operands have // pointer-to-member type, pointer-to-member conversions bring them to their // composite pointer type. -#include - +namespace p7_4_base_and_derived_pointer_to_member { struct Precedes { int preceding; }; @@ -17,7 +18,7 @@ struct InheritsValue : Precedes, DeclaresValue { int own; }; -int main() { +void test() { int DeclaresValue::*base_pm = &DeclaresValue::value; int InheritsValue::*derived_pm = &InheritsValue::own; InheritsValue obj; @@ -28,5 +29,10 @@ int main() { assert(obj.*(choose_base ? base_pm : derived_pm) == 2); choose_base = false; assert(obj.*(choose_base ? base_pm : derived_pm) == 3); +} +} // namespace p7_4_base_and_derived_pointer_to_member + +int main() { + p7_4_base_and_derived_pointer_to_member::test(); return 0; } diff --git a/tests/std/expr/expr.compound/expr.cond/p7.4-pointer-to-member-and-null.cpp b/tests/std/expr/expr.compound/expr.cond.cpp similarity index 79% rename from tests/std/expr/expr.compound/expr.cond/p7.4-pointer-to-member-and-null.cpp rename to tests/std/expr/expr.compound/expr.cond.cpp index 1df8833025..3533a2cbfa 100644 --- a/tests/std/expr/expr.compound/expr.cond/p7.4-pointer-to-member-and-null.cpp +++ b/tests/std/expr/expr.compound/expr.cond.cpp @@ -1,8 +1,9 @@ // ADDITIONAL_COMPILE_FLAGS: -std=c++23 -// N4950 [expr.cond]/7.4: if one or both of the second and third operands have -// pointer-to-member type, they are brought to their composite pointer type. #include +// N4950 [expr.cond]/7.4: if one or both of the second and third operands have +// pointer-to-member type, they are brought to their composite pointer type. +namespace p7_4_pointer_to_member_and_null { struct HasTwoInts { int first; int second; @@ -12,10 +13,15 @@ static int HasTwoInts::*second_or_null(bool choose_second) { return choose_second ? &HasTwoInts::second : nullptr; } -int main() { +void test() { HasTwoInts obj{3, 4}; assert(second_or_null(false) == nullptr); assert(second_or_null(true) == &HasTwoInts::second); assert(obj.*second_or_null(true) == 4); +} +} // namespace p7_4_pointer_to_member_and_null + +int main() { + p7_4_pointer_to_member_and_null::test(); return 0; } diff --git a/tests/std/expr/expr.compound/expr.eq/p4.3-pointer-to-virtual-member-function.cpp b/tests/std/expr/expr.compound/expr.eq-p4.3-pointer-to-virtual-member-function.cpp similarity index 100% rename from tests/std/expr/expr.compound/expr.eq/p4.3-pointer-to-virtual-member-function.cpp rename to tests/std/expr/expr.compound/expr.eq-p4.3-pointer-to-virtual-member-function.cpp diff --git a/tests/std/expr/expr.compound/expr.eq/p4.4-members-of-unrelated-classes.cpp b/tests/std/expr/expr.compound/expr.eq-p4.4-members-of-unrelated-classes.cpp similarity index 100% rename from tests/std/expr/expr.compound/expr.eq/p4.4-members-of-unrelated-classes.cpp rename to tests/std/expr/expr.compound/expr.eq-p4.4-members-of-unrelated-classes.cpp diff --git a/tests/std/expr/expr.compound/expr.eq-unsupported.cpp b/tests/std/expr/expr.compound/expr.eq-unsupported.cpp new file mode 100644 index 0000000000..7cdb80d6ba --- /dev/null +++ b/tests/std/expr/expr.compound/expr.eq-unsupported.cpp @@ -0,0 +1,98 @@ +// translation-fail: refcount, unsafe +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +#include + +// N4950 [expr.eq]/4.6: two pointers to members compare equal if they would +// refer to the same member of the same subobject, otherwise they compare +// unequal. +namespace p4_6_data_member_of_repeated_base { +struct RepeatedBase { + int value; +}; + +struct FirstPath : RepeatedBase {}; + +struct SecondPath : RepeatedBase {}; + +struct JoinsPaths : FirstPath, SecondPath {}; + +void test() { + int RepeatedBase::*base_pm = &RepeatedBase::value; + int FirstPath::*first_pm = base_pm; + int SecondPath::*second_pm = base_pm; + int JoinsPaths::*through_first = first_pm; + int JoinsPaths::*through_second = second_pm; + assert(base_pm == first_pm); + assert(through_first != through_second); + assert(!(through_first == through_second)); + JoinsPaths obj; + obj.FirstPath::value = 3; + obj.SecondPath::value = 4; + assert(obj.*through_first == 3); + assert(obj.*through_second == 4); +} +} // namespace p4_6_data_member_of_repeated_base + +// N4950 [expr.eq]/4.6: two pointers to members compare equal if they would +// refer to the same member of the same subobject, otherwise they compare +// unequal. +namespace p4_6_member_function_of_repeated_base { +struct RepeatedBase { + int value; + void increment() { ++value; } +}; + +struct FirstPath : RepeatedBase {}; + +struct SecondPath : RepeatedBase {}; + +struct JoinsPaths : FirstPath, SecondPath {}; + +void test() { + void (RepeatedBase::*base_pmf)() = &RepeatedBase::increment; + void (FirstPath::*first_pmf)() = base_pmf; + void (SecondPath::*second_pmf)() = base_pmf; + void (JoinsPaths::*through_first)() = first_pmf; + void (JoinsPaths::*through_second)() = second_pmf; + assert(base_pmf == first_pmf); + assert(through_first != through_second); + assert(!(through_first == through_second)); + JoinsPaths obj; + obj.FirstPath::value = 3; + obj.SecondPath::value = 5; + (obj.*through_first)(); + assert(obj.FirstPath::value == 4); + assert(obj.SecondPath::value == 5); + (obj.*through_second)(); + assert(obj.FirstPath::value == 4); + assert(obj.SecondPath::value == 6); +} +} // namespace p4_6_member_function_of_repeated_base + +// N4950 [expr.eq]/4.6: two pointers to members compare equal if they would +// refer to the same member of the same most derived object, otherwise they +// compare unequal. +namespace p4_6_member_functions { +struct HasTwoMemberFunctions { + void first() {} + void second() {} +}; + +void test() { + void (HasTwoMemberFunctions::*first_pmf)() = &HasTwoMemberFunctions::first; + void (HasTwoMemberFunctions::*also_first_pmf)() = + &HasTwoMemberFunctions::first; + void (HasTwoMemberFunctions::*second_pmf)() = &HasTwoMemberFunctions::second; + assert(first_pmf == also_first_pmf); + assert(!(first_pmf != also_first_pmf)); + assert(first_pmf != second_pmf); + assert(!(first_pmf == second_pmf)); +} +} // namespace p4_6_member_functions + +int main() { + p4_6_data_member_of_repeated_base::test(); + p4_6_member_function_of_repeated_base::test(); + p4_6_member_functions::test(); + return 0; +} diff --git a/tests/std/expr/expr.compound/expr.eq.cpp b/tests/std/expr/expr.compound/expr.eq.cpp new file mode 100644 index 0000000000..c7638c0384 --- /dev/null +++ b/tests/std/expr/expr.compound/expr.eq.cpp @@ -0,0 +1,80 @@ +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +#include + +// N4950 [expr.eq]/4.1: two pointers to members that are both the null member +// pointer value compare equal. +namespace p4_1_both_null { +struct HasTwoInts { + int first; + int second; +}; + +void test() { + int HasTwoInts::*first_null = nullptr; + int HasTwoInts::*second_null = nullptr; + assert(first_null == second_null); + assert(!(first_null != second_null)); +} +} // namespace p4_1_both_null + +// N4950 [expr.eq]/4.2: if only one of two pointers to members is the null +// member pointer value, they compare unequal. +namespace p4_2_one_null { +struct HasTwoInts { + int first; + int second; +}; + +void test() { + int HasTwoInts::*null_pm = nullptr; + int HasTwoInts::*first_pm = &HasTwoInts::first; + assert(first_pm != null_pm); + assert(!(first_pm == null_pm)); + assert(null_pm != first_pm); + assert(!(null_pm == first_pm)); +} +} // namespace p4_2_one_null + +// N4950 [expr.eq]/4.5: pointers to (possibly different) members of the same +// union compare equal. +namespace p4_5_members_of_same_union { +union HasTwoIntMembers { + int first; + int second; +}; + +void test() { + int HasTwoIntMembers::*first_pm = &HasTwoIntMembers::first; + int HasTwoIntMembers::*second_pm = &HasTwoIntMembers::second; + assert(first_pm == second_pm); + assert(!(first_pm != second_pm)); +} +} // namespace p4_5_members_of_same_union + +// N4950 [expr.eq]/4.6: two pointers to members compare equal if they would +// refer to the same member of the same most derived object, otherwise they +// compare unequal. +namespace p4_6_data_members { +struct HasTwoInts { + int first; + int second; +}; + +void test() { + int HasTwoInts::*first_pm = &HasTwoInts::first; + int HasTwoInts::*also_first_pm = &HasTwoInts::first; + int HasTwoInts::*second_pm = &HasTwoInts::second; + assert(first_pm == also_first_pm); + assert(!(first_pm != also_first_pm)); + assert(first_pm != second_pm); + assert(!(first_pm == second_pm)); +} +} // namespace p4_6_data_members + +int main() { + p4_1_both_null::test(); + p4_2_one_null::test(); + p4_5_members_of_same_union::test(); + p4_6_data_members::test(); + return 0; +} diff --git a/tests/std/expr/expr.compound/expr.eq/out/refcount/p4.1-both-null.rs b/tests/std/expr/expr.compound/expr.eq/out/refcount/p4.1-both-null.rs deleted file mode 100644 index d7c0353e6a..0000000000 --- a/tests/std/expr/expr.compound/expr.eq/out/refcount/p4.1-both-null.rs +++ /dev/null @@ -1,28 +0,0 @@ -extern crate libcc2rs; -use libcc2rs::*; -use std::cell::RefCell; -use std::collections::BTreeMap; -use std::io::prelude::*; -use std::io::{Read, Seek, Write}; -use std::os::fd::AsFd; -use std::rc::{Rc, Weak}; -#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] -#[byte_size(8)] -pub struct HasTwoInts { - #[offset(0)] - pub first: i32, - #[offset(4)] - pub second: i32, -} -pub fn main() { - __cpp2rust_init_globals(); - std::process::exit(main_0()); -} -fn main_0() -> i32 { - let mut first_null: isize = -1_isize; - let mut second_null: isize = -1_isize; - assert!((first_null == second_null)); - assert!(!(first_null != second_null)); - return 0; -} -pub fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/expr.compound/expr.eq/out/refcount/p4.2-one-null.rs b/tests/std/expr/expr.compound/expr.eq/out/refcount/p4.2-one-null.rs deleted file mode 100644 index b018abcf9a..0000000000 --- a/tests/std/expr/expr.compound/expr.eq/out/refcount/p4.2-one-null.rs +++ /dev/null @@ -1,30 +0,0 @@ -extern crate libcc2rs; -use libcc2rs::*; -use std::cell::RefCell; -use std::collections::BTreeMap; -use std::io::prelude::*; -use std::io::{Read, Seek, Write}; -use std::os::fd::AsFd; -use std::rc::{Rc, Weak}; -#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] -#[byte_size(8)] -pub struct HasTwoInts { - #[offset(0)] - pub first: i32, - #[offset(4)] - pub second: i32, -} -pub fn main() { - __cpp2rust_init_globals(); - std::process::exit(main_0()); -} -fn main_0() -> i32 { - let mut null_pm: isize = -1_isize; - let mut first_pm: isize = (offset_of_field!(HasTwoInts, first) as isize); - assert!((first_pm != null_pm)); - assert!(!(first_pm == null_pm)); - assert!((null_pm != first_pm)); - assert!(!(null_pm == first_pm)); - return 0; -} -pub fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/expr.compound/expr.eq/out/refcount/p4.5-members-of-same-union.rs b/tests/std/expr/expr.compound/expr.eq/out/refcount/p4.5-members-of-same-union.rs deleted file mode 100644 index 963b86e0a5..0000000000 --- a/tests/std/expr/expr.compound/expr.eq/out/refcount/p4.5-members-of-same-union.rs +++ /dev/null @@ -1,42 +0,0 @@ -extern crate libcc2rs; -use libcc2rs::*; -use std::cell::RefCell; -use std::collections::BTreeMap; -use std::io::prelude::*; -use std::io::{Read, Seek, Write}; -use std::os::fd::AsFd; -use std::rc::{Rc, Weak}; -#[derive(VaArg, FnPtrArg, ByteRepr, Clone)] -#[byte_size(4)] -pub struct HasTwoIntMembers { - #[offset(0)] - #[byte_size(4)] - __bytes: Box<[u8]>, -} -impl HasTwoIntMembers { - pub fn first(this: Ptr) -> Ptr { - this.reinterpret_cast() - } - pub fn second(this: Ptr) -> Ptr { - this.reinterpret_cast() - } -} -impl Default for HasTwoIntMembers { - fn default() -> Self { - HasTwoIntMembers { - __bytes: Box::from([0u8; 4]), - } - } -} -pub fn main() { - __cpp2rust_init_globals(); - std::process::exit(main_0()); -} -fn main_0() -> i32 { - let mut first_pm: isize = 0_isize; - let mut second_pm: isize = 0_isize; - assert!((first_pm == second_pm)); - assert!(!(first_pm != second_pm)); - return 0; -} -pub fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/expr.compound/expr.eq/out/refcount/p4.6-data-members.rs b/tests/std/expr/expr.compound/expr.eq/out/refcount/p4.6-data-members.rs deleted file mode 100644 index 2801de00fd..0000000000 --- a/tests/std/expr/expr.compound/expr.eq/out/refcount/p4.6-data-members.rs +++ /dev/null @@ -1,31 +0,0 @@ -extern crate libcc2rs; -use libcc2rs::*; -use std::cell::RefCell; -use std::collections::BTreeMap; -use std::io::prelude::*; -use std::io::{Read, Seek, Write}; -use std::os::fd::AsFd; -use std::rc::{Rc, Weak}; -#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] -#[byte_size(8)] -pub struct HasTwoInts { - #[offset(0)] - pub first: i32, - #[offset(4)] - pub second: i32, -} -pub fn main() { - __cpp2rust_init_globals(); - std::process::exit(main_0()); -} -fn main_0() -> i32 { - let mut first_pm: isize = (offset_of_field!(HasTwoInts, first) as isize); - let mut also_first_pm: isize = (offset_of_field!(HasTwoInts, first) as isize); - let mut second_pm: isize = (offset_of_field!(HasTwoInts, second) as isize); - assert!((first_pm == also_first_pm)); - assert!(!(first_pm != also_first_pm)); - assert!((first_pm != second_pm)); - assert!(!(first_pm == second_pm)); - return 0; -} -pub fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/expr.compound/expr.eq/out/unsafe/p4.1-both-null.rs b/tests/std/expr/expr.compound/expr.eq/out/unsafe/p4.1-both-null.rs deleted file mode 100644 index 39ee015834..0000000000 --- a/tests/std/expr/expr.compound/expr.eq/out/unsafe/p4.1-both-null.rs +++ /dev/null @@ -1,28 +0,0 @@ -extern crate libc; -use libc::*; -extern crate libcc2rs; -use libcc2rs::*; -use std::collections::BTreeMap; -use std::io::{Read, Seek, Write}; -use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; -use std::rc::Rc; -#[repr(C)] -#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] -pub struct HasTwoInts { - pub first: i32, - pub second: i32, -} -pub fn main() { - unsafe { - __cpp2rust_init_globals(); - std::process::exit(main_0() as i32); - } -} -unsafe fn main_0() -> i32 { - let mut first_null: isize = -1_isize; - let mut second_null: isize = -1_isize; - assert!(((first_null) == (second_null))); - assert!(!((first_null) != (second_null))); - return 0; -} -pub unsafe fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/expr.compound/expr.eq/out/unsafe/p4.2-one-null.rs b/tests/std/expr/expr.compound/expr.eq/out/unsafe/p4.2-one-null.rs deleted file mode 100644 index b05050afba..0000000000 --- a/tests/std/expr/expr.compound/expr.eq/out/unsafe/p4.2-one-null.rs +++ /dev/null @@ -1,30 +0,0 @@ -extern crate libc; -use libc::*; -extern crate libcc2rs; -use libcc2rs::*; -use std::collections::BTreeMap; -use std::io::{Read, Seek, Write}; -use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; -use std::rc::Rc; -#[repr(C)] -#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] -pub struct HasTwoInts { - pub first: i32, - pub second: i32, -} -pub fn main() { - unsafe { - __cpp2rust_init_globals(); - std::process::exit(main_0() as i32); - } -} -unsafe fn main_0() -> i32 { - let mut null_pm: isize = -1_isize; - let mut first_pm: isize = (::std::mem::offset_of!(HasTwoInts, first) as isize); - assert!(((first_pm) != (null_pm))); - assert!(!((first_pm) == (null_pm))); - assert!(((null_pm) != (first_pm))); - assert!(!((null_pm) == (first_pm))); - return 0; -} -pub unsafe fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/expr.compound/expr.eq/out/unsafe/p4.5-members-of-same-union.rs b/tests/std/expr/expr.compound/expr.eq/out/unsafe/p4.5-members-of-same-union.rs deleted file mode 100644 index 8e0c27c1ae..0000000000 --- a/tests/std/expr/expr.compound/expr.eq/out/unsafe/p4.5-members-of-same-union.rs +++ /dev/null @@ -1,33 +0,0 @@ -extern crate libc; -use libc::*; -extern crate libcc2rs; -use libcc2rs::*; -use std::collections::BTreeMap; -use std::io::{Read, Seek, Write}; -use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; -use std::rc::Rc; -#[repr(C)] -#[derive(Copy, Clone, FnPtrArg, VaArg)] -pub union HasTwoIntMembers { - pub first: i32, - pub second: i32, -} -impl Default for HasTwoIntMembers { - fn default() -> Self { - unsafe { std::mem::zeroed() } - } -} -pub fn main() { - unsafe { - __cpp2rust_init_globals(); - std::process::exit(main_0() as i32); - } -} -unsafe fn main_0() -> i32 { - let mut first_pm: isize = 0_isize; - let mut second_pm: isize = 0_isize; - assert!(((first_pm) == (second_pm))); - assert!(!((first_pm) != (second_pm))); - return 0; -} -pub unsafe fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/expr.compound/expr.eq/out/unsafe/p4.6-data-members.rs b/tests/std/expr/expr.compound/expr.eq/out/unsafe/p4.6-data-members.rs deleted file mode 100644 index 1d6d711a59..0000000000 --- a/tests/std/expr/expr.compound/expr.eq/out/unsafe/p4.6-data-members.rs +++ /dev/null @@ -1,31 +0,0 @@ -extern crate libc; -use libc::*; -extern crate libcc2rs; -use libcc2rs::*; -use std::collections::BTreeMap; -use std::io::{Read, Seek, Write}; -use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; -use std::rc::Rc; -#[repr(C)] -#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] -pub struct HasTwoInts { - pub first: i32, - pub second: i32, -} -pub fn main() { - unsafe { - __cpp2rust_init_globals(); - std::process::exit(main_0() as i32); - } -} -unsafe fn main_0() -> i32 { - let mut first_pm: isize = (::std::mem::offset_of!(HasTwoInts, first) as isize); - let mut also_first_pm: isize = (::std::mem::offset_of!(HasTwoInts, first) as isize); - let mut second_pm: isize = (::std::mem::offset_of!(HasTwoInts, second) as isize); - assert!(((first_pm) == (also_first_pm))); - assert!(!((first_pm) != (also_first_pm))); - assert!(((first_pm) != (second_pm))); - assert!(!((first_pm) == (second_pm))); - return 0; -} -pub unsafe fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/expr.compound/expr.eq/p4.1-both-null.cpp b/tests/std/expr/expr.compound/expr.eq/p4.1-both-null.cpp deleted file mode 100644 index 7de5adfd59..0000000000 --- a/tests/std/expr/expr.compound/expr.eq/p4.1-both-null.cpp +++ /dev/null @@ -1,17 +0,0 @@ -// ADDITIONAL_COMPILE_FLAGS: -std=c++23 -// N4950 [expr.eq]/4.1: two pointers to members that are both the null member -// pointer value compare equal. -#include - -struct HasTwoInts { - int first; - int second; -}; - -int main() { - int HasTwoInts::*first_null = nullptr; - int HasTwoInts::*second_null = nullptr; - assert(first_null == second_null); - assert(!(first_null != second_null)); - return 0; -} diff --git a/tests/std/expr/expr.compound/expr.eq/p4.2-one-null.cpp b/tests/std/expr/expr.compound/expr.eq/p4.2-one-null.cpp deleted file mode 100644 index 77df4c4fe7..0000000000 --- a/tests/std/expr/expr.compound/expr.eq/p4.2-one-null.cpp +++ /dev/null @@ -1,19 +0,0 @@ -// ADDITIONAL_COMPILE_FLAGS: -std=c++23 -// N4950 [expr.eq]/4.2: if only one of two pointers to members is the null -// member pointer value, they compare unequal. -#include - -struct HasTwoInts { - int first; - int second; -}; - -int main() { - int HasTwoInts::*null_pm = nullptr; - int HasTwoInts::*first_pm = &HasTwoInts::first; - assert(first_pm != null_pm); - assert(!(first_pm == null_pm)); - assert(null_pm != first_pm); - assert(!(null_pm == first_pm)); - return 0; -} diff --git a/tests/std/expr/expr.compound/expr.eq/p4.5-members-of-same-union.cpp b/tests/std/expr/expr.compound/expr.eq/p4.5-members-of-same-union.cpp deleted file mode 100644 index e74fd2b756..0000000000 --- a/tests/std/expr/expr.compound/expr.eq/p4.5-members-of-same-union.cpp +++ /dev/null @@ -1,17 +0,0 @@ -// ADDITIONAL_COMPILE_FLAGS: -std=c++23 -// N4950 [expr.eq]/4.5: pointers to (possibly different) members of the same -// union compare equal. -#include - -union HasTwoIntMembers { - int first; - int second; -}; - -int main() { - int HasTwoIntMembers::*first_pm = &HasTwoIntMembers::first; - int HasTwoIntMembers::*second_pm = &HasTwoIntMembers::second; - assert(first_pm == second_pm); - assert(!(first_pm != second_pm)); - return 0; -} diff --git a/tests/std/expr/expr.compound/expr.eq/p4.6-data-member-of-repeated-base.cpp b/tests/std/expr/expr.compound/expr.eq/p4.6-data-member-of-repeated-base.cpp deleted file mode 100644 index b247410628..0000000000 --- a/tests/std/expr/expr.compound/expr.eq/p4.6-data-member-of-repeated-base.cpp +++ /dev/null @@ -1,33 +0,0 @@ -// translation-fail: refcount, unsafe -// ADDITIONAL_COMPILE_FLAGS: -std=c++23 -// N4950 [expr.eq]/4.6: two pointers to members compare equal if they would -// refer to the same member of the same subobject, otherwise they compare -// unequal. -#include - -struct RepeatedBase { - int value; -}; - -struct FirstPath : RepeatedBase {}; - -struct SecondPath : RepeatedBase {}; - -struct JoinsPaths : FirstPath, SecondPath {}; - -int main() { - int RepeatedBase::*base_pm = &RepeatedBase::value; - int FirstPath::*first_pm = base_pm; - int SecondPath::*second_pm = base_pm; - int JoinsPaths::*through_first = first_pm; - int JoinsPaths::*through_second = second_pm; - assert(base_pm == first_pm); - assert(through_first != through_second); - assert(!(through_first == through_second)); - JoinsPaths obj; - obj.FirstPath::value = 3; - obj.SecondPath::value = 4; - assert(obj.*through_first == 3); - assert(obj.*through_second == 4); - return 0; -} diff --git a/tests/std/expr/expr.compound/expr.eq/p4.6-data-members.cpp b/tests/std/expr/expr.compound/expr.eq/p4.6-data-members.cpp deleted file mode 100644 index f52c54b8a2..0000000000 --- a/tests/std/expr/expr.compound/expr.eq/p4.6-data-members.cpp +++ /dev/null @@ -1,21 +0,0 @@ -// ADDITIONAL_COMPILE_FLAGS: -std=c++23 -// N4950 [expr.eq]/4.6: two pointers to members compare equal if they would -// refer to the same member of the same most derived object, otherwise they -// compare unequal. -#include - -struct HasTwoInts { - int first; - int second; -}; - -int main() { - int HasTwoInts::*first_pm = &HasTwoInts::first; - int HasTwoInts::*also_first_pm = &HasTwoInts::first; - int HasTwoInts::*second_pm = &HasTwoInts::second; - assert(first_pm == also_first_pm); - assert(!(first_pm != also_first_pm)); - assert(first_pm != second_pm); - assert(!(first_pm == second_pm)); - return 0; -} diff --git a/tests/std/expr/expr.compound/expr.eq/p4.6-member-function-of-repeated-base.cpp b/tests/std/expr/expr.compound/expr.eq/p4.6-member-function-of-repeated-base.cpp deleted file mode 100644 index 6e74da2816..0000000000 --- a/tests/std/expr/expr.compound/expr.eq/p4.6-member-function-of-repeated-base.cpp +++ /dev/null @@ -1,38 +0,0 @@ -// translation-fail: refcount, unsafe -// ADDITIONAL_COMPILE_FLAGS: -std=c++23 -// N4950 [expr.eq]/4.6: two pointers to members compare equal if they would -// refer to the same member of the same subobject, otherwise they compare -// unequal. -#include - -struct RepeatedBase { - int value; - void increment() { ++value; } -}; - -struct FirstPath : RepeatedBase {}; - -struct SecondPath : RepeatedBase {}; - -struct JoinsPaths : FirstPath, SecondPath {}; - -int main() { - void (RepeatedBase::*base_pmf)() = &RepeatedBase::increment; - void (FirstPath::*first_pmf)() = base_pmf; - void (SecondPath::*second_pmf)() = base_pmf; - void (JoinsPaths::*through_first)() = first_pmf; - void (JoinsPaths::*through_second)() = second_pmf; - assert(base_pmf == first_pmf); - assert(through_first != through_second); - assert(!(through_first == through_second)); - JoinsPaths obj; - obj.FirstPath::value = 3; - obj.SecondPath::value = 5; - (obj.*through_first)(); - assert(obj.FirstPath::value == 4); - assert(obj.SecondPath::value == 5); - (obj.*through_second)(); - assert(obj.FirstPath::value == 4); - assert(obj.SecondPath::value == 6); - return 0; -} diff --git a/tests/std/expr/expr.compound/expr.eq/p4.6-member-functions.cpp b/tests/std/expr/expr.compound/expr.eq/p4.6-member-functions.cpp deleted file mode 100644 index 21ecdfc3e2..0000000000 --- a/tests/std/expr/expr.compound/expr.eq/p4.6-member-functions.cpp +++ /dev/null @@ -1,23 +0,0 @@ -// translation-fail: refcount, unsafe -// ADDITIONAL_COMPILE_FLAGS: -std=c++23 -// N4950 [expr.eq]/4.6: two pointers to members compare equal if they would -// refer to the same member of the same most derived object, otherwise they -// compare unequal. -#include - -struct HasTwoMemberFunctions { - void first() {} - void second() {} -}; - -int main() { - void (HasTwoMemberFunctions::*first_pmf)() = &HasTwoMemberFunctions::first; - void (HasTwoMemberFunctions::*also_first_pmf)() = - &HasTwoMemberFunctions::first; - void (HasTwoMemberFunctions::*second_pmf)() = &HasTwoMemberFunctions::second; - assert(first_pmf == also_first_pmf); - assert(!(first_pmf != also_first_pmf)); - assert(first_pmf != second_pmf); - assert(!(first_pmf == second_pmf)); - return 0; -} diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/p4-dynamic-type-lacks-member.cpp b/tests/std/expr/expr.compound/expr.mptr.oper-p4-dynamic-type-lacks-member.cpp similarity index 100% rename from tests/std/expr/expr.compound/expr.mptr.oper/p4-dynamic-type-lacks-member.cpp rename to tests/std/expr/expr.compound/expr.mptr.oper-p4-dynamic-type-lacks-member.cpp diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/p4-object-type-not-similar.cpp b/tests/std/expr/expr.compound/expr.mptr.oper-p4-object-type-not-similar.cpp similarity index 100% rename from tests/std/expr/expr.compound/expr.mptr.oper/p4-object-type-not-similar.cpp rename to tests/std/expr/expr.compound/expr.mptr.oper-p4-object-type-not-similar.cpp diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/p6-null-pointer-to-data-member.cpp b/tests/std/expr/expr.compound/expr.mptr.oper-p6-null-pointer-to-data-member.cpp similarity index 100% rename from tests/std/expr/expr.compound/expr.mptr.oper/p6-null-pointer-to-data-member.cpp rename to tests/std/expr/expr.compound/expr.mptr.oper-p6-null-pointer-to-data-member.cpp diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/p6-null-pointer-to-member-function.cpp b/tests/std/expr/expr.compound/expr.mptr.oper-p6-null-pointer-to-member-function.cpp similarity index 100% rename from tests/std/expr/expr.compound/expr.mptr.oper/p6-null-pointer-to-member-function.cpp rename to tests/std/expr/expr.compound/expr.mptr.oper-p6-null-pointer-to-member-function.cpp diff --git a/tests/std/expr/expr.compound/expr.mptr.oper-unsupported.cpp b/tests/std/expr/expr.compound/expr.mptr.oper-unsupported.cpp new file mode 100644 index 0000000000..821d91afed --- /dev/null +++ b/tests/std/expr/expr.compound/expr.mptr.oper-unsupported.cpp @@ -0,0 +1,124 @@ +// no-compile: refcount, unsafe +// translation-fail: refcount, unsafe +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +#include + +// N4950 [expr.mptr.oper]/2: .* binds a "pointer to member of T" to a glvalue +// of class T or of a class of which T is an unambiguous and accessible base. +namespace p2_object_of_derived_class { +struct Precedes { + int preceding; +}; + +struct DeclaresValue { + int value; +}; + +struct InheritsValue : Precedes, DeclaresValue { + int own; +}; + +void test() { + int DeclaresValue::*pm = &DeclaresValue::value; + InheritsValue obj; + obj.preceding = 1; + obj.value = 2; + obj.own = 3; + assert(obj.*pm == 2); + obj.*pm = 4; + assert(obj.value == 4); + assert(obj.preceding == 1); + assert(obj.own == 3); +} +} // namespace p2_object_of_derived_class + +// N4950 [expr.mptr.oper]/3: the first operand of ->* is a "pointer to U" where +// U is T or a class of which T is an unambiguous and accessible base. +namespace p3_arrow_star_pointer_to_derived_class { +struct Precedes { + int preceding; +}; + +struct DeclaresValue { + int value; +}; + +struct InheritsValue : Precedes, DeclaresValue { + int own; +}; + +void test() { + int DeclaresValue::*pm = &DeclaresValue::value; + InheritsValue obj; + obj.preceding = 1; + obj.value = 2; + obj.own = 3; + InheritsValue *p = &obj; + assert(p->*pm == 2); + p->*pm = 4; + assert(obj.value == 4); + assert(obj.preceding == 1); + assert(obj.own == 3); +} +} // namespace p3_arrow_star_pointer_to_derived_class + +// N4950 [expr.mptr.oper]/6: if the result of .* or ->* is a function, it can +// be used only as the operand of the function call operator (). +namespace p6_member_function_call { +struct AccumulatesCalls { + int total = 0; + int add(int amount) { + total += amount; + return total; + } +}; + +void test() { + int (AccumulatesCalls::*pmf)(int) = &AccumulatesCalls::add; + AccumulatesCalls first; + AccumulatesCalls second; + assert((first.*pmf)(3) == 3); + assert(first.total == 3); + assert(second.total == 0); + AccumulatesCalls *p = &second; + assert((p->*pmf)(4) == 4); + assert(first.total == 3); + assert(second.total == 4); +} +} // namespace p6_member_function_call + +// N4950 [expr.mptr.oper]/6: if the result of .* or ->* is a function, it can +// be used only as the operand of the function call operator (). +namespace p6_pointer_to_virtual_member_function { +static int base_calls; +static int override_calls; + +struct DeclaresVirtual { + virtual void run() { ++base_calls; } +}; + +struct OverridesVirtual : DeclaresVirtual { + void run() override { ++override_calls; } +}; + +void test() { + void (DeclaresVirtual::*pmf)() = &DeclaresVirtual::run; + DeclaresVirtual base; + OverridesVirtual overrider; + (base.*pmf)(); + assert(base_calls == 1); + assert(override_calls == 0); + DeclaresVirtual &ref = overrider; + (ref.*pmf)(); + assert(base_calls == 1); + assert(override_calls == 1); +} +} // namespace p6_pointer_to_virtual_member_function + +int main() { + p2_object_of_derived_class::test(); + p3_arrow_star_pointer_to_derived_class::test(); + p6_member_function_call::test(); + p6_pointer_to_virtual_member_function::test(); + return 0; +} diff --git a/tests/std/expr/expr.compound/expr.mptr.oper.cpp b/tests/std/expr/expr.compound/expr.mptr.oper.cpp new file mode 100644 index 0000000000..6f56e2f41c --- /dev/null +++ b/tests/std/expr/expr.compound/expr.mptr.oper.cpp @@ -0,0 +1,105 @@ +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +#include +#include + +// N4950 [expr.mptr.oper]/3: E1->*E2 is converted into (*(E1)).*E2. +namespace p3_arrow_star { +struct HasTwoInts { + int first; + int second; +}; + +void test() { + int HasTwoInts::*pm = &HasTwoInts::second; + HasTwoInts obj{3, 4}; + HasTwoInts *p = &obj; + assert(p->*pm == 4); + p->*pm = 5; + assert(obj.second == 5); + assert(obj.first == 3); + assert(&(p->*pm) == &((*p).*pm)); +} +} // namespace p3_arrow_star + +// N4950 [expr.mptr.oper]/4: in E1.*E2, E1 is sequenced before E2. +namespace p4_object_expression_sequenced_first { +struct HasValue { + int value; +}; + +static int sequence; +static int object_stamp; +static int member_stamp; +static HasValue object{7}; + +static HasValue &select_object() { + object_stamp = ++sequence; + return object; +} + +static int HasValue::*select_member() { + member_stamp = ++sequence; + return &HasValue::value; +} + +void test() { + assert(select_object().*select_member() == 7); + assert(object_stamp == 1); + assert(member_stamp == 2); +} +} // namespace p4_object_expression_sequenced_first + +// N4950 [expr.mptr.oper]/6: the result of .* with a pointer to data member is +// an lvalue if the first operand is an lvalue. +namespace p6_data_member_of_lvalue_is_lvalue { +struct HasTwoInts { + int first; + int second; +}; + +void test() { + int HasTwoInts::*pm = &HasTwoInts::second; + HasTwoInts obj{3, 4}; + assert(&(obj.*pm) == &obj.second); + int &ref = obj.*pm; + ref = 5; + assert(obj.second == 5); + assert(obj.first == 3); +} +} // namespace p6_data_member_of_lvalue_is_lvalue + +// N4950 [expr.mptr.oper]/6: the result of .* with a pointer to data member is +// an lvalue if the first operand is an lvalue and an xvalue otherwise. +namespace p6_data_member_of_rvalue_is_xvalue { +struct CountsCopiesAndMoves { + static inline int copyCount = 0; + static inline int moveCount = 0; + + CountsCopiesAndMoves() = default; + CountsCopiesAndMoves(const CountsCopiesAndMoves &) { ++copyCount; } + CountsCopiesAndMoves(CountsCopiesAndMoves &&) { ++moveCount; } +}; + +struct HoldsCounted { + CountsCopiesAndMoves member; +}; + +void test() { + CountsCopiesAndMoves HoldsCounted::*pm = &HoldsCounted::member; + HoldsCounted holder; + CountsCopiesAndMoves from_lvalue = holder.*pm; + assert(CountsCopiesAndMoves::copyCount == 1); + assert(CountsCopiesAndMoves::moveCount == 0); + CountsCopiesAndMoves from_xvalue = std::move(holder).*pm; + assert(CountsCopiesAndMoves::copyCount == 1); + assert(CountsCopiesAndMoves::moveCount == 1); +} +} // namespace p6_data_member_of_rvalue_is_xvalue + +int main() { + p3_arrow_star::test(); + p4_object_expression_sequenced_first::test(); + p6_data_member_of_lvalue_is_lvalue::test(); + p6_data_member_of_rvalue_is_xvalue::test(); + return 0; +} diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p3-arrow-star.rs b/tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p3-arrow-star.rs deleted file mode 100644 index de03789803..0000000000 --- a/tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p3-arrow-star.rs +++ /dev/null @@ -1,35 +0,0 @@ -extern crate libcc2rs; -use libcc2rs::*; -use std::cell::RefCell; -use std::collections::BTreeMap; -use std::io::prelude::*; -use std::io::{Read, Seek, Write}; -use std::os::fd::AsFd; -use std::rc::{Rc, Weak}; -#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] -#[byte_size(8)] -pub struct HasTwoInts { - #[offset(0)] - pub first: i32, - #[offset(4)] - pub second: i32, -} -pub fn main() { - __cpp2rust_init_globals(); - std::process::exit(main_0()); -} -fn main_0() -> i32 { - let mut pm: isize = (offset_of_field!(HasTwoInts, second) as isize); - let obj: Value = Rc::new(RefCell::new(HasTwoInts { - first: 3, - second: 4, - })); - let mut p: Ptr = (obj.as_pointer()); - assert!((((p).member::(pm).read()) == 4)); - (p).member::(pm).write(5); - assert!(({ ({ (*obj.borrow()).second } == 5) })); - assert!(({ ({ (*obj.borrow()).first } == 3) })); - assert!((((p).member::(pm)) == ((p).member::(pm)))); - return 0; -} -pub fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p4-object-expression-sequenced-first.rs b/tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p4-object-expression-sequenced-first.rs deleted file mode 100644 index d87a482be0..0000000000 --- a/tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p4-object-expression-sequenced-first.rs +++ /dev/null @@ -1,57 +0,0 @@ -extern crate libcc2rs; -use libcc2rs::*; -use std::cell::RefCell; -use std::collections::BTreeMap; -use std::io::prelude::*; -use std::io::{Read, Seek, Write}; -use std::os::fd::AsFd; -use std::rc::{Rc, Weak}; -#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] -#[byte_size(4)] -pub struct HasValue { - #[offset(0)] - pub value: i32, -} -thread_local!( - pub static sequence_0: Value = Rc::new(RefCell::new(0_i32)); -); -thread_local!( - pub static object_stamp_1: Value = Rc::new(RefCell::new(0_i32)); -); -thread_local!( - pub static member_stamp_2: Value = Rc::new(RefCell::new(0_i32)); -); -thread_local!( - pub static object_3: Value = Rc::new(RefCell::new(HasValue { value: 7 })); -); -pub fn select_object_4() -> Ptr { - object_stamp_1 - .with(|rc| *rc.borrow_mut() = (*sequence_0.with(Value::clone).borrow_mut()).prefix_inc()); - return object_3.with(|v| v.as_pointer()); -} -pub fn select_member_5() -> isize { - member_stamp_2 - .with(|rc| *rc.borrow_mut() = (*sequence_0.with(Value::clone).borrow_mut()).prefix_inc()); - return (offset_of_field!(HasValue, value) as isize); -} -pub fn main() { - __cpp2rust_init_globals(); - std::process::exit(main_0()); -} -fn main_0() -> i32 { - assert!( - ((({ select_object_4() }) - .member::(({ select_member_5() })) - .read()) - == 7) - ); - assert!((object_stamp_1.with(|rc| *rc.borrow()) == 1)); - assert!((member_stamp_2.with(|rc| *rc.borrow()) == 2)); - return 0; -} -pub fn __cpp2rust_init_globals() { - let _ = sequence_0.with(|_| ()); - let _ = object_stamp_1.with(|_| ()); - let _ = member_stamp_2.with(|_| ()); - let _ = object_3.with(|_| ()); -} diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p6-data-member-of-lvalue-is-lvalue.rs b/tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p6-data-member-of-lvalue-is-lvalue.rs deleted file mode 100644 index c0723e25b8..0000000000 --- a/tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p6-data-member-of-lvalue-is-lvalue.rs +++ /dev/null @@ -1,34 +0,0 @@ -extern crate libcc2rs; -use libcc2rs::*; -use std::cell::RefCell; -use std::collections::BTreeMap; -use std::io::prelude::*; -use std::io::{Read, Seek, Write}; -use std::os::fd::AsFd; -use std::rc::{Rc, Weak}; -#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] -#[byte_size(8)] -pub struct HasTwoInts { - #[offset(0)] - pub first: i32, - #[offset(4)] - pub second: i32, -} -pub fn main() { - __cpp2rust_init_globals(); - std::process::exit(main_0()); -} -fn main_0() -> i32 { - let mut pm: isize = (offset_of_field!(HasTwoInts, second) as isize); - let obj: Value = Rc::new(RefCell::new(HasTwoInts { - first: 3, - second: 4, - })); - assert!((((obj.as_pointer()).member::(pm)) == (field_ptr!(obj.as_pointer(), second)))); - let ref_: Ptr = (obj.as_pointer()).member::(pm); - ref_.write(5); - assert!(({ ({ (*obj.borrow()).second } == 5) })); - assert!(({ ({ (*obj.borrow()).first } == 3) })); - return 0; -} -pub fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p6-data-member-of-rvalue-is-xvalue.rs b/tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p6-data-member-of-rvalue-is-xvalue.rs deleted file mode 100644 index cb4248b7f0..0000000000 --- a/tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p6-data-member-of-rvalue-is-xvalue.rs +++ /dev/null @@ -1,72 +0,0 @@ -extern crate libcc2rs; -use libcc2rs::*; -use std::cell::RefCell; -use std::collections::BTreeMap; -use std::io::prelude::*; -use std::io::{Read, Seek, Write}; -use std::os::fd::AsFd; -use std::rc::{Rc, Weak}; -thread_local!( - pub static copyCount_0: Value = Rc::new(RefCell::new(0)); -); -thread_local!( - pub static moveCount_1: Value = Rc::new(RefCell::new(0)); -); -#[derive(Record, ByteRepr, VaArg, FnPtrArg, MoveCtor, Default)] -#[byte_size(1)] -pub struct CountsCopiesAndMoves {} -impl CountsCopiesAndMoves { - pub fn copy_from(_a0: Ptr) -> Self { - let __this: CountsCopiesAndMoves = Self {}; - (*copyCount_0.with(Value::clone).borrow_mut()).prefix_inc(); - __this - } - pub fn move_from(_a0: Ptr) -> Self { - let __this: CountsCopiesAndMoves = Self {}; - (*moveCount_1.with(Value::clone).borrow_mut()).prefix_inc(); - __this - } -} -impl Clone for CountsCopiesAndMoves { - fn clone(&self) -> Self { - let __src: Value = Rc::new(RefCell::new(CountsCopiesAndMoves {})); - CountsCopiesAndMoves::copy_from(__src.as_pointer()) - } -} -#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, MoveCtor, Default)] -#[byte_size(1)] -pub struct HoldsCounted { - #[offset(0)] - #[byte_size(1)] - pub member: CountsCopiesAndMoves, -} -impl HoldsCounted { - pub fn move_from(_a0: Ptr) -> Self { - Self { - member: CountsCopiesAndMoves::move_from({ field_ptr!(_a0, member) }), - } - } -} -pub fn main() { - __cpp2rust_init_globals(); - std::process::exit(main_0()); -} -fn main_0() -> i32 { - let mut pm: isize = (offset_of_field!(HoldsCounted, member) as isize); - let holder: Value = Rc::new(RefCell::new(::default())); - let mut from_lvalue: CountsCopiesAndMoves = CountsCopiesAndMoves::copy_from({ - (holder.as_pointer()).member::(pm) - }); - assert!((copyCount_0.with(|rc| *rc.borrow()) == 1)); - assert!((moveCount_1.with(|rc| *rc.borrow()) == 0)); - let mut from_xvalue: CountsCopiesAndMoves = CountsCopiesAndMoves::move_from({ - (holder.as_pointer()).member::(pm) - }); - assert!((copyCount_0.with(|rc| *rc.borrow()) == 1)); - assert!((moveCount_1.with(|rc| *rc.borrow()) == 1)); - return 0; -} -pub fn __cpp2rust_init_globals() { - let _ = copyCount_0.with(|_| ()); - let _ = moveCount_1.with(|_| ()); -} diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p3-arrow-star.rs b/tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p3-arrow-star.rs deleted file mode 100644 index 9ac139c174..0000000000 --- a/tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p3-arrow-star.rs +++ /dev/null @@ -1,40 +0,0 @@ -extern crate libc; -use libc::*; -extern crate libcc2rs; -use libcc2rs::*; -use std::collections::BTreeMap; -use std::io::{Read, Seek, Write}; -use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; -use std::rc::Rc; -#[repr(C)] -#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] -pub struct HasTwoInts { - pub first: i32, - pub second: i32, -} -pub fn main() { - unsafe { - __cpp2rust_init_globals(); - std::process::exit(main_0() as i32); - } -} -unsafe fn main_0() -> i32 { - let mut pm: isize = (::std::mem::offset_of!(HasTwoInts, second) as isize); - let mut obj: HasTwoInts = HasTwoInts { - first: 3, - second: 4, - }; - let mut p: *mut HasTwoInts = (&mut obj as *mut HasTwoInts); - assert!(((*(p).wrapping_byte_offset(pm).cast::()) == (4))); - (*(p).wrapping_byte_offset(pm).cast::()) = 5; - assert!(((obj.second) == (5))); - assert!(((obj.first) == (3))); - assert!( - ((&mut (*(p).wrapping_byte_offset(pm).cast::()) as *mut i32) - == (&mut (*(&mut (*p) as *mut HasTwoInts) - .wrapping_byte_offset(pm) - .cast::()) as *mut i32)) - ); - return 0; -} -pub unsafe fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p4-object-expression-sequenced-first.rs b/tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p4-object-expression-sequenced-first.rs deleted file mode 100644 index 05d3d0b7c9..0000000000 --- a/tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p4-object-expression-sequenced-first.rs +++ /dev/null @@ -1,53 +0,0 @@ -extern crate libc; -use libc::*; -extern crate libcc2rs; -use libcc2rs::*; -use std::collections::BTreeMap; -use std::io::{Read, Seek, Write}; -use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; -use std::rc::Rc; -#[repr(C)] -#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] -pub struct HasValue { - pub value: i32, -} -pub static mut sequence_0: std::cell::LazyCell = std::cell::LazyCell::new(|| unsafe { 0_i32 }); -pub static mut object_stamp_1: std::cell::LazyCell = - std::cell::LazyCell::new(|| unsafe { 0_i32 }); -pub static mut member_stamp_2: std::cell::LazyCell = - std::cell::LazyCell::new(|| unsafe { 0_i32 }); -pub static mut object_3: std::cell::LazyCell = - std::cell::LazyCell::new(|| unsafe { HasValue { value: 7 } }); -pub unsafe fn select_object_4() -> *mut HasValue { - (*std::cell::LazyCell::force_mut(&mut *&raw mut object_stamp_1)) = - (*std::cell::LazyCell::force_mut(&mut *&raw mut sequence_0)).prefix_inc(); - return &mut (*std::cell::LazyCell::force_mut(&mut *&raw mut object_3)); -} -pub unsafe fn select_member_5() -> isize { - (*std::cell::LazyCell::force_mut(&mut *&raw mut member_stamp_2)) = - (*std::cell::LazyCell::force_mut(&mut *&raw mut sequence_0)).prefix_inc(); - return (::std::mem::offset_of!(HasValue, value) as isize); -} -pub fn main() { - unsafe { - __cpp2rust_init_globals(); - std::process::exit(main_0() as i32); - } -} -unsafe fn main_0() -> i32 { - assert!( - ((*(unsafe { select_object_4() }) - .wrapping_byte_offset((unsafe { select_member_5() })) - .cast::()) - == (7)) - ); - assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut object_stamp_1)) == (1))); - assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut member_stamp_2)) == (2))); - return 0; -} -pub unsafe fn __cpp2rust_init_globals() { - std::cell::LazyCell::force(&*&raw const sequence_0); - std::cell::LazyCell::force(&*&raw const object_stamp_1); - std::cell::LazyCell::force(&*&raw const member_stamp_2); - std::cell::LazyCell::force(&*&raw const object_3); -} diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p6-data-member-of-lvalue-is-lvalue.rs b/tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p6-data-member-of-lvalue-is-lvalue.rs deleted file mode 100644 index 061647cca2..0000000000 --- a/tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p6-data-member-of-lvalue-is-lvalue.rs +++ /dev/null @@ -1,41 +0,0 @@ -extern crate libc; -use libc::*; -extern crate libcc2rs; -use libcc2rs::*; -use std::collections::BTreeMap; -use std::io::{Read, Seek, Write}; -use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; -use std::rc::Rc; -#[repr(C)] -#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] -pub struct HasTwoInts { - pub first: i32, - pub second: i32, -} -pub fn main() { - unsafe { - __cpp2rust_init_globals(); - std::process::exit(main_0() as i32); - } -} -unsafe fn main_0() -> i32 { - let mut pm: isize = (::std::mem::offset_of!(HasTwoInts, second) as isize); - let mut obj: HasTwoInts = HasTwoInts { - first: 3, - second: 4, - }; - assert!( - ((&mut (*(&mut obj as *mut HasTwoInts) - .wrapping_byte_offset(pm) - .cast::()) as *mut i32) - == (&mut obj.second as *mut i32)) - ); - let ref_: *mut i32 = &mut (*(&mut obj as *mut HasTwoInts) - .wrapping_byte_offset(pm) - .cast::()); - (*ref_) = 5; - assert!(((obj.second) == (5))); - assert!(((obj.first) == (3))); - return 0; -} -pub unsafe fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p6-data-member-of-rvalue-is-xvalue.rs b/tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p6-data-member-of-rvalue-is-xvalue.rs deleted file mode 100644 index 06500e5461..0000000000 --- a/tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p6-data-member-of-rvalue-is-xvalue.rs +++ /dev/null @@ -1,72 +0,0 @@ -extern crate libc; -use libc::*; -extern crate libcc2rs; -use libcc2rs::*; -use std::collections::BTreeMap; -use std::io::{Read, Seek, Write}; -use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; -use std::rc::Rc; -pub static mut copyCount_0: std::cell::LazyCell = std::cell::LazyCell::new(|| unsafe { 0 }); -pub static mut moveCount_1: std::cell::LazyCell = std::cell::LazyCell::new(|| unsafe { 0 }); -#[repr(C)] -#[derive(VaArg, FnPtrArg, MoveCtorUnsafe, Default)] -pub struct CountsCopiesAndMoves {} -impl CountsCopiesAndMoves { - pub unsafe fn copy_from(_a0: *const CountsCopiesAndMoves) -> Self { - let mut this = Self {}; - (*std::cell::LazyCell::force_mut(&mut *&raw mut copyCount_0)).prefix_inc(); - this - } - pub unsafe fn move_from(_a0: *mut CountsCopiesAndMoves) -> Self { - let mut this = Self {}; - (*std::cell::LazyCell::force_mut(&mut *&raw mut moveCount_1)).prefix_inc(); - this - } -} -impl Clone for CountsCopiesAndMoves { - fn clone(&self) -> Self { - unsafe { CountsCopiesAndMoves::copy_from(self as *const CountsCopiesAndMoves) } - } -} -#[repr(C)] -#[derive(Clone, VaArg, FnPtrArg, MoveCtorUnsafe, Default)] -pub struct HoldsCounted { - pub member: CountsCopiesAndMoves, -} -impl HoldsCounted { - pub unsafe fn move_from(_a0: *mut HoldsCounted) -> Self { - let mut this = Self { - member: CountsCopiesAndMoves::move_from({ &mut (*_a0).member }), - }; - this - } -} -pub fn main() { - unsafe { - __cpp2rust_init_globals(); - std::process::exit(main_0() as i32); - } -} -unsafe fn main_0() -> i32 { - let mut pm: isize = (::std::mem::offset_of!(HoldsCounted, member) as isize); - let mut holder: HoldsCounted = ::default(); - let mut from_lvalue: CountsCopiesAndMoves = CountsCopiesAndMoves::copy_from({ - &(*(&mut holder as *mut HoldsCounted) - .wrapping_byte_offset(pm) - .cast::()) - }); - assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut copyCount_0)) == (1))); - assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut moveCount_1)) == (0))); - let mut from_xvalue: CountsCopiesAndMoves = CountsCopiesAndMoves::move_from({ - &mut (*(&mut holder as *mut HoldsCounted) - .wrapping_byte_offset(pm) - .cast::()) - }); - assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut copyCount_0)) == (1))); - assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut moveCount_1)) == (1))); - return 0; -} -pub unsafe fn __cpp2rust_init_globals() { - std::cell::LazyCell::force(&*&raw const copyCount_0); - std::cell::LazyCell::force(&*&raw const moveCount_1); -} diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/p2-object-of-derived-class.cpp b/tests/std/expr/expr.compound/expr.mptr.oper/p2-object-of-derived-class.cpp deleted file mode 100644 index 0ceef4799c..0000000000 --- a/tests/std/expr/expr.compound/expr.mptr.oper/p2-object-of-derived-class.cpp +++ /dev/null @@ -1,31 +0,0 @@ -// no-compile: refcount, unsafe -// ADDITIONAL_COMPILE_FLAGS: -std=c++23 -// N4950 [expr.mptr.oper]/2: .* binds a "pointer to member of T" to a glvalue -// of class T or of a class of which T is an unambiguous and accessible base. -#include - -struct Precedes { - int preceding; -}; - -struct DeclaresValue { - int value; -}; - -struct InheritsValue : Precedes, DeclaresValue { - int own; -}; - -int main() { - int DeclaresValue::*pm = &DeclaresValue::value; - InheritsValue obj; - obj.preceding = 1; - obj.value = 2; - obj.own = 3; - assert(obj.*pm == 2); - obj.*pm = 4; - assert(obj.value == 4); - assert(obj.preceding == 1); - assert(obj.own == 3); - return 0; -} diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/p3-arrow-star-pointer-to-derived-class.cpp b/tests/std/expr/expr.compound/expr.mptr.oper/p3-arrow-star-pointer-to-derived-class.cpp deleted file mode 100644 index e0612bfdac..0000000000 --- a/tests/std/expr/expr.compound/expr.mptr.oper/p3-arrow-star-pointer-to-derived-class.cpp +++ /dev/null @@ -1,32 +0,0 @@ -// no-compile: refcount, unsafe -// ADDITIONAL_COMPILE_FLAGS: -std=c++23 -// N4950 [expr.mptr.oper]/3: the first operand of ->* is a "pointer to U" where -// U is T or a class of which T is an unambiguous and accessible base. -#include - -struct Precedes { - int preceding; -}; - -struct DeclaresValue { - int value; -}; - -struct InheritsValue : Precedes, DeclaresValue { - int own; -}; - -int main() { - int DeclaresValue::*pm = &DeclaresValue::value; - InheritsValue obj; - obj.preceding = 1; - obj.value = 2; - obj.own = 3; - InheritsValue *p = &obj; - assert(p->*pm == 2); - p->*pm = 4; - assert(obj.value == 4); - assert(obj.preceding == 1); - assert(obj.own == 3); - return 0; -} diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/p3-arrow-star.cpp b/tests/std/expr/expr.compound/expr.mptr.oper/p3-arrow-star.cpp deleted file mode 100644 index e144c9c8d6..0000000000 --- a/tests/std/expr/expr.compound/expr.mptr.oper/p3-arrow-star.cpp +++ /dev/null @@ -1,20 +0,0 @@ -// ADDITIONAL_COMPILE_FLAGS: -std=c++23 -// N4950 [expr.mptr.oper]/3: E1->*E2 is converted into (*(E1)).*E2. -#include - -struct HasTwoInts { - int first; - int second; -}; - -int main() { - int HasTwoInts::*pm = &HasTwoInts::second; - HasTwoInts obj{3, 4}; - HasTwoInts *p = &obj; - assert(p->*pm == 4); - p->*pm = 5; - assert(obj.second == 5); - assert(obj.first == 3); - assert(&(p->*pm) == &((*p).*pm)); - return 0; -} diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/p4-object-expression-sequenced-first.cpp b/tests/std/expr/expr.compound/expr.mptr.oper/p4-object-expression-sequenced-first.cpp deleted file mode 100644 index 70932c22c4..0000000000 --- a/tests/std/expr/expr.compound/expr.mptr.oper/p4-object-expression-sequenced-first.cpp +++ /dev/null @@ -1,29 +0,0 @@ -// ADDITIONAL_COMPILE_FLAGS: -std=c++23 -// N4950 [expr.mptr.oper]/4: in E1.*E2, E1 is sequenced before E2. -#include - -struct HasValue { - int value; -}; - -static int sequence; -static int object_stamp; -static int member_stamp; -static HasValue object{7}; - -static HasValue &select_object() { - object_stamp = ++sequence; - return object; -} - -static int HasValue::*select_member() { - member_stamp = ++sequence; - return &HasValue::value; -} - -int main() { - assert(select_object().*select_member() == 7); - assert(object_stamp == 1); - assert(member_stamp == 2); - return 0; -} diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/p6-data-member-of-lvalue-is-lvalue.cpp b/tests/std/expr/expr.compound/expr.mptr.oper/p6-data-member-of-lvalue-is-lvalue.cpp deleted file mode 100644 index 872f4f872d..0000000000 --- a/tests/std/expr/expr.compound/expr.mptr.oper/p6-data-member-of-lvalue-is-lvalue.cpp +++ /dev/null @@ -1,20 +0,0 @@ -// ADDITIONAL_COMPILE_FLAGS: -std=c++23 -// N4950 [expr.mptr.oper]/6: the result of .* with a pointer to data member is -// an lvalue if the first operand is an lvalue. -#include - -struct HasTwoInts { - int first; - int second; -}; - -int main() { - int HasTwoInts::*pm = &HasTwoInts::second; - HasTwoInts obj{3, 4}; - assert(&(obj.*pm) == &obj.second); - int &ref = obj.*pm; - ref = 5; - assert(obj.second == 5); - assert(obj.first == 3); - return 0; -} diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/p6-data-member-of-rvalue-is-xvalue.cpp b/tests/std/expr/expr.compound/expr.mptr.oper/p6-data-member-of-rvalue-is-xvalue.cpp deleted file mode 100644 index 5f76b1b90f..0000000000 --- a/tests/std/expr/expr.compound/expr.mptr.oper/p6-data-member-of-rvalue-is-xvalue.cpp +++ /dev/null @@ -1,30 +0,0 @@ -// ADDITIONAL_COMPILE_FLAGS: -std=c++23 -// N4950 [expr.mptr.oper]/6: the result of .* with a pointer to data member is -// an lvalue if the first operand is an lvalue and an xvalue otherwise. -#include -#include - -struct CountsCopiesAndMoves { - static inline int copyCount = 0; - static inline int moveCount = 0; - - CountsCopiesAndMoves() = default; - CountsCopiesAndMoves(const CountsCopiesAndMoves &) { ++copyCount; } - CountsCopiesAndMoves(CountsCopiesAndMoves &&) { ++moveCount; } -}; - -struct HoldsCounted { - CountsCopiesAndMoves member; -}; - -int main() { - CountsCopiesAndMoves HoldsCounted::*pm = &HoldsCounted::member; - HoldsCounted holder; - CountsCopiesAndMoves from_lvalue = holder.*pm; - assert(CountsCopiesAndMoves::copyCount == 1); - assert(CountsCopiesAndMoves::moveCount == 0); - CountsCopiesAndMoves from_xvalue = std::move(holder).*pm; - assert(CountsCopiesAndMoves::copyCount == 1); - assert(CountsCopiesAndMoves::moveCount == 1); - return 0; -} diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/p6-member-function-call.cpp b/tests/std/expr/expr.compound/expr.mptr.oper/p6-member-function-call.cpp deleted file mode 100644 index bbb1fa9239..0000000000 --- a/tests/std/expr/expr.compound/expr.mptr.oper/p6-member-function-call.cpp +++ /dev/null @@ -1,27 +0,0 @@ -// translation-fail: refcount, unsafe -// ADDITIONAL_COMPILE_FLAGS: -std=c++23 -// N4950 [expr.mptr.oper]/6: if the result of .* or ->* is a function, it can -// be used only as the operand of the function call operator (). -#include - -struct AccumulatesCalls { - int total = 0; - int add(int amount) { - total += amount; - return total; - } -}; - -int main() { - int (AccumulatesCalls::*pmf)(int) = &AccumulatesCalls::add; - AccumulatesCalls first; - AccumulatesCalls second; - assert((first.*pmf)(3) == 3); - assert(first.total == 3); - assert(second.total == 0); - AccumulatesCalls *p = &second; - assert((p->*pmf)(4) == 4); - assert(first.total == 3); - assert(second.total == 4); - return 0; -} diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/p6-pointer-to-virtual-member-function.cpp b/tests/std/expr/expr.compound/expr.mptr.oper/p6-pointer-to-virtual-member-function.cpp deleted file mode 100644 index a51b7d955d..0000000000 --- a/tests/std/expr/expr.compound/expr.mptr.oper/p6-pointer-to-virtual-member-function.cpp +++ /dev/null @@ -1,30 +0,0 @@ -// translation-fail: refcount, unsafe -// ADDITIONAL_COMPILE_FLAGS: -std=c++23 -// N4950 [expr.mptr.oper]/6: if the result of .* or ->* is a function, it can -// be used only as the operand of the function call operator (). -#include - -static int base_calls; -static int override_calls; - -struct DeclaresVirtual { - virtual void run() { ++base_calls; } -}; - -struct OverridesVirtual : DeclaresVirtual { - void run() override { ++override_calls; } -}; - -int main() { - void (DeclaresVirtual::*pmf)() = &DeclaresVirtual::run; - DeclaresVirtual base; - OverridesVirtual overrider; - (base.*pmf)(); - assert(base_calls == 1); - assert(override_calls == 0); - DeclaresVirtual &ref = overrider; - (ref.*pmf)(); - assert(base_calls == 1); - assert(override_calls == 1); - return 0; -} diff --git a/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/p10-result-is-unspecified.cpp b/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast-p10-result-is-unspecified.cpp similarity index 100% rename from tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/p10-result-is-unspecified.cpp rename to tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast-p10-result-is-unspecified.cpp diff --git a/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/p10.1-member-function-round-trip.cpp b/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast-unsupported.cpp similarity index 81% rename from tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/p10.1-member-function-round-trip.cpp rename to tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast-unsupported.cpp index e447ac526b..0497bac8e4 100644 --- a/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/p10.1-member-function-round-trip.cpp +++ b/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast-unsupported.cpp @@ -1,10 +1,11 @@ // translation-fail: refcount, unsafe // ADDITIONAL_COMPILE_FLAGS: -std=c++23 +#include + // N4950 [expr.reinterpret.cast]/10.1: converting a pointer to member function // to a different pointer-to-member-function type and back yields the original // value. -#include - +namespace p10_1_member_function_round_trip { struct CountsCalls { int calls = 0; void run() { ++calls; } @@ -12,7 +13,7 @@ struct CountsCalls { struct Unrelated {}; -int main() { +void test() { void (Unrelated::*converted)(int) = reinterpret_cast(&CountsCalls::run); void (CountsCalls::*back)() = @@ -21,5 +22,10 @@ int main() { CountsCalls obj; (obj.*back)(); assert(obj.calls == 1); +} +} // namespace p10_1_member_function_round_trip + +int main() { + p10_1_member_function_round_trip::test(); return 0; } diff --git a/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/p10.2-data-member-round-trip.cpp b/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast.cpp similarity index 50% rename from tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/p10.2-data-member-round-trip.cpp rename to tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast.cpp index c81149f721..2e1e9922e7 100644 --- a/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/p10.2-data-member-round-trip.cpp +++ b/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast.cpp @@ -1,9 +1,29 @@ // ADDITIONAL_COMPILE_FLAGS: -std=c++23 +#include + +// N4950 [expr.reinterpret.cast]/10: the null member pointer value is converted +// to the null member pointer value of the destination type. +namespace p10_null_converts_to_null { +struct HasTwoInts { + int first; + int second; +}; + +struct HasChar { + char character; +}; + +void test() { + int HasTwoInts::*pm = nullptr; + char HasChar::*converted = reinterpret_cast(pm); + assert(converted == nullptr); +} +} // namespace p10_null_converts_to_null + // N4950 [expr.reinterpret.cast]/10.2: converting "pointer to data member of X // of type T1" to "pointer to data member of Y of type T2" (T2 no more strictly // aligned than T1) and back yields the original value. -#include - +namespace p10_2_data_member_round_trip { struct HasTwoInts { int first; int second; @@ -13,12 +33,18 @@ struct HasChar { char character; }; -int main() { +void test() { char HasChar::*converted = reinterpret_cast(&HasTwoInts::second); int HasTwoInts::*back = reinterpret_cast(converted); assert(back == &HasTwoInts::second); HasTwoInts obj{3, 4}; assert(obj.*back == 4); +} +} // namespace p10_2_data_member_round_trip + +int main() { + p10_null_converts_to_null::test(); + p10_2_data_member_round_trip::test(); return 0; } diff --git a/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/out/refcount/p10-null-converts-to-null.rs b/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/out/refcount/p10-null-converts-to-null.rs deleted file mode 100644 index f423c8bc8f..0000000000 --- a/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/out/refcount/p10-null-converts-to-null.rs +++ /dev/null @@ -1,33 +0,0 @@ -extern crate libcc2rs; -use libcc2rs::*; -use std::cell::RefCell; -use std::collections::BTreeMap; -use std::io::prelude::*; -use std::io::{Read, Seek, Write}; -use std::os::fd::AsFd; -use std::rc::{Rc, Weak}; -#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] -#[byte_size(8)] -pub struct HasTwoInts { - #[offset(0)] - pub first: i32, - #[offset(4)] - pub second: i32, -} -#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] -#[byte_size(1)] -pub struct HasChar { - #[offset(0)] - pub character: i8, -} -pub fn main() { - __cpp2rust_init_globals(); - std::process::exit(main_0()); -} -fn main_0() -> i32 { - let mut pm: isize = -1_isize; - let mut converted: isize = pm; - assert!(((converted) == -1_isize)); - return 0; -} -pub fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/out/refcount/p10.2-data-member-round-trip.rs b/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/out/refcount/p10.2-data-member-round-trip.rs deleted file mode 100644 index 027757226c..0000000000 --- a/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/out/refcount/p10.2-data-member-round-trip.rs +++ /dev/null @@ -1,38 +0,0 @@ -extern crate libcc2rs; -use libcc2rs::*; -use std::cell::RefCell; -use std::collections::BTreeMap; -use std::io::prelude::*; -use std::io::{Read, Seek, Write}; -use std::os::fd::AsFd; -use std::rc::{Rc, Weak}; -#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] -#[byte_size(8)] -pub struct HasTwoInts { - #[offset(0)] - pub first: i32, - #[offset(4)] - pub second: i32, -} -#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] -#[byte_size(1)] -pub struct HasChar { - #[offset(0)] - pub character: i8, -} -pub fn main() { - __cpp2rust_init_globals(); - std::process::exit(main_0()); -} -fn main_0() -> i32 { - let mut converted: isize = (offset_of_field!(HasTwoInts, second) as isize); - let mut back: isize = converted; - assert!((back == (offset_of_field!(HasTwoInts, second) as isize))); - let obj: Value = Rc::new(RefCell::new(HasTwoInts { - first: 3, - second: 4, - })); - assert!((((obj.as_pointer()).member::(back).read()) == 4)); - return 0; -} -pub fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/out/unsafe/p10-null-converts-to-null.rs b/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/out/unsafe/p10-null-converts-to-null.rs deleted file mode 100644 index b1773eeb67..0000000000 --- a/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/out/unsafe/p10-null-converts-to-null.rs +++ /dev/null @@ -1,32 +0,0 @@ -extern crate libc; -use libc::*; -extern crate libcc2rs; -use libcc2rs::*; -use std::collections::BTreeMap; -use std::io::{Read, Seek, Write}; -use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; -use std::rc::Rc; -#[repr(C)] -#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] -pub struct HasTwoInts { - pub first: i32, - pub second: i32, -} -#[repr(C)] -#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] -pub struct HasChar { - pub character: libc::c_char, -} -pub fn main() { - unsafe { - __cpp2rust_init_globals(); - std::process::exit(main_0() as i32); - } -} -unsafe fn main_0() -> i32 { - let mut pm: isize = -1_isize; - let mut converted: isize = pm; - assert!(((converted) == -1_isize)); - return 0; -} -pub unsafe fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/out/unsafe/p10.2-data-member-round-trip.rs b/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/out/unsafe/p10.2-data-member-round-trip.rs deleted file mode 100644 index 8b3fc92e6e..0000000000 --- a/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/out/unsafe/p10.2-data-member-round-trip.rs +++ /dev/null @@ -1,42 +0,0 @@ -extern crate libc; -use libc::*; -extern crate libcc2rs; -use libcc2rs::*; -use std::collections::BTreeMap; -use std::io::{Read, Seek, Write}; -use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; -use std::rc::Rc; -#[repr(C)] -#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] -pub struct HasTwoInts { - pub first: i32, - pub second: i32, -} -#[repr(C)] -#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] -pub struct HasChar { - pub character: libc::c_char, -} -pub fn main() { - unsafe { - __cpp2rust_init_globals(); - std::process::exit(main_0() as i32); - } -} -unsafe fn main_0() -> i32 { - let mut converted: isize = (::std::mem::offset_of!(HasTwoInts, second) as isize); - let mut back: isize = converted; - assert!(((back) == (::std::mem::offset_of!(HasTwoInts, second) as isize))); - let mut obj: HasTwoInts = HasTwoInts { - first: 3, - second: 4, - }; - assert!( - ((*(&mut obj as *mut HasTwoInts) - .wrapping_byte_offset(back) - .cast::()) - == (4)) - ); - return 0; -} -pub unsafe fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/p10-null-converts-to-null.cpp b/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/p10-null-converts-to-null.cpp deleted file mode 100644 index 0e25e92190..0000000000 --- a/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/p10-null-converts-to-null.cpp +++ /dev/null @@ -1,20 +0,0 @@ -// ADDITIONAL_COMPILE_FLAGS: -std=c++23 -// N4950 [expr.reinterpret.cast]/10: the null member pointer value is converted -// to the null member pointer value of the destination type. -#include - -struct HasTwoInts { - int first; - int second; -}; - -struct HasChar { - char character; -}; - -int main() { - int HasTwoInts::*pm = nullptr; - char HasChar::*converted = reinterpret_cast(pm); - assert(converted == nullptr); - return 0; -} diff --git a/tests/std/expr/expr.compound/expr.post/expr.static.cast/p13-base-unrelated-to-member-class.cpp b/tests/std/expr/expr.compound/expr.post/expr.static.cast-p13-base-unrelated-to-member-class.cpp similarity index 100% rename from tests/std/expr/expr.compound/expr.post/expr.static.cast/p13-base-unrelated-to-member-class.cpp rename to tests/std/expr/expr.compound/expr.post/expr.static.cast-p13-base-unrelated-to-member-class.cpp diff --git a/tests/std/expr/expr.compound/expr.post/expr.static.cast-unsupported.cpp b/tests/std/expr/expr.compound/expr.post/expr.static.cast-unsupported.cpp new file mode 100644 index 0000000000..7eec4a68b6 --- /dev/null +++ b/tests/std/expr/expr.compound/expr.post/expr.static.cast-unsupported.cpp @@ -0,0 +1,104 @@ +// translation-fail: refcount, unsafe +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +#include + +// N4950 [expr.static.cast]/13: "pointer to member of D of type T" can be +// converted to "pointer to member of B of type T", B a base class of D; the +// result points to the original member. +namespace p13_derived_to_base_data_member { +struct LacksValue { + int own; +}; + +struct AddsValue : LacksValue { + int value; +}; + +void test() { + int LacksValue::*pm = static_cast(&AddsValue::value); + AddsValue obj; + obj.own = 1; + obj.value = 2; + LacksValue &base = obj; + assert(base.*pm == 2); + base.*pm = 3; + assert(obj.value == 3); + assert(obj.own == 1); +} +} // namespace p13_derived_to_base_data_member + +// N4950 [expr.static.cast]/13: "pointer to member of D of type T" can be +// converted to "pointer to member of B of type T", B a base class of D; the +// result points to the original member. +namespace p13_derived_to_base_member_function { +struct LacksIncrement { + int own; +}; + +struct AddsIncrement : LacksIncrement { + int value; + void increment() { ++value; } +}; + +void test() { + void (LacksIncrement::*pmf)() = + static_cast(&AddsIncrement::increment); + AddsIncrement obj; + obj.own = 1; + obj.value = 2; + LacksIncrement &base = obj; + (base.*pmf)(); + assert(obj.value == 3); + assert(obj.own == 1); +} +} // namespace p13_derived_to_base_member_function + +// N4950 [expr.static.cast]/13: the null member pointer value is converted to +// the null member pointer value of the destination type. +namespace p13_null_converts_to_null { +struct Precedes { + int preceding; +}; + +struct DeclaresValue { + int value; +}; + +struct InheritsValue : Precedes, DeclaresValue {}; + +void test() { + int InheritsValue::*derived_pm = nullptr; + int DeclaresValue::*base_pm = static_cast(derived_pm); + assert(base_pm == nullptr); +} +} // namespace p13_null_converts_to_null + +// N4950 [expr.static.cast]/13: if class B contains the original member, the +// resulting pointer to member points to the original member. +namespace p13_round_trip_yields_original { +struct Precedes { + int preceding; +}; + +struct DeclaresValue { + int value; +}; + +struct InheritsValue : Precedes, DeclaresValue {}; + +void test() { + int InheritsValue::*derived_pm = &DeclaresValue::value; + int DeclaresValue::*base_pm = static_cast(derived_pm); + assert(base_pm == &DeclaresValue::value); + DeclaresValue obj{2}; + assert(obj.*base_pm == 2); +} +} // namespace p13_round_trip_yields_original + +int main() { + p13_derived_to_base_data_member::test(); + p13_derived_to_base_member_function::test(); + p13_null_converts_to_null::test(); + p13_round_trip_yields_original::test(); + return 0; +} diff --git a/tests/std/expr/expr.compound/expr.post/expr.static.cast/p13-derived-to-base-data-member.cpp b/tests/std/expr/expr.compound/expr.post/expr.static.cast/p13-derived-to-base-data-member.cpp deleted file mode 100644 index 2cbd8303db..0000000000 --- a/tests/std/expr/expr.compound/expr.post/expr.static.cast/p13-derived-to-base-data-member.cpp +++ /dev/null @@ -1,27 +0,0 @@ -// translation-fail: refcount, unsafe -// ADDITIONAL_COMPILE_FLAGS: -std=c++23 -// N4950 [expr.static.cast]/13: "pointer to member of D of type T" can be -// converted to "pointer to member of B of type T", B a base class of D; the -// result points to the original member. -#include - -struct LacksValue { - int own; -}; - -struct AddsValue : LacksValue { - int value; -}; - -int main() { - int LacksValue::*pm = static_cast(&AddsValue::value); - AddsValue obj; - obj.own = 1; - obj.value = 2; - LacksValue &base = obj; - assert(base.*pm == 2); - base.*pm = 3; - assert(obj.value == 3); - assert(obj.own == 1); - return 0; -} diff --git a/tests/std/expr/expr.compound/expr.post/expr.static.cast/p13-derived-to-base-member-function.cpp b/tests/std/expr/expr.compound/expr.post/expr.static.cast/p13-derived-to-base-member-function.cpp deleted file mode 100644 index 7a800b6c7a..0000000000 --- a/tests/std/expr/expr.compound/expr.post/expr.static.cast/p13-derived-to-base-member-function.cpp +++ /dev/null @@ -1,28 +0,0 @@ -// translation-fail: refcount, unsafe -// ADDITIONAL_COMPILE_FLAGS: -std=c++23 -// N4950 [expr.static.cast]/13: "pointer to member of D of type T" can be -// converted to "pointer to member of B of type T", B a base class of D; the -// result points to the original member. -#include - -struct LacksIncrement { - int own; -}; - -struct AddsIncrement : LacksIncrement { - int value; - void increment() { ++value; } -}; - -int main() { - void (LacksIncrement::*pmf)() = - static_cast(&AddsIncrement::increment); - AddsIncrement obj; - obj.own = 1; - obj.value = 2; - LacksIncrement &base = obj; - (base.*pmf)(); - assert(obj.value == 3); - assert(obj.own == 1); - return 0; -} diff --git a/tests/std/expr/expr.compound/expr.post/expr.static.cast/p13-null-converts-to-null.cpp b/tests/std/expr/expr.compound/expr.post/expr.static.cast/p13-null-converts-to-null.cpp deleted file mode 100644 index b39b04694a..0000000000 --- a/tests/std/expr/expr.compound/expr.post/expr.static.cast/p13-null-converts-to-null.cpp +++ /dev/null @@ -1,22 +0,0 @@ -// translation-fail: refcount, unsafe -// ADDITIONAL_COMPILE_FLAGS: -std=c++23 -// N4950 [expr.static.cast]/13: the null member pointer value is converted to -// the null member pointer value of the destination type. -#include - -struct Precedes { - int preceding; -}; - -struct DeclaresValue { - int value; -}; - -struct InheritsValue : Precedes, DeclaresValue {}; - -int main() { - int InheritsValue::*derived_pm = nullptr; - int DeclaresValue::*base_pm = static_cast(derived_pm); - assert(base_pm == nullptr); - return 0; -} diff --git a/tests/std/expr/expr.compound/expr.post/expr.static.cast/p13-round-trip-yields-original.cpp b/tests/std/expr/expr.compound/expr.post/expr.static.cast/p13-round-trip-yields-original.cpp deleted file mode 100644 index ab2be9d16f..0000000000 --- a/tests/std/expr/expr.compound/expr.post/expr.static.cast/p13-round-trip-yields-original.cpp +++ /dev/null @@ -1,24 +0,0 @@ -// translation-fail: refcount, unsafe -// ADDITIONAL_COMPILE_FLAGS: -std=c++23 -// N4950 [expr.static.cast]/13: if class B contains the original member, the -// resulting pointer to member points to the original member. -#include - -struct Precedes { - int preceding; -}; - -struct DeclaresValue { - int value; -}; - -struct InheritsValue : Precedes, DeclaresValue {}; - -int main() { - int InheritsValue::*derived_pm = &DeclaresValue::value; - int DeclaresValue::*base_pm = static_cast(derived_pm); - assert(base_pm == &DeclaresValue::value); - DeclaresValue obj{2}; - assert(obj.*base_pm == 2); - return 0; -} diff --git a/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/out/refcount/p10-result-is-unspecified.rs b/tests/std/expr/expr.compound/expr.post/out/refcount/expr.reinterpret.cast-p10-result-is-unspecified.rs similarity index 100% rename from tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/out/refcount/p10-result-is-unspecified.rs rename to tests/std/expr/expr.compound/expr.post/out/refcount/expr.reinterpret.cast-p10-result-is-unspecified.rs diff --git a/tests/std/expr/expr.compound/expr.post/out/refcount/expr.reinterpret.cast.rs b/tests/std/expr/expr.compound/expr.post/out/refcount/expr.reinterpret.cast.rs new file mode 100644 index 0000000000..1785ef8cd7 --- /dev/null +++ b/tests/std/expr/expr.compound/expr.post/out/refcount/expr.reinterpret.cast.rs @@ -0,0 +1,63 @@ +extern crate libcc2rs; +use libcc2rs::*; +use std::cell::RefCell; +use std::collections::BTreeMap; +use std::io::prelude::*; +use std::io::{Read, Seek, Write}; +use std::os::fd::AsFd; +use std::rc::{Rc, Weak}; +#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] +#[byte_size(8)] +pub struct p10_null_converts_to_null_HasTwoInts { + #[offset(0)] + pub first: i32, + #[offset(4)] + pub second: i32, +} +#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] +#[byte_size(1)] +pub struct p10_null_converts_to_null_HasChar { + #[offset(0)] + pub character: i8, +} +pub fn test_0() { + let mut pm: isize = -1_isize; + let mut converted: isize = pm; + assert!(((converted) == -1_isize)); +} +#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] +#[byte_size(8)] +pub struct p10_2_data_member_round_trip_HasTwoInts { + #[offset(0)] + pub first: i32, + #[offset(4)] + pub second: i32, +} +#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] +#[byte_size(1)] +pub struct p10_2_data_member_round_trip_HasChar { + #[offset(0)] + pub character: i8, +} +pub fn test_1() { + let mut converted: isize = + (offset_of_field!(p10_2_data_member_round_trip_HasTwoInts, second) as isize); + let mut back: isize = converted; + assert!((back == (offset_of_field!(p10_2_data_member_round_trip_HasTwoInts, second) as isize))); + let obj: Value = + Rc::new(RefCell::new(p10_2_data_member_round_trip_HasTwoInts { + first: 3, + second: 4, + })); + assert!((((obj.as_pointer()).member::(back).read()) == 4)); +} +pub fn main() { + __cpp2rust_init_globals(); + std::process::exit(main_0()); +} +fn main_0() -> i32 { + ({ test_0() }); + ({ test_1() }); + return 0; +} +pub fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/out/unsafe/p10-result-is-unspecified.rs b/tests/std/expr/expr.compound/expr.post/out/unsafe/expr.reinterpret.cast-p10-result-is-unspecified.rs similarity index 100% rename from tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast/out/unsafe/p10-result-is-unspecified.rs rename to tests/std/expr/expr.compound/expr.post/out/unsafe/expr.reinterpret.cast-p10-result-is-unspecified.rs diff --git a/tests/std/expr/expr.compound/expr.post/out/unsafe/expr.reinterpret.cast.rs b/tests/std/expr/expr.compound/expr.post/out/unsafe/expr.reinterpret.cast.rs new file mode 100644 index 0000000000..02a478c52e --- /dev/null +++ b/tests/std/expr/expr.compound/expr.post/out/unsafe/expr.reinterpret.cast.rs @@ -0,0 +1,67 @@ +extern crate libc; +use libc::*; +extern crate libcc2rs; +use libcc2rs::*; +use std::collections::BTreeMap; +use std::io::{Read, Seek, Write}; +use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; +use std::rc::Rc; +#[repr(C)] +#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] +pub struct p10_null_converts_to_null_HasTwoInts { + pub first: i32, + pub second: i32, +} +#[repr(C)] +#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] +pub struct p10_null_converts_to_null_HasChar { + pub character: libc::c_char, +} +pub unsafe fn test_0() { + let mut pm: isize = -1_isize; + let mut converted: isize = pm; + assert!(((converted) == -1_isize)); +} +#[repr(C)] +#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] +pub struct p10_2_data_member_round_trip_HasTwoInts { + pub first: i32, + pub second: i32, +} +#[repr(C)] +#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] +pub struct p10_2_data_member_round_trip_HasChar { + pub character: libc::c_char, +} +pub unsafe fn test_1() { + let mut converted: isize = + (::std::mem::offset_of!(p10_2_data_member_round_trip_HasTwoInts, second) as isize); + let mut back: isize = converted; + assert!( + ((back) + == (::std::mem::offset_of!(p10_2_data_member_round_trip_HasTwoInts, second) as isize)) + ); + let mut obj: p10_2_data_member_round_trip_HasTwoInts = + p10_2_data_member_round_trip_HasTwoInts { + first: 3, + second: 4, + }; + assert!( + ((*(&mut obj as *mut p10_2_data_member_round_trip_HasTwoInts) + .wrapping_byte_offset(back) + .cast::()) + == (4)) + ); +} +pub fn main() { + unsafe { + __cpp2rust_init_globals(); + std::process::exit(main_0() as i32); + } +} +unsafe fn main_0() -> i32 { + (unsafe { test_0() }); + (unsafe { test_1() }); + return 0; +} +pub unsafe fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/expr.compound/expr.unary/expr.unary.op-unsupported.cpp b/tests/std/expr/expr.compound/expr.unary/expr.unary.op-unsupported.cpp new file mode 100644 index 0000000000..2d41713354 --- /dev/null +++ b/tests/std/expr/expr.compound/expr.unary/expr.unary.op-unsupported.cpp @@ -0,0 +1,54 @@ +// panic: refcount +// no-compile: refcount, unsafe +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +#include + +// N4950 [expr.unary.op]/3.1: a qualified-id naming a variant member of some +// class C yields a pointer to member of class C. +namespace p3_1_anonymous_union_member { +struct HasAnonymousUnion { + int before; + union { + int as_int; + unsigned as_unsigned; + }; +}; + +void test() { + int HasAnonymousUnion::*pm = &HasAnonymousUnion::as_int; + HasAnonymousUnion obj; + obj.before = 1; + obj.as_int = 2; + assert(obj.*pm == 2); + obj.*pm = 3; + assert(obj.as_int == 3); + assert(obj.before == 1); +} +} // namespace p3_1_anonymous_union_member + +// N4950 [expr.unary.op]/3.1: for a qualified-id naming a non-static member m +// of some class C, the result has type "pointer to member of class C" and +// designates C::m; C is the class m is a member of, not the class named. +namespace p3_1_member_named_through_derived_class { +struct DeclaresValue { + int value; +}; + +struct InheritsValue : DeclaresValue { + int own; +}; + +void test() { + auto pm = &InheritsValue::value; + DeclaresValue base{3}; + assert(base.*pm == 3); + InheritsValue derived{{4}, 5}; + assert(derived.*pm == 4); +} +} // namespace p3_1_member_named_through_derived_class + +int main() { + p3_1_anonymous_union_member::test(); + p3_1_member_named_through_derived_class::test(); + return 0; +} diff --git a/tests/std/expr/expr.compound/expr.unary/expr.unary.op.cpp b/tests/std/expr/expr.compound/expr.unary/expr.unary.op.cpp new file mode 100644 index 0000000000..e4bbc2727d --- /dev/null +++ b/tests/std/expr/expr.compound/expr.unary/expr.unary.op.cpp @@ -0,0 +1,54 @@ +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +#include + +// N4950 [expr.unary.op]/3.2: for an operand that is not a non-static member, +// the result has type "pointer to T" and points to the designated object or +// function; a static member is such an operand. +namespace p3_2_static_member_is_ordinary_pointer { +struct HasStaticMembers { + static inline int shared = 3; + static inline int calls = 0; + static void run() { ++calls; } +}; + +void test() { + int *object_pointer = &HasStaticMembers::shared; + assert(*object_pointer == 3); + *object_pointer = 4; + assert(HasStaticMembers::shared == 4); + void (*function_pointer)() = &HasStaticMembers::run; + function_pointer(); + assert(HasStaticMembers::calls == 1); +} +} // namespace p3_2_static_member_is_ordinary_pointer + +// N4950 [expr.unary.op]/4: a pointer to member is only formed when an explicit +// & is used and its operand is a qualified-id not enclosed in parentheses. +namespace p4_parenthesized_qualified_id_is_object_pointer { +struct TakesAddressOfOwnMember { + int value; + int *parenthesized() { return &(TakesAddressOfOwnMember::value); } + int *unqualified() { return &value; } +}; + +void test() { + TakesAddressOfOwnMember first{3}; + TakesAddressOfOwnMember second{4}; + int *p = first.parenthesized(); + assert(p == &first.value); + *p = 5; + assert(first.value == 5); + assert(second.value == 4); + int *q = second.unqualified(); + assert(q == &second.value); + *q = 6; + assert(first.value == 5); + assert(second.value == 6); +} +} // namespace p4_parenthesized_qualified_id_is_object_pointer + +int main() { + p3_2_static_member_is_ordinary_pointer::test(); + p4_parenthesized_qualified_id_is_object_pointer::test(); + return 0; +} diff --git a/tests/std/expr/expr.compound/expr.unary/expr.unary.op/out/refcount/p3.1-anonymous-union-member.rs b/tests/std/expr/expr.compound/expr.unary/expr.unary.op/out/refcount/p3.1-anonymous-union-member.rs deleted file mode 100644 index 6032fc6601..0000000000 --- a/tests/std/expr/expr.compound/expr.unary/expr.unary.op/out/refcount/p3.1-anonymous-union-member.rs +++ /dev/null @@ -1,55 +0,0 @@ -extern crate libcc2rs; -use libcc2rs::*; -use std::cell::RefCell; -use std::collections::BTreeMap; -use std::io::prelude::*; -use std::io::{Read, Seek, Write}; -use std::os::fd::AsFd; -use std::rc::{Rc, Weak}; -#[derive(VaArg, FnPtrArg, ByteRepr, Clone)] -#[byte_size(4)] -pub struct anon_0 { - #[offset(0)] - #[byte_size(4)] - __bytes: Box<[u8]>, -} -impl anon_0 { - pub fn as_int(this: Ptr) -> Ptr { - this.reinterpret_cast() - } - pub fn as_unsigned(this: Ptr) -> Ptr { - this.reinterpret_cast() - } -} -impl Default for anon_0 { - fn default() -> Self { - anon_0 { - __bytes: Box::from([0u8; 4]), - } - } -} -#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] -#[byte_size(8)] -pub struct HasAnonymousUnion { - #[offset(0)] - pub before: i32, - #[offset(4)] - #[byte_size(4)] - pub anon_0: anon_0, -} -pub fn main() { - __cpp2rust_init_globals(); - std::process::exit(main_0()); -} -fn main_0() -> i32 { - let mut pm: isize = (offset_of_field!(HasAnonymousUnion, anon_0) as isize); - let obj: Value = Rc::new(RefCell::new(::default())); - (*obj.borrow_mut()).before = 1; - anon_0::as_int(field_ptr!(obj.as_pointer(), anon_0)).write(2); - assert!((((obj.as_pointer()).member::(pm).read()) == 2)); - (obj.as_pointer()).member::(pm).write(3); - assert!(((anon_0::as_int(field_ptr!(obj.as_pointer(), anon_0)).read()) == 3)); - assert!(({ ({ (*obj.borrow()).before } == 1) })); - return 0; -} -pub fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/expr.compound/expr.unary/expr.unary.op/out/refcount/p3.2-static-member-is-ordinary-pointer.rs b/tests/std/expr/expr.compound/expr.unary/expr.unary.op/out/refcount/p3.2-static-member-is-ordinary-pointer.rs deleted file mode 100644 index c92f8a48e8..0000000000 --- a/tests/std/expr/expr.compound/expr.unary/expr.unary.op/out/refcount/p3.2-static-member-is-ordinary-pointer.rs +++ /dev/null @@ -1,40 +0,0 @@ -extern crate libcc2rs; -use libcc2rs::*; -use std::cell::RefCell; -use std::collections::BTreeMap; -use std::io::prelude::*; -use std::io::{Read, Seek, Write}; -use std::os::fd::AsFd; -use std::rc::{Rc, Weak}; -thread_local!( - pub static shared_0: Value = Rc::new(RefCell::new(3)); -); -thread_local!( - pub static calls_1: Value = Rc::new(RefCell::new(0)); -); -#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] -#[byte_size(1)] -pub struct HasStaticMembers {} -impl HasStaticMembers { - pub fn run() { - (*calls_1.with(Value::clone).borrow_mut()).prefix_inc(); - } -} -pub fn main() { - __cpp2rust_init_globals(); - std::process::exit(main_0()); -} -fn main_0() -> i32 { - let mut object_pointer: Ptr = (shared_0.with(|v| v.as_pointer())); - assert!(((object_pointer.read()) == 3)); - object_pointer.write(4); - assert!((shared_0.with(|rc| *rc.borrow()) == 4)); - let mut function_pointer: FnPtr = (FnPtr::::new(HasStaticMembers::run)); - ({ function_pointer.call() }); - assert!((calls_1.with(|rc| *rc.borrow()) == 1)); - return 0; -} -pub fn __cpp2rust_init_globals() { - let _ = shared_0.with(|_| ()); - let _ = calls_1.with(|_| ()); -} diff --git a/tests/std/expr/expr.compound/expr.unary/expr.unary.op/out/refcount/p4-parenthesized-qualified-id-is-object-pointer.rs b/tests/std/expr/expr.compound/expr.unary/expr.unary.op/out/refcount/p4-parenthesized-qualified-id-is-object-pointer.rs deleted file mode 100644 index e776b36531..0000000000 --- a/tests/std/expr/expr.compound/expr.unary/expr.unary.op/out/refcount/p4-parenthesized-qualified-id-is-object-pointer.rs +++ /dev/null @@ -1,48 +0,0 @@ -extern crate libcc2rs; -use libcc2rs::*; -use std::cell::RefCell; -use std::collections::BTreeMap; -use std::io::prelude::*; -use std::io::{Read, Seek, Write}; -use std::os::fd::AsFd; -use std::rc::{Rc, Weak}; -#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] -#[byte_size(4)] -pub struct TakesAddressOfOwnMember { - #[offset(0)] - pub value: i32, -} -pub fn main() { - __cpp2rust_init_globals(); - std::process::exit(main_0()); -} -fn main_0() -> i32 { - let first: Value = - Rc::new(RefCell::new(TakesAddressOfOwnMember { value: 3 })); - let second: Value = - Rc::new(RefCell::new(TakesAddressOfOwnMember { value: 4 })); - let mut p: Ptr = ({ TakesAddressOfOwnMemberImpl::parenthesized(&first.as_pointer()) }); - assert!(({ (p).clone() } == { (field_ptr!(first.as_pointer(), value)) })); - p.write(5); - assert!(({ ({ (*first.borrow()).value } == 5) })); - assert!(({ ({ (*second.borrow()).value } == 4) })); - let mut q: Ptr = ({ TakesAddressOfOwnMemberImpl::unqualified(&second.as_pointer()) }); - assert!(({ (q).clone() } == { (field_ptr!(second.as_pointer(), value)) })); - q.write(6); - assert!(({ ({ (*first.borrow()).value } == 5) })); - assert!(({ ({ (*second.borrow()).value } == 6) })); - return 0; -} -pub trait TakesAddressOfOwnMemberImpl { - fn parenthesized(&self) -> Ptr; - fn unqualified(&self) -> Ptr; -} -impl TakesAddressOfOwnMemberImpl for Ptr { - fn parenthesized(&self) -> Ptr { - return (field_ptr!((*self), value)); - } - fn unqualified(&self) -> Ptr { - return (field_ptr!((*self), value)); - } -} -pub fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/expr.compound/expr.unary/expr.unary.op/out/unsafe/p3.1-anonymous-union-member.rs b/tests/std/expr/expr.compound/expr.unary/expr.unary.op/out/unsafe/p3.1-anonymous-union-member.rs deleted file mode 100644 index c4a027e65e..0000000000 --- a/tests/std/expr/expr.compound/expr.unary/expr.unary.op/out/unsafe/p3.1-anonymous-union-member.rs +++ /dev/null @@ -1,50 +0,0 @@ -extern crate libc; -use libc::*; -extern crate libcc2rs; -use libcc2rs::*; -use std::collections::BTreeMap; -use std::io::{Read, Seek, Write}; -use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; -use std::rc::Rc; -#[repr(C)] -#[derive(Copy, Clone, FnPtrArg, VaArg)] -pub union anon_0 { - pub as_int: i32, - pub as_unsigned: u32, -} -impl Default for anon_0 { - fn default() -> Self { - unsafe { std::mem::zeroed() } - } -} -#[repr(C)] -#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] -pub struct HasAnonymousUnion { - pub before: i32, - pub anon_0: anon_0, -} -pub fn main() { - unsafe { - __cpp2rust_init_globals(); - std::process::exit(main_0() as i32); - } -} -unsafe fn main_0() -> i32 { - let mut pm: isize = (::std::mem::offset_of!(HasAnonymousUnion, anon_0) as isize); - let mut obj: HasAnonymousUnion = ::default(); - obj.before = 1; - obj.anon_0.as_int = 2; - assert!( - ((*(&mut obj as *mut HasAnonymousUnion) - .wrapping_byte_offset(pm) - .cast::()) - == (2)) - ); - (*(&mut obj as *mut HasAnonymousUnion) - .wrapping_byte_offset(pm) - .cast::()) = 3; - assert!(((obj.anon_0.as_int) == (3))); - assert!(((obj.before) == (1))); - return 0; -} -pub unsafe fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/expr.compound/expr.unary/expr.unary.op/out/unsafe/p3.2-static-member-is-ordinary-pointer.rs b/tests/std/expr/expr.compound/expr.unary/expr.unary.op/out/unsafe/p3.2-static-member-is-ordinary-pointer.rs deleted file mode 100644 index 83acaff04d..0000000000 --- a/tests/std/expr/expr.compound/expr.unary/expr.unary.op/out/unsafe/p3.2-static-member-is-ordinary-pointer.rs +++ /dev/null @@ -1,39 +0,0 @@ -extern crate libc; -use libc::*; -extern crate libcc2rs; -use libcc2rs::*; -use std::collections::BTreeMap; -use std::io::{Read, Seek, Write}; -use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; -use std::rc::Rc; -pub static mut shared_0: std::cell::LazyCell = std::cell::LazyCell::new(|| unsafe { 3 }); -pub static mut calls_1: std::cell::LazyCell = std::cell::LazyCell::new(|| unsafe { 0 }); -#[repr(C)] -#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] -pub struct HasStaticMembers {} -impl HasStaticMembers { - pub unsafe fn run() { - (*std::cell::LazyCell::force_mut(&mut *&raw mut calls_1)).prefix_inc(); - } -} -pub fn main() { - unsafe { - __cpp2rust_init_globals(); - std::process::exit(main_0() as i32); - } -} -unsafe fn main_0() -> i32 { - let mut object_pointer: *mut i32 = - (&raw mut (*std::cell::LazyCell::force_mut(&mut *&raw mut shared_0)) as *mut i32); - assert!(((*object_pointer) == (3))); - (*object_pointer) = 4; - assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut shared_0)) == (4))); - let mut function_pointer: Option = (Some(HasStaticMembers::run)); - (unsafe { (function_pointer).unwrap()() }); - assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut calls_1)) == (1))); - return 0; -} -pub unsafe fn __cpp2rust_init_globals() { - std::cell::LazyCell::force(&*&raw const shared_0); - std::cell::LazyCell::force(&*&raw const calls_1); -} diff --git a/tests/std/expr/expr.compound/expr.unary/expr.unary.op/out/unsafe/p4-parenthesized-qualified-id-is-object-pointer.rs b/tests/std/expr/expr.compound/expr.unary/expr.unary.op/out/unsafe/p4-parenthesized-qualified-id-is-object-pointer.rs deleted file mode 100644 index 455511d14d..0000000000 --- a/tests/std/expr/expr.compound/expr.unary/expr.unary.op/out/unsafe/p4-parenthesized-qualified-id-is-object-pointer.rs +++ /dev/null @@ -1,43 +0,0 @@ -extern crate libc; -use libc::*; -extern crate libcc2rs; -use libcc2rs::*; -use std::collections::BTreeMap; -use std::io::{Read, Seek, Write}; -use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; -use std::rc::Rc; -#[repr(C)] -#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] -pub struct TakesAddressOfOwnMember { - pub value: i32, -} -impl TakesAddressOfOwnMember { - pub unsafe fn parenthesized(&mut self) -> *mut i32 { - return (&mut (self.value) as *mut i32); - } - pub unsafe fn unqualified(&mut self) -> *mut i32 { - return (&mut self.value as *mut i32); - } -} -pub fn main() { - unsafe { - __cpp2rust_init_globals(); - std::process::exit(main_0() as i32); - } -} -unsafe fn main_0() -> i32 { - let mut first: TakesAddressOfOwnMember = TakesAddressOfOwnMember { value: 3 }; - let mut second: TakesAddressOfOwnMember = TakesAddressOfOwnMember { value: 4 }; - let mut p: *mut i32 = (unsafe { TakesAddressOfOwnMember::parenthesized(&mut first) }); - assert!(((p) == (&mut first.value as *mut i32))); - (*p) = 5; - assert!(((first.value) == (5))); - assert!(((second.value) == (4))); - let mut q: *mut i32 = (unsafe { TakesAddressOfOwnMember::unqualified(&mut second) }); - assert!(((q) == (&mut second.value as *mut i32))); - (*q) = 6; - assert!(((first.value) == (5))); - assert!(((second.value) == (6))); - return 0; -} -pub unsafe fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/expr.compound/expr.unary/expr.unary.op/p3.1-anonymous-union-member.cpp b/tests/std/expr/expr.compound/expr.unary/expr.unary.op/p3.1-anonymous-union-member.cpp deleted file mode 100644 index 927ea7c259..0000000000 --- a/tests/std/expr/expr.compound/expr.unary/expr.unary.op/p3.1-anonymous-union-member.cpp +++ /dev/null @@ -1,25 +0,0 @@ -// panic: refcount -// ADDITIONAL_COMPILE_FLAGS: -std=c++23 -// N4950 [expr.unary.op]/3.1: a qualified-id naming a variant member of some -// class C yields a pointer to member of class C. -#include - -struct HasAnonymousUnion { - int before; - union { - int as_int; - unsigned as_unsigned; - }; -}; - -int main() { - int HasAnonymousUnion::*pm = &HasAnonymousUnion::as_int; - HasAnonymousUnion obj; - obj.before = 1; - obj.as_int = 2; - assert(obj.*pm == 2); - obj.*pm = 3; - assert(obj.as_int == 3); - assert(obj.before == 1); - return 0; -} diff --git a/tests/std/expr/expr.compound/expr.unary/expr.unary.op/p3.1-member-named-through-derived-class.cpp b/tests/std/expr/expr.compound/expr.unary/expr.unary.op/p3.1-member-named-through-derived-class.cpp deleted file mode 100644 index 5082576eb2..0000000000 --- a/tests/std/expr/expr.compound/expr.unary/expr.unary.op/p3.1-member-named-through-derived-class.cpp +++ /dev/null @@ -1,23 +0,0 @@ -// no-compile: refcount, unsafe -// ADDITIONAL_COMPILE_FLAGS: -std=c++23 -// N4950 [expr.unary.op]/3.1: for a qualified-id naming a non-static member m -// of some class C, the result has type "pointer to member of class C" and -// designates C::m; C is the class m is a member of, not the class named. -#include - -struct DeclaresValue { - int value; -}; - -struct InheritsValue : DeclaresValue { - int own; -}; - -int main() { - auto pm = &InheritsValue::value; - DeclaresValue base{3}; - assert(base.*pm == 3); - InheritsValue derived{{4}, 5}; - assert(derived.*pm == 4); - return 0; -} diff --git a/tests/std/expr/expr.compound/expr.unary/expr.unary.op/p3.2-static-member-is-ordinary-pointer.cpp b/tests/std/expr/expr.compound/expr.unary/expr.unary.op/p3.2-static-member-is-ordinary-pointer.cpp deleted file mode 100644 index d8403050b0..0000000000 --- a/tests/std/expr/expr.compound/expr.unary/expr.unary.op/p3.2-static-member-is-ordinary-pointer.cpp +++ /dev/null @@ -1,22 +0,0 @@ -// ADDITIONAL_COMPILE_FLAGS: -std=c++23 -// N4950 [expr.unary.op]/3.2: for an operand that is not a non-static member, -// the result has type "pointer to T" and points to the designated object or -// function; a static member is such an operand. -#include - -struct HasStaticMembers { - static inline int shared = 3; - static inline int calls = 0; - static void run() { ++calls; } -}; - -int main() { - int *object_pointer = &HasStaticMembers::shared; - assert(*object_pointer == 3); - *object_pointer = 4; - assert(HasStaticMembers::shared == 4); - void (*function_pointer)() = &HasStaticMembers::run; - function_pointer(); - assert(HasStaticMembers::calls == 1); - return 0; -} diff --git a/tests/std/expr/expr.compound/expr.unary/expr.unary.op/p4-parenthesized-qualified-id-is-object-pointer.cpp b/tests/std/expr/expr.compound/expr.unary/expr.unary.op/p4-parenthesized-qualified-id-is-object-pointer.cpp deleted file mode 100644 index 2ecacf4cd3..0000000000 --- a/tests/std/expr/expr.compound/expr.unary/expr.unary.op/p4-parenthesized-qualified-id-is-object-pointer.cpp +++ /dev/null @@ -1,26 +0,0 @@ -// ADDITIONAL_COMPILE_FLAGS: -std=c++23 -// N4950 [expr.unary.op]/4: a pointer to member is only formed when an explicit -// & is used and its operand is a qualified-id not enclosed in parentheses. -#include - -struct TakesAddressOfOwnMember { - int value; - int *parenthesized() { return &(TakesAddressOfOwnMember::value); } - int *unqualified() { return &value; } -}; - -int main() { - TakesAddressOfOwnMember first{3}; - TakesAddressOfOwnMember second{4}; - int *p = first.parenthesized(); - assert(p == &first.value); - *p = 5; - assert(first.value == 5); - assert(second.value == 4); - int *q = second.unqualified(); - assert(q == &second.value); - *q = 6; - assert(first.value == 5); - assert(second.value == 6); - return 0; -} diff --git a/tests/std/expr/expr.compound/expr.unary/out/refcount/expr.unary.op.rs b/tests/std/expr/expr.compound/expr.unary/out/refcount/expr.unary.op.rs new file mode 100644 index 0000000000..985297f0b2 --- /dev/null +++ b/tests/std/expr/expr.compound/expr.unary/out/refcount/expr.unary.op.rs @@ -0,0 +1,93 @@ +extern crate libcc2rs; +use libcc2rs::*; +use std::cell::RefCell; +use std::collections::BTreeMap; +use std::io::prelude::*; +use std::io::{Read, Seek, Write}; +use std::os::fd::AsFd; +use std::rc::{Rc, Weak}; +thread_local!( + pub static shared_0: Value = Rc::new(RefCell::new(3)); +); +thread_local!( + pub static calls_1: Value = Rc::new(RefCell::new(0)); +); +#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] +#[byte_size(1)] +pub struct p3_2_static_member_is_ordinary_pointer_HasStaticMembers {} +impl p3_2_static_member_is_ordinary_pointer_HasStaticMembers { + pub fn run() { + (*calls_1.with(Value::clone).borrow_mut()).prefix_inc(); + } +} +pub fn test_2() { + let mut object_pointer: Ptr = (shared_0.with(|v| v.as_pointer())); + assert!(((object_pointer.read()) == 3)); + object_pointer.write(4); + assert!((shared_0.with(|rc| *rc.borrow()) == 4)); + let mut function_pointer: FnPtr = + (FnPtr::::new(p3_2_static_member_is_ordinary_pointer_HasStaticMembers::run)); + ({ function_pointer.call() }); + assert!((calls_1.with(|rc| *rc.borrow()) == 1)); +} +#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] +#[byte_size(4)] +pub struct p4_parenthesized_qualified_id_is_object_pointer_TakesAddressOfOwnMember { + #[offset(0)] + pub value: i32, +} +pub fn test_3() { + let first: Value = + Rc::new(RefCell::new( + p4_parenthesized_qualified_id_is_object_pointer_TakesAddressOfOwnMember { value: 3 }, + )); + let second: Value = + Rc::new(RefCell::new( + p4_parenthesized_qualified_id_is_object_pointer_TakesAddressOfOwnMember { value: 4 }, + )); + let mut p: Ptr = ({ + p4_parenthesized_qualified_id_is_object_pointer_TakesAddressOfOwnMemberImpl::parenthesized( + &first.as_pointer(), + ) + }); + assert!(({ (p).clone() } == { (field_ptr!(first.as_pointer(), value)) })); + p.write(5); + assert!(({ ({ (*first.borrow()).value } == 5) })); + assert!(({ ({ (*second.borrow()).value } == 4) })); + let mut q: Ptr = ({ + p4_parenthesized_qualified_id_is_object_pointer_TakesAddressOfOwnMemberImpl::unqualified( + &second.as_pointer(), + ) + }); + assert!(({ (q).clone() } == { (field_ptr!(second.as_pointer(), value)) })); + q.write(6); + assert!(({ ({ (*first.borrow()).value } == 5) })); + assert!(({ ({ (*second.borrow()).value } == 6) })); +} +pub fn main() { + __cpp2rust_init_globals(); + std::process::exit(main_0()); +} +fn main_0() -> i32 { + ({ test_2() }); + ({ test_3() }); + return 0; +} +pub trait p4_parenthesized_qualified_id_is_object_pointer_TakesAddressOfOwnMemberImpl { + fn parenthesized(&self) -> Ptr; + fn unqualified(&self) -> Ptr; +} +impl p4_parenthesized_qualified_id_is_object_pointer_TakesAddressOfOwnMemberImpl + for Ptr +{ + fn parenthesized(&self) -> Ptr { + return (field_ptr!((*self), value)); + } + fn unqualified(&self) -> Ptr { + return (field_ptr!((*self), value)); + } +} +pub fn __cpp2rust_init_globals() { + let _ = shared_0.with(|_| ()); + let _ = calls_1.with(|_| ()); +} diff --git a/tests/std/expr/expr.compound/expr.unary/out/unsafe/expr.unary.op.rs b/tests/std/expr/expr.compound/expr.unary/out/unsafe/expr.unary.op.rs new file mode 100644 index 0000000000..004d0b1c2c --- /dev/null +++ b/tests/std/expr/expr.compound/expr.unary/out/unsafe/expr.unary.op.rs @@ -0,0 +1,81 @@ +extern crate libc; +use libc::*; +extern crate libcc2rs; +use libcc2rs::*; +use std::collections::BTreeMap; +use std::io::{Read, Seek, Write}; +use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; +use std::rc::Rc; +pub static mut shared_0: std::cell::LazyCell = std::cell::LazyCell::new(|| unsafe { 3 }); +pub static mut calls_1: std::cell::LazyCell = std::cell::LazyCell::new(|| unsafe { 0 }); +#[repr(C)] +#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] +pub struct p3_2_static_member_is_ordinary_pointer_HasStaticMembers {} +impl p3_2_static_member_is_ordinary_pointer_HasStaticMembers { + pub unsafe fn run() { + (*std::cell::LazyCell::force_mut(&mut *&raw mut calls_1)).prefix_inc(); + } +} +pub unsafe fn test_2() { + let mut object_pointer: *mut i32 = + (&raw mut (*std::cell::LazyCell::force_mut(&mut *&raw mut shared_0)) as *mut i32); + assert!(((*object_pointer) == (3))); + (*object_pointer) = 4; + assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut shared_0)) == (4))); + let mut function_pointer: Option = + (Some(p3_2_static_member_is_ordinary_pointer_HasStaticMembers::run)); + (unsafe { (function_pointer).unwrap()() }); + assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut calls_1)) == (1))); +} +#[repr(C)] +#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] +pub struct p4_parenthesized_qualified_id_is_object_pointer_TakesAddressOfOwnMember { + pub value: i32, +} +impl p4_parenthesized_qualified_id_is_object_pointer_TakesAddressOfOwnMember { + pub unsafe fn parenthesized(&mut self) -> *mut i32 { + return (&mut (self.value) as *mut i32); + } + pub unsafe fn unqualified(&mut self) -> *mut i32 { + return (&mut self.value as *mut i32); + } +} +pub unsafe fn test_3() { + let mut first: p4_parenthesized_qualified_id_is_object_pointer_TakesAddressOfOwnMember = + p4_parenthesized_qualified_id_is_object_pointer_TakesAddressOfOwnMember { value: 3 }; + let mut second: p4_parenthesized_qualified_id_is_object_pointer_TakesAddressOfOwnMember = + p4_parenthesized_qualified_id_is_object_pointer_TakesAddressOfOwnMember { value: 4 }; + let mut p: *mut i32 = (unsafe { + p4_parenthesized_qualified_id_is_object_pointer_TakesAddressOfOwnMember::parenthesized( + &mut first, + ) + }); + assert!(((p) == (&mut first.value as *mut i32))); + (*p) = 5; + assert!(((first.value) == (5))); + assert!(((second.value) == (4))); + let mut q: *mut i32 = (unsafe { + p4_parenthesized_qualified_id_is_object_pointer_TakesAddressOfOwnMember::unqualified( + &mut second, + ) + }); + assert!(((q) == (&mut second.value as *mut i32))); + (*q) = 6; + assert!(((first.value) == (5))); + assert!(((second.value) == (6))); +} +pub fn main() { + unsafe { + __cpp2rust_init_globals(); + std::process::exit(main_0() as i32); + } +} +unsafe fn main_0() -> i32 { + (unsafe { test_2() }); + (unsafe { test_3() }); + return 0; +} +pub unsafe fn __cpp2rust_init_globals() { + std::cell::LazyCell::force(&*&raw const shared_0); + std::cell::LazyCell::force(&*&raw const calls_1); +} diff --git a/tests/std/expr/expr.compound/expr.cond/out/refcount/p7.4-pointer-to-member-and-null.rs b/tests/std/expr/expr.compound/out/refcount/expr.cond.rs similarity index 61% rename from tests/std/expr/expr.compound/expr.cond/out/refcount/p7.4-pointer-to-member-and-null.rs rename to tests/std/expr/expr.compound/out/refcount/expr.cond.rs index f2456e545c..8de5164bf2 100644 --- a/tests/std/expr/expr.compound/expr.cond/out/refcount/p7.4-pointer-to-member-and-null.rs +++ b/tests/std/expr/expr.compound/out/refcount/expr.cond.rs @@ -8,7 +8,7 @@ use std::os::fd::AsFd; use std::rc::{Rc, Weak}; #[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] #[byte_size(8)] -pub struct HasTwoInts { +pub struct p7_4_pointer_to_member_and_null_HasTwoInts { #[offset(0)] pub first: i32, #[offset(4)] @@ -16,28 +16,35 @@ pub struct HasTwoInts { } pub fn second_or_null_0(mut choose_second: bool) -> isize { return if choose_second { - (offset_of_field!(HasTwoInts, second) as isize) + (offset_of_field!(p7_4_pointer_to_member_and_null_HasTwoInts, second) as isize) } else { -1_isize }; } -pub fn main() { - __cpp2rust_init_globals(); - std::process::exit(main_0()); -} -fn main_0() -> i32 { - let obj: Value = Rc::new(RefCell::new(HasTwoInts { - first: 3, - second: 4, - })); +pub fn test_1() { + let obj: Value = + Rc::new(RefCell::new(p7_4_pointer_to_member_and_null_HasTwoInts { + first: 3, + second: 4, + })); assert!((({ second_or_null_0(false,) }) == -1_isize)); - assert!((({ second_or_null_0(true,) }) == (offset_of_field!(HasTwoInts, second) as isize))); + assert!( + (({ second_or_null_0(true,) }) + == (offset_of_field!(p7_4_pointer_to_member_and_null_HasTwoInts, second) as isize)) + ); assert!( (((obj.as_pointer()) .member::(({ second_or_null_0(true,) })) .read()) == 4) ); +} +pub fn main() { + __cpp2rust_init_globals(); + std::process::exit(main_0()); +} +fn main_0() -> i32 { + ({ test_1() }); return 0; } pub fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/expr.compound/out/refcount/expr.eq.rs b/tests/std/expr/expr.compound/out/refcount/expr.eq.rs new file mode 100644 index 0000000000..4b6f1d551a --- /dev/null +++ b/tests/std/expr/expr.compound/out/refcount/expr.eq.rs @@ -0,0 +1,95 @@ +extern crate libcc2rs; +use libcc2rs::*; +use std::cell::RefCell; +use std::collections::BTreeMap; +use std::io::prelude::*; +use std::io::{Read, Seek, Write}; +use std::os::fd::AsFd; +use std::rc::{Rc, Weak}; +#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] +#[byte_size(8)] +pub struct p4_1_both_null_HasTwoInts { + #[offset(0)] + pub first: i32, + #[offset(4)] + pub second: i32, +} +pub fn test_0() { + let mut first_null: isize = -1_isize; + let mut second_null: isize = -1_isize; + assert!((first_null == second_null)); + assert!(!(first_null != second_null)); +} +#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] +#[byte_size(8)] +pub struct p4_2_one_null_HasTwoInts { + #[offset(0)] + pub first: i32, + #[offset(4)] + pub second: i32, +} +pub fn test_1() { + let mut null_pm: isize = -1_isize; + let mut first_pm: isize = (offset_of_field!(p4_2_one_null_HasTwoInts, first) as isize); + assert!((first_pm != null_pm)); + assert!(!(first_pm == null_pm)); + assert!((null_pm != first_pm)); + assert!(!(null_pm == first_pm)); +} +#[derive(VaArg, FnPtrArg, ByteRepr, Clone)] +#[byte_size(4)] +pub struct p4_5_members_of_same_union_HasTwoIntMembers { + #[offset(0)] + #[byte_size(4)] + __bytes: Box<[u8]>, +} +impl p4_5_members_of_same_union_HasTwoIntMembers { + pub fn first(this: Ptr) -> Ptr { + this.reinterpret_cast() + } + pub fn second(this: Ptr) -> Ptr { + this.reinterpret_cast() + } +} +impl Default for p4_5_members_of_same_union_HasTwoIntMembers { + fn default() -> Self { + p4_5_members_of_same_union_HasTwoIntMembers { + __bytes: Box::from([0u8; 4]), + } + } +} +pub fn test_2() { + let mut first_pm: isize = 0_isize; + let mut second_pm: isize = 0_isize; + assert!((first_pm == second_pm)); + assert!(!(first_pm != second_pm)); +} +#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] +#[byte_size(8)] +pub struct p4_6_data_members_HasTwoInts { + #[offset(0)] + pub first: i32, + #[offset(4)] + pub second: i32, +} +pub fn test_3() { + let mut first_pm: isize = (offset_of_field!(p4_6_data_members_HasTwoInts, first) as isize); + let mut also_first_pm: isize = (offset_of_field!(p4_6_data_members_HasTwoInts, first) as isize); + let mut second_pm: isize = (offset_of_field!(p4_6_data_members_HasTwoInts, second) as isize); + assert!((first_pm == also_first_pm)); + assert!(!(first_pm != also_first_pm)); + assert!((first_pm != second_pm)); + assert!(!(first_pm == second_pm)); +} +pub fn main() { + __cpp2rust_init_globals(); + std::process::exit(main_0()); +} +fn main_0() -> i32 { + ({ test_0() }); + ({ test_1() }); + ({ test_2() }); + ({ test_3() }); + return 0; +} +pub fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p6-null-pointer-to-data-member.rs b/tests/std/expr/expr.compound/out/refcount/expr.mptr.oper-p6-null-pointer-to-data-member.rs similarity index 100% rename from tests/std/expr/expr.compound/expr.mptr.oper/out/refcount/p6-null-pointer-to-data-member.rs rename to tests/std/expr/expr.compound/out/refcount/expr.mptr.oper-p6-null-pointer-to-data-member.rs diff --git a/tests/std/expr/expr.compound/out/refcount/expr.mptr.oper.rs b/tests/std/expr/expr.compound/out/refcount/expr.mptr.oper.rs new file mode 100644 index 0000000000..3af893a4bd --- /dev/null +++ b/tests/std/expr/expr.compound/out/refcount/expr.mptr.oper.rs @@ -0,0 +1,177 @@ +extern crate libcc2rs; +use libcc2rs::*; +use std::cell::RefCell; +use std::collections::BTreeMap; +use std::io::prelude::*; +use std::io::{Read, Seek, Write}; +use std::os::fd::AsFd; +use std::rc::{Rc, Weak}; +#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] +#[byte_size(8)] +pub struct p3_arrow_star_HasTwoInts { + #[offset(0)] + pub first: i32, + #[offset(4)] + pub second: i32, +} +pub fn test_0() { + let mut pm: isize = (offset_of_field!(p3_arrow_star_HasTwoInts, second) as isize); + let obj: Value = Rc::new(RefCell::new(p3_arrow_star_HasTwoInts { + first: 3, + second: 4, + })); + let mut p: Ptr = (obj.as_pointer()); + assert!((((p).member::(pm).read()) == 4)); + (p).member::(pm).write(5); + assert!(({ ({ (*obj.borrow()).second } == 5) })); + assert!(({ ({ (*obj.borrow()).first } == 3) })); + assert!((((p).member::(pm)) == ((p).member::(pm)))); +} +#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] +#[byte_size(4)] +pub struct p4_object_expression_sequenced_first_HasValue { + #[offset(0)] + pub value: i32, +} +thread_local!( + pub static sequence_1: Value = Rc::new(RefCell::new(0_i32)); +); +thread_local!( + pub static object_stamp_2: Value = Rc::new(RefCell::new(0_i32)); +); +thread_local!( + pub static member_stamp_3: Value = Rc::new(RefCell::new(0_i32)); +); +thread_local!( + pub static object_4: Value = Rc::new( + RefCell::new(p4_object_expression_sequenced_first_HasValue { value: 7 }), + ); +); +pub fn select_object_5() -> Ptr { + object_stamp_2 + .with(|rc| *rc.borrow_mut() = (*sequence_1.with(Value::clone).borrow_mut()).prefix_inc()); + return object_4.with(|v| v.as_pointer()); +} +pub fn select_member_6() -> isize { + member_stamp_3 + .with(|rc| *rc.borrow_mut() = (*sequence_1.with(Value::clone).borrow_mut()).prefix_inc()); + return (offset_of_field!(p4_object_expression_sequenced_first_HasValue, value) as isize); +} +pub fn test_7() { + assert!( + ((({ select_object_5() }) + .member::(({ select_member_6() })) + .read()) + == 7) + ); + assert!((object_stamp_2.with(|rc| *rc.borrow()) == 1)); + assert!((member_stamp_3.with(|rc| *rc.borrow()) == 2)); +} +#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] +#[byte_size(8)] +pub struct p6_data_member_of_lvalue_is_lvalue_HasTwoInts { + #[offset(0)] + pub first: i32, + #[offset(4)] + pub second: i32, +} +pub fn test_8() { + let mut pm: isize = + (offset_of_field!(p6_data_member_of_lvalue_is_lvalue_HasTwoInts, second) as isize); + let obj: Value = Rc::new(RefCell::new( + p6_data_member_of_lvalue_is_lvalue_HasTwoInts { + first: 3, + second: 4, + }, + )); + assert!((((obj.as_pointer()).member::(pm)) == (field_ptr!(obj.as_pointer(), second)))); + let ref_: Ptr = (obj.as_pointer()).member::(pm); + ref_.write(5); + assert!(({ ({ (*obj.borrow()).second } == 5) })); + assert!(({ ({ (*obj.borrow()).first } == 3) })); +} +thread_local!( + pub static copyCount_9: Value = Rc::new(RefCell::new(0)); +); +thread_local!( + pub static moveCount_10: Value = Rc::new(RefCell::new(0)); +); +#[derive(Record, ByteRepr, VaArg, FnPtrArg, MoveCtor, Default)] +#[byte_size(1)] +pub struct p6_data_member_of_rvalue_is_xvalue_CountsCopiesAndMoves {} +impl p6_data_member_of_rvalue_is_xvalue_CountsCopiesAndMoves { + pub fn copy_from(_a0: Ptr) -> Self { + let __this: p6_data_member_of_rvalue_is_xvalue_CountsCopiesAndMoves = Self {}; + (*copyCount_9.with(Value::clone).borrow_mut()).prefix_inc(); + __this + } + pub fn move_from(_a0: Ptr) -> Self { + let __this: p6_data_member_of_rvalue_is_xvalue_CountsCopiesAndMoves = Self {}; + (*moveCount_10.with(Value::clone).borrow_mut()).prefix_inc(); + __this + } +} +impl Clone for p6_data_member_of_rvalue_is_xvalue_CountsCopiesAndMoves { + fn clone(&self) -> Self { + let __src: Value = Rc::new( + RefCell::new(p6_data_member_of_rvalue_is_xvalue_CountsCopiesAndMoves {}), + ); + p6_data_member_of_rvalue_is_xvalue_CountsCopiesAndMoves::copy_from(__src.as_pointer()) + } +} +#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, MoveCtor, Default)] +#[byte_size(1)] +pub struct p6_data_member_of_rvalue_is_xvalue_HoldsCounted { + #[offset(0)] + #[byte_size(1)] + pub member: p6_data_member_of_rvalue_is_xvalue_CountsCopiesAndMoves, +} +impl p6_data_member_of_rvalue_is_xvalue_HoldsCounted { + pub fn move_from(_a0: Ptr) -> Self { + Self { + member: p6_data_member_of_rvalue_is_xvalue_CountsCopiesAndMoves::move_from({ + field_ptr!(_a0, member) + }), + } + } +} +pub fn test_11() { + let mut pm: isize = + (offset_of_field!(p6_data_member_of_rvalue_is_xvalue_HoldsCounted, member) as isize); + let holder: Value = Rc::new(RefCell::new( + ::default(), + )); + let mut from_lvalue: p6_data_member_of_rvalue_is_xvalue_CountsCopiesAndMoves = + p6_data_member_of_rvalue_is_xvalue_CountsCopiesAndMoves::copy_from({ + (holder.as_pointer()) + .member::(pm) + }); + assert!((copyCount_9.with(|rc| *rc.borrow()) == 1)); + assert!((moveCount_10.with(|rc| *rc.borrow()) == 0)); + let mut from_xvalue: p6_data_member_of_rvalue_is_xvalue_CountsCopiesAndMoves = + p6_data_member_of_rvalue_is_xvalue_CountsCopiesAndMoves::move_from({ + (holder.as_pointer()) + .member::(pm) + }); + assert!((copyCount_9.with(|rc| *rc.borrow()) == 1)); + assert!((moveCount_10.with(|rc| *rc.borrow()) == 1)); +} +pub fn main() { + __cpp2rust_init_globals(); + std::process::exit(main_0()); +} +fn main_0() -> i32 { + ({ test_0() }); + ({ test_7() }); + ({ test_8() }); + ({ test_11() }); + return 0; +} +pub fn __cpp2rust_init_globals() { + let _ = sequence_1.with(|_| ()); + let _ = object_stamp_2.with(|_| ()); + let _ = member_stamp_3.with(|_| ()); + let _ = object_4.with(|_| ()); + let _ = copyCount_9.with(|_| ()); + let _ = moveCount_10.with(|_| ()); +} diff --git a/tests/std/expr/expr.compound/expr.cond/out/unsafe/p7.4-pointer-to-member-and-null.rs b/tests/std/expr/expr.compound/out/unsafe/expr.cond.rs similarity index 61% rename from tests/std/expr/expr.compound/expr.cond/out/unsafe/p7.4-pointer-to-member-and-null.rs rename to tests/std/expr/expr.compound/out/unsafe/expr.cond.rs index 34b07edcc3..27419df8d9 100644 --- a/tests/std/expr/expr.compound/expr.cond/out/unsafe/p7.4-pointer-to-member-and-null.rs +++ b/tests/std/expr/expr.compound/out/unsafe/expr.cond.rs @@ -8,39 +8,44 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; use std::rc::Rc; #[repr(C)] #[derive(Copy, Clone, VaArg, FnPtrArg, Default)] -pub struct HasTwoInts { +pub struct p7_4_pointer_to_member_and_null_HasTwoInts { pub first: i32, pub second: i32, } pub unsafe fn second_or_null_0(mut choose_second: bool) -> isize { return if choose_second { - (::std::mem::offset_of!(HasTwoInts, second) as isize) + (::std::mem::offset_of!(p7_4_pointer_to_member_and_null_HasTwoInts, second) as isize) } else { -1_isize }; } -pub fn main() { - unsafe { - __cpp2rust_init_globals(); - std::process::exit(main_0() as i32); - } -} -unsafe fn main_0() -> i32 { - let mut obj: HasTwoInts = HasTwoInts { - first: 3, - second: 4, - }; +pub unsafe fn test_1() { + let mut obj: p7_4_pointer_to_member_and_null_HasTwoInts = + p7_4_pointer_to_member_and_null_HasTwoInts { + first: 3, + second: 4, + }; assert!(((unsafe { second_or_null_0(false,) }) == -1_isize)); assert!( ((unsafe { second_or_null_0(true,) }) - == (::std::mem::offset_of!(HasTwoInts, second) as isize)) + == (::std::mem::offset_of!(p7_4_pointer_to_member_and_null_HasTwoInts, second) + as isize)) ); assert!( - ((*(&mut obj as *mut HasTwoInts) + ((*(&mut obj as *mut p7_4_pointer_to_member_and_null_HasTwoInts) .wrapping_byte_offset((unsafe { second_or_null_0(true,) })) .cast::()) == (4)) ); +} +pub fn main() { + unsafe { + __cpp2rust_init_globals(); + std::process::exit(main_0() as i32); + } +} +unsafe fn main_0() -> i32 { + (unsafe { test_1() }); return 0; } pub unsafe fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/expr.compound/out/unsafe/expr.eq.rs b/tests/std/expr/expr.compound/out/unsafe/expr.eq.rs new file mode 100644 index 0000000000..fa658ad771 --- /dev/null +++ b/tests/std/expr/expr.compound/out/unsafe/expr.eq.rs @@ -0,0 +1,83 @@ +extern crate libc; +use libc::*; +extern crate libcc2rs; +use libcc2rs::*; +use std::collections::BTreeMap; +use std::io::{Read, Seek, Write}; +use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; +use std::rc::Rc; +#[repr(C)] +#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] +pub struct p4_1_both_null_HasTwoInts { + pub first: i32, + pub second: i32, +} +pub unsafe fn test_0() { + let mut first_null: isize = -1_isize; + let mut second_null: isize = -1_isize; + assert!(((first_null) == (second_null))); + assert!(!((first_null) != (second_null))); +} +#[repr(C)] +#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] +pub struct p4_2_one_null_HasTwoInts { + pub first: i32, + pub second: i32, +} +pub unsafe fn test_1() { + let mut null_pm: isize = -1_isize; + let mut first_pm: isize = (::std::mem::offset_of!(p4_2_one_null_HasTwoInts, first) as isize); + assert!(((first_pm) != (null_pm))); + assert!(!((first_pm) == (null_pm))); + assert!(((null_pm) != (first_pm))); + assert!(!((null_pm) == (first_pm))); +} +#[repr(C)] +#[derive(Copy, Clone, FnPtrArg, VaArg)] +pub union p4_5_members_of_same_union_HasTwoIntMembers { + pub first: i32, + pub second: i32, +} +impl Default for p4_5_members_of_same_union_HasTwoIntMembers { + fn default() -> Self { + unsafe { std::mem::zeroed() } + } +} +pub unsafe fn test_2() { + let mut first_pm: isize = 0_isize; + let mut second_pm: isize = 0_isize; + assert!(((first_pm) == (second_pm))); + assert!(!((first_pm) != (second_pm))); +} +#[repr(C)] +#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] +pub struct p4_6_data_members_HasTwoInts { + pub first: i32, + pub second: i32, +} +pub unsafe fn test_3() { + let mut first_pm: isize = + (::std::mem::offset_of!(p4_6_data_members_HasTwoInts, first) as isize); + let mut also_first_pm: isize = + (::std::mem::offset_of!(p4_6_data_members_HasTwoInts, first) as isize); + let mut second_pm: isize = + (::std::mem::offset_of!(p4_6_data_members_HasTwoInts, second) as isize); + assert!(((first_pm) == (also_first_pm))); + assert!(!((first_pm) != (also_first_pm))); + assert!(((first_pm) != (second_pm))); + assert!(!((first_pm) == (second_pm))); +} +pub fn main() { + unsafe { + __cpp2rust_init_globals(); + std::process::exit(main_0() as i32); + } +} +unsafe fn main_0() -> i32 { + (unsafe { test_0() }); + (unsafe { test_1() }); + (unsafe { test_2() }); + (unsafe { test_3() }); + return 0; +} +pub unsafe fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p6-null-pointer-to-data-member.rs b/tests/std/expr/expr.compound/out/unsafe/expr.mptr.oper-p6-null-pointer-to-data-member.rs similarity index 100% rename from tests/std/expr/expr.compound/expr.mptr.oper/out/unsafe/p6-null-pointer-to-data-member.rs rename to tests/std/expr/expr.compound/out/unsafe/expr.mptr.oper-p6-null-pointer-to-data-member.rs diff --git a/tests/std/expr/expr.compound/out/unsafe/expr.mptr.oper.rs b/tests/std/expr/expr.compound/out/unsafe/expr.mptr.oper.rs new file mode 100644 index 0000000000..b77b402a30 --- /dev/null +++ b/tests/std/expr/expr.compound/out/unsafe/expr.mptr.oper.rs @@ -0,0 +1,181 @@ +extern crate libc; +use libc::*; +extern crate libcc2rs; +use libcc2rs::*; +use std::collections::BTreeMap; +use std::io::{Read, Seek, Write}; +use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; +use std::rc::Rc; +#[repr(C)] +#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] +pub struct p3_arrow_star_HasTwoInts { + pub first: i32, + pub second: i32, +} +pub unsafe fn test_0() { + let mut pm: isize = (::std::mem::offset_of!(p3_arrow_star_HasTwoInts, second) as isize); + let mut obj: p3_arrow_star_HasTwoInts = p3_arrow_star_HasTwoInts { + first: 3, + second: 4, + }; + let mut p: *mut p3_arrow_star_HasTwoInts = (&mut obj as *mut p3_arrow_star_HasTwoInts); + assert!(((*(p).wrapping_byte_offset(pm).cast::()) == (4))); + (*(p).wrapping_byte_offset(pm).cast::()) = 5; + assert!(((obj.second) == (5))); + assert!(((obj.first) == (3))); + assert!( + ((&mut (*(p).wrapping_byte_offset(pm).cast::()) as *mut i32) + == (&mut (*(&mut (*p) as *mut p3_arrow_star_HasTwoInts) + .wrapping_byte_offset(pm) + .cast::()) as *mut i32)) + ); +} +#[repr(C)] +#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] +pub struct p4_object_expression_sequenced_first_HasValue { + pub value: i32, +} +pub static mut sequence_1: std::cell::LazyCell = std::cell::LazyCell::new(|| unsafe { 0_i32 }); +pub static mut object_stamp_2: std::cell::LazyCell = + std::cell::LazyCell::new(|| unsafe { 0_i32 }); +pub static mut member_stamp_3: std::cell::LazyCell = + std::cell::LazyCell::new(|| unsafe { 0_i32 }); +pub static mut object_4: std::cell::LazyCell = + std::cell::LazyCell::new(|| unsafe { + p4_object_expression_sequenced_first_HasValue { value: 7 } + }); +pub unsafe fn select_object_5() -> *mut p4_object_expression_sequenced_first_HasValue { + (*std::cell::LazyCell::force_mut(&mut *&raw mut object_stamp_2)) = + (*std::cell::LazyCell::force_mut(&mut *&raw mut sequence_1)).prefix_inc(); + return &mut (*std::cell::LazyCell::force_mut(&mut *&raw mut object_4)); +} +pub unsafe fn select_member_6() -> isize { + (*std::cell::LazyCell::force_mut(&mut *&raw mut member_stamp_3)) = + (*std::cell::LazyCell::force_mut(&mut *&raw mut sequence_1)).prefix_inc(); + return (::std::mem::offset_of!(p4_object_expression_sequenced_first_HasValue, value) as isize); +} +pub unsafe fn test_7() { + assert!( + ((*(unsafe { select_object_5() }) + .wrapping_byte_offset((unsafe { select_member_6() })) + .cast::()) + == (7)) + ); + assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut object_stamp_2)) == (1))); + assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut member_stamp_3)) == (2))); +} +#[repr(C)] +#[derive(Copy, Clone, VaArg, FnPtrArg, Default)] +pub struct p6_data_member_of_lvalue_is_lvalue_HasTwoInts { + pub first: i32, + pub second: i32, +} +pub unsafe fn test_8() { + let mut pm: isize = + (::std::mem::offset_of!(p6_data_member_of_lvalue_is_lvalue_HasTwoInts, second) as isize); + let mut obj: p6_data_member_of_lvalue_is_lvalue_HasTwoInts = + p6_data_member_of_lvalue_is_lvalue_HasTwoInts { + first: 3, + second: 4, + }; + assert!( + ((&mut (*(&mut obj as *mut p6_data_member_of_lvalue_is_lvalue_HasTwoInts) + .wrapping_byte_offset(pm) + .cast::()) as *mut i32) + == (&mut obj.second as *mut i32)) + ); + let ref_: *mut i32 = &mut (*(&mut obj as *mut p6_data_member_of_lvalue_is_lvalue_HasTwoInts) + .wrapping_byte_offset(pm) + .cast::()); + (*ref_) = 5; + assert!(((obj.second) == (5))); + assert!(((obj.first) == (3))); +} +pub static mut copyCount_9: std::cell::LazyCell = std::cell::LazyCell::new(|| unsafe { 0 }); +pub static mut moveCount_10: std::cell::LazyCell = std::cell::LazyCell::new(|| unsafe { 0 }); +#[repr(C)] +#[derive(VaArg, FnPtrArg, MoveCtorUnsafe, Default)] +pub struct p6_data_member_of_rvalue_is_xvalue_CountsCopiesAndMoves {} +impl p6_data_member_of_rvalue_is_xvalue_CountsCopiesAndMoves { + pub unsafe fn copy_from( + _a0: *const p6_data_member_of_rvalue_is_xvalue_CountsCopiesAndMoves, + ) -> Self { + let mut this = Self {}; + (*std::cell::LazyCell::force_mut(&mut *&raw mut copyCount_9)).prefix_inc(); + this + } + pub unsafe fn move_from( + _a0: *mut p6_data_member_of_rvalue_is_xvalue_CountsCopiesAndMoves, + ) -> Self { + let mut this = Self {}; + (*std::cell::LazyCell::force_mut(&mut *&raw mut moveCount_10)).prefix_inc(); + this + } +} +impl Clone for p6_data_member_of_rvalue_is_xvalue_CountsCopiesAndMoves { + fn clone(&self) -> Self { + unsafe { + p6_data_member_of_rvalue_is_xvalue_CountsCopiesAndMoves::copy_from( + self as *const p6_data_member_of_rvalue_is_xvalue_CountsCopiesAndMoves, + ) + } + } +} +#[repr(C)] +#[derive(Clone, VaArg, FnPtrArg, MoveCtorUnsafe, Default)] +pub struct p6_data_member_of_rvalue_is_xvalue_HoldsCounted { + pub member: p6_data_member_of_rvalue_is_xvalue_CountsCopiesAndMoves, +} +impl p6_data_member_of_rvalue_is_xvalue_HoldsCounted { + pub unsafe fn move_from(_a0: *mut p6_data_member_of_rvalue_is_xvalue_HoldsCounted) -> Self { + let mut this = Self { + member: p6_data_member_of_rvalue_is_xvalue_CountsCopiesAndMoves::move_from({ + &mut (*_a0).member + }), + }; + this + } +} +pub unsafe fn test_11() { + let mut pm: isize = + (::std::mem::offset_of!(p6_data_member_of_rvalue_is_xvalue_HoldsCounted, member) as isize); + let mut holder: p6_data_member_of_rvalue_is_xvalue_HoldsCounted = + ::default(); + let mut from_lvalue: p6_data_member_of_rvalue_is_xvalue_CountsCopiesAndMoves = + p6_data_member_of_rvalue_is_xvalue_CountsCopiesAndMoves::copy_from({ + &(*(&mut holder as *mut p6_data_member_of_rvalue_is_xvalue_HoldsCounted) + .wrapping_byte_offset(pm) + .cast::()) + }); + assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut copyCount_9)) == (1))); + assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut moveCount_10)) == (0))); + let mut from_xvalue: p6_data_member_of_rvalue_is_xvalue_CountsCopiesAndMoves = + p6_data_member_of_rvalue_is_xvalue_CountsCopiesAndMoves::move_from({ + &mut (*(&mut holder as *mut p6_data_member_of_rvalue_is_xvalue_HoldsCounted) + .wrapping_byte_offset(pm) + .cast::()) + }); + assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut copyCount_9)) == (1))); + assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut moveCount_10)) == (1))); +} +pub fn main() { + unsafe { + __cpp2rust_init_globals(); + std::process::exit(main_0() as i32); + } +} +unsafe fn main_0() -> i32 { + (unsafe { test_0() }); + (unsafe { test_7() }); + (unsafe { test_8() }); + (unsafe { test_11() }); + return 0; +} +pub unsafe fn __cpp2rust_init_globals() { + std::cell::LazyCell::force(&*&raw const sequence_1); + std::cell::LazyCell::force(&*&raw const object_stamp_2); + std::cell::LazyCell::force(&*&raw const member_stamp_3); + std::cell::LazyCell::force(&*&raw const object_4); + std::cell::LazyCell::force(&*&raw const copyCount_9); + std::cell::LazyCell::force(&*&raw const moveCount_10); +} diff --git a/tests/std/temp/temp.type/out/refcount/p2.6-pointer-to-member-argument.rs b/tests/std/temp/out/refcount/temp.type.rs similarity index 81% rename from tests/std/temp/temp.type/out/refcount/p2.6-pointer-to-member-argument.rs rename to tests/std/temp/out/refcount/temp.type.rs index d95a5b7b9e..bfc835ea6c 100644 --- a/tests/std/temp/temp.type/out/refcount/p2.6-pointer-to-member-argument.rs +++ b/tests/std/temp/out/refcount/temp.type.rs @@ -8,7 +8,7 @@ use std::os::fd::AsFd; use std::rc::{Rc, Weak}; #[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] #[byte_size(8)] -pub struct HasTwoInts { +pub struct p2_6_pointer_to_member_argument_HasTwoInts { #[offset(0)] pub first: i32, #[offset(4)] @@ -19,24 +19,22 @@ thread_local!( ); #[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] #[byte_size(1)] -pub struct CountsPerMember_refHasTwoInts_first_ {} +pub struct p2_6_pointer_to_member_argument_CountsPerMember_refp2_6_pointer_to_member_argument_HasTwoInts_first_ +{} thread_local!( pub static count_1: Value = Rc::new(RefCell::new(0)); ); #[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] #[byte_size(1)] -pub struct CountsPerMember_refHasTwoInts_second_ {} +pub struct p2_6_pointer_to_member_argument_CountsPerMember_refp2_6_pointer_to_member_argument_HasTwoInts_second_ +{} thread_local!( pub static count_2: Value = Rc::new(RefCell::new(0)); ); #[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)] #[byte_size(1)] -pub struct CountsPerMember_nullptr_ {} -pub fn main() { - __cpp2rust_init_globals(); - std::process::exit(main_0()); -} -fn main_0() -> i32 { +pub struct p2_6_pointer_to_member_argument_CountsPerMember_nullptr_ {} +pub fn test_3() { (*count_0.with(Value::clone).borrow_mut()).prefix_inc(); assert!((count_0.with(|rc| *rc.borrow()) == 1)); assert!((count_1.with(|rc| *rc.borrow()) == 0)); @@ -49,6 +47,13 @@ fn main_0() -> i32 { assert!((count_0.with(|rc| *rc.borrow()) == 1)); assert!((count_1.with(|rc| *rc.borrow()) == 2)); assert!((count_2.with(|rc| *rc.borrow()) == 3)); +} +pub fn main() { + __cpp2rust_init_globals(); + std::process::exit(main_0()); +} +fn main_0() -> i32 { + ({ test_3() }); return 0; } pub fn __cpp2rust_init_globals() { diff --git a/tests/std/temp/temp.type/out/unsafe/p2.6-pointer-to-member-argument.rs b/tests/std/temp/out/unsafe/temp.type.rs similarity index 83% rename from tests/std/temp/temp.type/out/unsafe/p2.6-pointer-to-member-argument.rs rename to tests/std/temp/out/unsafe/temp.type.rs index b8768d486a..a76f701569 100644 --- a/tests/std/temp/temp.type/out/unsafe/p2.6-pointer-to-member-argument.rs +++ b/tests/std/temp/out/unsafe/temp.type.rs @@ -8,29 +8,25 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; use std::rc::Rc; #[repr(C)] #[derive(Copy, Clone, VaArg, FnPtrArg, Default)] -pub struct HasTwoInts { +pub struct p2_6_pointer_to_member_argument_HasTwoInts { pub first: i32, pub second: i32, } pub static mut count_0: std::cell::LazyCell = std::cell::LazyCell::new(|| unsafe { 0 }); #[repr(C)] #[derive(Copy, Clone, VaArg, FnPtrArg, Default)] -pub struct CountsPerMember_refHasTwoInts_first_ {} +pub struct p2_6_pointer_to_member_argument_CountsPerMember_refp2_6_pointer_to_member_argument_HasTwoInts_first_ +{} pub static mut count_1: std::cell::LazyCell = std::cell::LazyCell::new(|| unsafe { 0 }); #[repr(C)] #[derive(Copy, Clone, VaArg, FnPtrArg, Default)] -pub struct CountsPerMember_refHasTwoInts_second_ {} +pub struct p2_6_pointer_to_member_argument_CountsPerMember_refp2_6_pointer_to_member_argument_HasTwoInts_second_ +{} pub static mut count_2: std::cell::LazyCell = std::cell::LazyCell::new(|| unsafe { 0 }); #[repr(C)] #[derive(Copy, Clone, VaArg, FnPtrArg, Default)] -pub struct CountsPerMember_nullptr_ {} -pub fn main() { - unsafe { - __cpp2rust_init_globals(); - std::process::exit(main_0() as i32); - } -} -unsafe fn main_0() -> i32 { +pub struct p2_6_pointer_to_member_argument_CountsPerMember_nullptr_ {} +pub unsafe fn test_3() { (*std::cell::LazyCell::force_mut(&mut *&raw mut count_0)).prefix_inc(); assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut count_0)) == (1))); assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut count_1)) == (0))); @@ -43,6 +39,15 @@ unsafe fn main_0() -> i32 { assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut count_0)) == (1))); assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut count_1)) == (2))); assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut count_2)) == (3))); +} +pub fn main() { + unsafe { + __cpp2rust_init_globals(); + std::process::exit(main_0() as i32); + } +} +unsafe fn main_0() -> i32 { + (unsafe { test_3() }); return 0; } pub unsafe fn __cpp2rust_init_globals() { diff --git a/tests/std/temp/temp.type/p2.6-pointer-to-member-argument.cpp b/tests/std/temp/temp.type.cpp similarity index 87% rename from tests/std/temp/temp.type/p2.6-pointer-to-member-argument.cpp rename to tests/std/temp/temp.type.cpp index 6c41ec8c6a..10f3f03e8e 100644 --- a/tests/std/temp/temp.type/p2.6-pointer-to-member-argument.cpp +++ b/tests/std/temp/temp.type.cpp @@ -1,9 +1,10 @@ // ADDITIONAL_COMPILE_FLAGS: -std=c++23 +#include + // N4950 [temp.type]/2.6: two values of pointer-to-member type are // template-argument-equivalent if they refer to the same class member or are // both the null member pointer value. -#include - +namespace p2_6_pointer_to_member_argument { struct HasTwoInts { int first; int second; @@ -13,7 +14,7 @@ template struct CountsPerMember { static inline int count = 0; }; -int main() { +void test() { ++CountsPerMember<&HasTwoInts::first>::count; assert(CountsPerMember<&HasTwoInts::first>::count == 1); assert(CountsPerMember<&HasTwoInts::second>::count == 0); @@ -26,5 +27,10 @@ int main() { assert(CountsPerMember<&HasTwoInts::first>::count == 1); assert(CountsPerMember<&HasTwoInts::second>::count == 2); assert(CountsPerMember::count == 3); +} +} // namespace p2_6_pointer_to_member_argument + +int main() { + p2_6_pointer_to_member_argument::test(); return 0; } diff --git a/tests/std/utilities/function.objects/func.require-unsupported.cpp b/tests/std/utilities/function.objects/func.require-unsupported.cpp new file mode 100644 index 0000000000..8f323ada6b --- /dev/null +++ b/tests/std/utilities/function.objects/func.require-unsupported.cpp @@ -0,0 +1,144 @@ +// translation-fail: refcount, unsafe +// no-compile: refcount, unsafe +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +#include +#include + +// N4950 [func.require]/1.1: INVOKE(f, t1, t2) is (t1.*f)(t2) when f is a +// pointer to a member function of a class T and t1 is a T or derived from T. +namespace p1_1_member_function_with_object { +struct AccumulatesCalls { + int total = 0; + int add(int amount) { + total += amount; + return total; + } +}; + +struct InheritsAccumulator : AccumulatesCalls {}; + +void test() { + int (AccumulatesCalls::*pmf)(int) = &AccumulatesCalls::add; + AccumulatesCalls obj; + assert(std::invoke(pmf, obj, 3) == 3); + assert(obj.total == 3); + InheritsAccumulator derived; + assert(std::invoke(pmf, derived, 4) == 4); + assert(derived.total == 4); + assert(obj.total == 3); +} +} // namespace p1_1_member_function_with_object + +// N4950 [func.require]/1.2: INVOKE(f, t1, t2) is (t1.get().*f)(t2) when f is a +// pointer to a member function and t1 is a reference_wrapper. +namespace p1_2_member_function_with_reference_wrapper { +struct AccumulatesCalls { + int total = 0; + int add(int amount) { + total += amount; + return total; + } +}; + +struct InheritsAccumulator : AccumulatesCalls {}; + +void test() { + int (AccumulatesCalls::*pmf)(int) = &AccumulatesCalls::add; + AccumulatesCalls obj; + assert(std::invoke(pmf, std::ref(obj), 3) == 3); + assert(obj.total == 3); +} +} // namespace p1_2_member_function_with_reference_wrapper + +// N4950 [func.require]/1.3: INVOKE(f, t1, t2) is ((*t1).*f)(t2) when f is a +// pointer to a member function and t1 is neither a T nor a reference_wrapper. +namespace p1_3_member_function_with_pointer { +struct AccumulatesCalls { + int total = 0; + int add(int amount) { + total += amount; + return total; + } +}; + +struct InheritsAccumulator : AccumulatesCalls {}; + +void test() { + int (AccumulatesCalls::*pmf)(int) = &AccumulatesCalls::add; + AccumulatesCalls obj; + assert(std::invoke(pmf, &obj, 3) == 3); + assert(obj.total == 3); +} +} // namespace p1_3_member_function_with_pointer + +// N4950 [func.require]/1.4: INVOKE(f, t1) is t1.*f when f is a pointer to data +// member of a class T and t1 is a T or derived from T. +namespace p1_4_data_member_with_object { +struct HasTwoInts { + int first; + int second; +}; + +struct InheritsTwoInts : HasTwoInts {}; + +void test() { + int HasTwoInts::*pm = &HasTwoInts::second; + HasTwoInts obj{3, 4}; + assert(std::invoke(pm, obj) == 4); + std::invoke(pm, obj) = 5; + assert(obj.second == 5); + assert(obj.first == 3); + InheritsTwoInts derived{{6, 7}}; + assert(std::invoke(pm, derived) == 7); +} +} // namespace p1_4_data_member_with_object + +// N4950 [func.require]/1.5: INVOKE(f, t1) is t1.get().*f when f is a pointer +// to data member and t1 is a reference_wrapper. +namespace p1_5_data_member_with_reference_wrapper { +struct HasTwoInts { + int first; + int second; +}; + +struct InheritsTwoInts : HasTwoInts {}; + +void test() { + int HasTwoInts::*pm = &HasTwoInts::second; + HasTwoInts obj{3, 4}; + assert(std::invoke(pm, std::ref(obj)) == 4); + std::invoke(pm, std::ref(obj)) = 5; + assert(obj.second == 5); + assert(obj.first == 3); +} +} // namespace p1_5_data_member_with_reference_wrapper + +// N4950 [func.require]/1.6: INVOKE(f, t1) is (*t1).*f when f is a pointer to +// data member and t1 is neither a T nor a reference_wrapper. +namespace p1_6_data_member_with_pointer { +struct HasTwoInts { + int first; + int second; +}; + +struct InheritsTwoInts : HasTwoInts {}; + +void test() { + int HasTwoInts::*pm = &HasTwoInts::second; + HasTwoInts obj{3, 4}; + assert(std::invoke(pm, &obj) == 4); + std::invoke(pm, &obj) = 5; + assert(obj.second == 5); + assert(obj.first == 3); +} +} // namespace p1_6_data_member_with_pointer + +int main() { + p1_1_member_function_with_object::test(); + p1_2_member_function_with_reference_wrapper::test(); + p1_3_member_function_with_pointer::test(); + p1_4_data_member_with_object::test(); + p1_5_data_member_with_reference_wrapper::test(); + p1_6_data_member_with_pointer::test(); + return 0; +} diff --git a/tests/std/utilities/function.objects/func.require/p1.1-member-function-with-object.cpp b/tests/std/utilities/function.objects/func.require/p1.1-member-function-with-object.cpp deleted file mode 100644 index b98bc12117..0000000000 --- a/tests/std/utilities/function.objects/func.require/p1.1-member-function-with-object.cpp +++ /dev/null @@ -1,28 +0,0 @@ -// translation-fail: refcount, unsafe -// ADDITIONAL_COMPILE_FLAGS: -std=c++23 -// N4950 [func.require]/1.1: INVOKE(f, t1, t2) is (t1.*f)(t2) when f is a -// pointer to a member function of a class T and t1 is a T or derived from T. -#include -#include - -struct AccumulatesCalls { - int total = 0; - int add(int amount) { - total += amount; - return total; - } -}; - -struct InheritsAccumulator : AccumulatesCalls {}; - -int main() { - int (AccumulatesCalls::*pmf)(int) = &AccumulatesCalls::add; - AccumulatesCalls obj; - assert(std::invoke(pmf, obj, 3) == 3); - assert(obj.total == 3); - InheritsAccumulator derived; - assert(std::invoke(pmf, derived, 4) == 4); - assert(derived.total == 4); - assert(obj.total == 3); - return 0; -} diff --git a/tests/std/utilities/function.objects/func.require/p1.2-member-function-with-reference-wrapper.cpp b/tests/std/utilities/function.objects/func.require/p1.2-member-function-with-reference-wrapper.cpp deleted file mode 100644 index da4476fe46..0000000000 --- a/tests/std/utilities/function.objects/func.require/p1.2-member-function-with-reference-wrapper.cpp +++ /dev/null @@ -1,24 +0,0 @@ -// translation-fail: refcount, unsafe -// ADDITIONAL_COMPILE_FLAGS: -std=c++23 -// N4950 [func.require]/1.2: INVOKE(f, t1, t2) is (t1.get().*f)(t2) when f is a -// pointer to a member function and t1 is a reference_wrapper. -#include -#include - -struct AccumulatesCalls { - int total = 0; - int add(int amount) { - total += amount; - return total; - } -}; - -struct InheritsAccumulator : AccumulatesCalls {}; - -int main() { - int (AccumulatesCalls::*pmf)(int) = &AccumulatesCalls::add; - AccumulatesCalls obj; - assert(std::invoke(pmf, std::ref(obj), 3) == 3); - assert(obj.total == 3); - return 0; -} diff --git a/tests/std/utilities/function.objects/func.require/p1.3-member-function-with-pointer.cpp b/tests/std/utilities/function.objects/func.require/p1.3-member-function-with-pointer.cpp deleted file mode 100644 index 548ecb86f2..0000000000 --- a/tests/std/utilities/function.objects/func.require/p1.3-member-function-with-pointer.cpp +++ /dev/null @@ -1,24 +0,0 @@ -// translation-fail: refcount, unsafe -// ADDITIONAL_COMPILE_FLAGS: -std=c++23 -// N4950 [func.require]/1.3: INVOKE(f, t1, t2) is ((*t1).*f)(t2) when f is a -// pointer to a member function and t1 is neither a T nor a reference_wrapper. -#include -#include - -struct AccumulatesCalls { - int total = 0; - int add(int amount) { - total += amount; - return total; - } -}; - -struct InheritsAccumulator : AccumulatesCalls {}; - -int main() { - int (AccumulatesCalls::*pmf)(int) = &AccumulatesCalls::add; - AccumulatesCalls obj; - assert(std::invoke(pmf, &obj, 3) == 3); - assert(obj.total == 3); - return 0; -} diff --git a/tests/std/utilities/function.objects/func.require/p1.4-data-member-with-object.cpp b/tests/std/utilities/function.objects/func.require/p1.4-data-member-with-object.cpp deleted file mode 100644 index df2c7e2eba..0000000000 --- a/tests/std/utilities/function.objects/func.require/p1.4-data-member-with-object.cpp +++ /dev/null @@ -1,25 +0,0 @@ -// no-compile: refcount, unsafe -// ADDITIONAL_COMPILE_FLAGS: -std=c++23 -// N4950 [func.require]/1.4: INVOKE(f, t1) is t1.*f when f is a pointer to data -// member of a class T and t1 is a T or derived from T. -#include -#include - -struct HasTwoInts { - int first; - int second; -}; - -struct InheritsTwoInts : HasTwoInts {}; - -int main() { - int HasTwoInts::*pm = &HasTwoInts::second; - HasTwoInts obj{3, 4}; - assert(std::invoke(pm, obj) == 4); - std::invoke(pm, obj) = 5; - assert(obj.second == 5); - assert(obj.first == 3); - InheritsTwoInts derived{{6, 7}}; - assert(std::invoke(pm, derived) == 7); - return 0; -} diff --git a/tests/std/utilities/function.objects/func.require/p1.5-data-member-with-reference-wrapper.cpp b/tests/std/utilities/function.objects/func.require/p1.5-data-member-with-reference-wrapper.cpp deleted file mode 100644 index ed736b8459..0000000000 --- a/tests/std/utilities/function.objects/func.require/p1.5-data-member-with-reference-wrapper.cpp +++ /dev/null @@ -1,23 +0,0 @@ -// no-compile: refcount, unsafe -// ADDITIONAL_COMPILE_FLAGS: -std=c++23 -// N4950 [func.require]/1.5: INVOKE(f, t1) is t1.get().*f when f is a pointer -// to data member and t1 is a reference_wrapper. -#include -#include - -struct HasTwoInts { - int first; - int second; -}; - -struct InheritsTwoInts : HasTwoInts {}; - -int main() { - int HasTwoInts::*pm = &HasTwoInts::second; - HasTwoInts obj{3, 4}; - assert(std::invoke(pm, std::ref(obj)) == 4); - std::invoke(pm, std::ref(obj)) = 5; - assert(obj.second == 5); - assert(obj.first == 3); - return 0; -} diff --git a/tests/std/utilities/function.objects/func.require/p1.6-data-member-with-pointer.cpp b/tests/std/utilities/function.objects/func.require/p1.6-data-member-with-pointer.cpp deleted file mode 100644 index 487f4547ed..0000000000 --- a/tests/std/utilities/function.objects/func.require/p1.6-data-member-with-pointer.cpp +++ /dev/null @@ -1,23 +0,0 @@ -// no-compile: refcount, unsafe -// ADDITIONAL_COMPILE_FLAGS: -std=c++23 -// N4950 [func.require]/1.6: INVOKE(f, t1) is (*t1).*f when f is a pointer to -// data member and t1 is neither a T nor a reference_wrapper. -#include -#include - -struct HasTwoInts { - int first; - int second; -}; - -struct InheritsTwoInts : HasTwoInts {}; - -int main() { - int HasTwoInts::*pm = &HasTwoInts::second; - HasTwoInts obj{3, 4}; - assert(std::invoke(pm, &obj) == 4); - std::invoke(pm, &obj) = 5; - assert(obj.second == 5); - assert(obj.first == 3); - return 0; -}