Fix u64/usize mismatch in array init and ctor call (#442)

Author: lucic71

cpp2rust/converter/converter.cpp

@@ -3398,7 +3398,7 @@ bool Converter::VisitInitListExpr(clang::InitListExpr *expr) {
     }
     PushBracket bracket(*this);
     for (auto *init : expr->inits()) {
-      ConvertVarInit(init->getType(), init);
+      ConvertVarInit(ctx_.getAsArrayType(qual_type)->getElementType(), init);
       StrCat(token::kComma);
     }
     if (expr->hasArrayFiller()) {

cpp2rust/converter/converter_lib.cpp

@@ -1450,19 +1450,20 @@ bool HasReceiver(clang::Expr *expr) {
 
 std::optional<clang::QualType> GetParamImplicitConvertTarget(clang::Expr *expr,
                                                              unsigned arg_idx) {
-  auto *call = clang::dyn_cast<clang::CallExpr>(expr);
-  if (!call) {
-    return std::nullopt;
+  const clang::FunctionDecl *fn = nullptr;
+  if (auto *call = clang::dyn_cast<clang::CallExpr>(expr)) {
+    fn = call->getDirectCallee();
+  } else if (auto *ctor = clang::dyn_cast<clang::CXXConstructExpr>(expr)) {
+    fn = ctor->getConstructor();
   }
-  auto *fn = call->getDirectCallee();
   if (!fn) {
     return std::nullopt;
   }
   unsigned param_idx = arg_idx - HasReceiver(expr);
   if (param_idx >= fn->getNumParams()) {
     return std::nullopt;
   }
-  return fn->getParamDecl(param_idx)->getType();
+  return fn->getParamDecl(param_idx)->getType().getNonReferenceType();
 }
 
 std::optional<IteratorCategory>

tests/unit/out/refcount/size_t_ssize_t.rs

@@ -208,6 +208,43 @@ fn main_0() -> i32 {
     (*a64.borrow_mut()) -= ((*c.borrow()) as i64);
     assert!(((*a64.borrow()) == 120_i64));
     assert!(((((*n.borrow()).wrapping_rem(7_usize)) as i32) == 1));
+    let mx: Value<usize> = Rc::new(RefCell::new(5_usize));
+    let mins: Value<Box<[usize]>> = Rc::new(RefCell::new(Box::new([
+        0_usize,
+        ({
+            let __tmp_0: Value<u64> = Rc::new(RefCell::new(1_u64));
+            let __tmp_1: Value<u64> = Rc::new(RefCell::new(((*mx.borrow()) as u64)));
+            (if __tmp_0.as_pointer().read() <= __tmp_1.as_pointer().read() {
+                __tmp_0.as_pointer()
+            } else {
+                __tmp_1.as_pointer()
+            }
+            .read())
+        } as usize),
+        ({
+            let __tmp_0: Value<u64> = Rc::new(RefCell::new(((*mx.borrow()) as u64)));
+            let __tmp_1: Value<u64> =
+                Rc::new(RefCell::new(((*mx.borrow()).wrapping_sub(3_usize) as u64)));
+            (if __tmp_0.as_pointer().read() <= __tmp_1.as_pointer().read() {
+                __tmp_0.as_pointer()
+            } else {
+                __tmp_1.as_pointer()
+            }
+            .read())
+        } as usize),
+        (*mx.borrow()),
+    ])));
+    assert!(((*mins.borrow())[(1) as usize] == 1_usize));
+    assert!(((*mins.borrow())[(2) as usize] == 2_usize));
+    let pr: Value<(Value<u64>, Value<i32>)> = Rc::new(RefCell::new((
+        Rc::new(RefCell::new(
+            ((*sz.borrow()) as u64)
+                .try_into()
+                .expect("failed conversion"),
+        )),
+        Rc::new(RefCell::new(1.try_into().expect("failed conversion"))),
+    )));
+    assert!(((*(*pr.borrow()).0.borrow()) == 21_u64));
     return 0;
 }
 pub fn __cpp2rust_init_globals() {}

tests/unit/out/unsafe/size_t_ssize_t.rs

@@ -161,6 +161,33 @@ unsafe fn main_0() -> i32 {
     a64 -= (c as i64);
     assert!(((a64) == (120_i64)));
     assert!(((((n).wrapping_rem(7_usize)) as i32) == (1)));
+    let mx: usize = 5_usize;
+    let mut mins: [usize; 4] = [
+        0_usize,
+        ({
+            let mut __tmp_0: u64 = 1_u64;
+            let mut __tmp_1: u64 = (mx as u64);
+            (*if *&mut __tmp_0 <= *&mut __tmp_1 {
+                (&mut __tmp_0) as *const _
+            } else {
+                (&mut __tmp_1) as *const _
+            })
+        } as usize),
+        ({
+            let mut __tmp_0: u64 = (mx as u64);
+            let mut __tmp_1: u64 = ((mx).wrapping_sub(3_usize) as u64);
+            (*if *&mut __tmp_0 <= *&mut __tmp_1 {
+                (&mut __tmp_0) as *const _
+            } else {
+                (&mut __tmp_1) as *const _
+            })
+        } as usize),
+        mx,
+    ];
+    assert!(((mins[(1) as usize]) == (1_usize)));
+    assert!(((mins[(2) as usize]) == (2_usize)));
+    let mut pr: (u64, i32) = ((sz as u64).into(), 1.into());
+    assert!(((pr.0) == (21_u64)));
     return 0;
 }
 pub unsafe fn __cpp2rust_init_globals() {}

tests/unit/size_t_ssize_t.cpp

@@ -3,6 +3,7 @@
 #include <cstddef>
 #include <cstdint>
 #include <sys/types.h>
+#include <utility>
 
 static size_t add_sizes(size_t a, size_t b) { return a + b; }
 
@@ -97,5 +98,14 @@ int main() {
   assert(a64 == 120);
 
   assert((int)(n % 7) == 1);
+
+  const std::size_t mx = 5;
+  std::size_t mins[] = {0, std::min<std::size_t>(1, mx), std::min(mx, mx - 3),
+                        mx};
+  assert(mins[1] == 1);
+  assert(mins[2] == 2);
+
+  std::pair<std::size_t, int> pr(sz, 1);
+  assert(pr.first == 21);
   return 0;
 }