Test const comparison in constructor

Author: lucic71

tests/unit/out/refcount/this.rs

@@ -36,6 +36,19 @@ impl S {
         }
         Rc::try_unwrap(__this).ok().unwrap().into_inner()
     }
+    pub fn S3(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();
+        }
+        Rc::try_unwrap(__this).ok().unwrap().into_inner()
+    }
 }
 impl Clone for S {
     fn clone(&self) -> Self {
@@ -186,6 +199,9 @@ fn main_0() -> i32 {
         let _lhs = (*(*u.borrow()).self__.borrow()).clone();
         _lhs == (s.as_pointer())
     });
+    let s_const: Value<S> = Rc::new(RefCell::new(S::S1({ 100 })));
+    let u1: Value<S> = Rc::new(RefCell::new(S::S3({ 1 }, { (s_const.as_pointer()) })));
+    assert!((*(*u1.borrow()).self__.borrow()).is_null());
     return 0;
 }
 pub trait SImpl {

tests/unit/out/unsafe/this.rs

@@ -32,6 +32,16 @@ impl S {
         }
         this
     }
+    pub unsafe fn S3(mut a: i32, mut other: *const S) -> Self {
+        let mut this = Self {
+            a_: a,
+            self__: std::ptr::null_mut(),
+        };
+        if (((&raw mut this).cast_const()) == (other)) {
+            this.self__ = std::ptr::null_mut();
+        }
+        this
+    }
     pub unsafe fn returns_this_reference(&mut self) -> *mut S {
         return &mut (*(self as *mut S)) as *mut S;
     }
@@ -170,5 +180,8 @@ unsafe fn main_0() -> i32 {
     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)));
+    let s_const: S = S::S1({ 100 });
+    let mut u1: S = S::S3({ 1 }, { (&s_const as *const S) });
+    assert!((u1.self__).is_null());
     return 0;
 }

tests/unit/this.cpp

@@ -14,6 +14,12 @@ struct S {
     }
   }
 
+  S(int a, const S *other) : a_(a) {
+    if (this == other) {
+      self_ = nullptr;
+    }
+  }
+
   S &returns_this_reference() { return *this; }
 
   S *returns_this_pointer() { return this; }
@@ -131,5 +137,9 @@ int main() {
   S u(1, &s);
   assert(u.self_ == &s);
 
+  const S s_const = S(100);
+  S u1(1, &s_const);
+  assert(u1.self_ == nullptr);
+
   return 0;
 }