Fix arrity and deduction for aggregate

Author: lucic71

cpp2rust/converter/converter.cpp

@@ -3625,6 +3625,7 @@ bool Converter::VisitInitListExpr(clang::InitListExpr *expr) {
       SetFreshType(qual_type);
       return false;
     }
+    assert(IsUserDefinedDecl(record) && "aggregate list without a rule");
 
     StrCat(GetUnsafeTypeAsString(qual_type));
     PushBrace brace(*this);

cpp2rust/converter/models/converter_refcount.cpp

@@ -1901,6 +1901,7 @@ bool ConverterRefCount::VisitInitListExpr(clang::InitListExpr *expr) {
         return false;
       }
     }
+    assert(IsUserDefinedDecl(record) && "aggregate list without a rule");
 
     if (record->isUnion()) {
       auto *field = expr->getInitializedFieldInUnion();

cpp2rust/converter/rules/expr_matcher.cpp

@@ -170,7 +170,8 @@ std::vector<clang::Expr *> getOperands(clang::ASTContext &ctx,
     operands.assign(construct->arg_begin(), construct->arg_end());
   } else if (auto list = llvm::dyn_cast<clang::InitListExpr>(expr)) {
     operands.assign(list->inits().begin(), list->inits().end());
-  } else if (auto list = llvm::dyn_cast<clang::CXXStdInitializerListExpr>(expr)) {
+  } else if (auto list =
+                 llvm::dyn_cast<clang::CXXStdInitializerListExpr>(expr)) {
     operands.push_back(list->getSubExpr()->IgnoreImplicit());
   } else if (auto member = llvm::dyn_cast<clang::MemberExpr>(expr)) {
     auto macro_base =
@@ -256,7 +257,10 @@ clang::TemplateArgumentListInfo getResultArgs(clang::Sema &sema,
   clang::TemplateArgumentListInfo explicit_args(loc, loc);
   llvm::SmallBitVector deducible;
   sema.MarkDeducedTemplateParameters(rule, deducible);
-  if (deducible.all()) {
+  bool aggregate =
+      llvm::isa<clang::InitListExpr, clang::CXXStdInitializerListExpr>(
+          RuleDecls::SkipImplicit(use));
+  if (deducible.all() && !aggregate) {
     return explicit_args;
   }
   auto params = rule->getTemplateParameters();
@@ -270,7 +274,7 @@ clang::TemplateArgumentListInfo getResultArgs(clang::Sema &sema,
     return explicit_args;
   }
   auto last = static_cast<unsigned>(deducible.find_last_unset());
-  for (unsigned i = 0; i <= last; ++i) {
+  for (unsigned i = 0; i < params->size() && i <= last; ++i) {
     auto param = params->getParam(i);
     if (param->isParameterPack() || (*deduced)[i].isNull()) {
       break;

tests/unit/out/refcount/lambda_capture_library_types.rs

@@ -11,7 +11,7 @@ pub fn main() {
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
-    let v: Value<Vec<i32>> = Rc::new(RefCell::new(vec![1, 2]));
+    let v: Value<Vec<i32>> = Rc::new(RefCell::new(Vec::from([1, 2])));
     let f: Value<FnPtr<fn() -> i32>> = Rc::new(RefCell::new(lambda!(
         {
             let v: Value<Vec<i32>> = Rc::new(RefCell::new((*v.borrow()).clone()));

tests/unit/out/refcount/operator_traits.rs

@@ -159,7 +159,11 @@ pub fn main() {
 fn main_0() -> i32 {
     let mut w: Wrapped_int_ = Wrapped_int_ { v: 2 };
     assert!((w.v == 2));
-    let lts: Value<Vec<Lt>> = Rc::new(RefCell::new(vec![Lt { v: 3 }, Lt { v: 1 }, Lt { v: 2 }]));
+    let lts: Value<Vec<Lt>> = Rc::new(RefCell::new(Vec::from([
+        Lt { v: 3 },
+        Lt { v: 1 },
+        Lt { v: 2 },
+    ])));
     {
         let __n = RandomAccessIterator::Vec((lts.as_pointer() as Ptr<Lt>).to_end())
             .iter_distance(&RandomAccessIterator::Vec((lts.as_pointer() as Ptr<Lt>)));
@@ -191,7 +195,11 @@ fn main_0() -> i32 {
         (({ (*lts.borrow())[0_usize].v } == 1) && ({ (*lts.borrow())[1_usize].v } == 2))
             && ({ (*lts.borrow())[2_usize].v } == 3)
     );
-    let eqs: Value<Vec<Eq>> = Rc::new(RefCell::new(vec![Eq { v: 1 }, Eq { v: 2 }, Eq { v: 3 }]));
+    let eqs: Value<Vec<Eq>> = Rc::new(RefCell::new(Vec::from([
+        Eq { v: 1 },
+        Eq { v: 2 },
+        Eq { v: 3 },
+    ])));
     let mut two: Eq = Eq { v: 2 };
     let mut nine: Eq = Eq { v: 9 };
     assert!(
@@ -219,8 +227,11 @@ fn main_0() -> i32 {
             __it
         } == RandomAccessIterator::Vec((eqs.as_pointer() as Ptr<Eq>).to_end())
     );
-    let cmps: Value<Vec<Cmp>> =
-        Rc::new(RefCell::new(vec![Cmp { v: 3 }, Cmp { v: 1 }, Cmp { v: 2 }]));
+    let cmps: Value<Vec<Cmp>> = Rc::new(RefCell::new(Vec::from([
+        Cmp { v: 3 },
+        Cmp { v: 1 },
+        Cmp { v: 2 },
+    ])));
     {
         let __n = RandomAccessIterator::Vec((cmps.as_pointer() as Ptr<Cmp>).to_end())
             .iter_distance(&RandomAccessIterator::Vec((cmps.as_pointer() as Ptr<Cmp>)));
@@ -264,7 +275,7 @@ fn main_0() -> i32 {
         .with(|__s| __s.v)
             == 3)
     );
-    let frees: Value<Vec<Free>> = Rc::new(RefCell::new(vec![Free { v: 2 }, Free { v: 1 }]));
+    let frees: Value<Vec<Free>> = Rc::new(RefCell::new(Vec::from([Free { v: 2 }, Free { v: 1 }])));
     {
         let __n = RandomAccessIterator::Vec((frees.as_pointer() as Ptr<Free>).to_end())
             .iter_distance(&RandomAccessIterator::Vec(

tests/unit/out/unsafe/lambda_capture_library_types.rs

@@ -13,7 +13,7 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    let mut v: Vec<i32> = vec![1, 2];
+    let mut v: Vec<i32> = Vec::from([1, 2]);
     let mut f: FnPtr<fn() -> i32> = lambda_unsafe!(
         {
             let v: Vec<i32> = v.clone();

tests/unit/out/unsafe/operator_traits.rs

@@ -137,7 +137,7 @@ pub fn main() {
 unsafe fn main_0() -> i32 {
     let mut w: Wrapped_int_ = Wrapped_int_ { v: 2 };
     assert!(((w.v) == (2)));
-    let mut lts: Vec<Lt> = vec![Lt { v: 3 }, Lt { v: 1 }, Lt { v: 2 }];
+    let mut lts: Vec<Lt> = Vec::from([Lt { v: 3 }, Lt { v: 1 }, Lt { v: 2 }]);
     {
         let __n = UnsafeRandomAccessIterator::Vec(lts.as_mut_ptr().add(lts.len()))
             .iter_distance(&UnsafeRandomAccessIterator::Vec(lts.as_mut_ptr()));
@@ -162,7 +162,7 @@ unsafe fn main_0() -> i32 {
     assert!(
         (((lts[(0_usize)].v) == (1)) && ((lts[(1_usize)].v) == (2))) && ((lts[(2_usize)].v) == (3))
     );
-    let mut eqs: Vec<Eq> = vec![Eq { v: 1 }, Eq { v: 2 }, Eq { v: 3 }];
+    let mut eqs: Vec<Eq> = Vec::from([Eq { v: 1 }, Eq { v: 2 }, Eq { v: 3 }]);
     let mut two: Eq = Eq { v: 2 };
     let mut nine: Eq = Eq { v: 9 };
     assert!(
@@ -189,7 +189,7 @@ unsafe fn main_0() -> i32 {
             __it
         } == UnsafeRandomAccessIterator::Vec(eqs.as_mut_ptr().add(eqs.len()))
     );
-    let mut cmps: Vec<Cmp> = vec![Cmp { v: 3 }, Cmp { v: 1 }, Cmp { v: 2 }];
+    let mut cmps: Vec<Cmp> = Vec::from([Cmp { v: 3 }, Cmp { v: 1 }, Cmp { v: 2 }]);
     {
         let __n = UnsafeRandomAccessIterator::Vec(cmps.as_mut_ptr().add(cmps.len()))
             .iter_distance(&UnsafeRandomAccessIterator::Vec(cmps.as_mut_ptr()));
@@ -226,7 +226,7 @@ unsafe fn main_0() -> i32 {
         .iter_deref())
         .v) == (3))
     );
-    let mut frees: Vec<Free> = vec![Free { v: 2 }, Free { v: 1 }];
+    let mut frees: Vec<Free> = Vec::from([Free { v: 2 }, Free { v: 1 }]);
     {
         let __n = UnsafeRandomAccessIterator::Vec(frees.as_mut_ptr().add(frees.len()))
             .iter_distance(&UnsafeRandomAccessIterator::Vec(frees.as_mut_ptr()));