Use raw borrows instead of normal borrows

Author: Rua

c2rust-ast-builder/src/builder.rs

@@ -9,7 +9,7 @@ use syn::{__private::ToTokens, punctuated::Punctuated, *};
 
 pub mod properties {
     use proc_macro2::Span;
-    use syn::{StaticMutability, Token};
+    use syn::{PointerMutability, StaticMutability, Token};
 
     pub trait ToToken {
         type Token;
@@ -33,6 +33,13 @@ pub mod properties {
     }
 
     impl Mutability {
+        pub fn to_pointer_mutability(&self, span: Span) -> PointerMutability {
+            match self {
+                Mutability::Mutable => PointerMutability::Mut(Token![mut](span)),
+                Mutability::Immutable => PointerMutability::Const(Token![const](span)),
+            }
+        }
+
         pub fn to_static_mutability(&self, span: Span) -> StaticMutability {
             match self {
                 Mutability::Mutable => StaticMutability::Mut(Token![mut](span)),
@@ -953,7 +960,7 @@ impl Builder {
         self.path_expr(vec![name])
     }
 
-    pub fn addr_of_expr(self, e: Box<Expr>) -> Box<Expr> {
+    pub fn borrow_expr(self, e: Box<Expr>) -> Box<Expr> {
         Box::new(parenthesize_if_necessary(Expr::Reference(ExprReference {
             attrs: self.attrs,
             and_token: Token![&](self.span),
@@ -962,6 +969,16 @@ impl Builder {
         })))
     }
 
+    pub fn raw_borrow_expr(self, e: Box<Expr>) -> Box<Expr> {
+        Box::new(parenthesize_if_necessary(Expr::RawAddr(ExprRawAddr {
+            attrs: self.attrs,
+            and_token: Token![&](self.span),
+            raw: Token![raw](self.span),
+            mutability: self.mutbl.to_pointer_mutability(self.span),
+            expr: e,
+        })))
+    }
+
     pub fn mac_expr(self, mac: Macro) -> Box<Expr> {
         Box::new(Expr::Macro(ExprMacro {
             attrs: self.attrs,

c2rust-transpile/src/translator/assembly.rs

@@ -819,7 +819,7 @@ impl<'c> Translation<'c> {
                     // c2rust-ast-exporter added it (there's no gcc equivalent);
                     // in this case, we need to do what clang does and pass in
                     // the operand by-address instead of by-value
-                    out_expr = mk().mutbl().addr_of_expr(out_expr);
+                    out_expr = mk().mutbl().borrow_expr(out_expr);
                 }
 
                 if let Some(_tied_operand) = tied_operands.get(&(output_idx, true)) {
@@ -836,7 +836,7 @@ impl<'c> Translation<'c> {
                     let output_local = mk().local(
                         mk().ident_pat(&output_name),
                         None,
-                        Some(mk().mutbl().addr_of_expr(out_expr)),
+                        Some(mk().mutbl().borrow_expr(out_expr)),
                     );
                     stmts.push(mk().local_stmt(Box::new(output_local)));
 
@@ -860,7 +860,7 @@ impl<'c> Translation<'c> {
                 let mut in_expr = in_expr.into_value();
 
                 if operand.mem_only {
-                    in_expr = mk().addr_of_expr(in_expr);
+                    in_expr = mk().borrow_expr(in_expr);
                 }
                 if let Some(tied_operand) = tied_operands.get(&(input_idx, false)) {
                     self.use_crate(ExternCrate::C2RustAsmCasts);

c2rust-transpile/src/translator/mod.rs

@@ -2979,12 +2979,8 @@ impl<'c> Translation<'c> {
                 }
             }
             _ => {
-                let addr_lhs = mk().set_mutbl(mutbl).addr_of_expr(lhs);
-
-                let lhs_type = self.convert_type(lhs_type.ctype)?;
-                let ty = mk().set_mutbl(mutbl).ptr_ty(lhs_type);
-
-                mk().cast_expr(addr_lhs, ty)
+                self.use_feature("raw_ref_op");
+                mk().set_mutbl(mutbl).raw_borrow_expr(lhs)
             }
         };
         Ok(addr_lhs)
@@ -4512,25 +4508,19 @@ impl<'c> Translation<'c> {
                         {
                             Ok(val)
                         } else {
-                            let method = if is_const || ctx.is_static {
-                                "as_ptr"
+                            let mutbl = if is_const {
+                                Mutability::Immutable
                             } else {
-                                "as_mut_ptr"
+                                Mutability::Mutable
                             };
-
-                            let call = val.map(|x| mk().method_call_expr(x, method, vec![]));
-
-                            // Static arrays can now use as_ptr. Can also cast that const ptr to a
-                            // mutable pointer as we do here:
-                            if ctx.is_static && !is_const {
-                                return Ok(call.map(|val| {
-                                    let inferred_type = mk().infer_ty();
-                                    let ptr_type = mk().mutbl().ptr_ty(inferred_type);
-                                    mk().cast_expr(val, ptr_type)
-                                }));
-                            }
-
-                            Ok(call)
+                            let target_ty = self.convert_type(ty.ctype)?;
+
+                            Ok(val.map(|x| {
+                                self.use_feature("raw_ref_op");
+                                let borrow = mk().set_mutbl(mutbl).raw_borrow_expr(x);
+                                // TODO: Change to call `ptr::as_[mut]_ptr` once that is available.
+                                mk().cast_expr(borrow, target_ty)
+                            }))
                         }
                     }
                 }

c2rust-transpile/src/translator/operators.rs

@@ -901,7 +901,6 @@ impl<'c> Translation<'c> {
         lrvalue: LRValue,
     ) -> TranslationResult<WithStmts<Box<Expr>>> {
         let CQualTypeId { ctype, .. } = cqual_type;
-        let ty = self.convert_type(ctype)?;
         let resolved_ctype = self.ast_context.resolve_type(ctype);
 
         let mut unary = match name {
@@ -942,35 +941,8 @@ impl<'c> Translation<'c> {
                         Mutability::Mutable
                     };
 
-                    arg.result_map(|a| {
-                        let mut addr_of_arg: Box<Expr>;
-
-                        if ctx.is_static {
-                            // static variable initializers aren't able to use &mut,
-                            // so we work around that by using & and an extra cast
-                            // through & to *const to *mut
-                            addr_of_arg = mk().addr_of_expr(a);
-                            if let Mutability::Mutable = mutbl {
-                                let mut qtype = pointee_ty;
-                                qtype.qualifiers.is_const = true;
-                                let ty_ = self
-                                    .type_converter
-                                    .borrow_mut()
-                                    .convert_pointer(&self.ast_context, qtype)?;
-                                addr_of_arg = mk().cast_expr(addr_of_arg, ty_);
-                            }
-                        } else {
-                            // Normal case is allowed to use &mut if needed
-                            addr_of_arg = mk().set_mutbl(mutbl).addr_of_expr(a);
-
-                            // Avoid unnecessary reference to pointer decay in fn call args:
-                            if ctx.decay_ref.is_no() {
-                                return Ok(addr_of_arg);
-                            }
-                        }
-
-                        Ok(mk().cast_expr(addr_of_arg, ty))
-                    })
+                    self.use_feature("raw_ref_op");
+                    Ok(arg.map(|a| mk().set_mutbl(mutbl).raw_borrow_expr(a)))
                 }
             }
             c_ast::UnOp::PreIncrement => self.convert_pre_increment(ctx, cqual_type, true, arg),