fixes )};{( and other fun

Cargo.toml

@@ -27,3 +27,5 @@ once_cell = "1.13"
 humantime = "2.1.0"
 rand = "0.8.5"
 chrono = "0.4.26"
+syn = { version = "2.0.60", features = ["full"] }
+quote = "1.0.36"

src/commands/playground/misc_commands.rs

@@ -20,8 +20,12 @@ pub async fn miri(
 	code: poise::CodeBlock,
 ) -> Result<(), Error> {
 	ctx.say(stub_message(ctx)).await?;
-
-	let code = &maybe_wrap(&code.code, ResultHandling::Discard);
+	let code = &maybe_wrapped(
+		&code.code,
+		ResultHandling::Discard,
+		ctx.prefix().contains("sweat"),
+		ctx.prefix().contains("owo"),
+	);
 	let (flags, flag_parse_errors) = parse_flags(flags);
 
 	let mut result: PlayResult = ctx
@@ -142,7 +146,12 @@ pub async fn clippy(
 		// dead_code: https://github.com/kangalioo/rustbot/issues/44
 		// let_unit_value: silence warning about `let _ = { ... }` wrapper that swallows return val
 		"#![allow(dead_code, clippy::let_unit_value)] {}",
-		maybe_wrap(&code.code, ResultHandling::Discard)
+		maybe_wrapped(
+			&code.code,
+			ResultHandling::Discard,
+			ctx.prefix().contains("sweat"),
+			false,
+		)
 	);
 	let (flags, flag_parse_errors) = parse_flags(flags);
 

src/commands/playground/play_eval.rs

@@ -14,7 +14,12 @@ async fn play_or_eval(
 ) -> Result<(), Error> {
 	ctx.say(stub_message(ctx)).await?;
 
-	let code = maybe_wrap(&code.code, result_handling);
+	let code = maybe_wrapped(
+		&code.code,
+		result_handling,
+		ctx.prefix().contains("sweat"),
+		ctx.prefix().contains("owo"),
+	);
 	let (mut flags, flag_parse_errors) = parse_flags(flags);
 
 	if force_warnings {

src/commands/playground/util.rs

@@ -198,26 +198,69 @@ pub fn hoise_crate_attributes(code: &str, after_crate_attrs: &str, after_code: &
 /// Utility used by the commands to wrap the given code in a `fn main` if not already wrapped.
 /// To check, whether a wrap was done, check if the return type is Cow::Borrowed vs Cow::Owned
 /// If a wrap was done, also hoists crate attributes to the top so they keep working
-pub fn maybe_wrap(code: &str, result_handling: ResultHandling) -> Cow<'_, str> {
-	if code.contains("fn main") || code.contains("#![no_main]") {
-		return Cow::Borrowed(code);
+pub fn maybe_wrap(code: &str, result_handling: ResultHandling) -> Cow<str> {
+	maybe_wrapped(code, result_handling, false, false)
+}
+
+pub fn maybe_wrapped(
+	code: &str,
+	result_handling: ResultHandling,
+	unsf: bool,
+	pretty: bool,
+) -> Cow<str> {
+	use quote::quote;
+	use syn::{parse::Parse, *};
+
+	struct Inline {
+		attrs: Vec<Attribute>,
+		stmts: Vec<Stmt>,
 	}
 
-	// fn main boilerplate
-	let after_crate_attrs = match result_handling {
-		ResultHandling::None => "fn main() {\n",
-		ResultHandling::Discard => "fn main() { let _ = {\n",
-		ResultHandling::Print => "fn main() { println!(\"{:?}\", {\n",
-	};
+	impl Parse for Inline {
+		fn parse(input: parse::ParseStream) -> Result<Self> {
+			let attrs = Attribute::parse_inner(input)?;
+			let stmts = Block::parse_within(input)?;
+			for stmt in &stmts {
+				if let Stmt::Item(Item::Fn(ItemFn { sig, .. })) = stmt {
+					if sig.ident.to_string() == "main" && sig.inputs.len() == 0 {
+						return Err(input.error("main"));
+					}
+				}
+			}
+			Ok(Self { attrs, stmts })
+		}
+	}
 
-	// fn main boilerplate counterpart
-	let after_code = match result_handling {
-		ResultHandling::None => "}",
-		ResultHandling::Discard => "}; }",
-		ResultHandling::Print => "}); }",
+	let Ok(Inline { attrs, mut stmts }) = parse_str::<Inline>(code) else {
+		return Cow::Borrowed(code);
 	};
-
-	Cow::Owned(hoise_crate_attributes(code, after_crate_attrs, after_code))
+	if unsf {
+		stmts = vec![Stmt::Expr(
+			Expr::Unsafe(ExprUnsafe {
+				attrs: vec![],
+				unsafe_token: syn::token::Unsafe::default(),
+				block: Block {
+					brace_token: syn::token::Brace::default(),
+					stmts,
+				},
+			}),
+			None,
+		)];
+	}
+	match result_handling {
+		ResultHandling::None => quote! { #(#attrs)* fn main() { #(#stmts)* } },
+		ResultHandling::Discard => {
+			quote! { #(#attrs)* fn main() { _ = (|| { #(#stmts)* })() } }
+		}
+		ResultHandling::Print if pretty => {
+			quote! { #(#attrs)* fn main() { ::std::println!("{:#?}", (|| { #(#stmts)* })()) } }
+		}
+		ResultHandling::Print => {
+			quote! { #(#attrs)* fn main() { ::std::println!("{:?}", (|| { #(#stmts)* })()) } }
+		}
+	}
+	.to_string()
+	.into()
 }
 
 /// Send a Discord reply with the formatted contents of a Playground result
@@ -362,6 +405,7 @@ pub fn format_play_eval_stderr(stderr: &str, show_compiler_warnings: bool) -> St
 		} else {
 			program_stderr.to_owned()
 		}
+		.replace('`', "\u{200b}`")
 	} else {
 		// Program didn't get to run, so there must be an error, so we yield the compiler output
 		// regardless of whether warn is enabled or not

src/main.rs

@@ -81,10 +81,14 @@ async fn poise(#[shuttle_secrets::Secrets] secret_store: SecretStore) -> Shuttle
 					poise::Prefix::Literal("🦀"),
 					poise::Prefix::Literal("<:ferris:358652670585733120> "),
 					poise::Prefix::Literal("<:ferris:358652670585733120>"),
-					poise::Prefix::Literal("<:ferrisballSweat:678714352450142239> "),
-					poise::Prefix::Literal("<:ferrisballSweat:678714352450142239>"),
+					poise::Prefix::Literal("<:sweat:678714352450142239> "),
+					poise::Prefix::Literal("<:sweat:678714352450142239>"),
+					poise::Prefix::Literal("<:owo:678714352450142239> "),
+					poise::Prefix::Literal("<:owo:678714352450142239>"),
+					poise::Prefix::Literal("<:owo:579331467000283136> "),
+					poise::Prefix::Literal("<:owo:579331467000283136>"),
 					poise::Prefix::Regex(
-						"(yo|hey) (crab|ferris|fewwis),? can you (please |pwease )?"
+						"(yo |hey )?(crab|ferris|fewwis),? can you (please |pwease )?"
 							.parse()
 							.unwrap(),
 					),