Skip to content

Implement Ord for Ptr #385

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
nunoplopes merged 1 commit into from
Sep 20, 2026
Merged

Implement Ord for Ptr #385

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
3 changes: 2 additions & 1 deletion cpp2rust/converter/converter.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -2575,7 +2575,8 @@ bool Converter::VisitCXXRewrittenBinaryOperator(

bool Converter::VisitBinaryOperator(clang::BinaryOperator *expr) {
if (expr->getOpcode() == clang::BO_Cmp) {
StrCat(std::format("({}).cmp(&({}))", ConvertRValue(expr->getLHS()),
StrCat(std::format("std::cmp::Ord::cmp(&({}), &({}))",
ConvertRValue(expr->getLHS()),
ConvertRValue(expr->getRHS())));
computed_expr_type_ = ComputedExprType::FreshValue;
return false;
Expand Down
14 changes: 10 additions & 4 deletions libcc2rs/src/rc.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -167,15 +167,21 @@ impl<T> PartialEq for Ptr<T> {

impl<T> Eq for Ptr<T> {}

impl<T> PartialOrd for Ptr<T> {
fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
impl<T> Ord for Ptr<T> {
fn cmp(&self, other: &Self) -> std::cmp::Ordering {
match self.kind.partial_cmp(&other.kind) {
Some(std::cmp::Ordering::Equal) => self.byte_offset().partial_cmp(&other.byte_offset()),
ord => ord,
Some(std::cmp::Ordering::Equal) | None => self.byte_offset().cmp(&other.byte_offset()),
Some(ord) => ord,
}
}
}

impl<T> PartialOrd for Ptr<T> {
fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
Some(self.cmp(other))
}
}

impl<T> Ptr<T> {
#[inline]
pub fn null() -> Self {
Expand Down
10 changes: 10 additions & 0 deletions tests/unit/operator_comparison_defaulted.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -48,6 +48,11 @@ struct Secondary {
bool operator>=(const Secondary &) const = default;
};

struct PtrMember {
int *p;
auto operator<=>(const PtrMember &) const = default;
};

int main() {
Eq e1{1, 2}, e2{1, 2}, e3{1, 3};
assert(e1 == e2);
Expand All @@ -72,5 +77,10 @@ int main() {
assert(s1 < s2);
assert(s2 >= s1);
assert(!(s2 < s1));
int arr[2] = {0, 0};
PtrMember p1{arr}, p2{arr + 1}, p3{arr};
assert(p1 < p2);
assert(p1 == p3);
assert((p2 <=> p1) == std::strong_ordering::greater);
return 0;
}
153 changes: 125 additions & 28 deletions tests/unit/out/refcount/operator_comparison_defaulted.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -407,6 +407,58 @@ impl ByteRepr for Secondary {
}
}
}
#[derive(Default)]
pub struct PtrMember {
pub p: Value<Ptr<i32>>,
}
impl std::cmp::Ord for PtrMember {
fn cmp(&self, other: &Self) -> std::cmp::Ordering {
{
PtrMemberImpl::operator_cmp(
&Rc::new(RefCell::new(PtrMember { p: self.p.clone() })).as_pointer(),
Rc::new(RefCell::new(PtrMember { p: other.p.clone() })).as_pointer(),
)
}
}
}
impl std::cmp::PartialOrd for PtrMember {
fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
Some(self.cmp(other))
}
}
impl std::cmp::PartialEq for PtrMember {
fn eq(&self, other: &Self) -> bool {
{
PtrMemberImpl::operator_cmp(
&Rc::new(RefCell::new(PtrMember { p: self.p.clone() })).as_pointer(),
Rc::new(RefCell::new(PtrMember { p: other.p.clone() })).as_pointer(),
) == std::cmp::Ordering::Equal
}
}
}
impl std::cmp::Eq for PtrMember {}
impl Clone for PtrMember {
fn clone(&self) -> Self {
let __this: Value<PtrMember> = Rc::new(RefCell::new(Self {
p: Rc::new(RefCell::new((*self.p.borrow()).clone())),
}));
let this: Ptr<PtrMember> = __this.as_pointer();
Rc::try_unwrap(__this).ok().unwrap().into_inner()
}
}
impl ByteRepr for PtrMember {
fn byte_size() -> usize {
8
}
fn to_bytes(&self, buf: &mut [u8]) {
(*self.p.borrow()).to_bytes(&mut buf[0..8]);
}
fn from_bytes(buf: &[u8]) -> Self {
Self {
p: Rc::new(RefCell::new(<Ptr<i32>>::from_bytes(&buf[0..8]))),
}
}
}
pub fn main() {
__cpp2rust_init_globals();
std::process::exit(main_0());
Expand Down Expand Up @@ -525,6 +577,27 @@ fn main_0() -> i32 {
assert!(({ SecondaryImpl::operator_lt(&s1.as_pointer(), s2.as_pointer(),) }));
assert!(({ SecondaryImpl::operator_ge(&s2.as_pointer(), s1.as_pointer(),) }));
assert!(!({ SecondaryImpl::operator_lt(&s2.as_pointer(), s1.as_pointer(),) }));
let arr: Value<Box<[i32]>> = Rc::new(RefCell::new(Box::new([0, 0])));
let p1: Value<PtrMember> = Rc::new(RefCell::new(PtrMember {
p: Rc::new(RefCell::new((arr.as_pointer() as Ptr<i32>))),
}));
let p2: Value<PtrMember> = Rc::new(RefCell::new(PtrMember {
p: Rc::new(RefCell::new(
(arr.as_pointer() as Ptr<i32>).offset((1) as isize),
)),
}));
let p3: Value<PtrMember> = Rc::new(RefCell::new(PtrMember {
p: Rc::new(RefCell::new((arr.as_pointer() as Ptr<i32>))),
}));
assert!(
({ PtrMemberImpl::operator_cmp(&p1.as_pointer(), p2.as_pointer(),) })
== std::cmp::Ordering::Less
);
assert!(({ PtrMemberImpl::operator_eq(&p1.as_pointer(), p3.as_pointer(),) }));
assert!(
({ PtrMemberImpl::operator_cmp(&p2.as_pointer(), p1.as_pointer(),) })
== std::cmp::Ordering::Greater
);
return 0;
}
pub trait BothImpl {
Expand All @@ -540,10 +613,10 @@ impl BothImpl for Ptr<Both> {
}
fn operator_cmp(&self, _a0: Ptr<Both>) -> std::cmp::Ordering {
{
let cmp: Value<std::cmp::Ordering> = Rc::new(RefCell::new(
(*(*(*self).upgrade().deref()).a.borrow())
.cmp(&(*(*_a0.upgrade().deref()).a.borrow())),
));
let cmp: Value<std::cmp::Ordering> = Rc::new(RefCell::new(std::cmp::Ord::cmp(
&(*(*(*self).upgrade().deref()).a.borrow()),
&(*(*_a0.upgrade().deref()).a.borrow()),
)));
if !((*cmp.borrow()) == std::cmp::Ordering::Equal) {
return (*cmp.borrow_mut()).clone();
}
Expand All @@ -558,19 +631,19 @@ pub trait CmpImpl {
impl CmpImpl for Ptr<Cmp> {
fn operator_cmp(&self, _a0: Ptr<Cmp>) -> std::cmp::Ordering {
{
let cmp: Value<std::cmp::Ordering> = Rc::new(RefCell::new(
(*(*(*self).upgrade().deref()).a.borrow())
.cmp(&(*(*_a0.upgrade().deref()).a.borrow())),
));
let cmp: Value<std::cmp::Ordering> = Rc::new(RefCell::new(std::cmp::Ord::cmp(
&(*(*(*self).upgrade().deref()).a.borrow()),
&(*(*_a0.upgrade().deref()).a.borrow()),
)));
if !((*cmp.borrow()) == std::cmp::Ordering::Equal) {
return (*cmp.borrow_mut()).clone();
}
}
{
let cmp: Value<std::cmp::Ordering> = Rc::new(RefCell::new(
(*(*(*self).upgrade().deref()).b.borrow())
.cmp(&(*(*_a0.upgrade().deref()).b.borrow())),
));
let cmp: Value<std::cmp::Ordering> = Rc::new(RefCell::new(std::cmp::Ord::cmp(
&(*(*(*self).upgrade().deref()).b.borrow()),
&(*(*_a0.upgrade().deref()).b.borrow()),
)));
if !((*cmp.borrow()) == std::cmp::Ordering::Equal) {
return (*cmp.borrow_mut()).clone();
}
Expand Down Expand Up @@ -608,10 +681,10 @@ pub trait InnerImpl {
impl InnerImpl for Ptr<Inner> {
fn operator_cmp(&self, _a0: Ptr<Inner>) -> std::cmp::Ordering {
{
let cmp: Value<std::cmp::Ordering> = Rc::new(RefCell::new(
(*(*(*self).upgrade().deref()).x.borrow())
.cmp(&(*(*_a0.upgrade().deref()).x.borrow())),
));
let cmp: Value<std::cmp::Ordering> = Rc::new(RefCell::new(std::cmp::Ord::cmp(
&(*(*(*self).upgrade().deref()).x.borrow()),
&(*(*_a0.upgrade().deref()).x.borrow()),
)));
if !((*cmp.borrow()) == std::cmp::Ordering::Equal) {
return (*cmp.borrow_mut()).clone();
}
Expand All @@ -631,10 +704,10 @@ pub trait OrdOnlyImpl {
impl OrdOnlyImpl for Ptr<OrdOnly> {
fn operator_cmp(&self, _a0: Ptr<OrdOnly>) -> std::cmp::Ordering {
{
let cmp: Value<std::cmp::Ordering> = Rc::new(RefCell::new(
(*(*(*self).upgrade().deref()).a.borrow())
.cmp(&(*(*_a0.upgrade().deref()).a.borrow())),
));
let cmp: Value<std::cmp::Ordering> = Rc::new(RefCell::new(std::cmp::Ord::cmp(
&(*(*(*self).upgrade().deref()).a.borrow()),
&(*(*_a0.upgrade().deref()).a.borrow()),
)));
if !((*cmp.borrow()) == std::cmp::Ordering::Equal) {
return (*cmp.borrow_mut()).clone();
}
Expand All @@ -660,10 +733,10 @@ impl OuterImpl for Ptr<Outer> {
}
}
{
let cmp: Value<std::cmp::Ordering> = Rc::new(RefCell::new(
(*(*(*self).upgrade().deref()).y.borrow())
.cmp(&(*(*_a0.upgrade().deref()).y.borrow())),
));
let cmp: Value<std::cmp::Ordering> = Rc::new(RefCell::new(std::cmp::Ord::cmp(
&(*(*(*self).upgrade().deref()).y.borrow()),
&(*(*_a0.upgrade().deref()).y.borrow()),
)));
if !((*cmp.borrow()) == std::cmp::Ordering::Equal) {
return (*cmp.borrow_mut()).clone();
}
Expand All @@ -680,6 +753,30 @@ impl OuterImpl for Ptr<Outer> {
});
}
}
pub trait PtrMemberImpl {
fn operator_cmp(&self, _a0: Ptr<PtrMember>) -> std::cmp::Ordering;
fn operator_eq(&self, _a0: Ptr<PtrMember>) -> bool;
}
impl PtrMemberImpl for Ptr<PtrMember> {
fn operator_cmp(&self, _a0: Ptr<PtrMember>) -> std::cmp::Ordering {
{
let cmp: Value<std::cmp::Ordering> = Rc::new(RefCell::new(std::cmp::Ord::cmp(
&(*(*(*self).upgrade().deref()).p.borrow()),
&(*(*_a0.upgrade().deref()).p.borrow()),
)));
if !((*cmp.borrow()) == std::cmp::Ordering::Equal) {
return (*cmp.borrow_mut()).clone();
}
}
return std::cmp::Ordering::Equal;
}
fn operator_eq(&self, _a0: Ptr<PtrMember>) -> bool {
return {
let _lhs = (*(*(*self).upgrade().deref()).p.borrow()).clone();
_lhs == (*(*_a0.upgrade().deref()).p.borrow()).clone()
};
}
}
pub trait SecondaryImpl {
fn operator_eq(&self, _a0: Ptr<Secondary>) -> bool;
fn operator_ne(&self, _a0: Ptr<Secondary>) -> bool;
Expand All @@ -702,10 +799,10 @@ impl SecondaryImpl for Ptr<Secondary> {
}
fn operator_cmp(&self, _a0: Ptr<Secondary>) -> std::cmp::Ordering {
{
let cmp: Value<std::cmp::Ordering> = Rc::new(RefCell::new(
(*(*(*self).upgrade().deref()).a.borrow())
.cmp(&(*(*_a0.upgrade().deref()).a.borrow())),
));
let cmp: Value<std::cmp::Ordering> = Rc::new(RefCell::new(std::cmp::Ord::cmp(
&(*(*(*self).upgrade().deref()).a.borrow()),
&(*(*_a0.upgrade().deref()).a.borrow()),
)));
if !((*cmp.borrow()) == std::cmp::Ordering::Equal) {
return (*cmp.borrow_mut()).clone();
}
Expand Down
6 changes: 4 additions & 2 deletions tests/unit/out/refcount/operator_traits.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -487,8 +487,10 @@ pub trait CmpImpl {
}
impl CmpImpl for Ptr<Cmp> {
fn operator_cmp(&self, o: Ptr<Cmp>) -> std::cmp::Ordering {
return (*(*(*self).upgrade().deref()).v.borrow())
.cmp(&(*(*o.upgrade().deref()).v.borrow()));
return std::cmp::Ord::cmp(
&(*(*(*self).upgrade().deref()).v.borrow()),
&(*(*o.upgrade().deref()).v.borrow()),
);
}
fn operator_eq(&self, o: Ptr<Cmp>) -> bool {
return {
Expand Down
Loading
Loading