transpile: Replace WithStmts::new_unsafe_val with builder calls

Author: Rua

c2rust-transpile/src/translator/literals.rs

@@ -140,7 +140,7 @@ impl<'c> Translation<'c> {
                         val = mk().const_block_expr(mk().const_block(stmts));
                     }
 
-                    Ok(WithStmts::new_unsafe_val(val))
+                    Ok(WithStmts::new_val(val).set_unsafe())
                 }
             }
         }

c2rust-transpile/src/translator/operators.rs

@@ -422,11 +422,11 @@ impl<'c> Translation<'c> {
             let assign_stmt = match op {
                 // Regular (possibly volatile) assignment
                 Assign if !is_volatile => WithStmts::new_val(mk().assign_expr(write, rhs)),
-                Assign => WithStmts::new_unsafe_val(self.volatile_write(
+                Assign => WithStmts::new_val(self.volatile_write(
                     write,
                     initial_lhs_type_id,
                     rhs,
-                )?),
+                )?).set_unsafe(),
 
                 // Anything volatile needs to be desugared into explicit reads and writes
                 op if is_volatile || is_unsigned_arith => {
@@ -473,9 +473,9 @@ impl<'c> Translation<'c> {
                     #[allow(clippy::let_and_return /* , reason = "block is large, so variable name helps" */)]
                     let write = if is_volatile {
                         val.and_then_try(|val| {
-                            TranslationResult::Ok(WithStmts::new_unsafe_val(
+                            TranslationResult::Ok(WithStmts::new_val(
                                 self.volatile_write(write, initial_lhs_type_id, val)?,
-                            ))
+                            ).set_unsafe())
                         })?
                     } else {
                         val.map(|val| mk().assign_expr(write, val))
@@ -617,7 +617,7 @@ impl<'c> Translation<'c> {
                 offset = mk().binary_expr(BinOp::Div(Default::default()), offset, div);
             }
 
-            Ok(WithStmts::new_unsafe_val(mk().cast_expr(offset, ty)))
+            Ok(WithStmts::new_val(mk().cast_expr(offset, ty)).set_unsafe())
         } else if let &CTypeKind::Pointer(pointee) = lhs_type {
             Ok(self.convert_pointer_offset(lhs, rhs, pointee.ctype, true, false))
         } else if lhs_type.is_unsigned_integral_type() {

c2rust-transpile/src/translator/pointers.rs

@@ -382,7 +382,7 @@ impl<'c> Translation<'c> {
             res = mk().unary_expr(UnOp::Deref(Default::default()), res);
         }
 
-        WithStmts::new_unsafe_val(res)
+        WithStmts::new_val(res).set_unsafe()
     }
 
     /// Construct an expression for a NULL at any type, including forward declarations,
@@ -450,7 +450,7 @@ impl<'c> Translation<'c> {
             self.import_type(target_cty);
 
             Ok(val.and_then(|val| {
-                WithStmts::new_unsafe_val(transmute_expr(source_ty, target_ty, val))
+                WithStmts::new_val(transmute_expr(source_ty, target_ty, val)).set_unsafe()
             }))
         } else {
             // Normal case
@@ -483,7 +483,7 @@ impl<'c> Translation<'c> {
                 let intptr_t = mk().abs_path_ty(vec!["libc", "intptr_t"]);
                 val = mk().cast_expr(val, intptr_t.clone());
 
-                WithStmts::new_unsafe_val(transmute_expr(intptr_t, target_ty, val))
+                WithStmts::new_val(transmute_expr(intptr_t, target_ty, val)).set_unsafe()
             }))
         } else if source_ty_kind.is_bool() {
             self.use_crate(ExternCrate::Libc);
@@ -520,7 +520,7 @@ impl<'c> Translation<'c> {
 
         if self.ast_context.is_function_pointer(source_cty) {
             Ok(val.and_then(|val| {
-                WithStmts::new_unsafe_val(transmute_expr(source_ty, target_ty, val))
+                WithStmts::new_val(transmute_expr(source_ty, target_ty, val)).set_unsafe()
             }))
         } else if let &CTypeKind::Enum(enum_decl_id) = target_ty_kind {
             val.try_map(|val| self.convert_cast_to_enum(ctx, target_cty, enum_decl_id, expr, val))

c2rust-transpile/src/translator/simd.rs

@@ -270,11 +270,10 @@ impl<'c> Translation<'c> {
             let n_bytes_expr = mk().lit_expr(mk().int_lit(bytes, ""));
             let expr = mk().repeat_expr(zero_expr, n_bytes_expr);
 
-            Ok(WithStmts::new_unsafe_val(transmute_expr(
-                mk().infer_ty(),
-                mk().infer_ty(),
-                expr,
-            )))
+            Ok(
+                WithStmts::new_val(transmute_expr(mk().infer_ty(), mk().infer_ty(), expr))
+                    .set_unsafe(),
+            )
         } else {
             self.import_simd_function(fn_name)
                 .expect("None of these fns should be unsupported in rust");

c2rust-transpile/src/translator/structs_unions.rs

@@ -541,12 +541,7 @@ impl<'a> Translation<'a> {
                 stmts.push(mk().expr_stmt(mk().ident_expr("init")));
 
                 let val = mk().block_expr(mk().block(stmts));
-
-                if is_unsafe {
-                    WithStmts::new_unsafe_val(val)
-                } else {
-                    WithStmts::new_val(val)
-                }
+                WithStmts::new_val(val).merge_unsafe(is_unsafe)
             });
         }
 

c2rust-transpile/src/with_stmts.rs

@@ -27,14 +27,6 @@ impl<T> WithStmts<T> {
         }
     }
 
-    pub fn new_unsafe_val(val: T) -> Self {
-        WithStmts {
-            stmts: vec![],
-            val,
-            is_unsafe: true,
-        }
-    }
-
     pub fn and_then<U, F>(self, f: F) -> WithStmts<U>
     where
         F: FnOnce(T) -> WithStmts<U>,