Fix address of conditional operand (#403)

Author: lucic71

cpp2rust/converter/converter.cpp

@@ -2958,10 +2958,11 @@ bool Converter::VisitConditionalOperator(clang::ConditionalOperator *expr) {
   ConvertCondition(expr->getCond());
   bool branch_is_addr =
       expr->isLValue() && !isRValue() && !expr->getType()->isFunctionType();
+  bool branch_is_mut = curr_init_type_.empty() || IsMut(curr_init_type_.back());
   {
     PushBrace then_brace(*this);
     if (branch_is_addr) {
-      StrCat(token::kRef, keyword_mut_);
+      StrCat(token::kRef, branch_is_mut ? keyword_mut_ : "");
     }
     PushExplicitAutoref no_autoref(*this, branch_is_addr ? std::nullopt
                                                          : autoref_mut_);
@@ -2973,7 +2974,7 @@ bool Converter::VisitConditionalOperator(clang::ConditionalOperator *expr) {
   {
     PushBrace else_brace(*this);
     if (branch_is_addr) {
-      StrCat(token::kRef, keyword_mut_);
+      StrCat(token::kRef, branch_is_mut ? keyword_mut_ : "");
     }
     PushExplicitAutoref no_autoref(*this, branch_is_addr ? std::nullopt
                                                          : autoref_mut_);
@@ -4190,6 +4191,18 @@ void Converter::ConvertVarInit(clang::QualType qual_type, clang::Expr *expr) {
       StrCat(EmitMaterializedTempBinding(qual_type, expr));
       return;
     }
+    if (auto *cond = clang::dyn_cast<clang::ConditionalOperator>(
+            expr->IgnoreParenImpCasts());
+        cond && cond->isLValue()) {
+      {
+        PushExprKind push(*this, ExprKind::LValue);
+        PushInitType init_type(*this, qual_type);
+        Convert(cond);
+      }
+      StrCat(keyword::kAs);
+      Convert(qual_type);
+      return;
+    }
     StrCat(token::kRef);
     if (IsMut(qual_type)) {
       StrCat(keyword_mut_);

tests/unit/09_references.cpp

@@ -11,5 +11,26 @@ int main() {
   h_ref2 = 17;
 
   assert(h_ref1 + h_ref2 == 34);
+
+  int a = 1;
+  int b = 2;
+  int &r = a < b ? a : b;
+  r = 10;
+  assert(a == 10);
+
+  const int &cr = a > b ? a : b;
+  assert(cr == 10);
+
+  const int x = 1;
+  const int y = 2;
+  const int &cx = x < y ? x : y;
+  assert(cx == 1);
+
+  const int *cp = a > b ? &a : &b;
+  assert(*cp == 10);
+
+  int *mp = a < b ? &a : &b;
+  *mp = 20;
+  assert(b == 20);
   return 0;
 }

tests/unit/out/refcount/09_references.rs

@@ -23,6 +23,42 @@ fn main_0() -> i32 {
             _lhs + (h_ref2.read())
         } == 34)
     );
+    let a: Value<i32> = Rc::new(RefCell::new(1));
+    let b: Value<i32> = Rc::new(RefCell::new(2));
+    let r: Ptr<i32> = if ((*a.borrow()) < (*b.borrow())) {
+        a.as_pointer()
+    } else {
+        b.as_pointer()
+    };
+    r.write(10);
+    assert!(((*a.borrow()) == 10));
+    let cr: Ptr<i32> = if ((*a.borrow()) > (*b.borrow())) {
+        a.as_pointer()
+    } else {
+        b.as_pointer()
+    };
+    assert!(((cr.read()) == 10));
+    let x: Value<i32> = Rc::new(RefCell::new(1));
+    let y: Value<i32> = Rc::new(RefCell::new(2));
+    let cx: Ptr<i32> = if ((*x.borrow()) < (*y.borrow())) {
+        x.as_pointer()
+    } else {
+        y.as_pointer()
+    };
+    assert!(((cx.read()) == 1));
+    let cp: Value<Ptr<i32>> = Rc::new(RefCell::new(if ((*a.borrow()) > (*b.borrow())) {
+        (a.as_pointer())
+    } else {
+        (b.as_pointer())
+    }));
+    assert!((((*cp.borrow()).read()) == 10));
+    let mp: Value<Ptr<i32>> = Rc::new(RefCell::new(if ((*a.borrow()) < (*b.borrow())) {
+        (a.as_pointer())
+    } else {
+        (b.as_pointer())
+    }));
+    (*mp.borrow()).write(20);
+    assert!(((*b.borrow()) == 20));
     return 0;
 }
 pub fn __cpp2rust_init_globals() {}

tests/unit/out/unsafe/09_references.rs

@@ -20,6 +20,31 @@ unsafe fn main_0() -> i32 {
     let h_ref2: *mut i32 = &mut (*h_ptr);
     (*h_ref2) = 17;
     assert!((((*h_ref1) + (*h_ref2)) == (34)));
+    let mut a: i32 = 1;
+    let mut b: i32 = 2;
+    let r: *mut i32 = if ((a) < (b)) { &mut a } else { &mut b } as *mut i32;
+    (*r) = 10;
+    assert!(((a) == (10)));
+    let cr: *const i32 = if ((a) > (b)) { &a } else { &b } as *const i32;
+    assert!(((*cr) == (10)));
+    let x: i32 = 1;
+    let y: i32 = 2;
+    let cx: *const i32 = if ((x) < (y)) { &x } else { &y } as *const i32;
+    assert!(((*cx) == (1)));
+    let mut cp: *const i32 = (if ((a) > (b)) {
+        (&mut a as *mut i32)
+    } else {
+        (&mut b as *mut i32)
+    })
+    .cast_const();
+    assert!(((*cp) == (10)));
+    let mut mp: *mut i32 = if ((a) < (b)) {
+        (&mut a as *mut i32)
+    } else {
+        (&mut b as *mut i32)
+    };
+    (*mp) = 20;
+    assert!(((b) == (20)));
     return 0;
 }
 pub unsafe fn __cpp2rust_init_globals() {}

tests/unit/out/unsafe/cout_alias.rs

@@ -20,23 +20,23 @@ unsafe fn main_0() -> i32 {
         libcc2rs::cerr_unsafe()
     };
     write!((*os1), "hello\n",);
-    let os2: *mut std::fs::File = &mut if cond {
-        std::fs::File::from_raw_fd(
+    let os2: *mut std::fs::File = if cond {
+        &mut std::fs::File::from_raw_fd(
             std::io::stdout()
                 .as_fd()
                 .try_clone_to_owned()
                 .unwrap()
                 .into_raw_fd(),
         )
     } else {
-        std::fs::File::from_raw_fd(
+        &mut std::fs::File::from_raw_fd(
             std::io::stderr()
                 .as_fd()
                 .try_clone_to_owned()
                 .unwrap()
                 .into_raw_fd(),
         )
-    };
+    } as *mut std::fs::File;
     write!((*os2), "hello\n",);
     return 0;
 }