Merge branch 'master' into idiomatic-name

Author: lucic71

cpp2rust/converter/converter.cpp

@@ -1376,7 +1376,12 @@ bool Converter::VisitIfStmt(clang::IfStmt *stmt) {
     return false;
   }
   StrCat(keyword::kIf);
-  ConvertCondition(stmt->getCond());
+  if (auto *cond = clang::dyn_cast<clang::ConstantExpr>(stmt->getCond());
+      cond && stmt->isConstexpr()) {
+    StrCat(cond->getResultAsAPSInt() != 0 ? keyword::kTrue : keyword::kFalse);
+  } else {
+    ConvertCondition(stmt->getCond());
+  }
   ConvertBody(stmt->getThen());
   if (stmt->hasElseStorage()) {
     StrCat(keyword::kElse);

cpp2rust/converter/converter.h

@@ -438,6 +438,7 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
   VisitUnaryExprOrTypeTraitExpr(clang::UnaryExprOrTypeTraitExpr *expr);
 
   virtual bool VisitTypeTraitExpr(clang::TypeTraitExpr *expr);
+
   virtual bool VisitSizeOfPackExpr(clang::SizeOfPackExpr *expr);
 
   virtual bool VisitOffsetOfExpr(clang::OffsetOfExpr *expr);

tests/unit/if_constexpr.cpp

@@ -0,0 +1,28 @@
+#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 keep_both(int x) {
+  if constexpr (sizeof(int) > 2) {
+    return x + 1;
+  } else {
+    return x - 1;
+  }
+}
+
+int main() {
+  int v = 7;
+  assert(classify(&v) == 7);
+  assert(classify(1L) == 2);
+  assert(classify(1) == 1);
+  assert(keep_both(1) == 2);
+  return 0;
+}

tests/unit/out/refcount/if_constexpr.rs

@@ -0,0 +1,53 @@
+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));
+    if true {
+        return ((*x.borrow()).read());
+    } else {
+    }
+    return 1;
+}
+pub fn classify_1(x: i64) -> i32 {
+    let x: Value<i64> = Rc::new(RefCell::new(x));
+    if false {
+    } else if true {
+        return 2;
+    }
+    return 1;
+}
+pub fn classify_2(x: i32) -> i32 {
+    let x: Value<i32> = Rc::new(RefCell::new(x));
+    if false {
+    } else if false {
+    }
+    return 1;
+}
+pub fn keep_both_3(x: i32) -> i32 {
+    let x: Value<i32> = Rc::new(RefCell::new(x));
+    if true {
+        return ((*x.borrow()) + 1);
+    } else {
+        return ((*x.borrow()) - 1);
+    }
+    panic!("ub: non-void function does not return a value")
+}
+pub fn main() {
+    __cpp2rust_init_globals();
+    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));
+    assert!((({ keep_both_3(1,) }) == 2));
+    return 0;
+}
+pub fn __cpp2rust_init_globals() {}

tests/unit/out/unsafe/if_constexpr.rs

@@ -0,0 +1,51 @@
+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 {
+    if true {
+        return (*x);
+    } else {
+    }
+    return 1;
+}
+pub unsafe fn classify_1(mut x: i64) -> i32 {
+    if false {
+    } else if true {
+        return 2;
+    }
+    return 1;
+}
+pub unsafe fn classify_2(mut x: i32) -> i32 {
+    if false {
+    } else if false {
+    }
+    return 1;
+}
+pub unsafe fn keep_both_3(mut x: i32) -> i32 {
+    if true {
+        return ((x) + (1));
+    } else {
+        return ((x) - (1));
+    }
+    panic!("ub: non-void function does not return a value")
+}
+pub fn main() {
+    unsafe {
+        __cpp2rust_init_globals();
+        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)));
+    assert!(((unsafe { keep_both_3(1,) }) == (2)));
+    return 0;
+}
+pub unsafe fn __cpp2rust_init_globals() {}