transpile: Strip tail return only when transpiling a function

Author: Rua

c2rust-transpile/src/cfg/mod.rs

@@ -558,6 +558,8 @@ pub enum ImplicitReturnType {
     ///
     /// TODO: document
     StmtExpr(ExprContext, CExprId, Label),
+
+    StmtExprVoid,
 }
 
 /// A complete control-flow graph
@@ -632,6 +634,7 @@ impl Cfg<Label, StmtOrDecl> {
                             mk().break_expr_value(Some(brk_label.pretty_print()), Some(val)),
                         )));
                     }
+                    ImplicitReturnType::StmtExprVoid => (),
                 };
 
                 cfg_builder.add_wip_block(wip, End);
@@ -2114,13 +2117,8 @@ impl CfgBuilder {
         };
 
         // Run relooper
-        let mut stmts = translator.convert_cfg(
-            &format!("<substmt_{:?}>", stmt_id),
-            graph,
-            store,
-            live_in,
-            false,
-        )?;
+        let mut stmts =
+            translator.convert_cfg(&format!("<substmt_{:?}>", stmt_id), graph, store, live_in)?;
 
         let inner_span = stmts.first().map(|stmt| stmt.span());
 

c2rust-transpile/src/cfg/structures.rs

@@ -2,7 +2,7 @@
 
 use super::*;
 use log::warn;
-use syn::{spanned::Spanned as _, ExprBreak, ExprIf, ExprReturn, ExprUnary, Stmt};
+use syn::{spanned::Spanned as _, ExprBreak, ExprIf, ExprUnary, Stmt};
 
 use crate::rust_ast::{comment_store, set_span::SetSpan, BytePos, SpanExt};
 
@@ -12,7 +12,6 @@ pub fn structured_cfg(
     comment_store: &mut comment_store::CommentStore,
     current_block: Box<Expr>,
     debug_labels: bool,
-    cut_out_trailing_ret: bool,
 ) -> TranslationResult<Vec<Stmt>> {
     let ast: StructuredAST<Box<Expr>, Pat, Label, Stmt> =
         structured_cfg_help(vec![], &IndexSet::new(), root, &mut IndexSet::new())?;
@@ -21,15 +20,7 @@ pub fn structured_cfg(
         debug_labels,
         current_block,
     };
-    let (mut stmts, _span) = s.to_stmt(ast, comment_store);
-
-    // If the very last statement in the vector is a `return`, we can either cut it out or replace
-    // it with the returned value.
-    if cut_out_trailing_ret {
-        if let Some(Stmt::Expr(Expr::Return(ExprReturn { expr: None, .. }), _)) = stmts.last() {
-            stmts.pop();
-        }
-    }
+    let (stmts, _span) = s.to_stmt(ast, comment_store);
 
     Ok(stmts)
 }

c2rust-transpile/src/translator/mod.rs

@@ -15,11 +15,11 @@ use proc_macro2::{Punct, Spacing::*, Span, TokenStream, TokenTree};
 use syn::spanned::Spanned as _;
 use syn::{
     AttrStyle, BareVariadic, Block, Expr, ExprBinary, ExprBlock, ExprBreak, ExprCast, ExprField,
-    ExprIndex, ExprParen, ExprUnary, FnArg, ForeignItem, ForeignItemFn, ForeignItemMacro,
-    ForeignItemStatic, ForeignItemType, Ident, Item, ItemConst, ItemEnum, ItemExternCrate, ItemFn,
-    ItemForeignMod, ItemImpl, ItemMacro, ItemMod, ItemStatic, ItemStruct, ItemTrait,
-    ItemTraitAlias, ItemType, ItemUnion, ItemUse, Lit, MacroDelimiter, PathSegment, ReturnType,
-    Stmt, Type, TypeTuple, UseTree, Visibility,
+    ExprIndex, ExprParen, ExprReturn, ExprUnary, FnArg, ForeignItem, ForeignItemFn,
+    ForeignItemMacro, ForeignItemStatic, ForeignItemType, Ident, Item, ItemConst, ItemEnum,
+    ItemExternCrate, ItemFn, ItemForeignMod, ItemImpl, ItemMacro, ItemMod, ItemStatic, ItemStruct,
+    ItemTrait, ItemTraitAlias, ItemType, ItemUnion, ItemUse, Lit, MacroDelimiter, PathSegment,
+    ReturnType, Stmt, Type, TypeTuple, UseTree, Visibility,
 };
 use syn::{BinOp, UnOp}; // To override `c_ast::{BinOp,UnOp}` from glob import.
 
