Remove proc_macro2 and quote dependencies.

Author: m-ou-se

macros/Cargo.toml

@@ -10,8 +10,6 @@ repository = "https://github.com/m-ou-se/inline-python"
 proc-macro = true
 
 [dependencies]
-proc-macro2 = { version = "1.0", features = ["span-locations"] }
-quote = "1.0"
 pyo3 = { version = "0.24", default-features = false, features = ["auto-initialize"] }
 
 [target.'cfg(unix)'.dependencies]

macros/src/embed_python.rs

@@ -1,6 +1,5 @@
-use proc_macro::Span;
-use proc_macro2::{Delimiter, Ident, Spacing, TokenStream, TokenTree};
-use quote::quote_spanned;
+use super::compile_error;
+use proc_macro::{Delimiter, Ident, Spacing, Span, TokenStream, TokenTree};
 use std::collections::BTreeMap;
 use std::fmt::Write;
 
@@ -34,7 +33,7 @@ impl EmbedPython {
 			}
 			let first_indent = *self.first_indent.get_or_insert(column);
 			let indent = column.checked_sub(first_indent);
-			let indent = indent.ok_or_else(|| quote_spanned!(span.into() => compile_error!{"Invalid indentation"}))?;
+			let indent = indent.ok_or_else(|| compile_error(Some((span, span)), "invalid indent"))?;
 			for _ in 0..indent {
 				self.python.push(' ');
 			}
