Translate std::launder (#417)

Initially I wanted to special case this in the converter like std::move
and std::forward. However since this is just a passthrough rule that
receives a pointer and returns a pointer + does not change the value
category of the argument, I put this in rules.

Author: lucic71

rules/new/src.cpp

@@ -10,3 +10,5 @@ void f2(void *a0) { return ::operator delete(a0); }
 void *f3(std::size_t a0) { return ::operator new[](a0); }
 
 void f4(void *a0) { return ::operator delete[](a0); }
+
+template <typename T1> T1 *f5(T1 *a0) { return std::launder(a0); }

rules/new/tgt_refcount.rs

@@ -18,3 +18,7 @@ fn f3(a0: usize) -> AnyPtr {
 fn f4(a0: AnyPtr) {
     libcc2rs::free_refcount(a0)
 }
+
+fn f5<T1>(a0: Ptr<T1>) -> Ptr<T1> {
+    a0
+}

rules/new/tgt_unsafe.rs

@@ -16,3 +16,7 @@ unsafe fn f3(a0: usize) -> *mut ::libc::c_void {
 unsafe fn f4(a0: *mut ::libc::c_void) {
     libcc2rs::free_unsafe(a0)
 }
+
+unsafe fn f5<T1>(a0: *mut T1) -> *mut T1 {
+    a0
+}

tests/unit/as_const.cpp

@@ -1,4 +1,5 @@
 #include <cassert>
+#include <new>
 #include <utility>
 
 enum Overload {
@@ -34,5 +35,10 @@ int main() {
   assert(cs.f() == kConstOverload);
   assert(cs.v == 9);
 
+  S *p = std::launder(&s);
+  p->v = 11;
+  assert(s.v == 11);
+  assert(std::launder(p)->f() == kMutableOverload);
+
   return 0;
 }

tests/unit/out/refcount/as_const.rs

@@ -59,6 +59,10 @@ fn main_0() -> i32 {
     let cs: Ptr<S> = s.as_pointer();
     assert!(((({ SImpl::f_const(&cs,) }) as i32) == (Overload_kConstOverload as i32)));
     assert!(((*(*cs.upgrade().deref()).v.borrow()) == 9));
+    let p: Value<Ptr<S>> = Rc::new(RefCell::new((s.as_pointer())));
+    (*(*(*p.borrow()).upgrade().deref()).v.borrow_mut()) = 11;
+    assert!(((*(*s.borrow()).v.borrow()) == 11));
+    assert!(((({ SImpl::f(&(*p.borrow()),) }) as i32) == (Overload_kMutableOverload as i32)));
     return 0;
 }
 pub trait SImpl {

tests/unit/out/unsafe/as_const.rs

@@ -52,6 +52,10 @@ unsafe fn main_0() -> i32 {
     let cs: *const S = &s;
     assert!((((unsafe { S::f_const(&(*cs),) }) as i32) == (Overload_kConstOverload as i32)));
     assert!((((*cs).v) == (9)));
+    let mut p: *mut S = (&mut s as *mut S);
+    (*p).v = 11;
+    assert!(((s.v) == (11)));
+    assert!((((unsafe { S::f(&mut (*p),) }) as i32) == (Overload_kMutableOverload as i32)));
     return 0;
 }
 pub unsafe fn __cpp2rust_init_globals() {}