Merge branch 'master' into 2-explicit-cast-expr-key

Author: nunoplopes

cpp2rust/compat/arpa/inet.h

@@ -8,10 +8,16 @@
 #undef htonl
 #undef htons
 
+#ifdef __cplusplus
+extern "C" {
+#endif
 uint32_t cpp2rust_ntohl(uint32_t x);
 uint16_t cpp2rust_ntohs(uint16_t x);
 uint32_t cpp2rust_htonl(uint32_t x);
 uint16_t cpp2rust_htons(uint16_t x);
+#ifdef __cplusplus
+}
+#endif
 
 #define ntohl(x) cpp2rust_ntohl(x)
 #define ntohs(x) cpp2rust_ntohs(x)

cpp2rust/compat/errno.h

@@ -5,6 +5,12 @@
 
 #undef errno
 
+#ifdef __cplusplus
+extern "C" {
+#endif
 int *cpp2rust_errno(void);
+#ifdef __cplusplus
+}
+#endif
 
 #define errno (*cpp2rust_errno())

cpp2rust/compat/sys/select.h

@@ -8,10 +8,16 @@
 #undef FD_ISSET
 #undef FD_ZERO
 
+#ifdef __cplusplus
+extern "C" {
+#endif
 void cpp2rust_fd_set(int fd, fd_set *set);
 void cpp2rust_fd_clr(int fd, fd_set *set);
 int cpp2rust_fd_isset(int fd, const fd_set *set);
 void cpp2rust_fd_zero(fd_set *set);
+#ifdef __cplusplus
+}
+#endif
 
 #define FD_SET(fd, set) cpp2rust_fd_set(fd, set)
 #define FD_CLR(fd, set) cpp2rust_fd_clr(fd, set)

cpp2rust/converter/converter.cpp

@@ -219,10 +219,15 @@ std::string Converter::ConvertFreshPointer(
   return str;
 }
 
