Merge branch 'master' into mismatched-pointers

Author: lucic71

cmake/rust-toolchain.cmake

@@ -1,2 +1,2 @@
-set(RUST_STABLE_VERSION "1.98.0")
-set(RUST_NIGHTLY_VERSION "nightly-2026-08-27")
+set(RUST_STABLE_VERSION "1.99.0")
+set(RUST_NIGHTLY_VERSION "nightly-2026-10-01")

cpp2rust/converter/converter.cpp

@@ -595,7 +595,8 @@ void Converter::ConvertGlobalVarDecl(clang::VarDecl *decl) {
 }
 
 bool Converter::VisitVarDecl(clang::VarDecl *decl) {
-  if (clang::isa<clang::VarTemplatePartialSpecializationDecl>(decl)) {
+  if (clang::isa<clang::VarTemplatePartialSpecializationDecl>(decl) ||
+      decl->getDeclContext()->isDependentContext()) {
     return false;
   }
   if (ConvertLambdaVarDecl(decl)) {
@@ -760,6 +761,11 @@ void Converter::EmitRustStructOrUnion(clang::RecordDecl *decl) {
       VisitEnumDecl(enum_decl);
     }
     if (auto *var_decl = clang::dyn_cast<clang::VarDecl>(d)) {
+      if (auto *def = var_decl->getDefinition();
+          def && var_decl->getInstantiatedFromStaticDataMember() &&
+          !var_decl->hasInit()) {
+        var_decl = def;
+      }
       VisitVarDecl(var_decl);
     }
     if (auto *friend_decl = clang::dyn_cast<clang::FriendDecl>(d)) {
@@ -3430,7 +3436,7 @@ bool Converter::VisitInitListExpr(clang::InitListExpr *expr) {
     }
     PushBracket bracket(*this);
     for (auto *init : expr->inits()) {
-      ConvertVarInit(init->getType(), init);
+      ConvertVarInit(ctx_.getAsArrayType(qual_type)->getElementType(), init);
       StrCat(token::kComma);
     }
     if (expr->hasArrayFiller()) {

cpp2rust/converter/converter_lib.cpp

@@ -1338,6 +1338,16 @@ GetAllVars(const clang::Stmt *stmt) {
   return vars;
 }
 
+bool ReadsMemory(const clang::Stmt *stmt) {
+  if (auto *cast = clang::dyn_cast<clang::ImplicitCastExpr>(stmt);
+      cast && cast->getCastKind() == clang::CK_LValueToRValue) {
+    return true;
+  }
+  return std::ranges::any_of(stmt->children(), [](const clang::Stmt *child) {
+    return child && ReadsMemory(child);
+  });
+}
+
 bool ReferencesThis(const clang::Stmt *stmt) {
   if (!stmt) {
     return false;
@@ -1450,19 +1460,20 @@ bool HasReceiver(clang::Expr *expr) {
 
 std::optional<clang::QualType> GetParamImplicitConvertTarget(clang::Expr *expr,
                                                              unsigned arg_idx) {
-  auto *call = clang::dyn_cast<clang::CallExpr>(expr);
-  if (!call) {
-    return std::nullopt;
+  const clang::FunctionDecl *fn = nullptr;
+  if (auto *call = clang::dyn_cast<clang::CallExpr>(expr)) {
+    fn = call->getDirectCallee();
+  } else if (auto *ctor = clang::dyn_cast<clang::CXXConstructExpr>(expr)) {
+    fn = ctor->getConstructor();
   }
-  auto *fn = call->getDirectCallee();
   if (!fn) {
     return std::nullopt;
   }
   unsigned param_idx = arg_idx - HasReceiver(expr);
   if (param_idx >= fn->getNumParams()) {
     return std::nullopt;
   }
-  return fn->getParamDecl(param_idx)->getType();
+  return fn->getParamDecl(param_idx)->getType().getNonReferenceType();
 }
 
 std::optional<IteratorCategory>

cpp2rust/converter/converter_lib.h

@@ -242,6 +242,9 @@ GetAllVars(const clang::Stmt *stmt);
 
 bool ReferencesThis(const clang::Stmt *stmt);
 
+// Whether evaluating `stmt` reads a value from memory, e.g., a pointer.
+bool ReadsMemory(const clang::Stmt *stmt);
+
 bool MayCauseBorrowMutError(const clang::Expr *lhs, const clang::Expr *rhs);
 
 bool ArgsMayAlias(const clang::Expr *a, const clang::Expr *b);

cpp2rust/converter/models/converter_refcount.cpp

@@ -561,45 +561,28 @@ bool ConverterRefCount::RecordDerivesClone(const clang::RecordDecl *decl) {
   });
 }
 
-void ConverterRefCount::AddCloneTrait(const clang::RecordDecl *decl) {
-  auto record_name = GetRecordName(decl);
-
+bool ConverterRefCount::RecordDerivesDeepClone(const clang::RecordDecl *decl) {
   if (decl->isUnion()) {
-    StrCat("impl Clone for", record_name);
-    PushBrace impl_brace(*this);
-    StrCat("fn clone(&self) -> Self");
-    PushBrace fn_brace(*this);
-    StrCat(record_name,
-           "{ __bytes: Rc::new(RefCell::new(self.__bytes.borrow().clone())) }");
-    return;
+    return true;
   }
-
   if (RecordDerivesClone(decl) || !RecordImplementsClone(decl)) {
-    return;
+    return false;
   }
   // Without a user-defined copy constructor, each field is copied with its
   // own clone(), and Values are copied deeply.
   auto *cxx = clang::dyn_cast<clang::CXXRecordDecl>(decl);
-  if (!cxx ||
-      (!GetUserDefinedCopyConstructor(cxx) && cxx->getNumBases() == 0)) {
-    StrCat(keyword::kImpl, "Clone for", record_name);
-    PushBrace impl_brace(*this);
-    StrCat("fn clone(&self) -> Self");
-    PushBrace fn_brace(*this);
-    StrCat("Self");
-    PushBrace init_brace(*this);
-    for (auto *field : decl->fields()) {
-      auto name = GetNamedDeclAsString(field);
-      auto value = std::format("self.{}.clone()", name);
-      if (IsValueField(ctx_, field)) {
-        value = std::format(
-            "Rc::new(RefCell::new((*self.{}.borrow()).clone()))", name);
-      }
-      StrCat(std::format("{}: {},", name, value));
-    }
+  return !cxx ||
+         (!GetUserDefinedCopyConstructor(cxx) && cxx->getNumBases() == 0);
+}
+
+void ConverterRefCount::AddCloneTrait(const clang::RecordDecl *decl) {
+  if (RecordDerivesClone(decl) || RecordDerivesDeepClone(decl) ||
+      !RecordImplementsClone(decl)) {
     return;
   }
 
+  auto record_name = GetRecordName(decl);
+  auto *cxx = clang::cast<clang::CXXRecordDecl>(decl);
   StrCat(keyword::kImpl, "Clone for", record_name, '{');
   StrCat("fn clone(&self) -> Self {");
 
@@ -648,10 +631,10 @@ void ConverterRefCount::EmitRustUnion(clang::RecordDecl *decl) {
       std::vector<std::string>(attrs.begin(), attrs.end()));
 
   auto size = ctx_.getTypeSizeInChars(ctx_.getCanonicalTagType(decl));
-  StrCat(std::format("#[derive(ByteRepr)] #[byte_size({0})] pub struct {1} {{ "
-                     "#[offset(0)] #[byte_size({0})] __bytes: Value<Box<[u8]>> "
-                     "}}",
-                     size.getQuantity(), name));
+  StrCat(std::format(
+      "#[derive(ByteRepr, DeepClone)] #[byte_size({0})] pub struct {1} {{ "
+      "#[offset(0)] #[byte_size({0})] __bytes: Value<Box<[u8]>> }}",
+      size.getQuantity(), name));
 
   StrCat("impl", name);
   {
@@ -1833,12 +1816,16 @@ bool ConverterRefCount::VisitMemberExpr(clang::MemberExpr *expr) {
     return false;
   }
 
+  // A pointer to a Value field is made without copying the Value out.
+  bool value_field_ptr = isAddrOf() && !known &&
+                         clang::isa<clang::FieldDecl>(member) &&
+                         !member->getType()->isReferenceType();
   std::string str;
   if (known) {
     str = GetMappedAsString(expr);
   } else if (clang::isa<clang::FieldDecl>(member)) {
     // The Value or the pointer that the field holds.
-    str = ReadField(expr);
+    str = ReadField(expr, value_field_ptr ? ".as_pointer()" : ".clone()");
   } else {
     Buffer buf(*this);
     PushExprKind push(*this, ExprKind::RValue);
@@ -1851,7 +1838,7 @@ bool ConverterRefCount::VisitMemberExpr(clang::MemberExpr *expr) {
     if (member->getType()->isReferenceType()) {
       computed_expr_type_ = ComputedExprType::Pointer;
     } else {
-      StrCat(".as_pointer()");
+      StrCat(value_field_ptr ? "" : ".as_pointer()");
       computed_expr_type_ = ComputedExprType::FreshPointer;
     }
     return false;
@@ -1924,7 +1911,8 @@ std::string ConverterRefCount::ConvertRecordPtr(clang::MemberExpr *expr) {
   return std::move(buf).str();
 }
 
-std::string ConverterRefCount::ReadField(clang::MemberExpr *expr) {
+std::string ConverterRefCount::ReadField(clang::MemberExpr *expr,
+                                         std::string_view copy) {
   // Unless the struct is reached through a pointer, in which case the field
   // is read in a closure, the borrow of the struct ends at the end of the
   // block.
@@ -1939,7 +1927,7 @@ std::string ConverterRefCount::ReadField(clang::MemberExpr *expr) {
     str = std::move(buf).str();
   }
   if (!TypeIsCopyable(expr->getMemberDecl()->getType())) {
-    str += ".clone()";
+    str += copy;
   }
   return ptr.empty() ? std::format("{{ {} }}", str)
                      : std::format("{}.with(|__s| {})", ptr, str);
@@ -2298,6 +2286,8 @@ ConverterRefCount::GetStructAttributes(const clang::RecordDecl *decl) {
 
   if (RecordDerivesClone(decl)) {
     attrs.emplace_back("Clone");
+  } else if (RecordDerivesDeepClone(decl)) {
+    attrs.emplace_back("DeepClone");
   }
 
   // Gives access to the fields through pointers to them.
@@ -2426,7 +2416,10 @@ void ConverterRefCount::ConvertAssignment(clang::Expr *lhs, clang::Expr *rhs,
 
   PushBrace brace(*this, isRValue());
 
-  if (MayCauseBorrowMutError(lhs, rhs)) {
+  // C++ evaluates the assigned value first, which may modify what the place
+  // is computed from, like a pointer it is reached through.
+  if (MayCauseBorrowMutError(lhs, rhs) ||
+      (rhs->HasSideEffects(ctx_) && ReadsMemory(lhs))) {
     if (CanBraceAssignedValue(lhs, rhs, assign_operator)) {
       rhs_as_string = std::format("{{ {} }}", rhs_as_string);
     } else {
@@ -2589,7 +2582,7 @@ bool ConverterRefCount::ConvertCXXOperatorCallExpr(
     if (isLValue()) {
       PushConversionKind push_ck(*this, ConversionKind::Unboxed);
       pending_deref_.set(
-          std::format("({} as {}).offset({})",
+          std::format("elem!(({} as {}), {})",
                       ConvertObject(expr->getArg(0), ObjectShape::Element),
                       ConvertPtrType(expr->getArg(0)->getType()),
                       ConvertSubscriptIndex(expr->getArg(1))),
@@ -2609,10 +2602,12 @@ bool ConverterRefCount::ConvertCXXOperatorCallExpr(
       }
 
       PushConversionKind push(*this, ConversionKind::Unboxed);
-      StrCat(std::format("({} as {}).offset({})",
-                         ConvertObject(expr->getArg(0), ObjectShape::Element),
-                         ConvertPtrType(expr->getArg(0)->getType()),
-                         ConvertSubscriptIndex(expr->getArg(1))));
+      auto ptr = std::format(
+          "({} as {})", ConvertObject(expr->getArg(0), ObjectShape::Element),
+          ConvertPtrType(expr->getArg(0)->getType()));
+      auto idx = ConvertSubscriptIndex(expr->getArg(1));
+      StrCat(deref && !is_inner_boxed ? std::format("elem!({}, {})", ptr, idx)
+                                      : std::format("{}.offset({})", ptr, idx));
 
       if (is_inner_boxed) {
         StrCat(GetPointerDerefSuffix(expr->getType()), ".as_pointer()");
@@ -2739,6 +2734,12 @@ void ConverterRefCount::ConvertArraySubscript(clang::Expr *base,
   }
 }
 
+void ConverterRefCount::ConvertPointerElem(clang::Expr *base,
+                                           clang::Expr *idx) {
+  StrCat(std::format("elem!({}, {})", ToString(base), ConvertRValue(idx)));
+  computed_expr_type_ = ComputedExprType::FreshPointer;
+}
+
 void ConverterRefCount::ConvertPointerSubscript(
     clang::ArraySubscriptExpr *expr) {
   auto *base = expr->getBase();
@@ -2747,7 +2748,7 @@ void ConverterRefCount::ConvertPointerSubscript(
   if (isLValue()) {
     pending_deref_.assert_consumed();
     Buffer buf(*this);
-    ConvertPointerOffset(base, idx);
+    ConvertPointerElem(base, idx);
     pending_deref_.set_unchecked(std::move(buf).str(), isFresh(), expr);
     return;
   }
@@ -2756,8 +2757,10 @@ void ConverterRefCount::ConvertPointerSubscript(
   PushParen paren(*this, deref);
   if (deref) {
     StrCat(GetPointerDerefPrefix(expr->getType()));
+    ConvertPointerElem(base, idx);
+  } else {
+    ConvertPointerOffset(base, idx);
   }
-  ConvertPointerOffset(base, idx);
   if (deref) {
     StrCat(GetPointerDerefSuffix(expr->getType()));
     SetValueFreshness(expr->getType());

cpp2rust/converter/models/converter_refcount.h

@@ -53,6 +53,8 @@ class ConverterRefCount final : public Converter {
 
   bool RecordDerivesClone(const clang::RecordDecl *decl);
 
+  bool RecordDerivesDeepClone(const clang::RecordDecl *decl);
+
   void EmitByteSizeAttr(const clang::RecordDecl *decl) override;
 
   bool
@@ -153,7 +155,8 @@ class ConverterRefCount final : public Converter {
 
   // Copies the value of the field `expr` out of its struct, such that the
   // struct doesn't stay borrowed.
-  std::string ReadField(clang::MemberExpr *expr);
+  std::string ReadField(clang::MemberExpr *expr,
+                        std::string_view copy = ".clone()");
 
   // A field that is read through a pointer to its struct is read in a
   // closure, `p.with(|__s| __s.x)`. While converting the struct whose field
@@ -382,6 +385,9 @@ class ConverterRefCount final : public Converter {
 
   std::string ConvertSubscriptIndex(clang::Expr *idx);
 
+  // Element `idx` of pointer `base`, accessed without creating a pointer to it.
+  void ConvertPointerElem(clang::Expr *base, clang::Expr *idx);
+
   std::string GetSafeTypeAsString(clang::QualType qual_type) const;
 
   bool NeedsMut(const clang::VarDecl *decl, clang::QualType type,

libcc2rs-macros/src/deep_clone.rs

@@ -0,0 +1,62 @@
+// Copyright (c) 2022-present INESC-ID.
+// Distributed under the MIT license that can be found in the LICENSE file.
+
+use proc_macro::TokenStream;
+use proc_macro2::TokenStream as TokenStream2;
+use quote::quote;
+use syn::{Data, DeriveInput, Fields, Index, Type, parse_macro_input};
+
+// Whether `ty` is a Value<_>, which is copied with DeepClone.
+fn is_value(ty: &Type) -> bool {
+    match ty {
+        Type::Path(path) => path
+            .path
+            .segments
+            .last()
+            .is_some_and(|segment| segment.ident == "Value"),
+        _ => false,
+    }
+}
+
+fn clone_field(ty: &Type, field: TokenStream2) -> TokenStream2 {
+    if is_value(ty) {
+        quote! { ::libcc2rs::DeepClone::deep_clone(&self.#field) }
+    } else {
+        quote! { ::core::clone::Clone::clone(&self.#field) }
+    }
+}
+
+pub fn expand(input: TokenStream) -> TokenStream {
+    let input = parse_macro_input!(input as DeriveInput);
+    let name = &input.ident;
+    let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
+    let Data::Struct(data) = &input.data else {
+        panic!("derive(DeepClone) is only supported on structs, `{name}` is not one");
+    };
+    let body = match &data.fields {
+        Fields::Named(fields) => {
+            let fields = fields.named.iter().map(|field| {
+                let ident = field.ident.as_ref().unwrap();
+                let value = clone_field(&field.ty, quote! { #ident });
+                quote! { #ident: #value }
+            });
+            quote! { Self { #(#fields,)* } }
+        }
+        Fields::Unnamed(fields) => {
+            let fields = fields.unnamed.iter().enumerate().map(|(i, field)| {
+                let index = Index::from(i);
+                clone_field(&field.ty, quote! { #index })
+            });
+            quote! { Self(#(#fields,)*) }
+        }
+        Fields::Unit => quote! { Self },
+    };
+    quote! {
+        impl #impl_generics ::core::clone::Clone for #name #ty_generics #where_clause {
+            fn clone(&self) -> Self {
+                #body
+            }
+        }
+    }
+    .into()
+}