Evaluate default arguments lazily and support reference defaults (#459)

The old `arg.unwrap(default_value)` pattern unconditionally evaluated
default_value. This is wrong if default_value has side effects and the
default value is never used.

Also fix default arguments bound to reference arguments.

Author: lucic71

cpp2rust/converter/converter.cpp

@@ -1206,14 +1206,29 @@ void Converter::EmitFunctionPreamble(clang::FunctionDecl *decl) {
   auto params = decl->getDefinition() ? decl->getDefinition()->parameters()
                                       : decl->parameters();
   for (auto *param : params) {
-    if (HasUsableDefaultArg(param)) {
-      auto name = GetNamedDeclAsString(param);
-      auto type = ToString(param->getType());
-      auto init = std::format("{}.unwrap_or({})", name,
-                              ToString(param->getDefaultArg()));
-      StrCat(std::format("let mut {} : {} = {}", name, type, init),
+    if (!HasUsableDefaultArg(param)) {
+      continue;
+    }
+    auto name = GetNamedDeclAsString(param);
+    auto type = ToString(param->getType());
+    std::string value;
+    if (auto *temp = GetDefaultArgTemporary(param)) {
+      auto storage = std::format("__{}_default", name);
+      StrCat(std::format("let mut {} : Option<{}> = None", storage,
+                         ToString(temp->getType().getUnqualifiedType())),
              token::kSemiColon);
+      value = std::format("{}.insert({}) as {}", storage,
+                          ToString(temp->getSubExpr()), type);
+    } else if (param->getType()->isReferenceType()) {
+      Buffer buf(*this);
+      ConvertVarInit(param->getType(), param->getDefaultArg());
+      value = std::move(buf).str();
+    } else {
+      value = ToString(param->getDefaultArg());
     }
+    StrCat(std::format("let mut {} : {} = {}.unwrap_or_else(|| {} {{ {} }})",
+                       name, type, name, keyword_unsafe_, value),
+           token::kSemiColon);
   }
 }
 

cpp2rust/converter/converter_lib.cpp

@@ -636,7 +636,8 @@ unsigned GetCtorIndex(clang::CXXConstructorDecl *ctor) {
 clang::CXXConstructorDecl *
 GetUserDefinedDefaultConstructor(const clang::CXXRecordDecl *decl) {
   for (auto c : decl->ctors()) {
-    if (c->isUserProvided() && c->isDefaultConstructor() && c->hasBody()) {
+    if (c->isUserProvided() && c->isDefaultConstructor() && c->hasBody() &&
+        std::ranges::all_of(c->parameters(), HasUsableDefaultArg)) {
       return c;
     }
   }
@@ -647,6 +648,15 @@ bool HasUsableDefaultArg(const clang::ParmVarDecl *param) {
   return param->hasDefaultArg() && !param->hasUninstantiatedDefaultArg();
 }
 
+const clang::MaterializeTemporaryExpr *
+GetDefaultArgTemporary(const clang::ParmVarDecl *param) {
+  if (!param->getType()->isReferenceType()) {
+    return nullptr;
+  }
+  return clang::dyn_cast<clang::MaterializeTemporaryExpr>(
+      param->getDefaultArg()->IgnoreParens());
+}
+
 std::string GetMainFileName(const clang::ASTContext &ctx) {
   const auto &src_mgr = ctx.getSourceManager();
   auto file_id = src_mgr.getMainFileID();

cpp2rust/converter/converter_lib.h

@@ -154,6 +154,9 @@ GetUserDefinedDefaultConstructor(const clang::CXXRecordDecl *decl);
 
 bool HasUsableDefaultArg(const clang::ParmVarDecl *param);
 
+const clang::MaterializeTemporaryExpr *
+GetDefaultArgTemporary(const clang::ParmVarDecl *param);
+
 std::string GetMainFileName(const clang::ASTContext &ctx);
 
 std::string GetFileName(const clang::Decl *decl);

cpp2rust/converter/models/converter_refcount.cpp

@@ -778,6 +778,30 @@ void ConverterRefCount::EmitFunctionPreamble(clang::FunctionDecl *decl) {
   auto params = decl->getDefinition() ? decl->getDefinition()->parameters()
                                       : decl->parameters();
   for (auto *param : params) {
+    if (param->getType()->isReferenceType()) {
+      auto name = GetNamedDeclAsString(param);
+      if (name == "_" || !HasUsableDefaultArg(param)) {
+        continue;
+      }
+      auto type = ToString(param->getType());
+      std::string value;
+      if (auto *temp = GetDefaultArgTemporary(param)) {
+        auto storage = std::format("__{}_default", name);
+        StrCat(std::format("let mut {} : Option<{}> = None", storage,
+                           ToString(temp->getType().getUnqualifiedType())),
+               token::kSemiColon);
+        value = std::format("{}.insert(Rc::new(RefCell::new({}))).as_pointer()",
+                            storage, ToString(temp->getSubExpr()));
+      } else {
+        Buffer buf(*this);
+        ConvertVarInit(param->getType(), param->getDefaultArg());
+        value = std::move(buf).str();
+      }
+      StrCat(std::format("let {} : {} = {}.unwrap_or_else(|| {})", name, type,
+                         name, value),
+             token::kSemiColon);
+      continue;
+    }
     if (!param->getType()->isReferenceType()) {
       auto name = GetNamedDeclAsString(param);
       // Skip emitting the preamble for unnamed parameters
@@ -788,7 +812,7 @@ void ConverterRefCount::EmitFunctionPreamble(clang::FunctionDecl *decl) {
       auto init = name;
 
       if (HasUsableDefaultArg(param)) {
-        init = std::format("{}.unwrap_or({})", name,
+        init = std::format("{}.unwrap_or_else(|| {})", name,
                            ToString(param->getDefaultArg()));
       }
 

tests/unit/default_function_arguments.cpp

@@ -9,6 +9,23 @@ struct Bar {
   Bar(int v = 1) : v(v) {}
 };
 
+int counter = 0;
+
+int next() { return ++counter; }
+
+int lazy(int x = next()) { return x; }
+
+int by_ref(const Bar &b = Bar(7)) { return b.v; }
+
+Bar global_bar(9);
+
+int by_global_ref(const Bar &b = global_bar) { return b.v; }
+
+template <typename T> struct Holder {
+  T v;
+  explicit Holder(T v = 0) : v(v) {}
+};
+
 int main() {
   assert(foo(1) == 11);
   assert(foo(1, 2) == 3);
@@ -25,5 +42,18 @@ int main() {
   assert(arr[0].v == 1);
   assert(arr[2].v == 1);
 
+  assert(lazy(5) == 5);
+  assert(counter == 0);
+  assert(lazy() == 1);
+  assert(counter == 1);
+
+  assert(by_ref() == 7);
+  assert(by_ref(Bar(3)) == 3);
+  assert(by_global_ref() == 9);
+  assert(by_global_ref(Bar(4)) == 4);
+
+  Holder<int> h(4);
+  assert(h.v == 4);
+
   return 0;
 }

tests/unit/out/refcount/default_function_arguments.rs

@@ -7,11 +7,11 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn foo_0(mut a: i32, b: Option<i32>) -> i32 {
-    let mut b: i32 = b.unwrap_or(10);
+    let mut b: i32 = b.unwrap_or_else(|| 10);
     return (a + b);
 }
 pub fn baz_1(mut a: Ptr<i32>, b: Option<Ptr<i32>>) -> bool {
-    let mut b: Ptr<i32> = b.unwrap_or(Ptr::<i32>::null());
+    let mut b: Ptr<i32> = b.unwrap_or_else(|| Ptr::<i32>::null());
     return ({ a } == { b });
 }
 #[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg)]
@@ -22,7 +22,7 @@ pub struct Bar {
 }
 impl Bar {
     pub fn new(v: Option<i32>) -> Self {
-        let mut v: i32 = v.unwrap_or(1);
+        let mut v: i32 = v.unwrap_or_else(|| 1);
         Self { v: v }
     }
 }
@@ -31,6 +31,43 @@ impl Default for Bar {
         { Bar::new(None) }
     }
 }
+thread_local!(
+    pub static counter_2: Value<i32> = Rc::new(RefCell::new(0));
+);
+pub fn next_3() -> i32 {
+    return (*counter_2.with(Value::clone).borrow_mut()).prefix_inc();
+}
+pub fn lazy_4(x: Option<i32>) -> i32 {
+    let mut x: i32 = x.unwrap_or_else(|| ({ next_3() }));
+    return x;
+}
+pub fn by_ref_5(b: Option<Ptr<Bar>>) -> i32 {
+    let mut __b_default: Option<Value<Bar>> = None;
+    let b: Ptr<Bar> = b.unwrap_or_else(|| {
+        __b_default
+            .insert(Rc::new(RefCell::new(Bar::new({ Some(7) }))))
+            .as_pointer()
+    });
+    return b.with(|__s| __s.v);
+}
+thread_local!(
+    pub static global_bar_6: Value<Bar> = Rc::new(RefCell::new(Bar::new({ Some(9) })));
+);
+pub fn by_global_ref_7(b: Option<Ptr<Bar>>) -> i32 {
+    let b: Ptr<Bar> = b.unwrap_or_else(|| global_bar_6.with(|v| v.as_pointer()));
+    return b.with(|__s| __s.v);
+}
+#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)]
+#[byte_size(4)]
+pub struct Holder_int_ {
+    #[offset(0)]
+    pub v: i32,
+}
+impl Holder_int_ {
+    pub fn new(mut v: i32) -> Self {
+        Self { v: v }
+    }
+}
 pub fn main() {
     __cpp2rust_init_globals();
     std::process::exit(main_0());
@@ -54,6 +91,29 @@ fn main_0() -> i32 {
     let mut arr: [Bar; 3] = [Bar::new(None), Bar::new(None), Bar::new(None)];
     assert!(({ arr[(0) as usize].v } == 1));
     assert!(({ arr[(2) as usize].v } == 1));
+    assert!((({ lazy_4(Some(5),) }) == 5));
+    assert!((counter_2.with(|rc| *rc.borrow()) == 0));
+    assert!((({ lazy_4(None,) }) == 1));
+    assert!((counter_2.with(|rc| *rc.borrow()) == 1));
+    assert!((({ by_ref_5(None,) }) == 7));
+    assert!(
+        (({
+            let _b: Value<Bar> = Rc::new(RefCell::new(Bar::new({ Some(3) })));
+            by_ref_5(Some(_b.as_pointer()))
+        }) == 3)
+    );
+    assert!((({ by_global_ref_7(None,) }) == 9));
+    assert!(
+        (({
+            let _b: Value<Bar> = Rc::new(RefCell::new(Bar::new({ Some(4) })));
+            by_global_ref_7(Some(_b.as_pointer()))
+        }) == 4)
+    );
+    let mut h: Holder_int_ = Holder_int_::new({ 4 });
+    assert!((h.v == 4));
     return 0;
 }
-pub fn __cpp2rust_init_globals() {}
+pub fn __cpp2rust_init_globals() {
+    let _ = counter_2.with(|_| ());
+    let _ = global_bar_6.with(|_| ());
+}

tests/unit/out/refcount/fn_ptr_default_arg.rs

@@ -10,7 +10,7 @@ pub fn identity_0(mut x: i32) -> i32 {
     return x;
 }
 pub fn apply_1(mut x: i32, fn_: Option<FnPtr<fn(i32) -> i32>>) -> i32 {
-    let mut fn_: FnPtr<fn(i32) -> i32> = fn_.unwrap_or(FnPtr::<fn(i32) -> i32>::null());
+    let mut fn_: FnPtr<fn(i32) -> i32> = fn_.unwrap_or_else(|| FnPtr::<fn(i32) -> i32>::null());
     if !(fn_).is_null() {
         return ({ fn_.call(x) });
     }

tests/unit/out/refcount/size_t_pointer.rs

@@ -7,13 +7,13 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn out_param_0(out: Option<Ptr<usize>>) {
-    let mut out: Ptr<usize> = out.unwrap_or(Ptr::<usize>::null());
+    let mut out: Ptr<usize> = out.unwrap_or_else(|| Ptr::<usize>::null());
     if !(out).is_null() {
         out.write(4_usize);
     }
 }
 pub fn parse_1(mut v: i32, idx: Option<Ptr<usize>>) -> i32 {
-    let mut idx: Ptr<usize> = idx.unwrap_or(Ptr::<usize>::null());
+    let mut idx: Ptr<usize> = idx.unwrap_or_else(|| Ptr::<usize>::null());
     if !(idx).is_null() {
         idx.write(3_usize);
     }

tests/unit/out/refcount/template_default_arg.rs

@@ -53,15 +53,15 @@ impl NoDefault {
     }
 }
 pub fn used_0(x: Option<A>) -> i32 {
-    let mut x: A = x.unwrap_or(A::new_1());
+    let mut x: A = x.unwrap_or_else(|| A::new_1());
     return x.v;
 }
 pub fn used_1(x: Option<B>) -> i32 {
-    let mut x: B = x.unwrap_or(B::new());
+    let mut x: B = x.unwrap_or_else(|| B::new());
     return x.v;
 }
 pub fn scaled_2(mut x: A, n: Option<i32>) -> i32 {
-    let mut n: i32 = n.unwrap_or((4usize as i32));
+    let mut n: i32 = n.unwrap_or_else(|| (4usize as i32));
     return (x.v * n);
 }
 pub fn always_given_3(mut x: NoDefault) -> i32 {

tests/unit/out/refcount/unboxed_locals.rs

@@ -38,7 +38,7 @@ pub fn sum_3(mut arr: Ptr<i32>, mut n: i32) -> i32 {
     return s;
 }
 pub fn countdown_4(mut n: i32, step: Option<i32>) -> i32 {
-    let mut step: i32 = step.unwrap_or(1);
+    let mut step: i32 = step.unwrap_or_else(|| 1);
     let mut steps: i32 = 0;
     'loop_: while (n > 0) {
         n -= step;