Unbox variables used in ternary operators

Author: nunoplopes

cpp2rust/converter/models/boxed_vars.cpp

@@ -32,10 +32,10 @@ bool IsFlatVec(clang::QualType type) {
 }
 
 // Whether decl may be stored without a Value, if its address is not taken:
-// scalars, arrays of non-arrays, user-defined structs, unique_ptrs and
-// vectors, unless they have a destructor, which is called with a pointer to
-// them.
-bool CanUnbox(const clang::VarDecl *decl) {
+// scalars, arrays of non-arrays, user-defined structs, unique_ptrs, vectors
+// and iterators translated to pointers, unless they have a destructor, which
+// is called with a pointer to them.
+bool CanUnbox(clang::ASTContext &ctx, const clang::VarDecl *decl) {
   auto type = decl->getType();
   if (IsFlatVec(type)) {
     // Vectors are flat Vecs.
@@ -44,7 +44,8 @@ bool CanUnbox(const clang::VarDecl *decl) {
       return false;
     }
   } else if (type->isStructureOrClassType()) {
-    if ((!IsUserDefinedDecl(type->getAsRecordDecl()) && !IsUniquePtr(type)) ||
+    if ((!IsUserDefinedDecl(type->getAsRecordDecl()) && !IsUniquePtr(type) &&
+         !RuleRegistry::MapsToRefcountPointer(ctx, type)) ||
         TypeNeedsDestruction(type)) {
       return false;
     }
@@ -194,7 +195,8 @@ class AddressTakenVisitor
 
 private:
   // The arguments of a call translated by a rule are passed by value or
-  // borrowed, unless the rule takes a pointer to them.
+  // borrowed, unless the rule takes a pointer to them. A pointer parameter
+  // receives the value of an argument that is itself translated to a pointer.
   void AddRuleArgs(clang::Expr *expr, clang::Expr **args, unsigned num_args) {
     auto *rule = RuleRegistry::GetExprRule(ctx_, expr);
     if (!rule) {
@@ -203,8 +205,10 @@ class AddressTakenVisitor
     // Variadic arguments are not considered.
     auto all_args = BuildUnifiedArgs(expr, args, num_args);
     for (unsigned i = 0; i < all_args.size() && i < rule->params.size(); ++i) {
-      if (!rule->params[i].is_pointer()) {
-        AddValueUse(IgnoreNoOpCasts(all_args[i]));
+      auto *arg = IgnoreNoOpCasts(all_args[i]);
+      if (!rule->params[i].is_pointer() || arg->getType()->isPointerType() ||
+          RuleRegistry::MapsToPointer(ctx_, arg->getType())) {
+        AddValueUse(arg);
       }
     }
   }
@@ -213,7 +217,14 @@ class AddressTakenVisitor
   // without making a pointer to it.
   void AddValueUse(clang::Expr *expr, bool write = false) {
     expr = expr->IgnoreParens();
-    if (auto *member = clang::dyn_cast<clang::MemberExpr>(expr)) {
+    // The value of a conditional lvalue is the value of either operand; it is
+    // written through a pointer to the operand.
+    if (auto *cond = clang::dyn_cast<clang::ConditionalOperator>(expr)) {
+      if (!write) {
+        AddValueUse(cond->getTrueExpr());
+        AddValueUse(cond->getFalseExpr());
+      }
+    } else if (auto *member = clang::dyn_cast<clang::MemberExpr>(expr)) {
       auto *field = clang::dyn_cast<clang::FieldDecl>(member->getMemberDecl());
       // A union member is accessed through a pointer to the union.
       if (!member->isArrow() && field && !field->getParent()->isUnion()) {
@@ -244,7 +255,7 @@ class AddressTakenVisitor
 
   void AddressTaken(const clang::ValueDecl *decl) {
     if (auto *var = clang::dyn_cast<clang::VarDecl>(decl);
-        var && CanUnbox(var)) {
+        var && CanUnbox(ctx_, var)) {
       address_taken_.insert(var);
     }
   }
@@ -256,13 +267,13 @@ class AddressTakenVisitor
 };
 } // namespace
 
-BoxedVars::BoxedVars(clang::ASTContext &ctx) {
+BoxedVars::BoxedVars(clang::ASTContext &ctx) : ctx_(ctx) {
   AddressTakenVisitor(ctx, address_taken_)
       .TraverseDecl(ctx.getTranslationUnitDecl());
 }
 
 bool BoxedVars::contains(const clang::VarDecl *decl) const {
-  return !CanUnbox(decl) || address_taken_.contains(decl);
+  return !CanUnbox(ctx_, decl) || address_taken_.contains(decl);
 }
 
 namespace {

cpp2rust/converter/models/boxed_vars.h

@@ -16,15 +16,17 @@ namespace cpp2rust {
 // to a function, or captured by a lambda. Any use that doesn't just read or
 // write the value of a variable is taken to make a pointer to it.
 //
-// Only scalars, arrays and user-defined structs are stored directly; other
-// variables are always boxed.
+// Only scalars, arrays, user-defined structs, unique_ptrs, vectors and
+// iterators translated to pointers are stored directly; other variables are
+// always boxed.
 class BoxedVars {
 public:
   explicit BoxedVars(clang::ASTContext &ctx);
 
   bool contains(const clang::VarDecl *decl) const;
 
 private:
+  clang::ASTContext &ctx_;
   std::unordered_set<const clang::VarDecl *> address_taken_;
 };
 

tests/unit/out/refcount/elidable_iterator_copy_cxx11.rs

@@ -20,7 +20,7 @@ fn main_0() -> i32 {
         let __a1 = 7;
         (*v.borrow_mut()).push(__a1)
     };
-    let it: Value<Ptr<i32>> = Rc::new(RefCell::new({
+    let mut it: Ptr<i32> = {
         let count = ((v.as_pointer() as Ptr<i32>).to_end().get_offset()
             - (v.as_pointer() as Ptr<i32>).get_offset()) as usize;
         (v.as_pointer() as Ptr<i32>).offset(
@@ -31,9 +31,9 @@ fn main_0() -> i32 {
                 .position(|value_0| value_0.read() == 7)
                 .unwrap_or(count) as isize,
         )
-    }));
-    assert!((*it.borrow()) != (v.as_pointer() as Ptr<i32>).to_end());
-    assert!((((*it.borrow()).read()) == 7));
+    };
+    assert!(it != (v.as_pointer() as Ptr<i32>).to_end());
+    assert!(((it.read()) == 7));
     return 0;
 }
 pub fn __cpp2rust_init_globals() {}

tests/unit/out/refcount/find.rs

@@ -24,20 +24,20 @@ fn main_0() -> i32 {
         let __a1 = 3;
         (*v.borrow_mut()).push(__a1)
     };
-    let v_begin: Value<Ptr<i32>> = Rc::new(RefCell::new((v.as_pointer() as Ptr<i32>)));
-    let v_end: Value<Ptr<i32>> = Rc::new(RefCell::new((v.as_pointer() as Ptr<i32>).to_end()));
-    let it: Value<Ptr<i32>> = Rc::new(RefCell::new({
-        let count = ((*v_end.borrow()).get_offset() - (*v_begin.borrow()).get_offset()) as usize;
-        (*v_begin.borrow()).offset(
-            (*v_begin.borrow())
+    let mut v_begin: Ptr<i32> = (v.as_pointer() as Ptr<i32>);
+    let mut v_end: Ptr<i32> = (v.as_pointer() as Ptr<i32>).to_end();
+    let mut it: Ptr<i32> = {
+        let count = (v_end.get_offset() - v_begin.get_offset()) as usize;
+        v_begin.offset(
+            v_begin
                 .clone()
                 .into_iter()
                 .take(count)
                 .position(|value_0| value_0.read() == 2)
                 .unwrap_or(count) as isize,
         )
-    }));
-    let mut v_result_true: bool = (*it.borrow()) != (v.as_pointer() as Ptr<i32>).to_end();
+    };
+    let mut v_result_true: bool = it != (v.as_pointer() as Ptr<i32>).to_end();
     let m: Value<BTreeMap<i32, Value<(Value<i32>, Value<f64>)>>> =
         Rc::new(RefCell::new(BTreeMap::new()));
     (m.as_pointer() as Ptr<BTreeMap<i32, Value<(Value<i32>, Value<f64>)>>>)

tests/unit/out/refcount/iterator_freshness.rs

@@ -6,9 +6,7 @@ use std::io::prelude::*;
 use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
-pub fn foo_0(a0: Ptr<i32>) {
-    let a0: Value<Ptr<i32>> = Rc::new(RefCell::new(a0));
-}
+pub fn foo_0(mut a0: Ptr<i32>) {}
 pub fn main() {
     __cpp2rust_init_globals();
     std::process::exit(main_0());
@@ -19,8 +17,8 @@ fn main_0() -> i32 {
             .map(|_| <i32>::default())
             .collect::<Vec<_>>(),
     ));
-    let it: Value<Ptr<i32>> = Rc::new(RefCell::new((vec_.as_pointer() as Ptr<i32>)));
-    ({ foo_0((*it.borrow()).clone()) });
+    let mut it: Ptr<i32> = (vec_.as_pointer() as Ptr<i32>);
+    ({ foo_0((it).clone()) });
     return 0;
 }
 pub fn __cpp2rust_init_globals() {}

tests/unit/out/refcount/reference_wrapper.rs

@@ -14,13 +14,11 @@ pub struct Point {
     #[offset(4)]
     pub y: i32,
 }
-pub fn set_0(ref_: Ptr<i32>, mut val: i32) {
-    let ref_: Value<Ptr<i32>> = Rc::new(RefCell::new(ref_));
-    (*ref_.borrow()).write(val);
+pub fn set_0(mut ref_: Ptr<i32>, mut val: i32) {
+    ref_.write(val);
 }
-pub fn read_1(ref_: Ptr<i32>) -> i32 {
-    let ref_: Value<Ptr<i32>> = Rc::new(RefCell::new(ref_));
-    let r: Ptr<i32> = (*ref_.borrow()).clone();
+pub fn read_1(mut ref_: Ptr<i32>) -> i32 {
+    let r: Ptr<i32> = (ref_).clone();
     return (r.read());
 }
 pub fn main() {
@@ -29,36 +27,36 @@ pub fn main() {
 }
 fn main_0() -> i32 {
     let i1: Value<i32> = Rc::new(RefCell::new(10));
-    let ref_1: Value<Ptr<i32>> = Rc::new(RefCell::new(i1.as_pointer()));
-    (*ref_1.borrow()).write(20);
-    let i2: Ptr<i32> = (*ref_1.borrow()).clone();
+    let mut ref_1: Ptr<i32> = i1.as_pointer();
+    ref_1.write(20);
+    let i2: Ptr<i32> = (ref_1).clone();
     {
         i2.with_mut(|__v| *__v = *__v + 5)
     };
     write!(libcc2rs::cout(), "{:}\n", (*i1.borrow()),);
     let i3: Value<i32> = Rc::new(RefCell::new(1));
     let i4: Value<i32> = Rc::new(RefCell::new(2));
-    let ref_3: Value<Ptr<i32>> = Rc::new(RefCell::new(i3.as_pointer()));
-    let ref_4: Value<Ptr<i32>> = Rc::new(RefCell::new(i4.as_pointer()));
-    let __rhs = ((*ref_4.borrow()).read());
-    (*ref_3.borrow()).write(__rhs);
+    let mut ref_3: Ptr<i32> = i3.as_pointer();
+    let mut ref_4: Ptr<i32> = i4.as_pointer();
+    let __rhs = (ref_4.read());
+    ref_3.write(__rhs);
     write!(
         libcc2rs::cout(),
         "{:} {:}\n",
         (*i3.borrow()),
         (*i4.borrow()),
     );
-    ({ set_0((*ref_1.borrow()).clone(), 99) });
+    ({ set_0((ref_1).clone(), 99) });
     write!(
         libcc2rs::cout(),
         "{:} {:}\n",
         (*i1.borrow()),
-        ({ read_1((*ref_1.borrow()).clone(),) }),
+        ({ read_1((ref_1).clone(),) }),
     );
     let point: Value<Point> = Rc::new(RefCell::new(Point { x: 3, y: 4 }));
-    let point_ref: Value<Ptr<Point>> = Rc::new(RefCell::new(point.as_pointer()));
-    field!((*point_ref.borrow()), x).write(30);
-    field!((*point_ref.borrow()), y).write(40);
+    let mut point_ref: Ptr<Point> = point.as_pointer();
+    field!(point_ref, x).write(30);
+    field!(point_ref, y).write(40);
     write!(libcc2rs::cout(), "{:} {:}\n", { (*point.borrow()).x }, {
         (*point.borrow()).y
     },);

tests/unit/out/refcount/return_move.rs

@@ -30,13 +30,11 @@ thread_local!(
 pub fn id_1(mut n: Ptr<node>) -> Ptr<node> {
     return n;
 }
-pub fn pick_2(a: Ptr<node>, b: Ptr<node>) -> Ptr<node> {
-    let a: Value<Ptr<node>> = Rc::new(RefCell::new(a));
-    let b: Value<Ptr<node>> = Rc::new(RefCell::new(b));
-    return if !(*a.borrow()).is_null() {
-        (*a.borrow()).clone()
+pub fn pick_2(mut a: Ptr<node>, mut b: Ptr<node>) -> Ptr<node> {
+    return if !(a).is_null() {
+        (a).clone()
     } else {
-        (*b.borrow()).clone()
+        (b).clone()
     };
 }
 pub fn local_ptr_3(mut n: Ptr<node>) -> Ptr<node> {

tests/unit/out/refcount/split_binop_aliased_borrows.rs

@@ -12,10 +12,10 @@ pub fn main() {
 }
 fn main_0() -> i32 {
     let v: Value<Vec<i32>> = Rc::new(RefCell::new(vec![1, 2]));
-    let p: Value<Ptr<i32>> = Rc::new(RefCell::new((v.as_pointer() as Ptr<i32>)));
+    let mut p: Ptr<i32> = (v.as_pointer() as Ptr<i32>);
     let r: Ptr<i32> = (v.as_pointer() as Ptr<i32>).offset(1_usize);
     let __rhs = (r.read());
-    (*p.borrow()).write(__rhs);
+    p.write(__rhs);
     assert!(({ (*v.borrow())[0_usize] } == 2));
     return 0;
 }

tests/unit/out/refcount/unboxed_conditional_iterator.rs

@@ -0,0 +1,113 @@
+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 median_0(mut w: i32, mut n: i32, mut nw: i32) -> i32 {
+    let mut mx: i32 = if (w > n) { w } else { n };
+    let mut mn: i32 = ((w + n) - mx);
+    if (nw > mx) {
+        return mn;
+    } else if (nw < mn) {
+        return mx;
+    }
+    return ((n + w) - nw);
+}
+pub fn assign_1(mut c: bool, mut v: i32) -> i32 {
+    let a: Value<i32> = Rc::new(RefCell::new(1));
+    let b: Value<i32> = Rc::new(RefCell::new(2));
+    if c {
+        (a.as_pointer())
+    } else {
+        (b.as_pointer())
+    }
+    .write(v);
+    if c {
+        (a.as_pointer())
+    } else {
+        (b.as_pointer())
+    }
+    .with_mut(|__v| __v.prefix_inc());
+    return (((*a.borrow()) * 10) + (*b.borrow()));
+}
+pub fn lehmer_2(mut sigma: Ptr<u32>, mut len: u32, mut code: Ptr<u32>) {
+    let items: Value<Vec<u32>> = Rc::new(RefCell::new(
+        (0..(len as usize) as usize)
+            .map(|_| <u32>::default())
+            .collect::<Vec<_>>(),
+    ));
+    let mut i: u32 = 0_u32;
+    'loop_: while (i < len) {
+        let __rhs = i;
+        (*items.borrow_mut())[(i as usize)] = __rhs;
+        i.prefix_inc();
+    }
+    let mut i: u32 = 0_u32;
+    'loop_: while (i < len) {
+        let mut it: Ptr<u32> = {
+            let count = ((items.as_pointer() as Ptr<u32>).to_end().get_offset()
+                - (items.as_pointer() as Ptr<u32>).get_offset()) as usize;
+            (items.as_pointer() as Ptr<u32>).offset(
+                (items.as_pointer() as Ptr<u32>)
+                    .clone()
+                    .into_iter()
+                    .take(count)
+                    .position(|value_0| value_0.read() == (elem!(sigma, i).read()))
+                    .unwrap_or(count) as isize,
+            )
+        };
+        assert!(it != (items.as_pointer() as Ptr<u32>).to_end());
+        let __rhs = (((it.get_offset() as isize)
+            - ((items.as_pointer() as Ptr<u32>).get_offset() as isize))
+            as u32);
+        elem!(code, i).write(__rhs);
+        {
+            let idx = it.get_offset();
+            (items.as_pointer() as Ptr<Vec<u32>>).with_mut(|__v: &mut Vec<u32>| __v.remove(idx));
+            (items.as_pointer() as Ptr<Vec<u32>>).decay()
+        };
+        i.prefix_inc();
+    }
+}
+pub fn sum_3(v: Ptr<Vec<i32>>) -> i32 {
+    let mut s: i32 = 0;
+    let mut it: Ptr<i32> = (Ptr::<Vec<i32>>::decay(&(v)) as Ptr<i32>);
+    'loop_: while it != (Ptr::<Vec<i32>>::decay(&(v)) as Ptr<i32>).to_end() {
+        s += (it.read());
+        it.prefix_inc();
+    }
+    return s;
+}
+pub fn main() {
+    __cpp2rust_init_globals();
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    assert!((({ median_0(1, 5, 7,) }) == 1));
+    assert!((({ median_0(1, 5, 0,) }) == 5));
+    assert!((({ median_0(1, 5, 3,) }) == 3));
+    assert!((({ assign_1(true, 5,) }) == 62));
+    assert!((({ assign_1(false, 5,) }) == 16));
+    let sigma: Value<Box<[u32]>> = Rc::new(RefCell::new(Box::new([2_u32, 0_u32, 3_u32, 1_u32])));
+    let code: Value<Box<[u32]>> =
+        Rc::new(RefCell::new((0..4).map(|_| 0_u32).collect::<Box<[u32]>>()));
+    ({
+        lehmer_2(
+            (sigma.as_pointer() as Ptr<u32>),
+            4_u32,
+            (code.as_pointer() as Ptr<u32>),
+        )
+    });
+    assert!(
+        ((((*code.borrow())[(0) as usize] == 2_u32) && ((*code.borrow())[(1) as usize] == 0_u32))
+            && ((*code.borrow())[(2) as usize] == 1_u32))
+            && ((*code.borrow())[(3) as usize] == 0_u32)
+    );
+    let v: Value<Vec<i32>> = Rc::new(RefCell::new(vec![1, 2, 3]));
+    assert!((({ sum_3(v.as_pointer(),) }) == 6));
+    return 0;
+}
+pub fn __cpp2rust_init_globals() {}