Add support for rules that receive argument packs (#416)

Add support for rules like `std::vector<T1>::emplace_back(Args&&....)`
and `std::unique_ptr<T>::make_unique(Args&&...)`. This also deletes the
emplace back plugin.

This sets the stage for adding other argument pack rules like
`std::construct_at` or `std::map::try_emplace`.

Rust does not support forwarding argument packs. So emplace_back is
translated as `v.push(T::new(arg1, arg2, ...))`, i.e. it builds the
object at the call site. For things that might not build the object
using the provided arguments, like try_emplace, we will use the
following translation that conditionally builds the object:
`m.entry(key).or_insert_with(|| T::new(arg1, arg2, ...))`.

I used a new node in Rules IR, called init, which rule-preprocessor
creates when encountering a pack that builds an object. cpp2rust reads
the init node and creates a construct expression which is then
translated in order to create `T::new(arg1, arg2, ...)`.

Author: lucic71

cpp2rust/converter/converter.cpp

@@ -8,6 +8,7 @@
 #include <clang/Basic/LangOptions.h>
 #include <clang/Basic/SourceManager.h>
 #include <clang/Basic/Version.h>
+#include <clang/Sema/Template.h>
 #include <llvm/ADT/DenseMap.h>
 #include <llvm/Support/ConvertUTF.h>
 #include <llvm/Support/ErrorHandling.h>
@@ -1766,15 +1767,6 @@ void Converter::ConvertPrintf(clang::CallExpr *expr) {
   StrCat(')');
 }
 
-std::optional<std::string> Converter::TryPluginConvert(clang::CallExpr *call) {
-  if (emplace_back_plugin_match(call)) {
-    Buffer buf(*this);
-    emplace_back_plugin_convert(call);
-    return std::move(buf).str();
-  }
-  return std::nullopt;
-}
-
 void Converter::ConvertVariadicArg(clang::Expr *arg) {
   if (arg->getType()->isFunctionPointerType()) {
     Convert(arg);
@@ -1829,12 +1821,6 @@ bool Converter::VisitCallExpr(clang::CallExpr *expr) {
     return false;
   }
 
-  if (auto plugin_str = TryPluginConvert(expr)) {
-    StrCat(*plugin_str);
-    SetFreshType(expr->getType());
-    return false;
-  }
-
   if (Mapper::Contains(expr->getCallee())) {
     if (Mapper::IsLibcPassthrough(GetCalleeOrExpr(expr))) {
       ConvertGenericCallExpr(expr);
@@ -3623,6 +3609,7 @@ void Converter::ConvertArrayCXXConstructExpr(clang::CXXConstructExpr *expr) {
 }
 
 void Converter::ConvertCXXConstructExprArgs(clang::CXXConstructExpr *expr) {
+  HoistMaterializedTempBindings hoist_temps(*this, /*as_block=*/true);
   auto ctor = expr->getConstructor();
   StrCat(GetRecordName(ctor->getParent()), token::kDoubleColon,
          GetCtorName(ctor));
@@ -3645,7 +3632,6 @@ void Converter::ConvertCXXConstructExprArgs(clang::CXXConstructExpr *expr) {
     if (arg_idx < expr->getNumArgs()) {
       clang::Expr *arg = expr->getArg(arg_idx++);
       PushBrace brace(*this);
-      HoistMaterializedTempBindings hoist_temps(*this);
 
       if (has_default) {
         StrCat("Some(");
@@ -5042,6 +5028,8 @@ std::string Converter::ConvertIRFragment(
       result += ConvertPlaceholder(expr, arg, ph_ctx);
     } else if (std::get_if<TranslationRule::VaArgsFragment>(&frag)) {
       result += ConvertVariadicTail(expr, all_args);
+    } else if (std::get_if<TranslationRule::InitFragment>(&frag)) {
+      result += ConvertInitFragment(expr, all_args);
     } else if (auto *mc =
                    std::get_if<std::unique_ptr<MethodCallFragment>>(&frag)) {
       result += ConvertMappedMethodCall(expr, **mc, args, num_args, ctx);
@@ -5070,6 +5058,43 @@ Converter::ConvertVariadicTail(clang::Expr *expr,
   return std::move(buf).str();
 }
 
+std::string
+Converter::ConvertInitFragment(clang::Expr *expr,
+                               const std::vector<clang::Expr *> &all_args) {
+  const auto *tgt_ir = Mapper::GetExprRule(GetCalleeOrExpr(expr));
+  assert(tgt_ir && tgt_ir->init_type.valid());
+  auto *callee = clang::cast<clang::CallExpr>(expr)->getDirectCallee();
+  assert(callee);
+  auto type = GetSema()
+                  .getTemplateInstantiationArgs(callee)(tgt_ir->init_type.depth,
+                                                        tgt_ir->init_type.index)
+                  .getAsType();
+
+  Buffer buf(*this);
+  ConvertConstructFromArgs(
+      type, llvm::ArrayRef(all_args).drop_front(tgt_ir->params.size()),
+      expr->getExprLoc());
+  return std::move(buf).str();
+}
+
+void Converter::ConvertConstructFromArgs(clang::QualType type,
+                                         llvm::ArrayRef<clang::Expr *> args,
+                                         clang::SourceLocation loc) {
+  auto *init = BuildInitExpr(GetSema(), type, args, loc);
+  assert(init && "type cannot be initialized from the arguments");
+  if (auto *ctor =
+          clang::dyn_cast<clang::CXXConstructExpr>(init->IgnoreImplicit())) {
+    ConvertConstructedValue(type, ctor);
+    return;
+  }
+
+  if (args.empty()) {
+    StrCat(GetDefaultAsString(type));
+    return;
+  }
+  Convert(init);
+}
+
 std::string Converter::AccessLValueObject(clang::MemberExpr *member) {
   auto *object = member->getBase();
   auto type = object->getType();
@@ -5168,9 +5193,9 @@ void Converter::dump_expr_kinds() {
         << ", isVoid: " << isVoid() << '\n';
 }
 
-void Converter::emplace_back_plugin_construct_arg(
-    clang::QualType elem_type, clang::CXXConstructExpr *ctor) {
-  ConvertVarInit(elem_type, ctor);
+void Converter::ConvertConstructedValue(clang::QualType type,
+                                        clang::CXXConstructExpr *ctor) {
+  ConvertVarInit(type, ctor);
 }
 
 const char *Converter::GetPointerDerefPrefix(clang::QualType pointee_type) {

cpp2rust/converter/converter.h

@@ -692,6 +692,16 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
   std::string ConvertVariadicTail(clang::Expr *expr,
                                   const std::vector<clang::Expr *> &all_args);
 
+  std::string ConvertInitFragment(clang::Expr *expr,
+                                  const std::vector<clang::Expr *> &all_args);
+
+  void ConvertConstructFromArgs(clang::QualType type,
+                                llvm::ArrayRef<clang::Expr *> args,
+                                clang::SourceLocation loc);
+
+  virtual void ConvertConstructedValue(clang::QualType type,
+                                       clang::CXXConstructExpr *ctor);
+
   virtual std::string ConvertMappedMethodCall(
       clang::Expr *expr, const TranslationRule::MethodCallFragment &mc,
       clang::Expr **args, unsigned num_args, TempMaterializationCtx *ctx);
@@ -865,17 +875,23 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
     std::string *prev;
     std::string bindings;
     std::optional<Buffer> buf;
+    bool as_block;
 
   public:
-    explicit HoistMaterializedTempBindings(Converter &c)
-        : c(c), prev(c.materialized_temp_bindings_), buf(c) {
+    explicit HoistMaterializedTempBindings(Converter &c, bool as_block = false)
+        : c(c), prev(c.materialized_temp_bindings_), buf(c),
+          as_block(as_block) {
       c.materialized_temp_bindings_ = &bindings;
     }
     ~HoistMaterializedTempBindings() {
       c.materialized_temp_bindings_ = prev;
       std::string body = std::move(*buf).str();
       buf.reset();
 
+      if (as_block && !bindings.empty()) {
+        c.StrCat('{', bindings, body, '}');
+        return;
+      }
       c.StrCat(bindings, body);
     }
     HoistMaterializedTempBindings(const HoistMaterializedTempBindings &) =
@@ -1052,19 +1068,6 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
   std::string EmitMaterializedTempBinding(clang::QualType param_type,
                                           clang::Expr *expr);
 
-  // TODO: move this into the Plugin infrastructure. Plugins are used for
-  // functions that cannot be translated using the rules/ directory. For
-  // example emplace_back, make_unique, printf, etc. Generally variadic
-  // argument functions and functions that use perfect forwarding.
-  std::optional<std::string> TryPluginConvert(clang::CallExpr *call);
-
-  bool emplace_back_plugin_match(clang::CallExpr *call);
-  virtual bool emplace_back_plugin_convert(clang::CallExpr *call);
-  virtual void emplace_back_plugin_construct_arg(clang::QualType elem_type,
-                                                 clang::CXXConstructExpr *ctor);
-  virtual void emplace_back_emit_push(clang::CXXMemberCallExpr *call,
-                                      std::string_view arg);
-
   virtual const char *GetPointerDerefPrefix(clang::QualType pointee_type);
 
   TempMaterializationCtx CollectRefBindingTempArgs(clang::CallExpr *expr);

cpp2rust/converter/converter_lib.cpp

@@ -8,6 +8,8 @@
 #include <clang/AST/Mangle.h>
 #include <clang/AST/ParentMapContext.h>
 #include <clang/Basic/SourceManager.h>
+#include <clang/Sema/Initialization.h>
+#include <clang/Sema/Sema.h>
 #include <llvm/Support/Path.h>
 #include <llvm/Support/raw_ostream.h>
 
@@ -1308,6 +1310,28 @@ BuildUnifiedArgs(clang::Expr *expr, clang::Expr **args, unsigned num_args) {
   return all_args;
 }
 
+clang::Expr *BuildInitExpr(clang::Sema &sema, clang::QualType type,
+                           llvm::ArrayRef<clang::Expr *> args,
+                           clang::SourceLocation loc) {
+  llvm::SmallVector<clang::Expr *, 4> init_args(args.begin(), args.end());
+  auto kind = args.size() == 1 && clang::isa<clang::InitListExpr>(
+                                      args[0]->IgnoreParenImpCasts())
+                  ? clang::InitializationKind::CreateDirectList(loc)
+                  : clang::InitializationKind::CreateDirect(loc, {}, {});
+  auto entity = clang::InitializedEntity::InitializeTemporary(type);
+  clang::InitializationSequence seq(sema, entity, kind, init_args);
+  if (!seq) {
+    return nullptr;
+  }
+
+  auto result = seq.Perform(sema, entity, kind, init_args);
+  if (result.isInvalid()) {
+    return nullptr;
+  }
+
+  return result.get();
+}
+
 clang::Expr *GetCallee(clang::CallExpr *expr) {
   if (auto op_call = clang::dyn_cast<clang::CXXOperatorCallExpr>(expr)) {
     if (op_call->getOperator() == clang::OO_Call) {

cpp2rust/converter/converter_lib.h

@@ -19,6 +19,10 @@
 
 #include "logging.h"
 
+namespace clang {
+class Sema;
+} // namespace clang
+
 namespace cpp2rust {
 
 // Order matters: each category is a superset of the previous one.
@@ -245,6 +249,10 @@ std::optional<clang::QualType> GetParamImplicitConvertTarget(clang::Expr *expr,
 std::vector<clang::Expr *>
 BuildUnifiedArgs(clang::Expr *expr, clang::Expr **args, unsigned num_args);
 
+clang::Expr *BuildInitExpr(clang::Sema &sema, clang::QualType type,
+                           llvm::ArrayRef<clang::Expr *> args,
+                           clang::SourceLocation loc);
+
 const clang::CXXForRangeStmt *
 GetParentForRange(clang::ASTContext &ctx, const clang::MemberExpr *member);
 

cpp2rust/converter/mapper.cpp

@@ -74,6 +74,8 @@ std::string GetExprMapKey(const std::string &str) {
   return result;
 }
 
+constexpr const char kPackMarker[] = "&&...";
+
 std::string GetTypeMapKey(const std::string &str) {
   auto n = str.find_first_of("<[");
   if (n == std::string::npos || str[n] == '<') {
@@ -898,6 +900,13 @@ std::string ToString(clang::QualType qual_type, ScalarSugar sugar) {
   return normalizeTranslationRule(std::move(type));
 }
 
+bool HasFunctionParameterPack(const clang::FunctionDecl *decl) {
+  if (auto *primary = decl->getPrimaryTemplate()) {
+    decl = primary->getTemplatedDecl();
+  }
+  return decl->getNumParams() && decl->parameters().back()->isParameterPack();
+}
+
 std::string ToString(const clang::NamedDecl *decl) {
   if (auto *record = clang::dyn_cast<clang::RecordDecl>(decl);
       record && !record->getIdentifier()) {
@@ -970,13 +979,27 @@ std::string ToString(const clang::NamedDecl *decl) {
     func_decl->printQualifiedName(os, getPrintPolicy());
   }
 
+  bool has_pack = HasFunctionParameterPack(func_decl);
+  unsigned num_params = func_decl->getNumParams();
+  if (has_pack) {
+    const auto *primary = func_decl->getPrimaryTemplate();
+    num_params =
+        (primary ? primary->getTemplatedDecl() : func_decl)->getNumParams() - 1;
+  }
+
   os << '(';
-  for (unsigned i = 0, n = func_decl->getNumParams(); i < n; ++i) {
+  for (unsigned i = 0; i < num_params; ++i) {
     if (i) {
       os << ", ";
     }
     os << ToString(func_decl->getParamDecl(i)->getType());
   }
+  if (has_pack) {
+    if (num_params) {
+      os << ", ";
+    }
+    os << kPackMarker;
+  }
   if (func_decl->isVariadic()) {
     if (func_decl->getNumParams()) {
       os << ", ";

cpp2rust/converter/mapper.h

@@ -46,6 +46,8 @@ enum class ScalarSugar {
   kPreserve,
 };
 
+bool HasFunctionParameterPack(const clang::FunctionDecl *decl);
+
 clang::QualType GetTypeForDecl(const clang::NamedDecl *decl);
 std::string ToString(clang::QualType qual_type,
                      ScalarSugar sugar = ScalarSugar::kDesugar);

cpp2rust/converter/models/converter_refcount.cpp

@@ -1126,10 +1126,7 @@ bool ConverterRefCount::VisitCallExpr(clang::CallExpr *expr) {
 
   std::optional<TempMaterializationCtx> ctx;
   std::string str;
-  if (auto plugin_str = TryPluginConvert(expr)) {
-    StrCat(*plugin_str);
-    return false;
-  } else {
+  {
     PushConversionKind push(*this, ConversionKind::Unboxed);
     Buffer buf(*this);
     ctx = Converter::ConvertCallExpr(expr);
@@ -2685,24 +2682,10 @@ std::string ConverterRefCount::AccessLValueObject(clang::MemberExpr *member) {
   return is_mut ? ConvertLValue(object) : ConvertRValue(object);
 }
 
-void ConverterRefCount::emplace_back_plugin_construct_arg(
-    clang::QualType elem_type, clang::CXXConstructExpr *ctor) {
-  PushUnboxedIfSimple push(*this, "Vec<%>", elem_type);
-  ConvertVarInit(elem_type, ctor);
-}
-
-void ConverterRefCount::emplace_back_emit_push(clang::CXXMemberCallExpr *call,
-                                               std::string_view arg) {
-  auto *obj = GetCallObject(call);
-  auto obj_type = obj->getType().getNonReferenceType();
-  if (obj_type->isPointerType()) {
-    obj_type = obj_type->getPointeeType();
-  }
-  StrCat(ConvertObject(obj), ".with_mut");
-  PushParen outer(*this);
-  StrCat("|__v: &mut ", ToString(obj_type.getNonReferenceType()), "| __v.push");
-  PushParen inner(*this);
-  StrCat(arg);
+void ConverterRefCount::ConvertConstructedValue(clang::QualType type,
+                                                clang::CXXConstructExpr *ctor) {
+  PushConversionKind push(*this, ConversionKind::Unboxed);
+  ConvertVarInit(type, ctor);
 }
 
 const char *

cpp2rust/converter/models/converter_refcount.h

@@ -268,11 +268,8 @@ class ConverterRefCount final : public Converter {
   MaterializeTemp(const std::string &binding_name, clang::QualType param_type,
                   clang::Expr *expr) override;
 
-  void
-  emplace_back_plugin_construct_arg(clang::QualType elem_type,
-                                    clang::CXXConstructExpr *ctor) override;
-  void emplace_back_emit_push(clang::CXXMemberCallExpr *call,
-                              std::string_view arg) override;
+  void ConvertConstructedValue(clang::QualType type,
+                               clang::CXXConstructExpr *ctor) override;
 
   const char *GetPointerDerefSuffix(clang::QualType pointee_type);
   const char *GetPointerDerefPrefix(clang::QualType pointee_type) override;