@@ -2500,7 +2500,8 @@ impl<'c> Translation<'c> {
                     _ => panic!("function body expects to be a compound statement"),
                 };
                 let mut converted_body =
-                    self.convert_function_body(ctx, name, body_ids, return_type, ret)?;
+                    self.convert_block_with_scope(ctx, name, body_ids, return_type, ret)?;
+                strip_tail_return(&mut converted_body);
 
                 // If `alloca` was used in the function body, include a variable to hold the
                 // allocations.
@@ -2617,7 +2618,6 @@ impl<'c> Translation<'c> {
         graph: cfg::Cfg<cfg::Label, cfg::StmtOrDecl>,
         store: cfg::DeclStmtStore,
         live_in: IndexSet<CDeclId>,
-        cut_out_trailing_ret: bool,
     ) -> TranslationResult<Vec<Stmt>> {
         if self.tcfg.dump_function_cfgs {
             graph
@@ -2679,12 +2679,11 @@ impl<'c> Translation<'c> {
             &mut self.comment_store.borrow_mut(),
             current_block,
             self.tcfg.debug_relooper_labels,
-            cut_out_trailing_ret,
         )?);
         Ok(stmts)
     }
 
-    fn convert_function_body(
+    fn convert_block_with_scope(
         &self,
         ctx: ExprContext,
         name: &str,
@@ -2695,7 +2694,7 @@ impl<'c> Translation<'c> {
         // Function body scope
         self.with_scope(|| {
             let (graph, store) = cfg::Cfg::from_stmts(self, ctx, body_ids, ret, ret_ty)?;
-            self.convert_cfg(name, graph, store, IndexSet::new(), true)
+            self.convert_cfg(name, graph, store, IndexSet::new())
         })
     }
 
@@ -4359,15 +4358,21 @@ impl<'c> Translation<'c> {
                 let mut stmts = match self.ast_context[result_id].kind {
                     CStmtKind::Expr(expr_id) => {
                         let ret = cfg::ImplicitReturnType::StmtExpr(ctx, expr_id, lbl.clone());
-                        self.convert_function_body(ctx, &name, &substmt_ids[0..(n - 1)], None, ret)?
+                        self.convert_block_with_scope(
+                            ctx,
+                            &name,
+                            &substmt_ids[0..(n - 1)],
+                            None,
+                            ret,
+                        )?
                     }
 
-                    _ => self.convert_function_body(
+                    _ => self.convert_block_with_scope(
                         ctx,
                         &name,
                         substmt_ids,
                         None,
-                        cfg::ImplicitReturnType::Void,
+                        cfg::ImplicitReturnType::StmtExprVoid,
                     )?,
                 };
 
@@ -5379,3 +5384,11 @@ impl<'c> Translation<'c> {
         }
     }
 }
+
+// If the very last statement in the vector is a `return`, either cut it out or replace it with
+// the returned value.
+fn strip_tail_return(stmts: &mut Vec<Stmt>) {
+    if let Some(Stmt::Expr(Expr::Return(ExprReturn { expr: None, .. }), _)) = stmts.last() {
+        stmts.pop();
+    }
+}

c2rust-transpile/tests/snapshots/snapshots__transpile@exprs.c.snap

@@ -59,5 +59,6 @@ pub unsafe extern "C" fn compound_literal() {
 #[no_mangle]
 pub unsafe extern "C" fn statement_expr() {
     puts(b"should execute\0" as *const u8 as *const ::core::ffi::c_char);
+    return;
     puts(b"should be unreachable!\0" as *const u8 as *const ::core::ffi::c_char);
 }