From 9df96aa1dc7735f9a1c179bc547fbafe7e268e9d Mon Sep 17 00:00:00 2001 From: Lucian Popescu Date: Tue, 20 Oct 2026 13:04:51 +0100 Subject: [PATCH 1/3] Add RefExpr in RulesIR to avoid value -> pointer -> value roundtrips --- cpp2rust/converter/converter.cpp | 37 +++++++++++++++---------- cpp2rust/converter/mapper.cpp | 5 ++++ cpp2rust/converter/mapper.h | 1 + cpp2rust/converter/rules/registry.cpp | 4 +++ cpp2rust/converter/translation_rule.cpp | 32 +++++++++++++++++++++ cpp2rust/converter/translation_rule.h | 12 +++++++- docs/src/rules/ir.md | 5 ++++ docs/src/rules/loading.md | 2 ++ rule-preprocessor/src/ir.rs | 15 ++++++++++ rule-preprocessor/src/syntactic.rs | 28 +++++++++++++++++-- 10 files changed, 124 insertions(+), 17 deletions(-) diff --git a/cpp2rust/converter/converter.cpp b/cpp2rust/converter/converter.cpp index 754d3a220..0818da69e 100644 --- a/cpp2rust/converter/converter.cpp +++ b/cpp2rust/converter/converter.cpp @@ -1765,6 +1765,7 @@ void Converter::ConvertPrintf(clang::CallExpr *expr) { } void Converter::ConvertVariadicArg(clang::Expr *arg) { + PushExprKind push(*this, ExprKind::RValue); if (arg->getType()->isFunctionPointerType()) { Convert(arg); StrCat(".map_or(::std::ptr::null_mut(), |f| f as *mut ::libc::c_void)"); @@ -1832,19 +1833,16 @@ bool Converter::VisitCallExpr(clang::CallExpr *expr) { return false; } + bool deref_ref = (IsReferenceType(expr) || + GetReturnTypeOfFunction(expr)->isReferenceType()) && + !isAddrOf() && !isVoid(); + auto **args = expr->getArgs(); auto num_args = expr->getNumArgs(); auto ctx = CollectRefBindingTempArgs(expr); - std::string str; - { - PushExprKind push(*this, ExprKind::RValue); - str = GetMappedAsString(expr, args, num_args, &ctx); - }; + auto str = GetMappedAsString(expr, args, num_args, &ctx); - bool deref_ref = (IsReferenceType(expr) || - GetReturnTypeOfFunction(expr)->isReferenceType()) && - !isAddrOf() && !isVoid(); - if (deref_ref) { + if (deref_ref && !Mapper::IsRefExpr(ctx_, expr)) { str = "( * " + std::move(str) + " )"; } @@ -3152,7 +3150,8 @@ std::string Converter::ConvertDeclRef(clang::Expr *expr, if (ShouldReplaceWithMappedBody(decl)) { if (auto str = GetMappedAsString(expr); !str.empty()) { - if (RuleRegistry::ReturnsReference(expr) && !isAddrOf()) { + if (RuleRegistry::ReturnsReference(expr) && !isAddrOf() && + !Mapper::IsRefExpr(ctx_, expr)) { return std::format("({}{})", GetPointerDerefPrefix(expr->getType()), str); } @@ -3409,10 +3408,11 @@ bool Converter::VisitMemberExpr(clang::MemberExpr *expr) { is_reference_type |= method->getReturnType()->isReferenceType(); } - if (is_reference_type) { + if (is_reference_type || RuleRegistry::ReturnsPointer(ctx_, expr)) { computed_expr_type_ = ComputedExprType::Pointer; } else { - StrCat(token::kRef); + StrCat(token::kRef, + expr->getType().isConstQualified() ? "" : keyword_mut_); computed_expr_type_ = ComputedExprType::FreshPointer; } StrCat(str); @@ -3462,7 +3462,8 @@ void Converter::SetUFCSReceiver(clang::Expr *base, bool is_arrow, void Converter::ConvertMemberExpr(clang::MemberExpr *expr) { if (auto mapped = GetMappedAsString(expr); !mapped.empty()) { - if (RuleRegistry::ReturnsPointer(ctx_, expr)) { + if (RuleRegistry::ReturnsPointer(ctx_, expr) && !isAddrOf() && + !Mapper::IsRefExpr(ctx_, expr)) { PushParen paren(*this); StrCat(token::kStar, mapped); } else { @@ -5203,7 +5204,10 @@ std::string Converter::GetMappedAsString(clang::Expr *expr, clang::Expr **args, return {}; auto saved_borrows = std::exchange(mut_borrows_, {}); - auto result = ConvertIRFragment(tgt_ir->body, expr, args, num_args, ctx); + auto *operand = tgt_ir->refExprOperand(); + bool lvalue = operand && !isAddrOf(); + auto result = ConvertIRFragment(lvalue ? *operand : tgt_ir->body, expr, args, + num_args, ctx); if (tgt_ir->multi_statement) { result = '{' + result + '}'; } @@ -5257,6 +5261,10 @@ std::string Converter::ConvertIRFragment( } else if (auto *mc = std::get_if>(&frag)) { result += ConvertMappedMethodCall(expr, **mc, args, num_args, ctx); + } else if (auto *re = + std::get_if>(&frag)) { + result += (*re)->prefix + ' ' + + ConvertIRFragment((*re)->inner, expr, args, num_args, ctx); } } @@ -5292,6 +5300,7 @@ Converter::ConvertInitFragment(clang::Expr *expr, auto type = RuleRegistry::GetInitType(expr); Buffer buf(*this); + PushExprKind push(*this, ExprKind::RValue); ConvertConstructFromArgs( type, llvm::ArrayRef(all_args).drop_front(tgt_ir->params.size()), expr->getExprLoc()); diff --git a/cpp2rust/converter/mapper.cpp b/cpp2rust/converter/mapper.cpp index 963ef8298..716647e95 100644 --- a/cpp2rust/converter/mapper.cpp +++ b/cpp2rust/converter/mapper.cpp @@ -27,6 +27,11 @@ bool Contains(clang::ASTContext &ctx, const clang::Expr *expr) { return RuleRegistry::Search(ctx, expr).first != nullptr; } +bool IsRefExpr(clang::ASTContext &ctx, const clang::Expr *expr) { + const auto *rule = RuleRegistry::GetExprRule(ctx, expr); + return rule && rule->refExprOperand(); +} + std::string MapFunctionName(clang::ASTContext &ctx, const clang::FunctionDecl *decl) { assert(decl); diff --git a/cpp2rust/converter/mapper.h b/cpp2rust/converter/mapper.h index cabd516e7..d58449e4f 100644 --- a/cpp2rust/converter/mapper.h +++ b/cpp2rust/converter/mapper.h @@ -18,6 +18,7 @@ class Converter; namespace cpp2rust::Mapper { bool Contains(clang::ASTContext &ctx, clang::QualType qual_type); bool Contains(clang::ASTContext &ctx, const clang::Expr *expr); +bool IsRefExpr(clang::ASTContext &ctx, const clang::Expr *expr); std::string Map(clang::ASTContext &ctx, clang::QualType qual_type); std::string Map(Converter &converter, clang::QualType qual_type); diff --git a/cpp2rust/converter/rules/registry.cpp b/cpp2rust/converter/rules/registry.cpp index fd19c1722..98cca6d1c 100644 --- a/cpp2rust/converter/rules/registry.cpp +++ b/cpp2rust/converter/rules/registry.cpp @@ -95,6 +95,10 @@ void collectGenerics(const std::vector &body, &fragment)) { collectGenerics((*call)->receiver, used); collectGenerics((*call)->body, used); + } else if (auto ref_expr = std::get_if< + std::unique_ptr>( + &fragment)) { + collectGenerics((*ref_expr)->inner, used); } } } diff --git a/cpp2rust/converter/translation_rule.cpp b/cpp2rust/converter/translation_rule.cpp index 5beafea1f..e6f450fd5 100644 --- a/cpp2rust/converter/translation_rule.cpp +++ b/cpp2rust/converter/translation_rule.cpp @@ -72,6 +72,15 @@ MethodCallFragment ParseMethodCallFragmentJSON(const llvm::json::Object &obj) { return mc; } +RefExprFragment ParseRefExprFragmentJSON(const llvm::json::Object &obj) { + RefExprFragment re; + re.prefix = obj.getString("prefix").value_or("").str(); + if (auto *inner = obj.getArray("inner")) { + re.inner = ParseBodyFragmentsJSON(*inner); + } + return re; +} + std::vector ParseBodyFragmentsJSON(const llvm::json::Array &arr) { std::vector result; for (auto &frag : arr) { @@ -87,6 +96,9 @@ std::vector ParseBodyFragmentsJSON(const llvm::json::Array &arr) { } else if (auto *mc = frag_obj->getObject("method_call")) { result.push_back(std::make_unique( ParseMethodCallFragmentJSON(*mc))); + } else if (auto *re = frag_obj->getObject("ref_expr")) { + result.push_back( + std::make_unique(ParseRefExprFragmentJSON(*re))); } else if (frag_obj->get("va_args")) { result.push_back(VaArgsFragment{}); } else if (frag_obj->get("init")) { @@ -110,6 +122,8 @@ void BodyFragmentDump(const BodyFragment &frag) { } else if (auto *mc = std::get_if>(&frag)) { (*mc)->dump(); + } else if (auto *re = std::get_if>(&frag)) { + (*re)->dump(); } } @@ -118,6 +132,9 @@ bool HasInitFragment(const std::vector &body) { if (auto *mc = std::get_if>(&frag)) { return HasInitFragment((*mc)->receiver) || HasInitFragment((*mc)->body); } + if (auto *re = std::get_if>(&frag)) { + return HasInitFragment((*re)->inner); + } return std::holds_alternative(frag); }); } @@ -196,6 +213,21 @@ void ExprRule::dump() const { bool ExprRule::usesInit() const { return HasInitFragment(body); } +const std::vector *ExprRule::refExprOperand() const { + if (body.size() != 1) { + return nullptr; + } + auto *re = std::get_if>(&body[0]); + return re ? &(*re)->inner : nullptr; +} + +void RefExprFragment::dump() const { + log() << " ref_expr: " << prefix << '\n'; + for (auto &frag : inner) { + BodyFragmentDump(frag); + } +} + void GenericFragment::dump() const { log() << " generic: " << n << '\n'; } void TypeInfo::dump() const { diff --git a/cpp2rust/converter/translation_rule.h b/cpp2rust/converter/translation_rule.h index 6cc21da79..e80bb837a 100644 --- a/cpp2rust/converter/translation_rule.h +++ b/cpp2rust/converter/translation_rule.h @@ -49,10 +49,12 @@ struct InitFragment { }; struct MethodCallFragment; // forward declaration +struct RefExprFragment; using BodyFragment = std::variant>; + std::unique_ptr, + std::unique_ptr>; struct MethodCallFragment { std::vector receiver; @@ -62,6 +64,13 @@ struct MethodCallFragment { void dump() const; }; +struct RefExprFragment { + std::string prefix; + std::vector inner; + + void dump() const; +}; + struct TypeInfo { std::vector derives; std::string type; @@ -83,6 +92,7 @@ struct ExprRule { void dump() const; bool usesInit() const; + const std::vector *refExprOperand() const; }; struct TypeRule { diff --git a/docs/src/rules/ir.md b/docs/src/rules/ir.md index e28aae9cb..10dda2679 100644 --- a/docs/src/rules/ir.md +++ b/docs/src/rules/ir.md @@ -77,6 +77,11 @@ The fragment kinds are: - `method_call`: a method call split into `receiver` and `body` fragment lists, so the code generator can rewrite the pair (see [Rule Rewriting](./rewriting.md)). +- `ref_expr`: a body that takes the address of an lvalue, `&mut a0.0`, split + into the `prefix` (`&`, `&mut`, `&raw const`, `&raw mut`) and the `inner` + fragments of the lvalue. Where the converter would dereference the rule's + result it emits the lvalue alone, so `p.first = 1.5` is `p.0 = 1.5` rather + than `(*&mut p.0) = 1.5`. - `va_args`: the expansion point for a variadic tail. - `init`: the value built from the call's trailing arguments. diff --git a/docs/src/rules/loading.md b/docs/src/rules/loading.md index 5483f48df..9a9e810ef 100644 --- a/docs/src/rules/loading.md +++ b/docs/src/rules/loading.md @@ -90,6 +90,8 @@ When a rule matches, the converter walks its body fragments and emits: converter dereferences it; this only happens for receivers, not for ordinary arguments. - `generic` fragments as the Rust mapping of the bound C++ type, +- `ref_expr` fragments as the prefix followed by the lvalue, or as the lvalue + alone where the result is dereferenced, - `va_args` fragments as the converted variadic tail, - `init` fragments as the value built from the call's trailing arguments, - `method_call` fragments as receiver followed by body, possibly rewritten (see diff --git a/rule-preprocessor/src/ir.rs b/rule-preprocessor/src/ir.rs index 34653078d..421ea642a 100644 --- a/rule-preprocessor/src/ir.rs +++ b/rule-preprocessor/src/ir.rs @@ -109,6 +109,7 @@ impl FnIr { BodyFragment::MethodCall { method_call } => { check(&method_call.receiver) || check(&method_call.body) } + BodyFragment::RefExpr { ref_expr } => check(&ref_expr.inner), _ => false, }) } @@ -161,6 +162,9 @@ pub enum BodyFragment { MethodCall { method_call: MethodCallInner, }, + RefExpr { + ref_expr: RefExprInner, + }, VaArgs { va_args: std::marker::PhantomData<()>, }, @@ -193,6 +197,12 @@ pub struct MethodCallInner { pub body: Vec, } +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct RefExprInner { + pub prefix: String, + pub inner: Vec, +} + // For convenience: match on fragment kind impl BodyFragment { pub fn as_text_mut(&mut self) -> Option<&mut String> { @@ -238,6 +248,11 @@ fn resolve_nth_unknown( return true; } } + BodyFragment::RefExpr { ref_expr } => { + if resolve(&mut ref_expr.inner, param, nth, count, patch) { + return true; + } + } _ => {} } } diff --git a/rule-preprocessor/src/syntactic.rs b/rule-preprocessor/src/syntactic.rs index b3f6ad797..d1f75d1c9 100644 --- a/rule-preprocessor/src/syntactic.rs +++ b/rule-preprocessor/src/syntactic.rs @@ -9,8 +9,8 @@ use std::collections::BTreeMap; use std::path::{Path, PathBuf}; use crate::ir::{ - Access, BodyFragment, FileIr, FnIr, MethodCallInner, Model, PlaceholderInner, RuleIr, RulesIR, - TypeInfo, TypeIr, + Access, BodyFragment, FileIr, FnIr, MethodCallInner, Model, PlaceholderInner, RefExprInner, + RuleIr, RulesIR, TypeInfo, TypeIr, }; /// Classify a type AST node as refcount pointer (`Ptr`), unsafe pointer @@ -490,6 +490,30 @@ impl<'a> FnIrBuilder<'a> { }; let stmt_list = body.stmt_list().unwrap(); + if stmt_list.statements().next().is_none() + && let Some(ast::Expr::RefExpr(ref_expr)) = stmt_list.tail_expr() + { + let mut prefix = String::from("&"); + if ref_expr.raw_token().is_some() { + prefix.push_str("raw "); + } + if ref_expr.mut_token().is_some() { + prefix.push_str("mut"); + } else if ref_expr.const_token().is_some() { + prefix.push_str("const"); + } + let mut inner_ctx = FragmentCtx::new(self, params, generic_names); + inner_ctx.visit(ra_ap_syntax::NodeOrToken::Node( + ref_expr.expr().unwrap().syntax().clone(), + )); + return vec![BodyFragment::RefExpr { + ref_expr: RefExprInner { + prefix: prefix.trim_end().to_string(), + inner: inner_ctx.finish(), + }, + }]; + } + let mut ctx = FragmentCtx::new(self, params, generic_names); for child in stmt_list.syntax().children_with_tokens() { if let ra_ap_syntax::NodeOrToken::Token(ref t) = child From b5cddb3910ecac9c58ef4b5d319c9f9bc0763991 Mon Sep 17 00:00:00 2001 From: Lucian Popescu Date: Tue, 20 Oct 2026 13:07:04 +0100 Subject: [PATCH 2/3] Update tests --- tests/unit/out/unsafe/clone_vs_move.rs | 13 +-- tests/unit/out/unsafe/find.rs | 6 +- tests/unit/out/unsafe/foreach_map.rs | 3 +- tests/unit/out/unsafe/inet_pton_ntop.rs | 49 ++++------ tests/unit/out/unsafe/map-reallocation.rs | 9 +- tests/unit/out/unsafe/map.rs | 93 +++++++------------ tests/unit/out/unsafe/map_copy.rs | 12 +-- tests/unit/out/unsafe/map_key_identity.rs | 32 +++---- tests/unit/out/unsafe/operator_traits.rs | 7 +- tests/unit/out/unsafe/pair_get.rs | 8 +- .../unsafe/redundant_copy_in_conversion.rs | 2 +- tests/unit/out/unsafe/sys_stat.rs | 36 ++++--- .../unit/out/unsafe/vector_iter_range_ctor.rs | 6 +- 13 files changed, 117 insertions(+), 159 deletions(-) diff --git a/tests/unit/out/unsafe/clone_vs_move.rs b/tests/unit/out/unsafe/clone_vs_move.rs index b962a6cfe..39621f0f1 100644 --- a/tests/unit/out/unsafe/clone_vs_move.rs +++ b/tests/unit/out/unsafe/clone_vs_move.rs @@ -169,22 +169,23 @@ unsafe fn main_0() -> i32 { let mut map1: UnsafeMap = UnsafeMap::new(); let mut i: i32 = 0; 'loop_: while ((i) < (N)) { - (*&mut (*map1.get_or_insert_with(i.clone(), || (i, ::default()))).1) = i; + (*map1.get_or_insert_with(i.clone(), || (i, ::default()))).1 = i; i.prefix_inc(); } let mut map2: UnsafeMap = map1.clone(); let mut i: i32 = 0; 'loop_: while ((i) < (N)) { - assert!(((*&mut (*map2.get_or_insert_with(i.clone(), || (i, ::default()))).1) == (i))); - (*&mut (*map2.get_or_insert_with(i.clone(), || (i, ::default()))).1).prefix_inc(); + assert!((((*map2.get_or_insert_with(i.clone(), || (i, ::default()))).1) == (i))); + (*map2.get_or_insert_with(i.clone(), || (i, ::default()))) + .1 + .prefix_inc(); i.prefix_inc(); } let mut i: i32 = 0; 'loop_: while ((i) < (N)) { - assert!(((*&mut (*map1.get_or_insert_with(i.clone(), || (i, ::default()))).1) == (i))); + assert!((((*map1.get_or_insert_with(i.clone(), || (i, ::default()))).1) == (i))); assert!( - ((*&mut (*map2.get_or_insert_with(i.clone(), || (i, ::default()))).1) - == ((i) + (1))) + (((*map2.get_or_insert_with(i.clone(), || (i, ::default()))).1) == ((i) + (1))) ); i.prefix_inc(); } diff --git a/tests/unit/out/unsafe/find.rs b/tests/unit/out/unsafe/find.rs index 7a050d5b1..cc1eba6e5 100644 --- a/tests/unit/out/unsafe/find.rs +++ b/tests/unit/out/unsafe/find.rs @@ -37,9 +37,9 @@ unsafe fn main_0() -> i32 { }; let mut v_result_true: bool = it != v.end(); let mut m: UnsafeMap = UnsafeMap::new(); - (*&mut (*m.get_or_insert_with(1.clone(), || (1, ::default()))).1) = 1_f64; - (*&mut (*m.get_or_insert_with(2.clone(), || (2, ::default()))).1) = 2_f64; - (*&mut (*m.get_or_insert_with(3.clone(), || (3, ::default()))).1) = 3_f64; + (*m.get_or_insert_with(1.clone(), || (1, ::default()))).1 = 1_f64; + (*m.get_or_insert_with(2.clone(), || (2, ::default()))).1 = 2_f64; + (*m.get_or_insert_with(3.clone(), || (3, ::default()))).1 = 3_f64; let mut m_begin: UnsafeBidirectionalIterator<(i32, f64)> = m.begin(); let mut m_end: UnsafeBidirectionalIterator<(i32, f64)> = m.end(); let mut m_result_true: bool = m_begin != m_end; diff --git a/tests/unit/out/unsafe/foreach_map.rs b/tests/unit/out/unsafe/foreach_map.rs index 0e0ea4f17..edebb4d6a 100644 --- a/tests/unit/out/unsafe/foreach_map.rs +++ b/tests/unit/out/unsafe/foreach_map.rs @@ -17,8 +17,7 @@ unsafe fn main_0() -> i32 { let mut i: i32 = 0; let mut k: i32 = 100; 'loop_: while ((i) < (100)) { - (*&mut (*m.get_or_insert_with(i.clone(), || (i, ::default()))).1) = - ((k as f64) / (2_f64)); + (*m.get_or_insert_with(i.clone(), || (i, ::default()))).1 = ((k as f64) / (2_f64)); { i.prefix_inc(); k.prefix_dec() diff --git a/tests/unit/out/unsafe/inet_pton_ntop.rs b/tests/unit/out/unsafe/inet_pton_ntop.rs index 30ef355ba..a3e651dfb 100644 --- a/tests/unit/out/unsafe/inet_pton_ntop.rs +++ b/tests/unit/out/unsafe/inet_pton_ntop.rs @@ -17,19 +17,18 @@ pub unsafe fn test_s6_addr_access_0() { if 16_usize != 0 { ::std::ptr::copy_nonoverlapping( (loopback.as_ptr() as *const ::libc::c_void), - ((*&raw mut (*(&mut addr as *mut ::libc::in6_addr)).s6_addr).as_mut_ptr() + ((*(&mut addr as *mut ::libc::in6_addr)).s6_addr.as_mut_ptr() as *mut ::libc::c_void), 16_usize as usize, ) } - ((*&raw mut (*(&mut addr as *mut ::libc::in6_addr)).s6_addr).as_mut_ptr() - as *mut ::libc::c_void) + ((*(&mut addr as *mut ::libc::in6_addr)).s6_addr.as_mut_ptr() as *mut ::libc::c_void) }; assert!( (((({ let sa = core::slice::from_raw_parts( - ((*&raw mut (*(ap as *mut ::libc::in6_addr)).s6_addr).as_mut_ptr() - as *const ::libc::c_void) as *const u8, + ((*(ap as *mut ::libc::in6_addr)).s6_addr.as_mut_ptr() as *const ::libc::c_void) + as *const u8, 16_usize as usize, ); let sb = core::slice::from_raw_parts( @@ -47,57 +46,49 @@ pub unsafe fn test_s6_addr_access_0() { }) == (0)) as i32) != 0) ); - (*&raw mut (*(&mut addr as *mut ::libc::in6_addr)).s6_addr)[(0) as usize] = 32_u8; - (*&raw mut (*(ap as *mut ::libc::in6_addr)).s6_addr)[(1) as usize] = 1_u8; + (*(&mut addr as *mut ::libc::in6_addr)).s6_addr[(0) as usize] = 32_u8; + (*(ap as *mut ::libc::in6_addr)).s6_addr[(1) as usize] = 1_u8; assert!( - ((((((((*&raw mut (*(&mut addr as *mut ::libc::in6_addr)).s6_addr)[(0) as usize] as i32) - == (32)) as i32) + ((((((((*(&mut addr as *mut ::libc::in6_addr)).s6_addr[(0) as usize] as i32) == (32)) + as i32) != 0) - && (((((*&raw mut (*(ap as *mut ::libc::in6_addr)).s6_addr)[(1) as usize] as i32) - == (1)) as i32) + && (((((*(ap as *mut ::libc::in6_addr)).s6_addr[(1) as usize] as i32) == (1)) as i32) != 0)) as i32) != 0) ); - (*&raw mut (*(&mut addr as *mut ::libc::in6_addr)).s6_addr)[(15) as usize] = - (((*&raw mut (*(&mut addr as *mut ::libc::in6_addr)).s6_addr)[(15) as usize] as i32) + 4) - as u8; - (*&raw mut (*(ap as *mut ::libc::in6_addr)).s6_addr)[(15) as usize].postfix_inc(); + (*(&mut addr as *mut ::libc::in6_addr)).s6_addr[(15) as usize] = + (((*(&mut addr as *mut ::libc::in6_addr)).s6_addr[(15) as usize] as i32) + 4) as u8; + (*(ap as *mut ::libc::in6_addr)).s6_addr[(15) as usize].postfix_inc(); assert!( - (((((*&raw mut (*(&mut addr as *mut ::libc::in6_addr)).s6_addr)[(15) as usize] as i32) - == (6)) as i32) + (((((*(&mut addr as *mut ::libc::in6_addr)).s6_addr[(15) as usize] as i32) == (6)) as i32) != 0) ); - let mut bytes: *mut u8 = - (*&raw mut (*(&mut addr as *mut ::libc::in6_addr)).s6_addr).as_mut_ptr(); + let mut bytes: *mut u8 = (*(&mut addr as *mut ::libc::in6_addr)).s6_addr.as_mut_ptr(); (*bytes.offset((2) as isize)) = 7_u8; assert!( - (((((*&raw mut (*(ap as *mut ::libc::in6_addr)).s6_addr)[(2) as usize] as i32) == (7)) - as i32) - != 0) + (((((*(ap as *mut ::libc::in6_addr)).s6_addr[(2) as usize] as i32) == (7)) as i32) != 0) ); let mut fourth: *mut u8 = - (&mut (*&raw mut (*(ap as *mut ::libc::in6_addr)).s6_addr)[(3) as usize] as *mut u8); + (&mut (*(ap as *mut ::libc::in6_addr)).s6_addr[(3) as usize] as *mut u8); (*fourth) = 8_u8; assert!( - (((((*&raw mut (*(&mut addr as *mut ::libc::in6_addr)).s6_addr)[(3) as usize] as i32) - == (8)) as i32) + (((((*(&mut addr as *mut ::libc::in6_addr)).s6_addr[(3) as usize] as i32) == (8)) as i32) != 0) ); { if 16_usize != 0 { ::std::ptr::copy_nonoverlapping( (loopback.as_ptr() as *const ::libc::c_void), - ((*&raw mut (*(ap as *mut ::libc::in6_addr)).s6_addr).as_mut_ptr() - as *mut ::libc::c_void), + ((*(ap as *mut ::libc::in6_addr)).s6_addr.as_mut_ptr() as *mut ::libc::c_void), 16_usize as usize, ) } - ((*&raw mut (*(ap as *mut ::libc::in6_addr)).s6_addr).as_mut_ptr() as *mut ::libc::c_void) + ((*(ap as *mut ::libc::in6_addr)).s6_addr.as_mut_ptr() as *mut ::libc::c_void) }; assert!( (((({ let sa = core::slice::from_raw_parts( - ((*&raw mut (*(&mut addr as *mut ::libc::in6_addr)).s6_addr).as_mut_ptr() + ((*(&mut addr as *mut ::libc::in6_addr)).s6_addr.as_mut_ptr() as *const ::libc::c_void) as *const u8, 16_usize as usize, ); diff --git a/tests/unit/out/unsafe/map-reallocation.rs b/tests/unit/out/unsafe/map-reallocation.rs index 8b3bddbd8..796378625 100644 --- a/tests/unit/out/unsafe/map-reallocation.rs +++ b/tests/unit/out/unsafe/map-reallocation.rs @@ -16,7 +16,7 @@ unsafe fn main_0() -> i32 { let N: i32 = 10000; let sentinel: i32 = ((N) / (2)); let mut m: UnsafeMap = UnsafeMap::new(); - (*&mut (*m.get_or_insert_with(sentinel.clone(), || (sentinel, ::default()))).1) = sentinel; + (*m.get_or_insert_with(sentinel.clone(), || (sentinel, ::default()))).1 = sentinel; let mut it: UnsafeBidirectionalIterator<(i32, i32)> = m.find(&sentinel); let mut p: *mut i32 = (&mut (*it.iter_deref()).1 as *mut i32); assert!( @@ -29,12 +29,12 @@ unsafe fn main_0() -> i32 { ); let mut i: i32 = 0; 'loop_: while ((i) < (sentinel)) { - (*&mut (*m.get_or_insert_with(i.clone(), || (i, ::default()))).1) = i; + (*m.get_or_insert_with(i.clone(), || (i, ::default()))).1 = i; i.prefix_inc(); } let mut i: i32 = ((sentinel) + (1)); 'loop_: while ((i) <= (N)) { - (*&mut (*m.get_or_insert_with(i.clone(), || (i, ::default()))).1) = i; + (*m.get_or_insert_with(i.clone(), || (i, ::default()))).1 = i; i.prefix_inc(); } assert!( @@ -52,8 +52,7 @@ unsafe fn main_0() -> i32 { ); (*it.iter_deref()).1 = 57005; assert!( - ((*&mut (*m.get_or_insert_with(sentinel.clone(), || (sentinel, ::default()))).1) - == (57005)) + (((*m.get_or_insert_with(sentinel.clone(), || (sentinel, ::default()))).1) == (57005)) ); assert!(((*p) == (57005))); assert!(((m.len()) == ((((N) + (1)) as u32) as usize))); diff --git a/tests/unit/out/unsafe/map.rs b/tests/unit/out/unsafe/map.rs index 58d16941c..bc2dc162a 100644 --- a/tests/unit/out/unsafe/map.rs +++ b/tests/unit/out/unsafe/map.rs @@ -20,51 +20,27 @@ pub fn main() { } unsafe fn main_0() -> i32 { let mut m: UnsafeMap = UnsafeMap::new(); - (*&mut (*m.get_or_insert_with(0_i16.clone(), || (0_i16, ::default()))).1) = 1_u32; - (*&mut (*m.get_or_insert_with(1_i16.clone(), || (1_i16, ::default()))).1) = 2_u32; - (*&mut (*m.get_or_insert_with(2_i16.clone(), || (2_i16, ::default()))).1) = 3_u32; + (*m.get_or_insert_with(0_i16.clone(), || (0_i16, ::default()))).1 = 1_u32; + (*m.get_or_insert_with(1_i16.clone(), || (1_i16, ::default()))).1 = 2_u32; + (*m.get_or_insert_with(2_i16.clone(), || (2_i16, ::default()))).1 = 3_u32; assert!(((m.len()) == (3_usize))); - assert!( - ((*&mut (*m.get_or_insert_with(0_i16.clone(), || (0_i16, ::default()))).1) == (1_u32)) - ); - assert!( - ((*&mut (*m.get_or_insert_with(1_i16.clone(), || (1_i16, ::default()))).1) == (2_u32)) - ); - assert!( - ((*&mut (*m.get_or_insert_with(2_i16.clone(), || (2_i16, ::default()))).1) == (3_u32)) - ); + assert!((((*m.get_or_insert_with(0_i16.clone(), || (0_i16, ::default()))).1) == (1_u32))); + assert!((((*m.get_or_insert_with(1_i16.clone(), || (1_i16, ::default()))).1) == (2_u32))); + assert!((((*m.get_or_insert_with(2_i16.clone(), || (2_i16, ::default()))).1) == (3_u32))); let mut x: i32 = 4; - (*&mut (*m.get_or_insert_with(1_i16.clone(), || (1_i16, ::default()))).1) = (x as u32); + (*m.get_or_insert_with(1_i16.clone(), || (1_i16, ::default()))).1 = (x as u32); assert!(((m.len()) == (3_usize))); - assert!( - ((*&mut (*m.get_or_insert_with(0_i16.clone(), || (0_i16, ::default()))).1) == (1_u32)) - ); - assert!( - ((*&mut (*m.get_or_insert_with(1_i16.clone(), || (1_i16, ::default()))).1) == (4_u32)) - ); - assert!( - ((*&mut (*m.get_or_insert_with(2_i16.clone(), || (2_i16, ::default()))).1) == (3_u32)) - ); - (unsafe { - foo_0((*&mut (*m.get_or_insert_with(0_i16.clone(), || (0_i16, ::default()))).1)) - }); - assert!( - ((*&mut (*m.get_or_insert_with(0_i16.clone(), || (0_i16, ::default()))).1) == (1_u32)) - ); - (unsafe { - bar_1(&mut (*&mut (*m.get_or_insert_with(2_i16.clone(), || (2_i16, ::default()))).1)) - }); - assert!( - ((*&mut (*m.get_or_insert_with(2_i16.clone(), || (2_i16, ::default()))).1) == (4_u32)) - ); - (*&mut (*m.get_or_insert_with(0_i16.clone(), || (0_i16, ::default()))).1) = - (*&mut (*m.get_or_insert_with(0_i16.clone(), || (0_i16, ::default()))).1) - .wrapping_add( - (*&mut (*m.get_or_insert_with(2_i16.clone(), || (2_i16, ::default()))).1), - ); - assert!( - ((*&mut (*m.get_or_insert_with(0_i16.clone(), || (0_i16, ::default()))).1) == (5_u32)) - ); + assert!((((*m.get_or_insert_with(0_i16.clone(), || (0_i16, ::default()))).1) == (1_u32))); + assert!((((*m.get_or_insert_with(1_i16.clone(), || (1_i16, ::default()))).1) == (4_u32))); + assert!((((*m.get_or_insert_with(2_i16.clone(), || (2_i16, ::default()))).1) == (3_u32))); + (unsafe { foo_0((*m.get_or_insert_with(0_i16.clone(), || (0_i16, ::default()))).1) }); + assert!((((*m.get_or_insert_with(0_i16.clone(), || (0_i16, ::default()))).1) == (1_u32))); + (unsafe { bar_1(&mut (*m.get_or_insert_with(2_i16.clone(), || (2_i16, ::default()))).1) }); + assert!((((*m.get_or_insert_with(2_i16.clone(), || (2_i16, ::default()))).1) == (4_u32))); + (*m.get_or_insert_with(0_i16.clone(), || (0_i16, ::default()))).1 = + ((*m.get_or_insert_with(0_i16.clone(), || (0_i16, ::default()))).1) + .wrapping_add((*m.get_or_insert_with(2_i16.clone(), || (2_i16, ::default()))).1); + assert!((((*m.get_or_insert_with(0_i16.clone(), || (0_i16, ::default()))).1) == (5_u32))); let mut end: UnsafeBidirectionalIterator<(i16, u32)> = m.end(); let mut it: UnsafeBidirectionalIterator<(i16, u32)> = m.find(&1_i16); let mut const_it: UnsafeBidirectionalIterator<(i16, u32)> = @@ -94,20 +70,16 @@ unsafe fn main_0() -> i32 { (*const_it.iter_deref()).1 }; assert!(((x4) == (0_u32))); - (*&mut (*m.get_or_insert_with(4_i16.clone(), || (4_i16, ::default()))).1) = 5_u32; + (*m.get_or_insert_with(4_i16.clone(), || (4_i16, ::default()))).1 = 5_u32; let mut it4: UnsafeBidirectionalIterator<(i16, u32)> = m.find(&4_i16); let mut p: *mut u32 = (&mut (*it4.iter_deref()).1 as *mut u32); let mut x5: u32 = (*p); - assert!( - ((*&mut (*m.get_or_insert_with(4_i16.clone(), || (4_i16, ::default()))).1) == (5_u32)) - ); + assert!((((*m.get_or_insert_with(4_i16.clone(), || (4_i16, ::default()))).1) == (5_u32))); assert!((((*it4.iter_deref()).1) == (5_u32))); assert!(((*p) == (5_u32))); assert!(((x5) == (5_u32))); (*p).prefix_inc(); - assert!( - ((*&mut (*m.get_or_insert_with(4_i16.clone(), || (4_i16, ::default()))).1) == (6_u32)) - ); + assert!((((*m.get_or_insert_with(4_i16.clone(), || (4_i16, ::default()))).1) == (6_u32))); assert!((((*it4.iter_deref()).1) == (6_u32))); assert!(((*p) == (6_u32))); assert!(((x5) == (5_u32))); @@ -120,9 +92,9 @@ unsafe fn main_0() -> i32 { (*r).erase(&(it4).clone()); assert!((((*r).len()) == (3_usize))); assert!(m.find(&4_i16) == m.end()); - (*&mut (*m.get_or_insert_with(7_i16.clone(), || (7_i16, ::default()))).1) = 7_u32; - (*&mut (*m.get_or_insert_with(8_i16.clone(), || (8_i16, ::default()))).1) = 8_u32; - (*&mut (*m.get_or_insert_with(9_i16.clone(), || (9_i16, ::default()))).1) = 9_u32; + (*m.get_or_insert_with(7_i16.clone(), || (7_i16, ::default()))).1 = 7_u32; + (*m.get_or_insert_with(8_i16.clone(), || (8_i16, ::default()))).1 = 8_u32; + (*m.get_or_insert_with(9_i16.clone(), || (9_i16, ::default()))).1 = 9_u32; assert!((((*r).len()) == (6_usize))); assert!(((m.erase_key(&10_i16)) == (0_usize))); let mut key9: i32 = 9; @@ -140,20 +112,19 @@ unsafe fn main_0() -> i32 { assert!(((other_map.len()) == (0_usize))); let mut key0: (i32, i64) = (1.into(), 1.into()); let mut value: f64 = 2_f64; - (*&mut (*other_map.get_or_insert_with(key0.clone(), || (key0, ::default()))).1) = value; - value = (*&mut (*other_map.get_or_insert_with(key0.clone(), || (key0, ::default()))).1); + (*other_map.get_or_insert_with(key0.clone(), || (key0, ::default()))).1 = value; + value = (*other_map.get_or_insert_with(key0.clone(), || (key0, ::default()))).1; assert!(((other_map.len()) == (1_usize))); assert!( - ((*&mut (*other_map.get_or_insert_with(key0.clone(), || (key0, ::default()))).1) - == (value)) + (((*other_map.get_or_insert_with(key0.clone(), || (key0, ::default()))).1) == (value)) ); assert!(((m.len()) == (3_usize))); let mut k: i32 = 0; - assert!(((*&raw const (*m.get(&(k as i16)).expect("out of range!")).1) == (5_u32))); + assert!((((*m.get(&(k as i16)).expect("out of range!")).1) == (5_u32))); k.prefix_inc(); - assert!(((*&raw const (*m.get(&(k as i16)).expect("out of range!")).1) == (4_u32))); + assert!((((*m.get(&(k as i16)).expect("out of range!")).1) == (4_u32))); k.prefix_inc(); - assert!(((*&raw const (*m.get(&(k as i16)).expect("out of range!")).1) == (4_u32))); + assert!((((*m.get(&(k as i16)).expect("out of range!")).1) == (4_u32))); let mut m2: UnsafeMap = UnsafeMap::new(); assert!(((m2.len()) == (0_usize))); let mut indexes: Vec = Vec::new(); @@ -183,10 +154,10 @@ unsafe fn main_0() -> i32 { } let mut i: u32 = 0_u32; 'loop_: while ((i as usize) < (indexes.len())) { - (*&mut (*m2.get_or_insert_with(indexes[(i as usize)].clone(), || { + (*m2.get_or_insert_with(indexes[(i as usize)].clone(), || { (indexes[(i as usize)], ::default()) })) - .1) = ((i).wrapping_rem(2_u32) != 0); + .1 = ((i).wrapping_rem(2_u32) != 0); i.prefix_inc(); } assert!(((m2.len()) == (indexes.len()))); diff --git a/tests/unit/out/unsafe/map_copy.rs b/tests/unit/out/unsafe/map_copy.rs index 44337897b..81effc1f0 100644 --- a/tests/unit/out/unsafe/map_copy.rs +++ b/tests/unit/out/unsafe/map_copy.rs @@ -14,15 +14,15 @@ pub fn main() { } unsafe fn main_0() -> i32 { let mut a: UnsafeMap = UnsafeMap::new(); - (*&mut (*a.get_or_insert_with(1.clone(), || (1, ::default()))).1) = 10; + (*a.get_or_insert_with(1.clone(), || (1, ::default()))).1 = 10; let mut b: UnsafeMap = a.clone(); - (*&mut (*b.get_or_insert_with(1.clone(), || (1, ::default()))).1) = 20; - assert!(((*&mut (*a.get_or_insert_with(1.clone(), || (1, ::default()))).1) == (10))); + (*b.get_or_insert_with(1.clone(), || (1, ::default()))).1 = 20; + assert!((((*a.get_or_insert_with(1.clone(), || (1, ::default()))).1) == (10))); let mut x: UnsafeMap = UnsafeMap::new(); - (*&mut (*x.get_or_insert_with(2.clone(), || (2, ::default()))).1) = 3; + (*x.get_or_insert_with(2.clone(), || (2, ::default()))).1 = 3; let mut y: UnsafeMap = x.clone(); - (*&mut (*y.get_or_insert_with(2.clone(), || (2, ::default()))).1) = 4; - assert!(((*&mut (*x.get_or_insert_with(2.clone(), || (2, ::default()))).1) == (3))); + (*y.get_or_insert_with(2.clone(), || (2, ::default()))).1 = 4; + assert!((((*x.get_or_insert_with(2.clone(), || (2, ::default()))).1) == (3))); return 0; } pub unsafe fn __cpp2rust_init_globals() {} diff --git a/tests/unit/out/unsafe/map_key_identity.rs b/tests/unit/out/unsafe/map_key_identity.rs index 9d82b0548..2ee2c8f5d 100644 --- a/tests/unit/out/unsafe/map_key_identity.rs +++ b/tests/unit/out/unsafe/map_key_identity.rs @@ -84,9 +84,9 @@ unsafe fn main_0() -> i32 { }) as i32)) != 0; let mut distinct: UnsafeMap = UnsafeMap::new(); - let a: *mut Mapped = &mut (*&mut (*distinct + let a: *mut Mapped = &mut (*distinct .get_or_insert_with(distinct_a.clone(), || (distinct_a, ::default()))) - .1); + .1; (*a).value = 11; let mut a_it: UnsafeBidirectionalIterator<(Key, Mapped)> = distinct.find(&distinct_a); let mut a_value: *mut Mapped = (&mut (*a_it.iter_deref()).1 as *mut Mapped); @@ -94,9 +94,9 @@ unsafe fn main_0() -> i32 { & (((*std::cell::LazyCell::force_mut(&mut *&raw mut default_constructions_0)) == (1)) as i32)) != 0; - let b: *mut Mapped = &mut (*&mut (*distinct + let b: *mut Mapped = &mut (*distinct .get_or_insert_with(distinct_b.clone(), || (distinct_b, ::default()))) - .1); + .1; (*b).value = 22; let mut b_it: UnsafeBidirectionalIterator<(Key, Mapped)> = distinct.find(&distinct_b); ok = ((ok as i32) @@ -149,9 +149,9 @@ unsafe fn main_0() -> i32 { let mut equivalent: UnsafeMap = UnsafeMap::new(); let before_equivalent: i32 = (*std::cell::LazyCell::force_mut(&mut *&raw mut default_constructions_0)); - let first: *mut Mapped = &mut (*&mut (*equivalent + let first: *mut Mapped = &mut (*equivalent .get_or_insert_with(equivalent_a.clone(), || (equivalent_a, ::default()))) - .1); + .1; (*first).value = 31; let mut first_it: UnsafeBidirectionalIterator<(Key, Mapped)> = equivalent.find(&equivalent_a); let mut first_value: *mut Mapped = (&mut (*first_it.iter_deref()).1 as *mut Mapped); @@ -159,9 +159,9 @@ unsafe fn main_0() -> i32 { & (((*std::cell::LazyCell::force_mut(&mut *&raw mut default_constructions_0)) == ((before_equivalent) + (1))) as i32)) != 0; - let second: *mut Mapped = &mut (*&mut (*equivalent + let second: *mut Mapped = &mut (*equivalent .get_or_insert_with(equivalent_b.clone(), || (equivalent_b, ::default()))) - .1); + .1; let reused: bool = ((*std::cell::LazyCell::force_mut(&mut *&raw mut default_constructions_0)) == ((before_equivalent) + (1))); ok = ((ok as i32) & (reused as i32)) != 0; @@ -198,9 +198,9 @@ unsafe fn main_0() -> i32 { order: 4, identity: 10, }; - let later: *mut Mapped = &mut (*&mut (*equivalent + let later: *mut Mapped = &mut (*equivalent .get_or_insert_with(later_key.clone(), || (later_key, ::default()))) - .1); + .1; (*later).value = 41; ok = ((ok as i32) & (((*std::cell::LazyCell::force_mut(&mut *&raw mut default_constructions_0)) @@ -229,9 +229,9 @@ unsafe fn main_0() -> i32 { let before_matching: i32 = (*std::cell::LazyCell::force_mut(&mut *&raw mut default_constructions_0)); let mut matching: UnsafeMap = UnsafeMap::new(); - let matched: *mut Mapped = &mut (*&mut (*matching + let matched: *mut Mapped = &mut (*matching .get_or_insert_with(matching_a.clone(), || (matching_a, ::default()))) - .1); + .1; (*matched).value = 51; let mut matched_it: UnsafeBidirectionalIterator<(Key, Mapped)> = matching.find(&matching_a); let mut matched_value: *mut Mapped = (&mut (*matched_it.iter_deref()).1 as *mut Mapped); @@ -239,9 +239,9 @@ unsafe fn main_0() -> i32 { & (((*std::cell::LazyCell::force_mut(&mut *&raw mut default_constructions_0)) == ((before_matching) + (1))) as i32)) != 0; - let matched_again: *mut Mapped = &mut (*&mut (*matching + let matched_again: *mut Mapped = &mut (*matching .get_or_insert_with(matching_b.clone(), || (matching_b, ::default()))) - .1); + .1; ok = ((ok as i32) & (((*std::cell::LazyCell::force_mut(&mut *&raw mut default_constructions_0)) == ((before_matching) + (1))) as i32)) @@ -253,9 +253,9 @@ unsafe fn main_0() -> i32 { & (((&mut (*matched_it.iter_deref()).1 as *mut Mapped) == (matched_value)) as i32)) != 0; ok = ((ok as i32) & ((((*matched_it.iter_deref()).1.value) == (51)) as i32)) != 0; - let other: *mut Mapped = &mut (*&mut (*matching + let other: *mut Mapped = &mut (*matching .get_or_insert_with(matching_c.clone(), || (matching_c, ::default()))) - .1); + .1; (*other).value = 61; ok = ((ok as i32) & (((*std::cell::LazyCell::force_mut(&mut *&raw mut default_constructions_0)) diff --git a/tests/unit/out/unsafe/operator_traits.rs b/tests/unit/out/unsafe/operator_traits.rs index 2fbe26e8c..993c95d07 100644 --- a/tests/unit/out/unsafe/operator_traits.rs +++ b/tests/unit/out/unsafe/operator_traits.rs @@ -230,12 +230,11 @@ unsafe fn main_0() -> i32 { .v) == (2)) ); let mut m: UnsafeMap = UnsafeMap::new(); - (*&mut (*m.get_or_insert_with(Lt { v: 2 }.clone(), || (Lt { v: 2 }, ::default()))).1) = 20; - (*&mut (*m.get_or_insert_with(Lt { v: 1 }.clone(), || (Lt { v: 1 }, ::default()))).1) = 10; + (*m.get_or_insert_with(Lt { v: 2 }.clone(), || (Lt { v: 2 }, ::default()))).1 = 20; + (*m.get_or_insert_with(Lt { v: 1 }.clone(), || (Lt { v: 1 }, ::default()))).1 = 10; assert!((((*m.begin().iter_deref()).1) == (10))); assert!( - ((*&mut (*m.get_or_insert_with(Lt { v: 2 }.clone(), || (Lt { v: 2 }, ::default()))) - .1) + (((*m.get_or_insert_with(Lt { v: 2 }.clone(), || (Lt { v: 2 }, ::default()))).1) == (20)) ); return 0; diff --git a/tests/unit/out/unsafe/pair_get.rs b/tests/unit/out/unsafe/pair_get.rs index 671010f58..2a5bf44c7 100644 --- a/tests/unit/out/unsafe/pair_get.rs +++ b/tests/unit/out/unsafe/pair_get.rs @@ -7,10 +7,10 @@ use std::io::{Read, Seek, Write}; use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; use std::rc::Rc; pub unsafe fn second_of_0(p: *const (f64, i32)) -> i32 { - return (*&(*p).1); + return (*p).1; } pub unsafe fn first_of_1(p: *const (f64, i32)) -> f64 { - return (*&(*p).0); + return (*p).0; } pub fn main() { unsafe { @@ -20,8 +20,8 @@ pub fn main() { } unsafe fn main_0() -> i32 { let mut p: (f64, i32) = (1.5_f64.into(), 2.into()); - assert!(((*&mut p.0) == (1.5_f64))); - assert!(((*&mut p.1) == (2))); + assert!(((p.0) == (1.5_f64))); + assert!(((p.1) == (2))); assert!(((unsafe { first_of_1(&p,) }) == (1.5_f64))); assert!(((unsafe { second_of_0(&p,) }) == (2))); return 0; diff --git a/tests/unit/out/unsafe/redundant_copy_in_conversion.rs b/tests/unit/out/unsafe/redundant_copy_in_conversion.rs index 307b0ed28..00c27aa61 100644 --- a/tests/unit/out/unsafe/redundant_copy_in_conversion.rs +++ b/tests/unit/out/unsafe/redundant_copy_in_conversion.rs @@ -23,7 +23,7 @@ pub fn main() { } unsafe fn main_0() -> i32 { let mut m: UnsafeMap = UnsafeMap::new(); - (*&mut (*m.get_or_insert_with(0.clone(), || (0, ::default()))).1) = 1; + (*m.get_or_insert_with(0.clone(), || (0, ::default()))).1 = 1; let mut end: UnsafeBidirectionalIterator<(i32, i32)> = m.end(); let mut it0: UnsafeBidirectionalIterator<(i32, i32)> = m.find(&0); let mut const_it: UnsafeBidirectionalIterator<(i32, i32)> = diff --git a/tests/unit/out/unsafe/sys_stat.rs b/tests/unit/out/unsafe/sys_stat.rs index a6930e034..e77e7f74f 100644 --- a/tests/unit/out/unsafe/sys_stat.rs +++ b/tests/unit/out/unsafe/sys_stat.rs @@ -16,7 +16,7 @@ pub unsafe fn test_stat_0() { let mut st: ::libc::stat = unsafe { std::mem::zeroed() }; assert!(((((libc::stat(path, (&mut st as *mut ::libc::stat))) == (0)) as i32) != 0)); assert!(((((st.st_size) == (5_i64)) as i32) != 0)); - assert!(((((*&raw mut (*(&mut st as *mut ::libc::stat)).st_mtime) > (0_i64)) as i32) != 0)); + assert!((((((*(&mut st as *mut ::libc::stat)).st_mtime) > (0_i64)) as i32) != 0)); libc::unlink(path); } pub unsafe fn test_fstat_1() { @@ -30,33 +30,31 @@ pub unsafe fn test_fstat_1() { let mut st: ::libc::stat = unsafe { std::mem::zeroed() }; assert!(((((libc::fstat(fd, (&mut st as *mut ::libc::stat))) == (0)) as i32) != 0)); assert!(((((st.st_size) == (11_i64)) as i32) != 0)); - assert!(((((*&raw mut (*(&mut st as *mut ::libc::stat)).st_mtime) > (0_i64)) as i32) != 0)); + assert!((((((*(&mut st as *mut ::libc::stat)).st_mtime) > (0_i64)) as i32) != 0)); assert!(((((libc::fclose(fp)) == (0)) as i32) != 0)); libc::unlink(path); } pub unsafe fn test_st_mtime_access_2() { let mut st: ::libc::stat = unsafe { std::mem::zeroed() }; let mut sp: *mut ::libc::stat = (&mut st as *mut ::libc::stat); - (*&raw mut (*(&mut st as *mut ::libc::stat)).st_mtime) = 5_i64; - assert!(((((*&raw mut (*(&mut st as *mut ::libc::stat)).st_mtime) == (5_i64)) as i32) != 0)); - (*&raw mut (*(sp as *mut ::libc::stat)).st_mtime) = 6_i64; - assert!(((((*&raw mut (*(sp as *mut ::libc::stat)).st_mtime) == (6_i64)) as i32) != 0)); - (*&raw mut (*(&mut st as *mut ::libc::stat)).st_mtime) += 2_i64; - assert!(((((*&raw mut (*(&mut st as *mut ::libc::stat)).st_mtime) == (8_i64)) as i32) != 0)); - (*&raw mut (*(sp as *mut ::libc::stat)).st_mtime) -= 1_i64; - assert!(((((*&raw mut (*(sp as *mut ::libc::stat)).st_mtime) == (7_i64)) as i32) != 0)); - (*&raw mut (*(&mut st as *mut ::libc::stat)).st_mtime).postfix_inc(); - (*&raw mut (*(sp as *mut ::libc::stat)).st_mtime).prefix_inc(); - assert!(((((*&raw mut (*(&mut st as *mut ::libc::stat)).st_mtime) == (9_i64)) as i32) != 0)); - let mut mtime: *mut i64 = - (&mut (*&raw mut (*(&mut st as *mut ::libc::stat)).st_mtime) as *mut i64); + (*(&mut st as *mut ::libc::stat)).st_mtime = 5_i64; + assert!((((((*(&mut st as *mut ::libc::stat)).st_mtime) == (5_i64)) as i32) != 0)); + (*(sp as *mut ::libc::stat)).st_mtime = 6_i64; + assert!((((((*(sp as *mut ::libc::stat)).st_mtime) == (6_i64)) as i32) != 0)); + (*(&mut st as *mut ::libc::stat)).st_mtime += 2_i64; + assert!((((((*(&mut st as *mut ::libc::stat)).st_mtime) == (8_i64)) as i32) != 0)); + (*(sp as *mut ::libc::stat)).st_mtime -= 1_i64; + assert!((((((*(sp as *mut ::libc::stat)).st_mtime) == (7_i64)) as i32) != 0)); + (*(&mut st as *mut ::libc::stat)).st_mtime.postfix_inc(); + (*(sp as *mut ::libc::stat)).st_mtime.prefix_inc(); + assert!((((((*(&mut st as *mut ::libc::stat)).st_mtime) == (9_i64)) as i32) != 0)); + let mut mtime: *mut i64 = (&mut (*(&mut st as *mut ::libc::stat)).st_mtime as *mut i64); (*mtime) = 10_i64; - assert!(((((*&raw mut (*(&mut st as *mut ::libc::stat)).st_mtime) == (10_i64)) as i32) != 0)); - let mut mtime_via_ptr: *mut i64 = - (&mut (*&raw mut (*(sp as *mut ::libc::stat)).st_mtime) as *mut i64); + assert!((((((*(&mut st as *mut ::libc::stat)).st_mtime) == (10_i64)) as i32) != 0)); + let mut mtime_via_ptr: *mut i64 = (&mut (*(sp as *mut ::libc::stat)).st_mtime as *mut i64); (*mtime_via_ptr) = 11_i64; assert!(((((*mtime) == (11_i64)) as i32) != 0)); - let mut copy: i64 = (*&raw mut (*(sp as *mut ::libc::stat)).st_mtime); + let mut copy: i64 = (*(sp as *mut ::libc::stat)).st_mtime; assert!(((((copy) == (11_i64)) as i32) != 0)); } pub fn main() { diff --git a/tests/unit/out/unsafe/vector_iter_range_ctor.rs b/tests/unit/out/unsafe/vector_iter_range_ctor.rs index 5e966cba9..91c0804cd 100644 --- a/tests/unit/out/unsafe/vector_iter_range_ctor.rs +++ b/tests/unit/out/unsafe/vector_iter_range_ctor.rs @@ -83,9 +83,9 @@ unsafe fn main_0() -> i32 { assert!(((v5.len()) == (5_usize))); assert!(((v5[(0_usize)] as i32) == (10)) && ((v5[(4_usize)] as i32) == (50))); let mut m: UnsafeMap = UnsafeMap::new(); - (*&mut (*m.get_or_insert_with(1.clone(), || (1, ::default()))).1) = 10; - (*&mut (*m.get_or_insert_with(2.clone(), || (2, ::default()))).1) = 20; - (*&mut (*m.get_or_insert_with(3.clone(), || (3, ::default()))).1) = 30; + (*m.get_or_insert_with(1.clone(), || (1, ::default()))).1 = 10; + (*m.get_or_insert_with(2.clone(), || (2, ::default()))).1 = 20; + (*m.get_or_insert_with(3.clone(), || (3, ::default()))).1 = 30; let mut v6: Vec<(i32, i32)> = { let mut __v = Vec::new(); let mut __it = m.begin(); From 859a8796ca24f128f4e4c853b0bb1ba1e2f19696 Mon Sep 17 00:00:00 2001 From: Lucian Popescu Date: Tue, 20 Oct 2026 13:24:18 +0100 Subject: [PATCH 3/3] Revert unwanted change --- cpp2rust/converter/converter.cpp | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/cpp2rust/converter/converter.cpp b/cpp2rust/converter/converter.cpp index 0818da69e..9774cf451 100644 --- a/cpp2rust/converter/converter.cpp +++ b/cpp2rust/converter/converter.cpp @@ -3411,8 +3411,7 @@ bool Converter::VisitMemberExpr(clang::MemberExpr *expr) { if (is_reference_type || RuleRegistry::ReturnsPointer(ctx_, expr)) { computed_expr_type_ = ComputedExprType::Pointer; } else { - StrCat(token::kRef, - expr->getType().isConstQualified() ? "" : keyword_mut_); + StrCat(token::kRef); computed_expr_type_ = ComputedExprType::FreshPointer; } StrCat(str);