work

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;
 }