Use generic get<N> for pair, array and tuple_element (#572)

std::pair::get is defined as:

```cpp
template< std::size_t I, class T1, class T2 >
typename std::tuple_element<I, std::pair<T1,T2> >::type&
    get( std::pair<T1, T2>& p ) noexcept;
```

Our rules wrote individual versions for `get<0>` and `get<1>`. This PR
adds the generic version `get<N>` as declared by the standard.

This PR also adds get for array and translates tuple_element.

---

Rust does not allow writing a rule as `get<N>(a0: (T1, T2)) { return a.N
}` with `N = {0, 1}`. So we need libcc2rs support for this. TupleElement
is the translation of `std::tuple_element` and TupleGet uses
TupleElement to translate `std::get`.

Author: lucic71

cpp2rust/converter/converter.cpp

@@ -133,6 +133,12 @@ Converter::GetTemplateArgumentAsString(const clang::TemplateArgument &arg) {
   case clang::TemplateArgument::Type:
     return GetUnboxedTypeAsString(arg.getAsType());
   case clang::TemplateArgument::Integral:
+    if (!arg.getIntegralType()->isBooleanType()) {
+      llvm::SmallString<16> value;
+      arg.getAsIntegral().toString(value);
+      return std::string(value);
+    }
+    [[fallthrough]];
   case clang::TemplateArgument::NullPtr:
   case clang::TemplateArgument::Declaration:
   case clang::TemplateArgument::StructuralValue: {
@@ -5114,8 +5120,6 @@ std::string Converter::GetMappedAsString(clang::Expr *expr, clang::Expr **args,
   if (!tgt_ir)
     return {};
 
-  CheckRuleReturnType(expr);
-
   auto saved_borrows = std::exchange(mut_borrows_, {});
   auto *operand = tgt_ir->refExprOperand();
   bool lvalue = operand && !isAddrOf();

cpp2rust/converter/converter.h

@@ -916,9 +916,6 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
     return false;
   }
 
-  // Checks that the rule of expr returns the type that expr returns in C++.
-  virtual void CheckRuleReturnType(clang::Expr * /*expr*/) {}
-
   bool RecordHasCopyableFields(const clang::RecordDecl *decl);
 
   bool ShouldReplaceWithMappedBody(const clang::ValueDecl *decl) const;

cpp2rust/converter/mapper.cpp

@@ -74,9 +74,4 @@ std::string GetParamType(Converter &converter, const clang::Expr *expr,
   return Matcher::InstantiateTgt(converter, subs, rule->params.at(index).type);
 }
 
-std::string GetReturnType(Converter &converter, const clang::Expr *expr) {
-  auto [rule, subs] = RuleRegistry::Search(converter.GetASTContext(), expr);
-  return Matcher::InstantiateTgt(converter, subs, rule->return_type.type);
-}
-
 } // namespace cpp2rust::Mapper

cpp2rust/converter/mapper.h

@@ -27,5 +27,4 @@ std::string MapFunctionName(clang::ASTContext &ctx,
                             const clang::FunctionDecl *decl);
 std::string GetParamType(Converter &converter, const clang::Expr *expr,
                          unsigned index);
-std::string GetReturnType(Converter &converter, const clang::Expr *expr);
 } // namespace cpp2rust::Mapper

cpp2rust/converter/models/converter_refcount.cpp

@@ -438,29 +438,6 @@ std::string ConverterRefCount::ConvertElementPtr(clang::Expr *arg) {
   return ConvertObject(arg, ObjectShape::Element);
 }
 
-void ConverterRefCount::CheckRuleReturnType(clang::Expr *expr) {
-  auto *call = clang::dyn_cast<clang::CallExpr>(expr);
-  if (!call ||
-      !RuleRegistry::GetExprRule(ctx_, expr)->return_type.is_refcount_pointer) {
-    return;
-  }
-  auto type = RuleRegistry::GetDeclaredReturnType(expr);
-  if (auto ref = type->getAs<clang::ReferenceType>()) {
-    auto pointee = ref->getPointeeType();
-    type = pointee->isRecordType() &&
-                   RuleRegistry::MapsToRefcountPointer(ctx_, pointee)
-               ? pointee
-               : ctx_.getPointerType(pointee);
-  }
-  auto ret = NormalizeType(Mapper::GetReturnType(*this, expr));
-  auto expected = NormalizeType(ToString(type));
-  if (ret != expected) {
-    llvm::errs() << "rule return type " << ret << " is not " << expected
-                 << '\n';
-    llvm::report_fatal_error("rule return type does not match the C++ one");
-  }
-}
-
 std::string ConverterRefCount::ConvertFreshObject(clang::Expr *expr) {
   return MakeFresh(ConvertObject(expr));
 }

cpp2rust/converter/models/converter_refcount.h

@@ -441,7 +441,6 @@ class ConverterRefCount final : public Converter {
   // The method that makes a pointer to an object of the given type, which is
   // one to its elements if they are what ConvertObject wants.
   std::string AsPointerMethod(clang::QualType type);
-  void CheckRuleReturnType(clang::Expr *expr) override;
 
   std::string ConvertTemporaryPointer(
       clang::Expr *expr,

cpp2rust/converter/rules/expr_matcher.cpp

@@ -298,6 +298,32 @@ getExplicitTemplateArgs(const clang::Expr *expr) {
   return {};
 }
 
+void deduceNonTypeFromExplicitArg(
+    clang::ASTContext &ctx, const clang::TemplateArgument &rule_arg,
+    const clang::Expr *use, unsigned i,
+    std::vector<clang::TemplateArgument> &deduced) {
+  auto ref = llvm::dyn_cast<clang::DeclRefExpr>(
+      rule_arg.getAsExpr()->IgnoreParenImpCasts());
+  auto nttp =
+      ref ? llvm::dyn_cast<clang::NonTypeTemplateParmDecl>(ref->getDecl())
+          : nullptr;
+  if (!nttp) {
+    return;
+  }
+  auto call = llvm::cast<clang::CallExpr>(RuleDecls::SkipImplicit(use));
+  auto callee = call->getDirectCallee();
+  auto spec = callee ? callee->getTemplateSpecializationArgs() : nullptr;
+  assert(spec && i < spec->size() &&
+         "explicit template argument of a non-specialized callee");
+  const auto &value = spec->get(i);
+  assert(value.getKind() == clang::TemplateArgument::Integral &&
+         "non-type template argument is not an integral");
+  auto &slot = deduced[nttp->getIndex()];
+  if (slot.isNull()) {
+    slot = clang::TemplateArgument(ctx, value.getAsIntegral(), nttp->getType());
+  }
+}
+
 void deduceFromExplicitArgs(clang::Sema &sema,
                             clang::FunctionTemplateDecl *rule,
                             const clang::Expr *use,
@@ -308,6 +334,10 @@ void deduceFromExplicitArgs(clang::Sema &sema,
   for (unsigned i = 0; i < rule_args.size() && i < use_args.size(); ++i) {
     const auto &rule_arg = rule_args[i].getArgument();
     const auto &use_arg = use_args[i].getArgument();
+    if (rule_arg.getKind() == clang::TemplateArgument::Expression) {
+      deduceNonTypeFromExplicitArg(sema.Context, rule_arg, use, i, deduced);
+      continue;
+    }
     if (rule_arg.getKind() != clang::TemplateArgument::Type ||
         use_arg.getKind() != clang::TemplateArgument::Type) {
       continue;

cpp2rust/converter/rules/registry.cpp

@@ -496,23 +496,6 @@ std::string InitAliasName(Model model, const std::string &name) {
                      model == Model::kRefCount ? "refcount" : "unsafe", name);
 }
 
-clang::QualType GetDeclaredReturnType(const clang::Expr *expr) {
-  auto match = findExpr(expr);
-  assert(match.rule_decl && "expression must have a translation rule");
-  auto function = match.rule_decl->decl->getAsFunction();
-  assert(function && "rule is not a function");
-  auto tmpl = function->getDescribedFunctionTemplate();
-  if (!tmpl) {
-    return function->getReturnType();
-  }
-  clang::MultiLevelTemplateArgumentList args(tmpl, match.args,
-                                             /*Final=*/false);
-  clang::Sema::InstantiatingTemplate inst(
-      *sema_, expr->getBeginLoc(), const_cast<clang::FunctionDecl *>(function));
-  return sema_->SubstType(function->getReturnType(), args, expr->getBeginLoc(),
-                          clang::DeclarationName());
-}
-
 bool HasExprRule(const clang::FunctionDecl *decl) {
   auto key = RuleKeys::GetDeclKey(decl);
   if (!key) {

cpp2rust/converter/rules/registry.h

@@ -50,8 +50,6 @@ clang::QualType GetGenericType(clang::ASTContext &ctx, const clang::Expr *expr,
 clang::QualType GetConversionSourceType(clang::ASTContext &ctx,
                                         const clang::Expr *expr, unsigned to);
 
-clang::QualType GetDeclaredReturnType(const clang::Expr *expr);
-
 bool HasExprRule(const clang::FunctionDecl *decl);
 bool IsLibcPassthrough(clang::ASTContext &ctx, const clang::Expr *expr);
 bool ReturnsPointer(clang::ASTContext &ctx, const clang::Expr *expr);

rule-preprocessor/src/syntactic.rs

@@ -481,9 +481,16 @@ impl<'a> FnIrBuilder<'a> {
 
         if let Some(gpl) = self.fn_item.generic_param_list() {
             for param in gpl.generic_params() {
-                if let ast::GenericParam::TypeParam(tp) = param {
-                    let name = tp.name().map(|n| n.text().to_string()).unwrap_or_default();
-                    generics.insert(name, extract_bounds(tp.type_bound_list()));
+                match param {
+                    ast::GenericParam::TypeParam(tp) => {
+                        let name = tp.name().map(|n| n.text().to_string()).unwrap_or_default();
+                        generics.insert(name, extract_bounds(tp.type_bound_list()));
+                    }
+                    ast::GenericParam::ConstParam(cp) => {
+                        let name = cp.name().map(|n| n.text().to_string()).unwrap_or_default();
+                        generics.insert(name, Vec::new());
+                    }
+                    _ => {}
                 }
             }
         }