-std::string Converter::ConvertFreshObject(clang::Expr *expr, std::string_view) {
+std::string Converter::ConvertFreshObject(clang::Expr *expr) {
   return ConvertFreshPointer(expr);
 }
 
+std::string Converter::ConvertPointerReceiver(clang::Expr *arg,
+                                              std::string_view param_type) {
+  return std::format("({} as {})", ConvertFreshObject(arg), param_type);
+}
+
 std::string Converter::ConvertTemporaryPointer(
     clang::Expr *expr, std::optional<clang::QualType> implicit_convert_to) {
   return std::format("&mut {}", ConvertFreshRValue(expr, implicit_convert_to));
@@ -5142,8 +5147,10 @@ std::string Converter::ConvertPlaceholder(clang::Expr *expr, clang::Expr *arg,
 
   if (ph_ctx.needs_pointer_receiver()) {
     auto param_type = Mapper::GetParamType(*this, expr, ph_ctx.arg_idx);
-    return std::format("({} as {})", ConvertFreshObject(arg, param_type),
-                       param_type);
+    bool borrowed = ph_ctx.access == TranslationRule::Access::kBorrow ||
+                    ph_ctx.access == TranslationRule::Access::kBorrowMut;
+    PushExprKind push(*this, borrowed ? ExprKind::Object : ExprKind::XValue);
+    return ConvertPointerReceiver(arg, param_type);
   }
 
   if (ph_ctx.needs_object_receiver()) {

cpp2rust/converter/converter.h

@@ -1076,15 +1076,17 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
   virtual std::string
   ConvertFreshPointer(clang::Expr *expr,
                       std::optional<clang::QualType> implicit_convert_to = {});
-  // target_ptr_type, when known (e.g. a translation rule's parameter type),
-  // is the Rust pointer type the result will be used as.
-  virtual std::string ConvertFreshObject(clang::Expr *expr,
-                                         std::string_view target_ptr_type = {});
+  virtual std::string ConvertFreshObject(clang::Expr *expr);
+
+  virtual std::string ConvertPointerReceiver(clang::Expr *arg,
+                                             std::string_view param_type);
+
   // A pointer to a new temporary with the value of the prvalue expr, which
   // lives until the end of the statement.
   virtual std::string
   ConvertTemporaryPointer(clang::Expr *expr,
                           std::optional<clang::QualType> implicit_convert_to);
+
   std::string
   ConvertPointer(clang::Expr *expr,
                  std::optional<clang::QualType> implicit_convert_to = {},

cpp2rust/converter/models/converter_refcount.cpp

@@ -392,27 +392,20 @@ std::string ConverterRefCount::ConvertObject(clang::Expr *expr,
   return str;
 }
 
-std::string
-ConverterRefCount::ConvertFreshObject(clang::Expr *expr,
-                                      std::string_view target_ptr_type) {
-  auto shape = ObjectShape::Whole;
-  if (!target_ptr_type.empty()) {
-    auto type = expr->getType().getNonReferenceType();
-    auto pointee = type->isPointerType() ? type->getPointeeType() : type;
-    if (IsBoxedType(ctx_, pointee) || pointee->isArrayType()) {
-      auto normalize = [](std::string s) {
-        std::erase(s, ' ');
-        for (size_t pos; (pos = s.find("::<")) != std::string::npos;)
-          s.erase(pos, 2);
-        return s;
-      };
-      if (normalize(std::string(target_ptr_type)) ==
-          normalize(ConvertPtrType(pointee))) {
-        shape = ObjectShape::Element;
-      }
-    }
-  }
-  auto str = ConvertObject(expr, shape);
+std::string ConverterRefCount::AsPointerMethod(clang::QualType type) const {
+  return isObject() && WantsElementPtr() &&
+                 type.getNonReferenceType()->isRecordType()
+             ? ".as_pointer().decay()"
+             : ".as_pointer()";
+}
+
+std::string ConverterRefCount::ConvertPointerReceiver(clang::Expr *arg,
+                                                      std::string_view) {
+  return isObject() ? ConvertObject(arg) : ConvertFreshObject(arg);
+}
+
+std::string ConverterRefCount::ConvertFreshObject(clang::Expr *expr) {
+  auto str = ConvertObject(expr);
   if (isFresh()) {
     return str;
   }
@@ -1072,11 +1065,12 @@ void ConverterRefCount::ConvertDeclRefValue(clang::Expr *expr,
 
   if (isAddrOf()) {
     if (is_global_value) {
-      StrCat(std::format("{}.with(|v| v.as_pointer())", std::move(str)));
+      StrCat(std::format("{}.with(|v| v{})", std::move(str),
+                         AsPointerMethod(decl_t)));
     } else if (is_global_ptr) {
       StrCat(str);
     } else {
-      StrCat(str, ".as_pointer()");
+      StrCat(str, AsPointerMethod(decl_t));
     }
     computed_expr_type_ = ComputedExprType::FreshPointer;
     return;
@@ -1353,7 +1347,7 @@ bool ConverterRefCount::VisitCallExpr(clang::CallExpr *expr) {
 
   if (isAddrOf() && !ty->isReferenceType() && !IsPointerType(ctx_, ty)) {
     PushConversionKind push(*this, ConversionKind::FullRefCount);
-    StrCat(BoxValue(std::move(str)), ".as_pointer()");
+    StrCat(BoxValue(std::move(str)), AsPointerMethod(ty));
     return false;
   }
 
@@ -2090,7 +2084,7 @@ bool ConverterRefCount::VisitMemberExpr(clang::MemberExpr *expr) {
     if (member->getType()->isReferenceType()) {
       computed_expr_type_ = ComputedExprType::Pointer;
     } else {
-      StrCat(".as_pointer()");
+      StrCat(AsPointerMethod(member->getType()));
       computed_expr_type_ = ComputedExprType::FreshPointer;
     }
     return false;
@@ -2125,8 +2119,8 @@ void ConverterRefCount::ConvertInlineField(clang::MemberExpr *expr) {
       StrCat(std::format("array_field_ptr!({}, {})", ConvertRecordPtr(expr),
                          name));
     } else if (IsBoxedType(ctx_, type)) {
-      StrCat(std::format("field_ref!({}, {}).as_pointer()",
-                         ConvertRecordPtr(expr), name));
+      StrCat(std::format("field_ref!({}, {}){}", ConvertRecordPtr(expr), name,
+                         AsPointerMethod(type)));
     } else {
       StrCat(std::format("field_ptr!({}, {})", ConvertRecordPtr(expr), name));
     }
@@ -2838,28 +2832,17 @@ bool ConverterRefCount::ConvertCXXOperatorCallExpr(
         StrCat(GetPointerDerefPrefix(expr->getType()));
       }
 
-      if (is_inner_boxed && !isObject()) {
-        StrCat('(');
-      }
-
       PushConversionKind push(*this, ConversionKind::Unboxed);
       if (deref && !is_inner_boxed) {
         StrCat(ConvertElemPlace(expr->getArg(0), expr->getArg(1)));
       } else {
-        StrCat(std::format("({} as {}).offset({})",
+        StrCat(std::format("{}.offset({})",
                            ConvertObject(expr->getArg(0), ObjectShape::Element),
-                           ConvertPtrType(expr->getArg(0)->getType()),
                            ConvertSubscriptIndex(expr->getArg(1))));
       }
 
-      // The pointer to the element is already a pointer to the whole inner
-      // container, which as_pointer can't tell from a pointer to its first
-      // element without a type.
-      if (is_inner_boxed && (!isObject() || WantsElementPtr())) {
-        StrCat(".as_pointer()");
-        if (!isObject()) {
-          StrCat(std::format("as Ptr<{}>)", ToString(expr->getType())));
-        }
+      if (is_inner_boxed && isObject() && WantsElementPtr()) {
+        StrCat(".decay()");
       }
 
       if (isAddrOf()) {
@@ -2918,10 +2901,9 @@ std::string ConverterRefCount::ConvertElemPlace(clang::Expr *container,
       return std::format("index!({}, {})", place, ConvertSubscriptIndex(idx));
     }
   }
-  auto ptr =
-      std::format("({} as {})", ConvertObject(container, ObjectShape::Element),
-                  ConvertPtrType(container->getType()));
-  return std::format("elem!({}, {})", ptr, ConvertSubscriptIndex(idx));
+  return std::format("elem!({}, {})",
+                     ConvertObject(container, ObjectShape::Element),
+                     ConvertSubscriptIndex(idx));
 }
 
 void ConverterRefCount::ConvertFunctionParameters(clang::FunctionDecl *decl) {
@@ -3420,8 +3402,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)) + ".as_pointer()";
+    ufcs_receiver_ = token::kRef + BoxValue(ConvertRValue(base)) +
+                     AsPointerMethod(base->getType());
     return;
   }
   ufcs_receiver_ = token::kRef + (base_is_pointer ? ConvertRValue(base)

cpp2rust/converter/models/converter_refcount.h

@@ -393,12 +393,17 @@ class ConverterRefCount final : public Converter {
   enum class ObjectShape { Whole, Element };
   std::string ConvertObject(clang::Expr *expr,
                             ObjectShape shape = ObjectShape::Whole);
-  std::string
-  ConvertFreshObject(clang::Expr *expr,
-                     std::string_view target_ptr_type = {}) override;
+  std::string ConvertFreshObject(clang::Expr *expr) override;
+
+  std::string ConvertPointerReceiver(clang::Expr *arg,
+                                     std::string_view param_type) override;
+
+  std::string AsPointerMethod(clang::QualType type) const;
+
   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,

cpp2rust/converter/rules/expr_matcher.cpp

@@ -75,7 +75,7 @@ using ResolvedDecl =
 ResolvedDecl getResolvedDecl(clang::ASTContext &ctx, const clang::Expr *expr,
                              bool must_resolve) {
   expr = RuleDecls::SkipImplicit(expr);
-  if (llvm::isa<clang::IntegerLiteral>(expr) &&
+  if (llvm::isa<clang::IntegerLiteral, clang::AtomicExpr>(expr) &&
       expr->getBeginLoc().isMacroID()) {
     return MacroUsage{
         clang::Lexer::getImmediateMacroName(

cpp2rust/converter/rules/rule_keys.cpp

@@ -120,7 +120,7 @@ std::optional<ExprKey> getDeclKey(const clang::NamedDecl *decl) {
 std::optional<ExprKey> getExprKey(clang::ASTContext &ctx,
                                   const clang::Expr *expr) {
   expr = RuleDecls::SkipImplicit(expr);
-  if (llvm::isa<clang::IntegerLiteral>(expr) &&
+  if (llvm::isa<clang::IntegerLiteral, clang::AtomicExpr>(expr) &&
       expr->getBeginLoc().isMacroID()) {
     auto macro = clang::Lexer::getImmediateMacroName(
         expr->getBeginLoc(), ctx.getSourceManager(), ctx.getLangOpts());

cpp2rust/converter/rules/rules_loader.cpp

@@ -477,7 +477,8 @@ std::string ExprKey(clang::ASTContext &ctx, const clang::Expr *expr) {
   if (auto cast = llvm::dyn_cast<clang::ExplicitCastExpr>(expr)) {
     return ExprKey(ctx, cast->getSubExpr());
   }
-  if (llvm::isa<clang::IntegerLiteral>(expr) &&
+  expr = expr->IgnoreParenImpCasts();
+  if (llvm::isa<clang::IntegerLiteral, clang::AtomicExpr>(expr) &&
       expr->getBeginLoc().isMacroID()) {
     return clang::Lexer::getImmediateMacroName(
                expr->getBeginLoc(), ctx.getSourceManager(), ctx.getLangOpts())
@@ -527,7 +528,7 @@ std::string TypeKey(clang::QualType type) {
     type = typeof_type->getUnderlyingExpr()->getType();
   }
   if (auto alias = type->getAs<clang::TypedefType>();
-      alias && type.getCanonicalType()->isBuiltinType()) {
+      alias && !type.getCanonicalType()->getAsTagDecl()) {
     return DeclKey(alias->getDecl());
   }
   if (auto sugar = type->getAs<clang::PredefinedSugarType>()) {