diff --git a/cpp2rust/converter/converter.cpp b/cpp2rust/converter/converter.cpp index dd77efdf57..d1a32a9e08 100644 --- a/cpp2rust/converter/converter.cpp +++ b/cpp2rust/converter/converter.cpp @@ -376,6 +376,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()); } @@ -742,7 +750,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; } @@ -2710,6 +2718,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; @@ -2777,6 +2797,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); @@ -2825,6 +2864,11 @@ bool Converter::VisitCXXRewrittenBinaryOperator( } bool Converter::VisitBinaryOperator(clang::BinaryOperator *expr) { + if (expr->isPtrMemOp()) { + ConvertMemberPtrAccess(expr); + return false; + } + if (expr->isAssignmentOp() && isAddrOf()) { ConvertAssignmentRef(expr); return false; @@ -3100,6 +3144,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; @@ -4192,6 +4240,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())", @@ -4378,6 +4429,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()) { @@ -4567,6 +4622,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()" @@ -5151,6 +5215,80 @@ void Converter::ConvertAddrOf(clang::Expr *expr, clang::QualType pointer_type) { } } +void Converter::ConvertMemberPtr(clang::UnaryOperator *expr) { + if (!expr->getType()->isMemberDataPointerType()) { + llvm::report_fatal_error("pointers to member functions are not supported"); + } + auto *ref = clang::cast(expr->getSubExpr()); + EmitFresh(GetMemberPtrAsString(ref->getDecl())); +} + +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"; + } + 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) { + 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 1f7246437f..18d23267d0 100644 --- a/cpp2rust/converter/converter.h +++ b/cpp2rust/converter/converter.h @@ -121,6 +121,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); @@ -469,7 +471,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()) { @@ -868,6 +871,22 @@ class Converter : public clang::RecursiveASTVisitor { virtual void ConvertAddrOf(clang::Expr *expr, clang::QualType pointer_type); + void ConvertMemberPtr(clang::UnaryOperator *expr); + + std::string GetMemberPtrAsString(const clang::ValueDecl *member); + + virtual std::string GetFieldOffsetAsString(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/converter_lib.cpp b/cpp2rust/converter/converter_lib.cpp index 80fd5acf39..0e65d1b204 100644 --- a/cpp2rust/converter/converter_lib.cpp +++ b/cpp2rust/converter/converter_lib.cpp @@ -385,6 +385,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 dacd1d0d4c..8953ec46d6 100644 --- a/cpp2rust/converter/models/converter_refcount.cpp +++ b/cpp2rust/converter/models/converter_refcount.cpp @@ -1464,6 +1464,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()"); @@ -1536,6 +1540,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() && @@ -2265,6 +2272,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); } @@ -2906,6 +2917,34 @@ void ConverterRefCount::ConvertAddrOf(clang::Expr *expr, StrCat(ConvertPointer(expr)); } +std::string +ConverterRefCount::GetFieldOffsetAsString(const clang::FieldDecl *field) { + return std::format("offset_of_field!({}, {})", + GetRecordName(field->getParent()), + 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 f0d9416587..e9fda29a46 100644 --- a/cpp2rust/converter/models/converter_refcount.h +++ b/cpp2rust/converter/models/converter_refcount.h @@ -318,6 +318,15 @@ class ConverterRefCount final : public Converter { void ConvertAddrOf(clang::Expr *expr, clang::QualType pointer_type) override; + std::string GetFieldOffsetAsString(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..349f6a0ce7 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 { @@ -731,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::() 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, + ) + } +} 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/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.cpp b/tests/std/dcl.dcl/dcl.decl/dcl.init/dcl.init.general.cpp new file mode 100644 index 0000000000..ff328142c6 --- /dev/null +++ b/tests/std/dcl.dcl/dcl.decl/dcl.init/dcl.init.general.cpp @@ -0,0 +1,34 @@ +// 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. +namespace p6_1_zero_initialized_pointer_to_member { +struct HasTwoInts { + int first; + int second; +}; + +struct HoldsSelector { + int HasTwoInts::*selector; +}; + +static int HasTwoInts::*static_pm; + +void test() { + 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); +} +} // 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/out/refcount/dcl.init.general.rs b/tests/std/dcl.dcl/dcl.decl/dcl.init/out/refcount/dcl.init.general.rs new file mode 100644 index 0000000000..fe8062d4e0 --- /dev/null +++ b/tests/std/dcl.dcl/dcl.decl/dcl.init/out/refcount/dcl.init.general.rs @@ -0,0 +1,65 @@ +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 p6_1_zero_initialized_pointer_to_member_HasTwoInts { + #[offset(0)] + pub first: i32, + #[offset(4)] + pub second: i32, +} +#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg)] +#[byte_size(8)] +pub struct p6_1_zero_initialized_pointer_to_member_HoldsSelector { + #[offset(0)] + #[byte_size(8)] + pub selector: isize, +} +impl Default for p6_1_zero_initialized_pointer_to_member_HoldsSelector { + fn default() -> Self { + { 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 test_1() { + assert!(((static_pm_0.with(|rc| *rc.borrow())) == -1_isize)); + assert!( + (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!(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!(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() { + let _ = static_pm_0.with(|_| ()); +} diff --git a/tests/std/dcl.dcl/dcl.decl/dcl.init/out/unsafe/dcl.init.general.rs b/tests/std/dcl.dcl/dcl.decl/dcl.init/out/unsafe/dcl.init.general.rs new file mode 100644 index 0000000000..b8b369db6c --- /dev/null +++ b/tests/std/dcl.dcl/dcl.decl/dcl.init/out/unsafe/dcl.init.general.rs @@ -0,0 +1,62 @@ +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 p6_1_zero_initialized_pointer_to_member_HasTwoInts { + pub first: i32, + pub second: i32, +} +#[repr(C)] +#[derive(Copy, Clone, VaArg, FnPtrArg)] +pub struct p6_1_zero_initialized_pointer_to_member_HoldsSelector { + pub selector: isize, +} +impl Default for p6_1_zero_initialized_pointer_to_member_HoldsSelector { + fn default() -> Self { + 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 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!(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!(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!(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() { + std::cell::LazyCell::force(&*&raw const static_pm_0); +} diff --git a/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.array-unsupported.cpp b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.array-unsupported.cpp new file mode 100644 index 0000000000..f61beafc94 --- /dev/null +++ b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.array-unsupported.cpp @@ -0,0 +1,43 @@ +// translation-fail: refcount, unsafe +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +#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; + int third_calls = 0; + void first() { ++first_calls; } + void second() { ++second_calls; } + void third() { ++third_calls; } +}; + +void test() { + 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); +} +} // 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.cpp b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.array.cpp new file mode 100644 index 0000000000..35e53f7b2b --- /dev/null +++ b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.array.cpp @@ -0,0 +1,35 @@ +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +#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; +}; + +void test() { + 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); +} +} // 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-unsupported.cpp b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr-unsupported.cpp new file mode 100644 index 0000000000..6d6a77fc8f --- /dev/null +++ b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/dcl.mptr-unsupported.cpp @@ -0,0 +1,31 @@ +// translation-fail: refcount, unsafe +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +#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; + void first(int amount) { first_total += amount; } + void second(int amount) { second_total += amount; } +}; + +void test() { + 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); +} +} // 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/out/refcount/dcl.array.rs b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/out/refcount/dcl.array.rs new file mode 100644 index 0000000000..82ad0a61f0 --- /dev/null +++ b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/out/refcount/dcl.array.rs @@ -0,0 +1,80 @@ +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 p6_array_of_pointers_to_data_members_HasThreeInts { + #[offset(0)] + pub first: i32, + #[offset(4)] + pub second: i32, + #[offset(8)] + pub third: i32, +} +pub fn test_0() { + let members: Value> = Rc::new(RefCell::new(Box::new([ + (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( + p6_array_of_pointers_to_data_members_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] = + (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/out/unsafe/dcl.array.rs b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/out/unsafe/dcl.array.rs new file mode 100644 index 0000000000..f87830d99a --- /dev/null +++ b/tests/std/dcl.dcl/dcl.decl/dcl.meaning/out/unsafe/dcl.array.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 p6_array_of_pointers_to_data_members_HasThreeInts { + pub first: i32, + pub second: i32, + pub third: i32, +} +pub unsafe fn test_0() { + let mut members: [isize; 3] = [ + (::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: 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 p6_array_of_pointers_to_data_members_HasThreeInts) + .wrapping_byte_offset(members[(0) as usize]) + .cast::()) + == (6)) + ); + assert!( + ((*(&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 p6_array_of_pointers_to_data_members_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 p6_array_of_pointers_to_data_members_HasThreeInts) + .wrapping_byte_offset((*element.offset((1) as isize))) + .cast::()) + == (4)) + ); + element.prefix_inc(); + element.prefix_inc(); + assert!(((element) == (&mut members[(2) as usize] as *mut isize))); + assert!( + ((*(&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!(p6_array_of_pointers_to_data_members_HasThreeInts, third) as isize); + assert!( + ((*(&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-unsupported.cpp b/tests/std/expr/conv/conv.bool-unsupported.cpp new file mode 100644 index 0000000000..553debe0c4 --- /dev/null +++ b/tests/std/expr/conv/conv.bool-unsupported.cpp @@ -0,0 +1,36 @@ +// translation-fail: refcount, unsafe +// ADDITIONAL_COMPILE_FLAGS: -std=c++23 +#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() {} +}; + +void test() { + 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); +} +} // namespace p1_pointer_to_member + +int main() { + p1_pointer_to_member::test(); + return 0; +} diff --git a/tests/std/expr/conv/conv.fctptr-unsupported.cpp b/tests/std/expr/conv/conv.fctptr-unsupported.cpp new file mode 100644 index 0000000000..67c8e74895 --- /dev/null +++ b/tests/std/expr/conv/conv.fctptr-unsupported.cpp @@ -0,0 +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. +namespace p1_pointer_to_noexcept_member_function { +struct HasNoexceptMember { + int calls = 0; + void run() noexcept { ++calls; } +}; + +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.cpp b/tests/std/expr/conv/conv.mem.cpp new file mode 100644 index 0000000000..7b53047b50 --- /dev/null +++ b/tests/std/expr/conv/conv.mem.cpp @@ -0,0 +1,24 @@ +// 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_first_member { +struct HasTwoInts { + int first; + int second; +}; + +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/out/refcount/conv.mem.rs b/tests/std/expr/conv/out/refcount/conv.mem.rs new file mode 100644 index 0000000000..d272ef1c0f --- /dev/null +++ b/tests/std/expr/conv/out/refcount/conv.mem.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 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 { + ({ test_0() }); + return 0; +} +pub fn __cpp2rust_init_globals() {} diff --git a/tests/std/expr/conv/out/unsafe/conv.mem.rs b/tests/std/expr/conv/out/unsafe/conv.mem.rs new file mode 100644 index 0000000000..b87445fc44 --- /dev/null +++ b/tests/std/expr/conv/out/unsafe/conv.mem.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 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(); + 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/expr/expr.compound/expr.cond-unsupported.cpp b/tests/std/expr/expr.compound/expr.cond-unsupported.cpp new file mode 100644 index 0000000000..e19becf301 --- /dev/null +++ b/tests/std/expr/expr.compound/expr.cond-unsupported.cpp @@ -0,0 +1,38 @@ +// 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. +namespace p7_4_base_and_derived_pointer_to_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 = &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); +} +} // 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.cpp b/tests/std/expr/expr.compound/expr.cond.cpp new file mode 100644 index 0000000000..3533a2cbfa --- /dev/null +++ b/tests/std/expr/expr.compound/expr.cond.cpp @@ -0,0 +1,27 @@ +// 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, they are brought to their composite pointer type. +namespace p7_4_pointer_to_member_and_null { +struct HasTwoInts { + int first; + int second; +}; + +static int HasTwoInts::*second_or_null(bool choose_second) { + return choose_second ? &HasTwoInts::second : nullptr; +} + +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 new file mode 100644 index 0000000000..c90d255878 --- /dev/null +++ b/tests/std/expr/expr.compound/expr.eq-p4.3-pointer-to-virtual-member-function.cpp @@ -0,0 +1,15 @@ +// 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 +// 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..1b1c0e5aff --- /dev/null +++ b/tests/std/expr/expr.compound/expr.eq-p4.4-members-of-unrelated-classes.cpp @@ -0,0 +1,24 @@ +// 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 +// 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-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.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..829c7af5d2 --- /dev/null +++ b/tests/std/expr/expr.compound/expr.mptr.oper-p4-dynamic-type-lacks-member.cpp @@ -0,0 +1,20 @@ +// translation-fail: refcount, unsafe +// 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-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..087ab06d4b --- /dev/null +++ b/tests/std/expr/expr.compound/expr.mptr.oper-p4-object-type-not-similar.cpp @@ -0,0 +1,23 @@ +// translation-fail: refcount +// no-compile: unsafe +// 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-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..c1499582d1 --- /dev/null +++ b/tests/std/expr/expr.compound/expr.mptr.oper-p6-null-pointer-to-member-function.cpp @@ -0,0 +1,17 @@ +// translation-fail: refcount, unsafe +// 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-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.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-unsupported.cpp b/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast-unsupported.cpp new file mode 100644 index 0000000000..0497bac8e4 --- /dev/null +++ b/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast-unsupported.cpp @@ -0,0 +1,31 @@ +// 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. +namespace p10_1_member_function_round_trip { +struct CountsCalls { + int calls = 0; + void run() { ++calls; } +}; + +struct Unrelated {}; + +void test() { + 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); +} +} // 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.cpp b/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast.cpp new file mode 100644 index 0000000000..2e1e9922e7 --- /dev/null +++ b/tests/std/expr/expr.compound/expr.post/expr.reinterpret.cast.cpp @@ -0,0 +1,50 @@ +// 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. +namespace p10_2_data_member_round_trip { +struct HasTwoInts { + int first; + int second; +}; + +struct HasChar { + char character; +}; + +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.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..82905a108d --- /dev/null +++ b/tests/std/expr/expr.compound/expr.post/expr.static.cast-p13-base-unrelated-to-member-class.cpp @@ -0,0 +1,24 @@ +// translation-fail: refcount, unsafe +// 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-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/out/refcount/expr.reinterpret.cast-p10-result-is-unspecified.rs b/tests/std/expr/expr.compound/expr.post/out/refcount/expr.reinterpret.cast-p10-result-is-unspecified.rs new file mode 100644 index 0000000000..2acb388099 --- /dev/null +++ b/tests/std/expr/expr.compound/expr.post/out/refcount/expr.reinterpret.cast-p10-result-is-unspecified.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(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: 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/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/out/unsafe/expr.reinterpret.cast-p10-result-is-unspecified.rs b/tests/std/expr/expr.compound/expr.post/out/unsafe/expr.reinterpret.cast-p10-result-is-unspecified.rs new file mode 100644 index 0000000000..67fb4e03fa --- /dev/null +++ b/tests/std/expr/expr.compound/expr.post/out/unsafe/expr.reinterpret.cast-p10-result-is-unspecified.rs @@ -0,0 +1,31 @@ +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: 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/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/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/out/refcount/expr.cond.rs b/tests/std/expr/expr.compound/out/refcount/expr.cond.rs new file mode 100644 index 0000000000..8de5164bf2 --- /dev/null +++ b/tests/std/expr/expr.compound/out/refcount/expr.cond.rs @@ -0,0 +1,50 @@ +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 p7_4_pointer_to_member_and_null_HasTwoInts { + #[offset(0)] + pub first: i32, + #[offset(4)] + pub second: i32, +} +pub fn second_or_null_0(mut choose_second: bool) -> isize { + return if choose_second { + (offset_of_field!(p7_4_pointer_to_member_and_null_HasTwoInts, second) as isize) + } else { + -1_isize + }; +} +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!(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/out/refcount/expr.mptr.oper-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 new file mode 100644 index 0000000000..f580b9bf45 --- /dev/null +++ b/tests/std/expr/expr.compound/out/refcount/expr.mptr.oper-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: isize = -1_isize; + 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/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/out/unsafe/expr.cond.rs b/tests/std/expr/expr.compound/out/unsafe/expr.cond.rs new file mode 100644 index 0000000000..27419df8d9 --- /dev/null +++ b/tests/std/expr/expr.compound/out/unsafe/expr.cond.rs @@ -0,0 +1,51 @@ +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 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!(p7_4_pointer_to_member_and_null_HasTwoInts, second) as isize) + } else { + -1_isize + }; +} +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!(p7_4_pointer_to_member_and_null_HasTwoInts, second) + as isize)) + ); + assert!( + ((*(&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/out/unsafe/expr.mptr.oper-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 new file mode 100644 index 0000000000..7fd683370a --- /dev/null +++ b/tests/std/expr/expr.compound/out/unsafe/expr.mptr.oper-p6-null-pointer-to-data-member.rs @@ -0,0 +1,31 @@ +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 = -1_isize; + let mut obj: HasTwoInts = HasTwoInts { + first: 3, + second: 4, + }; + 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/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/out/refcount/temp.type.rs b/tests/std/temp/out/refcount/temp.type.rs new file mode 100644 index 0000000000..bfc835ea6c --- /dev/null +++ b/tests/std/temp/out/refcount/temp.type.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 p2_6_pointer_to_member_argument_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 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 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 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)); + 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)); +} +pub fn main() { + __cpp2rust_init_globals(); + std::process::exit(main_0()); +} +fn main_0() -> i32 { + ({ test_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/out/unsafe/temp.type.rs b/tests/std/temp/out/unsafe/temp.type.rs new file mode 100644 index 0000000000..a76f701569 --- /dev/null +++ b/tests/std/temp/out/unsafe/temp.type.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 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 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 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 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))); + 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))); +} +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() { + 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.cpp b/tests/std/temp/temp.type.cpp new file mode 100644 index 0000000000..10f3f03e8e --- /dev/null +++ b/tests/std/temp/temp.type.cpp @@ -0,0 +1,36 @@ +// 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. +namespace p2_6_pointer_to_member_argument { +struct HasTwoInts { + int first; + int second; +}; + +template struct CountsPerMember { + static inline int count = 0; +}; + +void test() { + ++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); +} +} // 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; +}