Add pointer comparison in ctor

Author: lucic71

tests/unit/out/refcount/this.rs

@@ -12,7 +12,7 @@ pub struct S {
     pub self__: Value<Ptr<S>>,
 }
 impl S {
-    pub fn S(a: i32) -> Self {
+    pub fn S1(a: i32) -> Self {
         let a: Value<i32> = Rc::new(RefCell::new(a));
         let __this: Value<S> = Rc::new(RefCell::new(Self {
             a_: Rc::new(RefCell::new((*a.borrow()))),
@@ -21,6 +21,21 @@ impl S {
         let this: Ptr<S> = __this.as_pointer();
         Rc::try_unwrap(__this).ok().unwrap().into_inner()
     }
+    pub fn S2(a: i32, other: Ptr<S>) -> Self {
+        let a: Value<i32> = Rc::new(RefCell::new(a));
+        let other: Value<Ptr<S>> = Rc::new(RefCell::new(other));
+        let __this: Value<S> = Rc::new(RefCell::new(Self {
+            a_: Rc::new(RefCell::new((*a.borrow()))),
+            self__: Rc::new(RefCell::new(Ptr::<S>::null())),
+        }));
+        let this: Ptr<S> = __this.as_pointer();
+        if (this == (*other.borrow())) {
+            (*(*this.upgrade().deref()).self__.borrow_mut()) = Ptr::<S>::null();
+        } else {
+            (*(*this.upgrade().deref()).self__.borrow_mut()) = (*other.borrow()).clone();
+        }
+        Rc::try_unwrap(__this).ok().unwrap().into_inner()
+    }
 }
 impl Clone for S {
     fn clone(&self) -> Self {
@@ -92,7 +107,7 @@ pub fn main() {
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
-    let s: Value<S> = Rc::new(RefCell::new(S::S({ 1 })));
+    let s: Value<S> = Rc::new(RefCell::new(S::S1({ 1 })));
     let ref_: Ptr<S> = ({ SImpl::returns_this_reference(&s.as_pointer()) });
     (*(*ref_.upgrade().deref()).a_.borrow_mut()).postfix_inc();
     assert!(((*(*s.borrow()).a_.borrow()) == 2));
@@ -122,22 +137,22 @@ fn main_0() -> i32 {
     assert!(((*(*d.borrow()).a_.borrow()) == 6));
     let cr: Ptr<S> = ({ SImpl::cref(&s.as_pointer()) });
     assert!(((*(*cr.upgrade().deref()).a_.borrow()) == 9));
-    let t: Value<S> = Rc::new(RefCell::new(S::S({ 0 })));
+    let t: Value<S> = Rc::new(RefCell::new(S::S1({ 0 })));
     assert!(
         ({
             let _o: Ptr<S> = (s.as_pointer());
             SImpl::is(&s.as_pointer(), _o)
         })
     );
     assert!(!({ SImpl::is(&s.as_pointer(), (t.as_pointer()),) }));
-    let p: Value<Ptr<S>> = Rc::new(RefCell::new(Ptr::alloc(S::S({ 1 }))));
+    let p: Value<Ptr<S>> = Rc::new(RefCell::new(Ptr::alloc(S::S1({ 1 }))));
     let q: Value<Ptr<S>> = Rc::new(RefCell::new(
         ({ SImpl::returns_this_pointer(&(*p.borrow())) }),
     ));
     (*(*(*q.borrow()).upgrade().deref()).a_.borrow_mut()).postfix_inc();
     assert!(((*(*(*p.borrow()).upgrade().deref()).a_.borrow()) == 2));
     (*p.borrow()).delete();
-    let h: Value<Ptr<S>> = Rc::new(RefCell::new(Ptr::alloc(S::S({ 5 }))));
+    let h: Value<Ptr<S>> = Rc::new(RefCell::new(Ptr::alloc(S::S1({ 5 }))));
     ({ SImpl::destroy(&(*h.borrow())) });
     ({ SImpl::reset(&s.as_pointer()) });
     assert!(((*(*s.borrow()).a_.borrow()) == 0));
@@ -156,7 +171,7 @@ fn main_0() -> i32 {
         }) as i32)
             == (false as i32))
     );
-    let other: Value<S> = Rc::new(RefCell::new(S::S({ 22 })));
+    let other: Value<S> = Rc::new(RefCell::new(S::S1({ 22 })));
     assert!(
         ((({ SImpl::copy_if_different(&s.as_pointer(), (other.as_pointer()),) }) as i32)
             == (true as i32))
@@ -166,6 +181,11 @@ fn main_0() -> i32 {
         let _lhs = (*(*s.borrow()).self__.borrow()).clone();
         _lhs == (*(*other.borrow()).self__.borrow()).clone()
     });
+    let u: Value<S> = Rc::new(RefCell::new(S::S2({ 1 }, { (s.as_pointer()) })));
+    assert!({
+        let _lhs = (*(*u.borrow()).self__.borrow()).clone();
+        _lhs == (s.as_pointer())
+    });
     return 0;
 }
 pub trait SImpl {
@@ -222,7 +242,7 @@ impl SImpl for Ptr<S> {
         (*self).delete();
     }
     fn reset(&self) {
-        (*self).write(S::S({ 0 }));
+        (*self).write(S::S1({ 0 }));
     }
     fn copy_if_different_const(&self, other: Ptr<S>) -> bool {
         let other: Value<Ptr<S>> = Rc::new(RefCell::new(other));

tests/unit/out/unsafe/this.rs

@@ -13,14 +13,27 @@ pub struct S {
     pub self__: *mut S,
 }
 impl S {
-    pub unsafe fn S(mut a: i32) -> Self {
+    pub unsafe fn S1(mut a: i32) -> Self {
         let mut __this = Self {
             a_: a,
             self__: std::ptr::null_mut(),
         };
         let this = &raw mut __this;
         __this
     }
+    pub unsafe fn S2(mut a: i32, mut other: *mut S) -> Self {
+        let mut __this = Self {
+            a_: a,
+            self__: std::ptr::null_mut(),
+        };
+        let this = &raw mut __this;
+        if ((this) == (other)) {
+            (*this).self__ = std::ptr::null_mut();
+        } else {
+            (*this).self__ = other;
+        }
+        __this
+    }
     pub unsafe fn returns_this_reference(&mut self) -> *mut S {
         let this = self as *mut S;
         return &mut (*this) as *mut S;
@@ -68,7 +81,7 @@ impl S {
     }
     pub unsafe fn reset(&mut self) {
         let this = self as *mut S;
-        (*this) = S::S({ 0 });
+        (*this) = S::S1({ 0 });
     }
     pub unsafe fn copy_if_different_const(&mut self, mut other: *const S) -> bool {
         let this = self as *mut S;
@@ -111,7 +124,7 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    let mut s: S = S::S({ 1 });
+    let mut s: S = S::S1({ 1 });
     let ref_: *mut S = (unsafe { S::returns_this_reference(&mut s) });
     (*ref_).a_.postfix_inc();
     assert!(((s.a_) == (2)));
@@ -133,20 +146,20 @@ unsafe fn main_0() -> i32 {
     assert!(((d.a_) == (6)));
     let cr: *const S = (unsafe { S::cref(&s) });
     assert!((((*cr).a_) == (9)));
-    let mut t: S = S::S({ 0 });
+    let mut t: S = S::S1({ 0 });
     assert!(
         (unsafe {
             let _o: *const S = (&mut s as *mut S).cast_const();
             S::is(&s, _o)
         })
     );
     assert!(!(unsafe { S::is(&s, (&mut t as *mut S).cast_const(),) }));
-    let mut p: *mut S = (Box::leak(Box::new(S::S({ 1 }))) as *mut S);
+    let mut p: *mut S = (Box::leak(Box::new(S::S1({ 1 }))) as *mut S);
     let mut q: *mut S = (unsafe { S::returns_this_pointer(&mut (*p)) });
     (*q).a_.postfix_inc();
     assert!((((*p).a_) == (2)));
     ::std::mem::drop(Box::from_raw(p));
-    let mut h: *mut S = (Box::leak(Box::new(S::S({ 5 }))) as *mut S);
+    let mut h: *mut S = (Box::leak(Box::new(S::S1({ 5 }))) as *mut S);
     (unsafe { S::destroy(&mut (*h)) });
     (unsafe { S::reset(&mut s) });
     assert!(((s.a_) == (0)));
@@ -165,12 +178,14 @@ unsafe fn main_0() -> i32 {
         }) as i32)
             == (false as i32))
     );
-    let mut other: S = S::S({ 22 });
+    let mut other: S = S::S1({ 22 });
     assert!(
         (((unsafe { S::copy_if_different(&mut s, (&mut other as *mut S),) }) as i32)
             == (true as i32))
     );
     assert!(((s.a_) == (other.a_)));
     assert!(((s.self__) == (other.self__)));
+    let mut u: S = S::S2({ 1 }, { (&mut s as *mut S) });
+    assert!(((u.self__) == (&mut s as *mut S)));
     return 0;
 }

tests/unit/this.cpp

@@ -6,6 +6,14 @@ void bump(S *p);
 struct S {
   S(int a) : a_(a), self_(nullptr) {}
 
+  S(int a, S *other) : a_(a) {
+    if (this == other) {
+      self_ = nullptr;
+    } else {
+      self_ = other;
+    }
+  }
+
   S &returns_this_reference() { return *this; }
 
   S *returns_this_pointer() { return this; }
@@ -120,5 +128,8 @@ int main() {
   assert(s.a_ == other.a_);
   assert(s.self_ == other.self_);
 
+  S u(1, &s);
+  assert(u.self_ == &s);
+
   return 0;
 }