Don't use uninstantiated default argument

Author: lucic71

cpp2rust/converter/converter.cpp

@@ -551,7 +551,7 @@ bool Converter::ConvertVarDeclSkipInit(clang::VarDecl *decl) {
 
   bool is_parm_with_default_value = false;
   if (auto parm = clang::dyn_cast<clang::ParmVarDecl>(decl)) {
-    is_parm_with_default_value = parm->hasDefaultArg();
+    is_parm_with_default_value = HasUsableDefaultArg(parm);
   }
 
   if (is_parm_with_default_value) {
@@ -1226,7 +1226,7 @@ void Converter::EmitFunctionPreamble(clang::FunctionDecl *decl) {
   auto params = decl->getDefinition() ? decl->getDefinition()->parameters()
                                       : decl->parameters();
   for (auto *param : params) {
-    if (param->hasDefaultArg()) {
+    if (HasUsableDefaultArg(param)) {
       auto name = GetNamedDeclAsString(param);
       auto type = ToString(param->getType());
       auto init = std::format("{}.unwrap_or({})", name,
@@ -1943,7 +1943,8 @@ Converter::CallInfo Converter::CollectCallInfo(clang::CallExpr *expr) {
         .param_type = function ? function->getParamDecl(i)->getType()
                                : proto->getParamType(i),
         .expr = arg,
-        .has_default = function && function->getParamDecl(i)->hasDefaultArg(),
+        .has_default =
+            function && HasUsableDefaultArg(function->getParamDecl(i)),
         .kind = (IsLiteral(arg) || info.is_libc_passthrough) ? Kind::Inline
                                                              : Kind::Hoisted,
     };
@@ -3573,7 +3574,7 @@ void Converter::ConvertCXXConstructExprArgs(clang::CXXConstructExpr *expr) {
   for (unsigned param_idx = 0; param_idx < ctor->getNumParams(); ++param_idx) {
     auto param = ctor->getParamDecl(param_idx);
     auto param_type = param->getType();
-    bool has_default = param->hasDefaultArg();
+    bool has_default = HasUsableDefaultArg(param);
 
     if (arg_idx < expr->getNumArgs() &&
         clang::isa<clang::CXXDefaultArgExpr>(expr->getArg(arg_idx))) {

cpp2rust/converter/converter_lib.cpp

@@ -534,6 +534,10 @@ GetUserDefinedDefaultConstructor(const clang::CXXRecordDecl *decl) {
   return nullptr;
 }
 
+bool HasUsableDefaultArg(const clang::ParmVarDecl *param) {
+  return param->hasDefaultArg() && !param->hasUninstantiatedDefaultArg();
+}
+
 std::string GetMainFileName(const clang::ASTContext &ctx) {
   const auto &src_mgr = ctx.getSourceManager();
   auto file_id = src_mgr.getMainFileID();

cpp2rust/converter/converter_lib.h

@@ -130,6 +130,8 @@ unsigned GetCtorIndex(clang::CXXConstructorDecl *ctor);
 clang::CXXConstructorDecl *
 GetUserDefinedDefaultConstructor(const clang::CXXRecordDecl *decl);
 
+bool HasUsableDefaultArg(const clang::ParmVarDecl *param);
+
 std::string GetMainFileName(const clang::ASTContext &ctx);
 
 std::string GetFileName(const clang::Decl *decl);

cpp2rust/converter/models/converter_refcount.cpp

@@ -671,7 +671,7 @@ void ConverterRefCount::EmitFunctionPreamble(clang::FunctionDecl *decl) {
       auto type = ToString(param->getType());
       auto init = name;
 
-      if (param->hasDefaultArg()) {
+      if (HasUsableDefaultArg(param)) {
         init = std::format("{}.unwrap_or({})", name,
                            ToString(param->getDefaultArg()));
       }

tests/unit/out/refcount/template_default_arg.rs

@@ -143,8 +143,8 @@ pub fn scaled_2(x: A, n: Option<i32>) -> i32 {
     let n: Value<i32> = Rc::new(RefCell::new(n.unwrap_or((4usize as i32))));
     return ((*(*x.borrow()).v.borrow()) * (*n.borrow()));
 }
-pub fn always_given_3(x: Option<NoDefault>) -> i32 {
-    let x: Value<NoDefault> = Rc::new(RefCell::new(x.unwrap_or()));
+pub fn always_given_3(x: NoDefault) -> i32 {
+    let x: Value<NoDefault> = Rc::new(RefCell::new(x));
     return (*(*x.borrow()).v.borrow());
 }
 #[derive(Default)]
@@ -193,19 +193,17 @@ fn main_0() -> i32 {
     assert!((({ used_1(None,) }) == 2));
     assert!((({ scaled_2(A::A2({ 3 },), None,) }) == (3 * (4usize as i32))));
     assert!((({ scaled_2(A::A2({ 3 },), Some(2),) }) == 6));
-    assert!((({ always_given_3(Some(NoDefault::NoDefault({ 3 },)),) }) == 3));
+    assert!((({ always_given_3(NoDefault::NoDefault({ 3 },),) }) == 3));
     let s: Value<S_NoDefault_> = Rc::new(RefCell::new(S_NoDefault_::S_NoDefault_({ 1 })));
-    assert!(
-        (({ S_NoDefault_Impl::get(&s.as_pointer(), Some(NoDefault::NoDefault({ 4 },)),) }) == 5)
-    );
+    assert!((({ S_NoDefault_Impl::get(&s.as_pointer(), NoDefault::NoDefault({ 4 },),) }) == 5));
     return 0;
 }
 pub trait S_NoDefault_Impl {
-    fn get(&self, t: Option<NoDefault>) -> i32;
+    fn get(&self, t: NoDefault) -> i32;
 }
 impl S_NoDefault_Impl for Ptr<S_NoDefault_> {
-    fn get(&self, t: Option<NoDefault>) -> i32 {
-        let t: Value<NoDefault> = Rc::new(RefCell::new(t.unwrap_or()));
+    fn get(&self, t: NoDefault) -> i32 {
+        let t: Value<NoDefault> = Rc::new(RefCell::new(t));
         return ((*(*(*self).upgrade().deref()).v.borrow()) + (*(*t.borrow()).v.borrow()));
     }
 }

tests/unit/out/unsafe/template_default_arg.rs

@@ -65,8 +65,7 @@ pub unsafe fn scaled_2(mut x: A, mut n: Option<i32>) -> i32 {
     let mut n: i32 = n.unwrap_or((::std::mem::size_of::<A>() as i32));
     return ((x.v) * (n));
 }
-pub unsafe fn always_given_3(mut x: Option<NoDefault>) -> i32 {
-    let mut x: NoDefault = x.unwrap_or();
+pub unsafe fn always_given_3(mut x: NoDefault) -> i32 {
     return x.v;
 }
 #[repr(C)]
@@ -79,8 +78,7 @@ impl S_NoDefault_ {
         let mut this = Self { v: v };
         this
     }
-    pub unsafe fn get(&self, mut t: Option<NoDefault>) -> i32 {
-        let mut t: NoDefault = t.unwrap_or();
+    pub unsafe fn get(&self, mut t: NoDefault) -> i32 {
         return ((self.v) + (t.v));
     }
 }
@@ -99,9 +97,9 @@ unsafe fn main_0() -> i32 {
             == ((3) * (::std::mem::size_of::<A>() as i32)))
     );
     assert!(((unsafe { scaled_2(A::A2({ 3 },), Some(2),) }) == (6)));
-    assert!(((unsafe { always_given_3(Some(NoDefault::NoDefault({ 3 },)),) }) == (3)));
+    assert!(((unsafe { always_given_3(NoDefault::NoDefault({ 3 },),) }) == (3)));
     let mut s: S_NoDefault_ = S_NoDefault_::S_NoDefault_({ 1 });
-    assert!(((unsafe { S_NoDefault_::get(&s, Some(NoDefault::NoDefault({ 4 },)),) }) == (5)));
+    assert!(((unsafe { S_NoDefault_::get(&s, NoDefault::NoDefault({ 4 },),) }) == (5)));
     return 0;
 }
 pub unsafe fn __cpp2rust_init_globals() {}