Rules: deduce decay automatically

Author: nunoplopes

cpp2rust/converter/converter.cpp

@@ -763,11 +763,22 @@ bool Converter::TypeDerivesDefault(clang::QualType qual_type) {
   return true;
 }
 
-bool Converter::IsPassThroughRule(clang::Expr *expr) const {
+bool Converter::IsPassThroughRule(clang::Expr *expr) {
   const auto *rule = RuleRegistry::GetExprRule(ctx_, expr);
-  return rule && rule->body.size() == 1 &&
-         std::holds_alternative<TranslationRule::PlaceholderFragment>(
-             rule->body[0]);
+  if (!rule || rule->body.size() != 1) {
+    return false;
+  }
+  auto *ph = std::get_if<TranslationRule::PlaceholderFragment>(&rule->body[0]);
+  if (!ph) {
+    return false;
+  }
+  // A pointer to the elements of a container argument is a new pointer.
+  auto *call = clang::dyn_cast<clang::CallExpr>(expr);
+  return !call ||
+         !ParamIsElementPtr(
+             expr,
+             BuildUnifiedArgs(call, call->getArgs(), call->getNumArgs())[ph->n],
+             ph->n);
 }
 
 bool Converter::RecordDerivesCopy(clang::QualType type) {
@@ -5140,6 +5151,13 @@ std::string Converter::ConvertPlaceholder(clang::Expr *expr, clang::Expr *arg,
     }
   }
 
+  // A pointer to the elements of the container is a new pointer, whatever the
+  // rule does with it.
+  if ((ph_ctx.needs_pointer_receiver() || ph_ctx.needs_ptr_wrap()) &&
+      ParamIsElementPtr(expr, arg, ph_ctx.arg_idx)) {
+    return ConvertElementPtr(arg);
+  }
+
   if (ph_ctx.needs_pointer_receiver()) {
     auto param_type = Mapper::GetParamType(*this, expr, ph_ctx.arg_idx);
     bool borrowed = ph_ctx.access == TranslationRule::Access::kBorrow ||
@@ -5233,6 +5251,8 @@ 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

@@ -793,7 +793,17 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
 
   bool RecordDerivesCopy(clang::QualType type);
 
-  bool IsPassThroughRule(clang::Expr *expr) const;
+  bool IsPassThroughRule(clang::Expr *expr);
+
+  // Whether the rule of expr takes its argument number index, arg, a container
+  // in C++, as a pointer to its elements rather than to the container.
+  virtual bool ParamIsElementPtr(clang::Expr * /*expr*/, clang::Expr * /*arg*/,
+                                 unsigned /*index*/) {
+    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);
 
@@ -1081,6 +1091,11 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
   virtual std::string ConvertPointerReceiver(clang::Expr *arg,
                                              std::string_view param_type);
 
+  // A pointer to the elements of the container arg.
+  virtual std::string ConvertElementPtr(clang::Expr *arg) {
+    llvm_unreachable("no pointers to elements in this model");
+  }
+
   // A pointer to a new temporary with the value of the prvalue expr, which
   // lives until the end of the statement.
   virtual std::string

cpp2rust/converter/mapper.cpp

@@ -82,4 +82,9 @@ 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

@@ -29,4 +29,5 @@ std::string InstantiateTemplate(Converter &converter, const clang::Expr *expr,
                                 unsigned n);
 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

@@ -60,6 +60,17 @@ static bool IsBoxedType(clang::ASTContext &ctx, clang::QualType type) {
   return IsBoxedType(Mapper::Map(ctx, type.getUnqualifiedType()));
 }
 
+// A Rust type without whitespace, and with the paths into libcc2rs, which the
+// rules import, unqualified, to compare it with another.
+static std::string NormalizeType(std::string type) {
+  std::erase_if(type, [](char c) { return std::isspace(c); });
+  static constexpr std::string_view kLib = "libcc2rs::";
+  for (size_t pos; (pos = type.find(kLib)) != std::string::npos;) {
+    type.erase(pos, kLib.size());
+  }
+  return type;
+}
+
 // Virtual methods take &mut self, as the fields of the struct are stored in
 // it.
 static bool NeedsMutAccess(clang::ASTContext &ctx,
@@ -379,31 +390,92 @@ std::string ConverterRefCount::ConvertObject(clang::Expr *expr,
   PushExprKind push(*this, ExprKind::Object);
   auto saved_shape = std::exchange(object_shape_, shape);
   auto str = ToString(expr);
+  // Unless the visitor already made a pointer to the elements.
+  bool decay = object_shape_ == ObjectShape::Element;
   object_shape_ = saved_shape;
-  if (shape == ObjectShape::Element && expr->getType()->isPointerType()) {
-    auto pointee = expr->getType()->getPointeeType();
-    if (IsBoxedType(ctx_, pointee) || pointee->isArrayType()) {
-      PushConversionKind push(*this, ConversionKind::Pointee);
+  if (decay) {
+    auto type = expr->getType().getNonReferenceType();
+    bool is_ptr = type->isPointerType();
+    if (is_ptr) {
+      type = type->getPointeeType();
+    }
+    if (IsBoxedType(ctx_, type) || (is_ptr && type->isArrayType())) {
       computed_expr_type_ = ComputedExprType::FreshPointer;
-      return std::format("Ptr::<{}>::decay(&({}))", ToString(pointee),
-                         std::move(str));
+      return std::move(str) + ".decay()";
     }
   }
   return str;
 }
 
-std::string ConverterRefCount::AsPointerMethod(clang::QualType type) const {
-  return isObject() && WantsElementPtr() &&
-                 type.getNonReferenceType()->isRecordType()
-             ? ".as_pointer().decay()"
-             : ".as_pointer()";
+std::string ConverterRefCount::AsPointerMethod(clang::QualType type) {
+  if (isObject() && object_shape_ == ObjectShape::Element &&
+      type->isRecordType() && IsBoxedType(ctx_, type)) {
+    object_shape_ = ObjectShape::Whole;
+    return ".decay()";
+  }
+  return ".as_pointer()";
 }
 
 std::string ConverterRefCount::ConvertPointerReceiver(clang::Expr *arg,
                                                       std::string_view) {
   return isObject() ? ConvertObject(arg) : ConvertFreshObject(arg);
 }
 
+bool ConverterRefCount::ParamIsElementPtr(clang::Expr *expr, clang::Expr *arg,
+                                          unsigned index) {
+  if (!RuleRegistry::ParamIsPointer(ctx_, expr, index)) {
+    return false;
+  }
+  auto type = arg->getType().getNonReferenceType();
+  if (type->isPointerType()) {
+    type = type->getPointeeType();
+  }
+  type = type.getUnqualifiedType();
+  if (!IsBoxedType(ctx_, type)) {
+    return false;
+  }
+  // The C++ parameter is a reference or pointer to the container, which the
+  // rule takes either as a pointer to it or as one to its elements.
+  auto param = NormalizeType(Mapper::GetParamType(*this, expr, index));
+  auto whole = NormalizeType(ToString(ctx_.getPointerType(type)));
+  if (param == whole) {
+    return false;
+  }
+  auto element = NormalizeType(ConvertPtrType(type));
+  if (param != element) {
+    llvm::errs() << "rule parameter " << index << " of type " << param
+                 << " is neither " << whole << " nor " << element << '\n';
+    llvm::report_fatal_error("rule parameter does not match the C++ one");
+  }
+  return true;
+}
+
+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;
+  }
+  // A reference is returned as a pointer. The library may spell the pointer
+  // or reference type with a typedef of its own, e.g., iterator::pointer,
+  // which is not what the pointee is spelled with.
+  auto type = GetReturnTypeOfFunction(call).getDesugaredType(ctx_);
+  if (auto *ref = type->getAs<clang::ReferenceType>()) {
+    type = ctx_.getPointerType(ref->getPointeeType());
+  }
+  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) {
   auto str = ConvertObject(expr);
   if (isFresh()) {
@@ -1020,14 +1092,6 @@ void ConverterRefCount::ConvertDeclRefValue(clang::Expr *expr,
   }
 
   if (auto *ref = decl_t->getAs<clang::ReferenceType>()) {
-    if (auto pointee = ref->getPointeeType();
-        isObject() && WantsElementPtr() && IsBoxedType(ctx_, pointee)) {
-      StrCat(std::format("Ptr::<{}>::decay(&({}))", ToString(pointee),
-                         std::move(str)));
-      computed_expr_type_ = ComputedExprType::FreshPointer;
-      return;
-    }
-
     // references are not boxed
     if (isAddrOf()) {
       StrCat(str);
@@ -1351,14 +1415,6 @@ bool ConverterRefCount::VisitCallExpr(clang::CallExpr *expr) {
     return false;
   }
 
-  if (isObject() && WantsElementPtr() && ref &&
-      IsBoxedType(ctx_, ref->getPointeeType())) {
-    StrCat(std::format("Ptr::<{}>::decay(&({}))",
-                       ToString(ref->getPointeeType()), std::move(str)));
-    computed_expr_type_ = ComputedExprType::FreshPointer;
-    return false;
-  }
-
   if (ctx && !ctx->temporary_bindings.empty()) {
     str = std::format("({{ {} {} }})", ctx->temporary_bindings, str);
   }
@@ -2299,8 +2355,8 @@ bool ConverterRefCount::VisitCXXConstructExpr(clang::CXXConstructExpr *expr) {
   if (auto str = GetMappedAsString(expr, expr->getArgs(), expr->getNumArgs());
       !str.empty()) {
     if (isAddrOf()) {
-      StrCat(std::format("Rc::new(RefCell::new({})).as_pointer()",
-                         std::move(str)));
+      StrCat(std::format("Rc::new(RefCell::new({})){}", std::move(str),
+                         AsPointerMethod(expr->getType())));
       computed_expr_type_ = ComputedExprType::FreshPointer;
     } else {
       StrCat(str);
@@ -2841,10 +2897,6 @@ bool ConverterRefCount::ConvertCXXOperatorCallExpr(
                            ConvertSubscriptIndex(expr->getArg(1))));
       }
 
-      if (is_inner_boxed && isObject() && WantsElementPtr()) {
-        StrCat(".decay()");
-      }
-
       if (isAddrOf()) {
         computed_expr_type_ = ComputedExprType::FreshPointer;
       } else {
@@ -3123,16 +3175,6 @@ pub fn main() {{
 
 void ConverterRefCount::ConvertAddrOf(clang::Expr *expr,
                                       clang::QualType pointer_type) {
-  auto pointee_type = pointer_type->getPointeeType();
-  if (isObject() && WantsElementPtr() &&
-      (IsBoxedType(ctx_, pointee_type) || pointee_type->isArrayType())) {
-    auto ptr = ConvertPointer(expr);
-    PushConversionKind push(*this, ConversionKind::Pointee);
-    StrCat(std::format("Ptr::<{}>::decay(&({}))", ToString(pointee_type),
-                       std::move(ptr)));
-    computed_expr_type_ = ComputedExprType::FreshPointer;
-    return;
-  }
   StrCat(ConvertPointer(expr));
 }
 
@@ -3171,15 +3213,6 @@ void ConverterRefCount::ConvertDeref(clang::Expr *expr) {
   if (isAddrOf() && pointee_type->isArrayType()) {
     str = std::format("({}).as_pointer()", std::move(str));
   }
-
-  if (isObject() && WantsElementPtr() &&
-      (IsBoxedType(ctx_, pointee_type) || pointee_type->isArrayType())) {
-    PushConversionKind push(*this, ConversionKind::Pointee);
-    StrCat(std::format("Ptr::<{}>::decay(&({}))", ToString(pointee_type),
-                       std::move(str)));
-    computed_expr_type_ = ComputedExprType::FreshPointer;
-    return;
-  }
   StrCat(std::move(str));
 }
 
@@ -3402,8 +3435,8 @@ void ConverterRefCount::SetUFCSReceiver(clang::Expr *base, bool is_arrow,
   if (IsTemporaryObject(base) && base->getType()->isRecordType() &&
       !IsReferenceType(base->IgnoreImplicit())) {
     PushConversionKind push(*this, ConversionKind::FullRefCount);
-    ufcs_receiver_ = token::kRef + BoxValue(ConvertRValue(base)) +
-                     AsPointerMethod(base->getType());
+    ufcs_receiver_ =
+        token::kRef + BoxValue(ConvertRValue(base)) + ".as_pointer()";
     return;
   }
   ufcs_receiver_ = token::kRef + (base_is_pointer ? ConvertRValue(base)

cpp2rust/converter/models/converter_refcount.h

@@ -398,13 +398,18 @@ class ConverterRefCount final : public Converter {
   std::string ConvertPointerReceiver(clang::Expr *arg,
                                      std::string_view param_type) override;
 
-  std::string AsPointerMethod(clang::QualType type) const;
+  bool ParamIsElementPtr(clang::Expr *expr, clang::Expr *arg,
+                         unsigned index) override;
+  std::string ConvertElementPtr(clang::Expr *arg) override;
+  // 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,
       std::optional<clang::QualType> implicit_convert_to) override;
 
-  bool WantsElementPtr() const { return object_shape_ == ObjectShape::Element; }
   std::string
   ConvertFresh(clang::Expr *expr,
                std::optional<clang::QualType> implicit_convert_to = {});
@@ -516,6 +521,8 @@ class ConverterRefCount final : public Converter {
   std::string BoxValue(std::string &&str) const;
 
   std::vector<ConversionKind> conversion_kind_;
+  // The shape that the innermost ConvertObject wants, until a visitor makes a
+  // pointer of that shape.
   ObjectShape object_shape_ = ObjectShape::Whole;
 
   // Set by pointer-related visit methods (ConvertDeref,

libcc2rs/src/cstr.rs

@@ -331,7 +331,7 @@ impl<T: CChar> Ptr<T> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::AsPointer;
+    use crate::{AsPointer, Decay};
 
     // "ab\0cd\0": C string functions must stop at the first NUL.
     const EMBEDDED_NUL: [u8; 6] = [b'a', b'b', 0, b'c', b'd', 0];
@@ -357,7 +357,7 @@ mod tests {
     #[test]
     fn stops_at_first_nul_in_vec() {
         let v = std::rc::Rc::new(RefCell::new(EMBEDDED_NUL.to_vec()));
-        check(&v.as_pointer().decay());
+        check(&v.decay());
     }
 
     #[test]