Src ir

cpp2rust/converter/converter.cpp

@@ -673,8 +673,7 @@ bool Converter::RecordDerivesDefault(const clang::RecordDecl *decl) {
 bool Converter::IsPassThroughRule(clang::Expr *expr) const {
   const auto *rule = Mapper::GetExprRule(GetCalleeOrExpr(expr));
   return rule && rule->body.size() == 1 &&
-         std::holds_alternative<TranslationRule::PlaceholderFragment>(
-             rule->body[0]);
+         std::holds_alternative<IrTgt::PlaceholderFragment>(rule->body[0]);
 }
 
 bool Converter::RecordDerivesCopy(const clang::RecordDecl *decl) const {
@@ -2204,7 +2203,8 @@ static std::string getTypedLiteral(const char *num, std::string_view type) {
 std::string Converter::getIntegerLiteral(clang::IntegerLiteral *expr,
                                          bool incl_type,
                                          const clang::QualType *type) {
-  auto num_as_string = GetNumAsString(expr->getValue());
+  auto num_as_string =
+      GetNumAsString(expr->getValue(), expr->getType()->isSignedIntegerType());
   if (num_as_string[0] != '-' && !incl_type) {
     if (type && (*type)->isFloatingType() &&
         num_as_string.find('.') == llvm::StringRef::npos) {
@@ -4886,8 +4886,7 @@ std::string Converter::ConvertPlaceholder(clang::Expr *expr, clang::Expr *arg,
     Buffer buf(*this);
     PushExplicitAutoref autoref(
         *this, ph_ctx.is_index_base
-                   ? std::optional(ph_ctx.access ==
-                                   TranslationRule::Access::kBorrowMut)
+                   ? std::optional(ph_ctx.access == IrTgt::Access::kBorrowMut)
                    : std::nullopt);
     PushExprKind push(*this, ExprKind::RValue);
     ConvertDeref(arg);
@@ -4902,7 +4901,7 @@ std::string Converter::ConvertPlaceholder(clang::Expr *expr, clang::Expr *arg,
     return ConvertLValue(arg);
   }
 
-  if (ph_ctx.access == TranslationRule::Access::kTake) {
+  if (ph_ctx.access == IrTgt::Access::kTake) {
     if (clang::isa<clang::MaterializeTemporaryExpr>(arg)) {
       return ConvertRValue(arg);
     }
@@ -4926,16 +4925,16 @@ std::string Converter::ConvertPlaceholder(clang::Expr *expr, clang::Expr *arg,
     return std::format("std::mem::take(&mut {})", std::move(lvalue));
   }
 
-  if (ph_ctx.access == TranslationRule::Access::kMove) {
+  if (ph_ctx.access == IrTgt::Access::kMove) {
     return ConvertFreshRValue(arg, ph_ctx.implicit_convert_to);
   }
 
   return ConvertRValue(arg, ph_ctx.implicit_convert_to);
 }
 
 std::string Converter::ConvertMappedMethodCall(
-    clang::Expr *expr, const TranslationRule::MethodCallFragment &mc,
-    clang::Expr **args, unsigned num_args, TempMaterializationCtx *ctx) {
+    clang::Expr *expr, const IrTgt::MethodCallFragment &mc, clang::Expr **args,
+    unsigned num_args, TempMaterializationCtx *ctx) {
   return ConvertIRFragment(mc.receiver, expr, args, num_args, ctx) +
          ConvertIRFragment(mc.body, expr, args, num_args, ctx);
 }
@@ -4954,11 +4953,11 @@ std::string Converter::GetMappedAsString(clang::Expr *expr, clang::Expr **args,
   return result;
 }
 
-std::string Converter::ConvertIRFragment(
-    const std::vector<TranslationRule::BodyFragment> &fragments,
-    clang::Expr *expr, clang::Expr **args, unsigned num_args,
-    TempMaterializationCtx *ctx) {
-  using namespace TranslationRule;
+std::string
+Converter::ConvertIRFragment(const std::vector<IrTgt::BodyFragment> &fragments,
+                             clang::Expr *expr, clang::Expr **args,
+                             unsigned num_args, TempMaterializationCtx *ctx) {
+  using namespace IrTgt;
 
   auto all_args = BuildUnifiedArgs(expr, args, num_args);
 
@@ -4989,9 +4988,9 @@ std::string Converter::ConvertIRFragment(
           .is_index_base = ph->is_index_base,
       };
       result += ConvertPlaceholder(expr, arg, ph_ctx);
-    } else if (std::get_if<TranslationRule::VaArgsFragment>(&frag)) {
+    } else if (std::get_if<VaArgsFragment>(&frag)) {
       result += ConvertVariadicTail(expr, all_args);
-    } else if (std::get_if<TranslationRule::InitFragment>(&frag)) {
+    } else if (std::get_if<InitFragment>(&frag)) {
       result += ConvertInitFragment(expr, all_args);
     } else if (auto *mc =
                    std::get_if<std::unique_ptr<MethodCallFragment>>(&frag)) {
@@ -5025,12 +5024,13 @@ 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());
+  const auto &init_type = Mapper::GetInitType(GetCalleeOrExpr(expr));
+  assert(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)
+                  .getTemplateInstantiationArgs(callee)(init_type.depth,
+                                                        init_type.index)
                   .getAsType();
 
   Buffer buf(*this);

cpp2rust/converter/converter.h

@@ -20,7 +20,7 @@
 #include "converter/converter_lib.h"
 #include "converter/factory.h"
 #include "converter/lex.h"
-#include "converter/translation_rule.h"
+#include "converter/rules/ir_tgt.h"
 #include "logging.h"
 
 namespace cpp2rust {
@@ -247,7 +247,7 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
     std::optional<clang::QualType> implicit_convert_to;
     TempMaterializationCtx *materialize_ctx;
     int materialize_idx; // <0 = no idx, >=0 idx valid
-    TranslationRule::Access access;
+    IrTgt::Access access;
     bool is_receiver;
     bool is_cpp_ptr;
     bool maps_to_rust_ptr;
@@ -272,9 +272,7 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
              declared_in_rule_as_rust_ptr;
     }
 
-    bool needs_lvalue() const {
-      return access == TranslationRule::Access::kBorrowMut;
-    }
+    bool needs_lvalue() const { return access == IrTgt::Access::kBorrowMut; }
 
     void dump() const;
   };
@@ -695,7 +693,7 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
                                 TempMaterializationCtx *ctx = nullptr);
 
   std::string
-  ConvertIRFragment(const std::vector<TranslationRule::BodyFragment> &fragments,
+  ConvertIRFragment(const std::vector<IrTgt::BodyFragment> &fragments,
                     clang::Expr *expr, clang::Expr **args, unsigned num_args,
                     TempMaterializationCtx *ctx);
 
@@ -716,7 +714,7 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
                                        clang::CXXConstructExpr *ctor);
 
   virtual std::string ConvertMappedMethodCall(
-      clang::Expr *expr, const TranslationRule::MethodCallFragment &mc,
+      clang::Expr *expr, const IrTgt::MethodCallFragment &mc,
       clang::Expr **args, unsigned num_args, TempMaterializationCtx *ctx);
 
   virtual std::string AccessLValueObject(clang::MemberExpr *member);

cpp2rust/converter/converter_lib.cpp

@@ -1049,6 +1049,13 @@ std::string GetFunctionBaseName(const clang::FunctionDecl *decl) {
   return decl->getNameAsString();
 }
 
+bool HasFunctionParameterPack(const clang::FunctionDecl *decl) {
+  if (auto *primary = decl->getPrimaryTemplate()) {
+    decl = primary->getTemplatedDecl();
+  }
+  return decl->getNumParams() && decl->parameters().back()->isParameterPack();
+}
+
 void ToIdentifier(std::string &name) {
   ReplaceAll(name, "[", "arr");
   ReplaceAll(name, "]", "arr");

cpp2rust/converter/converter_lib.h

@@ -9,6 +9,7 @@
 #include <clang/AST/Expr.h>
 #include <clang/AST/StmtCXX.h>
 #include <clang/AST/Type.h>
+#include <llvm/ADT/APSInt.h>
 #include <llvm/ADT/STLFunctionalExtras.h>
 
 #include <optional>
@@ -175,12 +176,25 @@ template <class T> llvm::SmallString<16> GetNumAsString(const T &num) {
   return small_string;
 }
 
+inline llvm::SmallString<16> GetNumAsString(const llvm::APInt &num,
+                                            bool is_signed = false) {
+  llvm::SmallString<16> small_string;
+  num.toString(small_string, 10, is_signed);
+  return small_string;
+}
+
+inline llvm::SmallString<16> GetNumAsString(const llvm::APSInt &num) {
+  return GetNumAsString(num, num.isSigned());
+}
+
 clang::QualType GetReturnTypeOfFunction(const clang::CallExpr *expr);
 
 const char *GetOverloadedOperator(const clang::FunctionDecl *decl);
 
 std::string GetFunctionBaseName(const clang::FunctionDecl *decl);
 
+bool HasFunctionParameterPack(const clang::FunctionDecl *decl);
+
 void ToIdentifier(std::string &name);
 
 std::string GetConversionName(const clang::CXXConversionDecl *decl,