Move most of the python!{} expansion to a macro_rules.

Author: m-ou-se

macros/src/lib.rs

@@ -4,7 +4,7 @@
 
 extern crate proc_macro;
 
-use proc_macro::{Delimiter, Group, Literal, Span, TokenStream, TokenTree};
+use proc_macro::{Literal, Span, TokenStream, TokenTree};
 use pyo3::{Py, Python};
 use std::{
     collections::BTreeMap,
@@ -28,42 +28,15 @@ fn python_impl(input: TokenStream) -> Result<TokenStream, TokenStream> {
     let bytecode = compile_to_bytecode(&python, &filename, input)?;
     Ok(TokenStream::from_iter([
         punct(':'), punct(':'), ident("inline_python"),
-        punct(':'), punct(':'), ident("FromInlinePython"),
-        punct(':'), punct(':'), ident("from_python_macro"),
-        parens([
-            TokenTree::Literal(bytecode), punct(','),
-            punct('|'), ident("globals"), punct('|'),
-            braces(variables.into_iter().flat_map(|(key, value)| [
-                punct(':'), punct(':'), ident("inline_python"),
-                punct(':'), punct(':'), ident("pyo3"),
-                punct(':'), punct(':'), ident("prelude"),
-                punct(':'), punct(':'), ident("PyDictMethods"),
-                punct(':'), punct(':'), ident("set_item"),
-                parens([
-                    ident("globals"), punct(','),
-                    string(&key), punct(','),
-                    TokenTree::Ident(value)
-                ]),
-                punct('.'), ident("expect"), parens([string("python")]),
-                punct(';'),
-            ])),
-            punct(','),
-            punct('|'), ident("e"), punct('|'),
-            punct(':'), punct(':'), ident("std"),
-            punct(':'), punct(':'), ident("panic"),
-            punct(':'), punct(':'), ident("panic_any"),
-            parens([ident("e")]),
-        ]),
+        punct(':'), punct(':'), ident("_python_block"),
+        punct('!'),
+        braces(
+            [TokenTree::Literal(bytecode)].into_iter()
+            .chain(variables.into_iter().map(|(_, value)| TokenTree::Ident(value)))
+        ),
     ]))
 }
 
-fn parens(t: impl IntoIterator<Item = TokenTree>) -> TokenTree {
-    TokenTree::Group(Group::new(
-        Delimiter::Parenthesis,
-        TokenStream::from_iter(t),
-    ))
-}
-
 fn compile_to_bytecode(
     python: &CStr,
     filename: &CStr,

macros/src/shared.rs

@@ -116,13 +116,13 @@ pub(crate) fn python_from_macro(
                         && x.as_char() == '\''
                         && x.spacing() == Spacing::Joint
                     {
-                        let Some(TokenTree::Ident(name)) = tokens.next() else {
+                        let Some(TokenTree::Ident(ident)) = tokens.next() else {
                             unreachable!()
                         };
-                        let name_str = format!("_RUST_{name}");
-                        python.push_str(&name_str);
-                        loc.column += name_str.chars().count() - 6 + 1;
-                        variables.entry(name_str).or_insert(name);
+                        let name = ident.to_string();
+                        write!(python, "_RUST_{name}").unwrap();
+                        loc.column += name.chars().count() + 1;
+                        variables.entry(name).or_insert(ident);
                     } else if x.as_char() == '#' && x.spacing() == Spacing::Joint {
                         // Convert '##' to '//', because otherwise it's
                         // impossible to use the Python operators '//' and '//='.

src/lib.rs

@@ -143,6 +143,29 @@ pub use pyo3;
 /// See [the crate's module level documentation](index.html) for examples.
 pub use inline_python_macros::python;
 
+// `python!{..}` expands to `python_impl!{b"bytecode" var1 var2 …}`,
+// which then expands to a call to `FromInlinePython::from_python_macro`.
+#[macro_export]
+#[doc(hidden)]
+macro_rules! _python_block {
+    ($bytecode:literal $($var:ident)*) => {
+        $crate::FromInlinePython::from_python_macro(
+            // The compiled python bytecode:
+            $bytecode,
+            // The closure that puts all the captured variables in the 'globals' dictionary:
+            |globals| {
+                $(
+                    $crate::pyo3::prelude::PyDictMethods::set_item(
+                        globals, concat!("_RUST_", stringify!($var)), $var
+                    ).expect("python");
+                )*
+            },
+            // The closure that is used to throw panics with the right location:
+            |e| ::std::panic::panic_any(e),
+        )
+    }
+}
+
 #[doc(hidden)]
 pub trait FromInlinePython<F: FnOnce(&Bound<PyDict>)> {
     /// The `python!{}` macro expands to a call to this function.