#[tokio::main] allowing arbitrary return values from main

[monoclex]

Version

[dependencies]
tokio = { version = "1.17.0", features = ["macros", "rt-multi-thread"] }

Platform

Linux x86_64

Description

The following code compiles playground link

#[tokio::main]
async fn main() {
    return 1;
    ;
}

The following don't compile, as expected

#[tokio::main]
async fn main() {
    return 1;
    ()
}

#[tokio::main]
async fn main() {
    return 1;
}

#[tokio::main]
async fn main() {
    1
}

[Darksonn]

Thoughts? @taiki-e

[taiki-e]

Good catch!

The repro will be expanded to the following:

fn main() {
    let body = async { return 1; ; };

    #[allow(clippy :: expect_used)]
    tokio::runtime::Builder::new_multi_thread().enable_all().build().expect("Failed building the Runtime").block_on(body);
}

The heuristic to analyze the last expression and emit a semicolon without return seems wrong. (all branches that return (quote! {}, quote! { ; }) in the following code)

tokio/tokio-macros/src/entry.rs

Lines 386 to 399 in b4d82c3

	let (tail_return, tail_semicolon) = match body.stmts.last() {
	Some(syn::Stmt::Semi(syn::Expr::Return(_), _)) => (quote! { return }, quote! { ; }),
	Some(syn::Stmt::Semi(..)) | Some(syn::Stmt::Local(..)) | None => {
	match &input.sig.output {
	syn::ReturnType::Type(_, ty) if matches!(&**ty, syn::Type::Tuple(ty) if ty.elems.is_empty()) =>
	{
	(quote! {}, quote! { ; }) // unit
	}
	syn::ReturnType::Default => (quote! {}, quote! { ; }), // unit
	syn::ReturnType::Type(..) => (quote! {}, quote! {}), // ! or another
	}
	}
	_ => (quote! {}, quote! {}),
	};

[taiki-e]

The simplest fix for this is to remove all heuristics introduced in #4067 and relevant subsequent PRs.

However, it improved diagnostics, so I'm considering the approach that fixes the problem without regressions on the diagnostics.

Probably, using let () = where unit is expected to be returned should work well.

  let (tail_return, tail_semicolon) = match body.stmts.last() { 
       Some(syn::Stmt::Semi(syn::Expr::Return(_), _)) => (quote! { return }, quote! { ; }), 
       Some(syn::Stmt::Semi(..)) | Some(syn::Stmt::Local(..)) | None => { 
           match &input.sig.output { 
               syn::ReturnType::Type(_, ty) if matches!(&**ty, syn::Type::Tuple(ty) if ty.elems.is_empty()) => 
               { 
-                  (quote! {}, quote! { ; }) // unit 
+                  (quote! { let () = }, quote! { ; }) // unit 
               } 
-              syn::ReturnType::Default => (quote! {}, quote! { ; }), // unit 
+              syn::ReturnType::Default => (quote! { let () = }, quote! { ; }), // unit 
               syn::ReturnType::Type(..) => (quote! {}, quote! {}),   // ! or another 
           } 
       } 
       _ => (quote! {}, quote! {}), 
   }; 

[taiki-e]

filed #4636