Keep untaken branches on if-constexpr in non-template context

Author: lucic71

cpp2rust/converter/converter.cpp

@@ -1356,15 +1356,6 @@ void Converter::ConvertCondition(clang::Expr *cond) {
 }
 
 bool Converter::VisitIfStmt(clang::IfStmt *stmt) {
-  if (stmt->isConstexpr()) {
-    if (auto taken = stmt->getNondiscardedCase(ctx_)) {
-      if (*taken) {
-        Convert(*taken);
-      }
-      return false;
-    }
-  }
-
   if (auto *init = stmt->getInit()) {
     PushBrace scope(*this);
     Convert(init);
@@ -1374,7 +1365,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);

tests/unit/if_constexpr.cpp

@@ -10,10 +10,19 @@ template <typename T> int classify(T x) {
   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

@@ -8,22 +8,36 @@ 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());
@@ -33,6 +47,7 @@ fn main_0() -> i32 {
     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

@@ -7,20 +7,33 @@ 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();
@@ -32,6 +45,7 @@ unsafe fn main_0() -> i32 {
     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() {}