@@ -53,7 +52,7 @@ impl EmbedPython {
 		let mut tokens = input.into_iter();
 
 		while let Some(token) = tokens.next() {
-			let span = token.span().unwrap();
+			let span = token.span();
 			self.add_whitespace(span, span.line(), span.column())?;
 
 			match &token {
@@ -67,7 +66,7 @@ impl EmbedPython {
 					self.python.push_str(start);
 					self.column += start.len();
 					self.add(x.stream())?;
-					let end_span = token.span().unwrap().end();
+					let end_span = token.span().end();
 					self.add_whitespace(span, end_span.line(), end_span.column().saturating_sub(end.len()))?;
 					self.python.push_str(end);
 					self.column += end.len();
@@ -107,7 +106,7 @@ impl EmbedPython {
 				}
 				TokenTree::Ident(x) => {
 					write!(&mut self.python, "{}", x).unwrap();
-					let end_span = token.span().unwrap().end();
+					let end_span = token.span().end();
 					self.line = end_span.line();
 					self.column = end_span.column();
 				}
@@ -122,7 +121,7 @@ impl EmbedPython {
 						self.python.pop();
 					}
 					self.python += &s;
-					let end_span = token.span().unwrap().end();
+					let end_span = token.span().end();
 					self.line = end_span.line();
 					self.column = end_span.column();
 				}

macros/src/error.rs

@@ -1,23 +1,21 @@
-use proc_macro::{TokenTree, Span, TokenStream as TokenStream1};
-use proc_macro2::TokenStream;
-use pyo3::{prelude::*, types::PyTraceback, Bound, IntoPyObject, PyErr, PyResult, PyTypeInfo, Python};
-use quote::{quote, quote_spanned};
+use super::compile_error;
+use proc_macro::{Span, TokenStream, TokenTree};
+use pyo3::{Bound, IntoPyObject, PyErr, PyResult, PyTypeInfo, Python, prelude::*, types::PyTraceback};
 
 /// Format a nice error message for a python compilation error.
 pub fn compile_error_msg(py: Python, error: PyErr, tokens: TokenStream) -> TokenStream {
 	let value = (&error).into_pyobject(py).unwrap();
 
 	if value.is_none() {
-		let error = format!("python: {}", error.get_type(py).name().unwrap());
-		return quote!(compile_error! {#error});
+		return compile_error(None, &error.get_type(py).name().unwrap());
 	}
 
 	if let Ok(true) = error.matches(py, pyo3::exceptions::PySyntaxError::type_object(py)) {
 		let line: Option<usize> = value.getattr("lineno").ok().and_then(|x| x.extract().ok());
 		let msg: Option<String> = value.getattr("msg").ok().and_then(|x| x.extract().ok());
 		if let (Some(line), Some(msg)) = (line, msg) {
-			if let Some(spans) = spans_for_line(tokens.clone().into(), line) {
-				return compile_error(spans, format!("python: {msg}"));
+			if let Some(spans) = spans_for_line(tokens.clone(), line) {
+				return compile_error(Some(spans), &msg);
 			}
 		}
 	}
@@ -26,16 +24,15 @@ pub fn compile_error_msg(py: Python, error: PyErr, tokens: TokenStream) -> Token
 		if let Ok((file, line)) = get_traceback_info(tb) {
 			if file == Span::call_site().file() {
 				if let Ok(msg) = value.str() {
-					if let Some(spans) = spans_for_line(tokens.into(), line) {
-						return compile_error(spans, format!("python: {msg}"));
+					if let Some(spans) = spans_for_line(tokens, line) {
+						return compile_error(Some(spans), &msg);
 					}
 				}
 			}
 		}
 	}
 
-	let error = format!("python: {}", value.str().unwrap());
-	quote!(compile_error! {#error})
+	compile_error(None, &value.str().unwrap())
 }
 
 fn get_traceback_info(tb: &Bound<'_, PyTraceback>) -> PyResult<(String, usize)> {
@@ -46,7 +43,7 @@ fn get_traceback_info(tb: &Bound<'_, PyTraceback>) -> PyResult<(String, usize)>
 	Ok((file, line))
 }
 
-fn for_all_spans(input: TokenStream1, f: &mut impl FnMut(Span)) {
+fn for_all_spans(input: TokenStream, f: &mut impl FnMut(Span)) {
 	for token in input {
 		match token {
 			TokenTree::Group(group) => {
@@ -60,7 +57,7 @@ fn for_all_spans(input: TokenStream1, f: &mut impl FnMut(Span)) {
 }
 
 /// Get the first and last span for a specific line of input from a TokenStream.
-fn spans_for_line(input: TokenStream1, line: usize) -> Option<(Span, Span)> {
+fn spans_for_line(input: TokenStream, line: usize) -> Option<(Span, Span)> {
 	let mut spans = None;
 	for_all_spans(input, &mut |span| {
 		if span.start().line() == line {
@@ -69,9 +66,3 @@ fn spans_for_line(input: TokenStream1, line: usize) -> Option<(Span, Span)> {
 	});
 	spans
 }
-
-/// Create a compile_error!{} using two spans that mark the start and end of the error.
-fn compile_error(spans: (Span, Span), error: String) -> TokenStream {
-	let path = quote_spanned!(spans.0.into() => ::core::compile_error);
-	quote_spanned!(spans.1.into() => #path!{#error})
-}

macros/src/lib.rs

@@ -5,16 +5,15 @@
 extern crate proc_macro;
 
 use self::embed_python::EmbedPython;
-use proc_macro::{Span, TokenStream as TokenStream1};
-use proc_macro2::{Literal, TokenStream};
-use pyo3::{ffi, Py, PyObject, Python};
-use quote::quote;
-use std::ffi::CString;
+use proc_macro::{Delimiter, Group, Ident, Literal, Punct, Spacing, Span, TokenStream, TokenTree};
+use pyo3::{Py, PyObject, Python, ffi};
+use std::{ffi::CString, fmt::Display};
 
 mod embed_python;
 mod error;
 mod run;
 
+#[rustfmt::skip]
 fn python_impl(input: TokenStream) -> Result<TokenStream, TokenStream> {
 	let tokens = input.clone();
 
@@ -31,35 +30,55 @@ fn python_impl(input: TokenStream) -> Result<TokenStream, TokenStream> {
 
 	let bytecode = unsafe {
 		let result: Result<Literal, TokenStream> = Python::with_gil(|py| {
-			let code = PyObject::from_owned_ptr_or_err(py, ffi::Py_CompileString(python.as_ptr(), filename.as_ptr(), ffi::Py_file_input))
-				.map_err(|err| error::compile_error_msg(py, err, tokens))?;
-
-			Ok(Literal::byte_string(
-				Py::from_owned_ptr_or_err(py, ffi::PyMarshal_WriteObjectToString(code.as_ptr(), pyo3::marshal::VERSION))
-					.map_err(|_e| quote!(compile_error! {"failed to generate python bytecode"}))?
-					.as_bytes(py),
-			))
+			let code = PyObject::from_owned_ptr_or_err(py,
+				ffi::Py_CompileString(python.as_ptr(), filename.as_ptr(), ffi::Py_file_input)
+			).map_err(|err| error::compile_error_msg(py, err, tokens))?;
+			Ok(Literal::byte_string(Py::from_owned_ptr_or_err(py,
+				ffi::PyMarshal_WriteObjectToString(code.as_ptr(), pyo3::marshal::VERSION)
+			).map_err(|_| compile_error(None, "failed to generate bytecode"))?.as_bytes(py)))
 		});
 		result?
 	};
 
-	let varname = variables.keys();
-	let var = variables.values();
-
-	Ok(quote! {
-		::inline_python::FromInlinePython::from_python_macro(
-			#bytecode,
-			|globals| {
-				#(
-					::inline_python::pyo3::prelude::PyDictMethods::set_item(
-						globals,
-						#varname,
-						#var
-					).expect("Unable to convert variable to Python");
-				)*
-			},
-		)
-	})
+	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(';'),
+			]))
+		]),
+	]))
+}
+
+/// Create a compile_error!{} using two spans that mark the start and end of the error.
+#[rustfmt::skip]
+fn compile_error(spans: Option<(Span, Span)>, error: &(impl Display + ?Sized)) -> TokenStream {
+	let mut tokens = [
+		punct(':'), punct(':'), ident("core"),
+		punct(':'), punct(':'), ident("compile_error"),
+		punct('!'), braces([string(&format!("python: {error}"))]),
+	];
+	if let Some((span1, span2)) = spans {
+		for (i, t) in tokens.iter_mut().enumerate() {
+			t.set_span(if i < 6 { span1 } else { span2 });
+		}
+	}
+	TokenStream::from_iter(tokens)
 }
 
 fn ct_python_impl(input: TokenStream) -> Result<TokenStream, TokenStream> {
@@ -90,18 +109,38 @@ fn ct_python_impl(input: TokenStream) -> Result<TokenStream, TokenStream> {
 
 #[doc(hidden)]
 #[proc_macro]
-pub fn python(input: TokenStream1) -> TokenStream1 {
-	TokenStream1::from(match python_impl(TokenStream::from(input)) {
+pub fn python(input: TokenStream) -> TokenStream {
+	match python_impl(input) {
 		Ok(tokens) => tokens,
 		Err(tokens) => tokens,
-	})
+	}
 }
 
 #[doc(hidden)]
 #[proc_macro]
-pub fn ct_python(input: TokenStream1) -> TokenStream1 {
-	TokenStream1::from(match ct_python_impl(TokenStream::from(input)) {
+pub fn ct_python(input: TokenStream) -> TokenStream {
+	match ct_python_impl(input) {
 		Ok(tokens) => tokens,
 		Err(tokens) => tokens,
-	})
+	}
+}
+
+fn punct(p: char) -> TokenTree {
+	TokenTree::Punct(Punct::new(p, Spacing::Joint))
+}
+
+fn ident(s: &str) -> TokenTree {
+	TokenTree::Ident(Ident::new(s, Span::call_site()))
+}
+
+fn parens(t: impl IntoIterator<Item = TokenTree>) -> TokenTree {
+	TokenTree::Group(Group::new(Delimiter::Parenthesis, TokenStream::from_iter(t)))
+}
+
+fn braces(t: impl IntoIterator<Item = TokenTree>) -> TokenTree {
+	TokenTree::Group(Group::new(Delimiter::Brace, TokenStream::from_iter(t)))
+}
+
+fn string(s: &str) -> TokenTree {
+	TokenTree::Literal(Literal::string(s))
 }

macros/src/run.rs

@@ -1,5 +1,5 @@
 use crate::error::compile_error_msg;
-use proc_macro2::TokenStream;
+use proc_macro::TokenStream;
 use pyo3::{ffi, prelude::*, PyObject, PyResult, Python};
 use std::str::FromStr;