ast-builder: Add support for raw borrows

Author: Rua

c2rust-ast-builder/src/builder.rs

@@ -10,7 +10,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;
@@ -34,6 +34,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)),
@@ -826,7 +833,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),
@@ -835,6 +842,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/rust_ast/set_span.rs

@@ -140,6 +140,7 @@ impl SetSpan for Expr {
                 RangeLimits::Closed(mut r) => r.spans[0] = s,
                 RangeLimits::HalfOpen(mut r) => r.spans[0] = s,
             },
+            Expr::RawAddr(e) => e.and_token.span = s,
             Expr::Reference(e) => e.and_token.span = s,
             Expr::Return(e) => e.return_token.span = s,
             Expr::Try(e) => e.question_token.span = s,

c2rust-transpile/src/translator/assembly.rs

@@ -883,7 +883,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)) {
@@ -900,7 +900,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)));
 
@@ -924,7 +924,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

@@ -3032,7 +3032,7 @@ impl<'c> Translation<'c> {
                 }
             }
             _ => {
-                let addr_lhs = mk().set_mutbl(mutbl).addr_of_expr(lhs);
+                let addr_lhs = mk().set_mutbl(mutbl).borrow_expr(lhs);
 
                 let lhs_type = self.convert_type(lhs_type.ctype)?;
                 let ty = mk().set_mutbl(mutbl).ptr_ty(lhs_type);

c2rust-transpile/src/translator/operators.rs

@@ -963,7 +963,7 @@ impl<'c> Translation<'c> {
                             // 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);
+                            addr_of_arg = mk().borrow_expr(a);
                             if let Mutability::Mutable = mutbl {
                                 let mut qtype = pointee_ty;
                                 qtype.qualifiers.is_const = true;
@@ -975,7 +975,7 @@ impl<'c> Translation<'c> {
                             }
                         } else {
                             // Normal case is allowed to use &mut if needed
-                            addr_of_arg = mk().set_mutbl(mutbl).addr_of_expr(a);
+                            addr_of_arg = mk().set_mutbl(mutbl).borrow_expr(a);
 
                             // Avoid unnecessary reference to pointer decay in fn call args:
                             if ctx.decay_ref.is_no() {