Add if constexpr test

Author: lucic71

tests/unit/if_constexpr.cpp

@@ -0,0 +1,19 @@
+#include <cassert>
+#include <type_traits>
+
+template <typename T> int classify(T x) {
+  if constexpr (std::is_pointer_v<T>) {
+    return *x;
+  } else if constexpr (sizeof(T) > 4) {
+    return 2;
+  }
+  return 1;
+}
+
+int main() {
+  int v = 7;
+  assert(classify(&v) == 7);
+  assert(classify(1L) == 2);
+  assert(classify(1) == 1);
+  return 0;
+}

tests/unit/out/refcount/if_constexpr.rs

@@ -0,0 +1,36 @@
+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};
+pub fn classify_0(x: Ptr<i32>) -> i32 {
+    let x: Value<Ptr<i32>> = Rc::new(RefCell::new(x));
+    {
+        return ((*x.borrow()).read());
+    }
+    return 1;
+}
+pub fn classify_1(x: i64) -> i32 {
+    let x: Value<i64> = Rc::new(RefCell::new(x));
+    {
+        return 2;
+    }
+    return 1;
+}
+pub fn classify_2(x: i32) -> i32 {
+    let x: Value<i32> = Rc::new(RefCell::new(x));
+    return 1;
+}
+pub fn main() {
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    let v: Value<i32> = Rc::new(RefCell::new(7));
+    assert!((({ classify_0((v.as_pointer()),) }) == 7));
+    assert!((({ classify_1(1_i64,) }) == 2));
+    assert!((({ classify_2(1,) }) == 1));
+    return 0;
+}

tests/unit/out/unsafe/if_constexpr.rs

@@ -0,0 +1,35 @@
+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 unsafe fn classify_0(mut x: *mut i32) -> i32 {
+    {
+        return (*x);
+    }
+    return 1;
+}
+pub unsafe fn classify_1(mut x: i64) -> i32 {
+    {
+        return 2;
+    }
+    return 1;
+}
+pub unsafe fn classify_2(mut x: i32) -> i32 {
+    return 1;
+}
+pub fn main() {
+    unsafe {
+        std::process::exit(main_0() as i32);
+    }
+}
+unsafe fn main_0() -> i32 {
+    let mut v: i32 = 7;
+    assert!(((unsafe { classify_0((&mut v as *mut i32),) }) == (7)));
+    assert!(((unsafe { classify_1(1_i64,) }) == (2)));
+    assert!(((unsafe { classify_2(1,) }) == (1)));
+    return 0;
+}