Merge branch 'master' into get

Author: nunoplopes

cpp2rust/converter/converter.cpp

@@ -1846,11 +1846,16 @@ bool Converter::ConvertSpecialCall(clang::CallExpr *expr) {
   return false;
 }
 
+bool Converter::ExprMapsValueToPointer(const clang::CallExpr *expr) const {
+  return Mapper::Contains(ctx_, expr) && !expr->getType()->isPointerType() &&
+         RuleRegistry::MapsToPointer(ctx_, expr->getType());
+}
+
 void Converter::EmitCallResult(clang::CallExpr *expr, std::string str,
                                const TempMaterializationCtx *temps) {
   bool deref = (GetReturnTypeOfFunction(expr)->isReferenceType() ||
                 (temps && IsReferenceType(expr))) &&
-               !isAddrOf() && !isVoid();
+               !isAddrOf() && !isVoid() && !ExprMapsValueToPointer(expr);
   // The dereference is in the block of the temporaries, so they are still
   // alive, as is the read of a field of the result.
   if (deref && !(temps && Mapper::IsRefExpr(ctx_, expr))) {
@@ -5283,7 +5288,7 @@ Converter::ConvertInitFragment(clang::Expr *expr,
   if (!tgt_ir || !tgt_ir->usesInit()) {
     llvm::report_fatal_error("expression rule does not use Init");
   }
-  auto type = RuleRegistry::GetInitType(expr);
+  auto type = RuleRegistry::GetInitType(ctx_, expr);
 
   Buffer buf(*this);
   PushExprKind push(*this, ExprKind::RValue);

cpp2rust/converter/converter.h

@@ -899,6 +899,8 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
 
   virtual bool IsReferenceType(const clang::Expr *expr) const;
 
+  bool ExprMapsValueToPointer(const clang::CallExpr *expr) const;
+
   virtual bool RecordDerivesDefault(const clang::RecordDecl *decl);
 
   virtual bool TypeDerivesDefault(clang::QualType qual_type);

cpp2rust/converter/models/converter_refcount.cpp

@@ -1214,7 +1214,7 @@ void ConverterRefCount::EmitCallResult(clang::CallExpr *expr, std::string str,
   };
   auto ty = GetReturnTypeOfFunction(expr);
   if (auto *ref = ty->getAs<clang::ReferenceType>();
-      ref && !isAddrOf() && !isVoid()) {
+      ref && !isAddrOf() && !isVoid() && !ExprMapsValueToPointer(expr)) {
     if (isLValue()) {
       pending_deref_.set(wrap(std::move(str)), /*fresh=*/true);
       return;

cpp2rust/converter/rules/registry.cpp

@@ -60,31 +60,13 @@ bool pointsToUserType(clang::QualType type) {
   return tag && IsUserDefinedDecl(tag);
 }
 
+constexpr llvm::StringLiteral kInitAliasPrefix = "cpp2rust_init_";
+
 bool isRuleName(llvm::StringRef name) {
   return name.size() > 1 && (name[0] == 'f' || name[0] == 't') &&
          llvm::all_of(name.drop_front(), llvm::isDigit);
 }
 
-// The T of a rule's trailing `Init<T, Args> &&...args` pack.
-clang::QualType getInitPattern(const clang::FunctionDecl *rule) {
-  if (rule->param_empty()) {
-    return {};
-  }
-  auto expansion =
-      rule->parameters().back()->getType()->getAs<clang::PackExpansionType>();
-  if (!expansion) {
-    return {};
-  }
-  auto alias = expansion->getPattern()
-                   .getNonReferenceType()
-                   ->getAs<clang::TemplateSpecializationType>();
-  if (!alias || !alias->isTypeAlias() ||
-      alias->getTemplateName().getAsTemplateDecl()->getName() != "Init") {
-    return {};
-  }
-  return alias->template_arguments()[0].getAsType();
-}
-
 void collectGenerics(const std::vector<TranslationRule::BodyFragment> &body,
                      std::unordered_set<unsigned> &used) {
   TranslationRule::AnyFragment(body, [&](const TranslationRule::BodyFragment
@@ -158,6 +140,7 @@ void checkGenerics(const std::string &dir, const std::string &name,
   for (const auto &param : rule.params) {
     collectGenerics(param.type, used);
   }
+  collectGenerics(rule.init.type, used);
   for (unsigned i : used) {
     if (!declared.contains(std::format("T{}", i)) &&
         !isBoundArgument(rule, i)) {
@@ -166,10 +149,14 @@ void checkGenerics(const std::string &dir, const std::string &name,
       llvm::report_fatal_error("Absent generic from src");
     }
   }
-  if (rule.usesInit() && getInitPattern(decl).isNull()) {
+  if (rule.usesInit() &&
+      (decl->param_empty() || !decl->parameters()
+                                   .back()
+                                   ->getType()
+                                   ->getAs<clang::PackExpansionType>())) {
     llvm::errs() << dir << "::" << name << '\n';
-    llvm::report_fatal_error("Expr rule uses init but its src pack is not "
-                             "declared as Init<T, Args>");
+    llvm::report_fatal_error(
+        "Expr rule uses init but its src does not end in a pack");
   }
 }
 
@@ -219,6 +206,10 @@ void addCxxRules(clang::ASTContext &ctx, const clang::NamespaceDecl *rules) {
     }
     for (auto decl : ns->decls()) {
       auto named = llvm::cast<clang::NamedDecl>(decl);
+      if (llvm::isa<clang::TypeAliasTemplateDecl>(named) &&
+          named->getName().starts_with(kInitAliasPrefix)) {
+        continue;
+      }
       if (!isRuleName(named->getName())) {
         llvm::report_fatal_error("declaration is not a rule");
       }
@@ -451,18 +442,58 @@ clang::QualType GetConversionSourceType(clang::ASTContext &ctx,
   llvm::report_fatal_error("converted generic has no CppFrom bound");
 }
 
-clang::QualType GetInitType(const clang::Expr *expr) {
+clang::QualType GetInitType(clang::ASTContext &ctx, const clang::Expr *expr) {
   auto match = findExpr(expr);
   assert(match.rule_decl && "expression must have a translation rule");
+  const auto &rule = match.rule_decl->rule;
+  if (rule.init.cpp_type.empty()) {
+    llvm::StringRef type = rule.init.type;
+    unsigned n = 0;
+    [[maybe_unused]] bool bad =
+        !type.consume_front("T") || type.getAsInteger(10, n);
+    assert(!bad && "init type must be a bare generic or a cpp_type!");
+    return GetGenericType(ctx, expr, n);
+  }
   auto function = match.rule_decl->decl->getAsFunction();
-  auto pattern = getInitPattern(function);
-  assert(!pattern.isNull() && "rule has no Init<T, Args> pack");
-  clang::MultiLevelTemplateArgumentList args(
-      function->getDescribedFunctionTemplate(), match.args, /*Final=*/false);
+  auto tmpl = function->getDescribedFunctionTemplate();
+  assert(tmpl && "cpp_type! init in a non-template rule");
+  clang::TypeAliasTemplateDecl *alias = nullptr;
+  for (auto decl : function->getDeclContext()->lookup(
+           &ctx.Idents.get(InitAliasName(model_, function->getName().str())))) {
+    if ((alias = llvm::dyn_cast<clang::TypeAliasTemplateDecl>(decl))) {
+      break;
+    }
+  }
+  assert(alias && "cpp_type! init has no alias next to its rule");
+  clang::MultiLevelTemplateArgumentList args(tmpl, match.args,
+                                             /*Final=*/false);
   clang::Sema::InstantiatingTemplate inst(
       *sema_, expr->getBeginLoc(), const_cast<clang::FunctionDecl *>(function));
-  return sema_->SubstType(pattern, args, expr->getBeginLoc(),
-                          clang::DeclarationName());
+  auto type =
+      sema_->SubstType(alias->getTemplatedDecl()->getUnderlyingType(), args,
+                       expr->getBeginLoc(), clang::DeclarationName());
+  assert(!type.isNull() && "cpp_type! init does not substitute");
+  return type;
+}
+
+std::string InitCppType(Model model, const std::string &dir,
+                        const std::string &name) {
+  auto rule = findRule(model, dir, name);
+  if (!rule) {
+    rule = findRule(Model::kUnsafe, dir, name);
+  }
+  if (!rule) {
+    return {};
+  }
+  auto params = rule->getObject("params");
+  auto init = params ? params->getObject("init") : nullptr;
+  auto cpp_type = init ? init->getString("cpp_type") : std::nullopt;
+  return cpp_type ? cpp_type->str() : std::string();
+}
+
+std::string InitAliasName(Model model, const std::string &name) {
+  return std::format("{}{}_{}", kInitAliasPrefix.str(),
+                     model == Model::kRefCount ? "refcount" : "unsafe", name);
 }
 
 bool HasExprRule(const clang::FunctionDecl *decl) {

cpp2rust/converter/rules/registry.h

@@ -37,7 +37,12 @@ Matcher::Match<TranslationRule::TypeRule> Search(clang::ASTContext &ctx,
 
 const TranslationRule::ExprRule *GetExprRule(clang::ASTContext &ctx,
                                              const clang::Expr *expr);
-clang::QualType GetInitType(const clang::Expr *expr);
+clang::QualType GetInitType(clang::ASTContext &ctx, const clang::Expr *expr);
+
+std::string InitCppType(Model model, const std::string &dir,
+                        const std::string &name);
+
+std::string InitAliasName(Model model, const std::string &name);
 
 clang::QualType GetGenericType(clang::ASTContext &ctx, const clang::Expr *expr,
                                unsigned n);

cpp2rust/converter/rules/rules_loader.cpp

@@ -27,6 +27,7 @@
 
 #include "converter/converter_lib.h"
 #include "converter/rules/decls.h"
+#include "converter/rules/registry.h"
 #include "logging.h"
 
 namespace cpp2rust::RulesLoader {
@@ -314,6 +315,16 @@ const llvm::json::Object &CxxIndex() {
 std::string WrapRule(const llvm::json::Object &rule, bool is_cxx) {
   auto dir = rule.getString("dir")->str();
   auto text = rule.getString("text")->str();
+  if (auto header = rule.getString("template_header")) {
+    auto name = rule.getString("name")->str();
+    for (auto model : {Model::kUnsafe, Model::kRefCount}) {
+      auto cpp_type = RuleRegistry::InitCppType(model, dir, name);
+      if (!cpp_type.empty()) {
+        text += std::format("{} using {} = {};\n", header->str(),
+                            RuleRegistry::InitAliasName(model, name), cpp_type);
+      }
+    }
+  }
   if (!is_cxx) {
     return std::format("#define {0} cpp2rust_rules_{1}_{0}\n{2}#undef {0}\n",
                        rule.getString("name")->str(), dir, text);

cpp2rust/converter/translation_rule.cpp

@@ -20,6 +20,8 @@ TypeInfo ParseTypeInfoJSON(const llvm::json::Object &obj) {
   TypeInfo info;
   if (auto ty = obj.getString("type"))
     info.type = ty->str();
+  if (auto cpp_type = obj.getString("cpp_type"))
+    info.cpp_type = cpp_type->str();
   if (auto v = obj.getBoolean("is_refcount_pointer"))
     info.is_refcount_pointer = *v;
   if (auto v = obj.getBoolean("is_unsafe_pointer"))
@@ -296,6 +298,10 @@ ExprRule ParseExprRuleJSON(const llvm::json::Object &obj) {
   if (auto *params = obj.getObject("params")) {
     for (auto &[key, val] : *params) {
       if (auto *param_obj = val.getAsObject()) {
+        if (key == "init") {
+          ir.init = ParseTypeInfoJSON(*param_obj);
+          continue;
+        }
         size_t id = atoi(llvm::StringRef(key).data() + 1);
         ir.params.resize(std::max(ir.params.size(), id + 1));
         ir.params[id] = ParseTypeInfoJSON(*param_obj);

cpp2rust/converter/translation_rule.h

@@ -92,6 +92,7 @@ bool AnyFragment(const std::vector<BodyFragment> &body,
 struct TypeInfo {
   std::vector<std::string> derives;
   std::string type;
+  std::string cpp_type;
   bool is_refcount_pointer = false;
   bool is_unsafe_pointer = false;
 
@@ -102,6 +103,7 @@ struct TypeInfo {
 
 struct ExprRule {
   std::vector<TypeInfo> params;
+  TypeInfo init;
   TypeInfo return_type;
   std::vector<std::vector<Bound>> generics; // "T1" -> [Ord, Clone]
   std::vector<BodyFragment> body;

cpp2rust/rule_preprocessing/cpp_rule_indexer.cpp

@@ -78,7 +78,14 @@ void AddRequiredClasses(clang::QualType type,
   if (auto name = type->getAs<clang::DependentNameType>()) {
     auto qualifier = name->getQualifier();
     if (qualifier.getKind() == clang::NestedNameSpecifier::Kind::Type) {
-      AddRequiredClasses(clang::QualType(qualifier.getAsType(), 0), required);
+      if (auto spec = qualifier.getAsType()
+                          ->getAs<clang::TemplateSpecializationType>()) {
+        for (const auto &arg : spec->template_arguments()) {
+          if (arg.getKind() == clang::TemplateArgument::Type) {
+            AddRequiredClasses(arg.getAsType(), required);
+          }
+        }
+      }
     }
     return;
   }
@@ -286,6 +293,14 @@ void IndexRuleFile(clang::ASTContext &ctx, const std::string &dir_name,
     auto range = clang::tooling::getExtendedRange(*decl, clang::tok::semi, ctx);
     auto text = clang::tooling::getText(range, ctx).str() + '\n';
     llvm::json::Object rule{{"dir", dir_name}, {"name", name}, {"text", text}};
+    if (auto tmpl = llvm::dyn_cast<clang::FunctionTemplateDecl>(decl)) {
+      rule["template_header"] =
+          clang::tooling::getText(
+              clang::CharSourceRange::getTokenRange(
+                  tmpl->getTemplateParameters()->getSourceRange()),
+              ctx)
+              .str();
+    }
     if (any_class) {
       rule["requires"] = llvm::json::Array{RulesLoader::kAnyIteratorKey};
     } else if (auto required = RequiredClasses(decl, alias);

libcc2rs/src/conversion.rs

@@ -35,3 +35,10 @@ impl<T: Clone> CppFromUnsafe<T> for T {
         unsafe { (*src).clone() }
     }
 }
+
+#[macro_export]
+macro_rules! cpp_type {
+    ($cpp:literal, $rust:ty) => {
+        $rust
+    };
+}