Emit compile_error!{} instead of using feature(proc_macro_diagnostic).

This has the advantage that the compiler won't continue to parse our
(empty) output after emitting errors, which results in more errors.

Author: m-ou-se

macros/src/embed_python.rs

@@ -1,4 +1,5 @@
 use proc_macro2::{Delimiter, Ident, LineColumn, Spacing, Span, TokenStream, TokenTree};
+use quote::quote_spanned;
 use std::collections::BTreeMap;
 use std::fmt::Write;
 
@@ -21,15 +22,15 @@ impl EmbedPython {
 		}
 	}
 
-	fn add_whitespace(&mut self, span: Span, loc: LineColumn) -> Result<(), ()> {
+	fn add_whitespace(&mut self, span: Span, loc: LineColumn) -> Result<(), TokenStream> {
 		if loc.line > self.loc.line {
 			while loc.line > self.loc.line {
 				self.python.push('\n');
 				self.loc.line += 1;
 			}
 			let first_indent = *self.first_indent.get_or_insert(loc.column);
 			let indent = loc.column.checked_sub(first_indent);
-			let indent = indent.ok_or_else(|| span.unwrap().error("Invalid indentation").emit())?;
+			let indent = indent.ok_or_else(|| quote_spanned!(span => compile_error!{"Invalid indentation"}))?;
 			for _ in 0..indent {
 				self.python.push(' ');
 			}
@@ -44,7 +45,7 @@ impl EmbedPython {
 		Ok(())
 	}
 
-	pub fn add(&mut self, input: TokenStream) -> Result<(), ()> {
+	pub fn add(&mut self, input: TokenStream) -> Result<(), TokenStream> {
 		let mut tokens = input.into_iter();
 
 		while let Some(token) = tokens.next() {

macros/src/error.rs

@@ -1,26 +1,24 @@
 use proc_macro2::{Span, TokenStream};
+use quote::{quote, quote_spanned};
 use pyo3::type_object::PyTypeObject;
 use pyo3::{PyAny, AsPyRef, PyErr, PyResult, Python, ToPyObject};
 
 /// Format a nice error message for a python compilation error.
-pub fn emit_compile_error_msg(py: Python, error: PyErr, tokens: TokenStream) {
+pub fn compile_error_msg(py: Python, error: PyErr, tokens: TokenStream) -> TokenStream {
 	let value = error.to_object(py);
 
 	if value.is_none() {
-		Span::call_site()
-			.unwrap()
-			.error(format!("python: {}", error.ptype.as_ref(py).name()))
-			.emit();
-		return;
+		let error = format!("python: {}", error.ptype.as_ref(py).name());
+		return quote!(compile_error!{#error});
 	}
 
 	if error.matches(py, pyo3::exceptions::SyntaxError::type_object()) {
 		let line: Option<usize> = value.getattr(py, "lineno").ok().and_then(|x| x.extract(py).ok());
 		let msg: Option<String> = value.getattr(py, "msg").ok().and_then(|x| x.extract(py).ok());
 		if let (Some(line), Some(msg)) = (line, msg) {
 			if let Some(span) = span_for_line(tokens.clone(), line) {
-				span.unwrap().error(format!("python: {}", msg)).emit();
-				return;
+				let error = format!("python: {}", msg);
+				return quote_spanned!(span => compile_error!{#error});
 			}
 		}
 	}
@@ -30,18 +28,16 @@ pub fn emit_compile_error_msg(py: Python, error: PyErr, tokens: TokenStream) {
 			if file == Span::call_site().unwrap().source_file().path().to_string_lossy() {
 				if let Ok(msg) = value.as_ref(py).str() {
 					if let Some(span) = span_for_line(tokens, line) {
-						span.unwrap().error(format!("python: {}", msg)).emit();
-						return;
+						let error = format!("python: {}", msg);
+						return quote_spanned!(span => compile_error!{#error});
 					}
 				}
 			}
 		}
 	}
 
-	Span::call_site()
-		.unwrap()
-		.error(format!("python: {}", value.as_ref(py).str().unwrap()))
-		.emit();
+	let error = format!("python: {}", value.as_ref(py).str().unwrap());
+	quote!(compile_error!{#error})
 }
 
 fn get_traceback_info(tb: &PyAny) -> PyResult<(String, usize)> {

macros/src/lib.rs

@@ -1,5 +1,4 @@
 #![feature(proc_macro_span)]
-#![feature(proc_macro_diagnostic)]
 
 extern crate proc_macro;
 
@@ -14,7 +13,7 @@ mod embed_python;
 mod error;
 mod run;
 
-fn python_impl(input: TokenStream) -> Result<TokenStream, ()> {
+fn python_impl(input: TokenStream) -> Result<TokenStream, TokenStream> {
 	let tokens = input.clone();
 
 	check_no_attribute(input.clone())?;
@@ -35,11 +34,11 @@ fn python_impl(input: TokenStream) -> Result<TokenStream, ()> {
 		let py = gil.python();
 
 		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::emit_compile_error_msg(py, err, tokens))?;
+			.map_err(|err| error::compile_error_msg(py, err, tokens))?;
 
 		Literal::byte_string(
 			PyBytes::from_owned_ptr_or_err(py, ffi::PyMarshal_WriteObjectToString(code.as_ptr(), pyo3::marshal::VERSION))
-				.map_err(|_e| Span::call_site().unwrap().error("failed to generate python bytecode").emit())?
+				.map_err(|_e| quote!(compile_error!{"failed to generate python bytecode"}))?
 				.as_bytes(),
 		)
 	};
@@ -61,7 +60,7 @@ fn python_impl(input: TokenStream) -> Result<TokenStream, ()> {
 	})
 }
 
-fn ct_python_impl(input: TokenStream) -> Result<TokenStream, ()> {
+fn ct_python_impl(input: TokenStream) -> Result<TokenStream, TokenStream> {
 	let tokens = input.clone();
 
 	let filename = Span::call_site().unwrap().source_file().path().to_string_lossy().into_owned();
@@ -82,28 +81,23 @@ fn ct_python_impl(input: TokenStream) -> Result<TokenStream, ()> {
 
 	let code = unsafe {
 		PyObject::from_owned_ptr_or_err(py, ffi::Py_CompileString(python.as_ptr(), filename.as_ptr(), ffi::Py_file_input))
-			.map_err(|err| error::emit_compile_error_msg(py, err, tokens.clone()))?
+			.map_err(|err| error::compile_error_msg(py, err, tokens.clone()))?
 	};
 
 	run::run_ct_python(py, code, tokens)
 }
 
-fn check_no_attribute(input: TokenStream) -> Result<(), ()> {
+fn check_no_attribute(input: TokenStream) -> Result<(), TokenStream> {
 	let mut input = input.into_iter();
 	if let Some(token) = input.next() {
 		if token.to_string() == "#"
 			&& input.next().map_or(false, |t| t.to_string() == "!")
 			&& input.next().map_or(false, |t| t.to_string().starts_with('['))
 		{
-			token
-				.span()
-				.unwrap()
-				.error(
-					"Attributes in python!{} are no longer supported. \
-					Use context.run(python!{..}) to use a context.",
-				)
-				.emit();
-			return Err(());
+			return Err(quote!(compile_error!{
+				"Attributes in python!{} are no longer supported. \
+				Use context.run(python!{..}) to use a context.",
+			}));
 		}
 	}
 	Ok(())
@@ -113,14 +107,14 @@ fn check_no_attribute(input: TokenStream) -> Result<(), ()> {
 pub fn python(input: TokenStream1) -> TokenStream1 {
 	TokenStream1::from(match python_impl(TokenStream::from(input)) {
 		Ok(tokens) => tokens,
-		Err(()) => TokenStream::new(),
+		Err(tokens) => tokens,
 	})
 }
 
 #[proc_macro]
 pub fn ct_python(input: TokenStream1) -> TokenStream1 {
 	TokenStream1::from(match ct_python_impl(TokenStream::from(input)) {
 		Ok(tokens) => tokens,
-		Err(()) => quote!(unimplemented!()).into()
+		Err(tokens) => tokens,
 	})
 }

macros/src/run.rs

@@ -1,10 +1,10 @@
-use crate::error::emit_compile_error_msg;
-use proc_macro2::{Span, TokenStream};
+use crate::error::compile_error_msg;
+use proc_macro2::TokenStream;
 use pyo3::{ffi, AsPyPointer, PyObject, PyResult, Python};
 use std::str::FromStr;
 
 #[cfg(unix)]
-fn ensure_libpython_symbols_loaded(py: Python) -> PyResult<()>{
+fn ensure_libpython_symbols_loaded(py: Python) -> PyResult<()> {
 	// On Unix, Rustc loads proc-macro crates with RTLD_LOCAL, which (at least
 	// on Linux) means all their dependencies (in our case: libpython) don't
 	// get their symbols made available globally either. This means that
@@ -47,13 +47,10 @@ fn run_and_capture(py: Python, code: PyObject) -> PyResult<String> {
 	stdout.call_method0("getvalue")?.extract()
 }
 
-pub fn run_ct_python(py: Python, code: PyObject, tokens: TokenStream) -> Result<TokenStream, ()> {
-	let output = run_and_capture(py, code).map_err(|err| emit_compile_error_msg(py, err, tokens))?;
+pub fn run_ct_python(py: Python, code: PyObject, tokens: TokenStream) -> Result<TokenStream, TokenStream> {
+	let output = run_and_capture(py, code).map_err(|err| compile_error_msg(py, err, tokens))?;
 
-	Ok(TokenStream::from_str(&output).map_err(|e| {
-		Span::call_site()
-			.unwrap()
-			.error(format!("Unable to parse output of ct_python!{{}} script: {:?}", e))
-			.emit()
-	})?)
+	// TokenStream::from_str emits any errors directly, so we don't need to do
+	// anything with the returned LexError.
+	TokenStream::from_str(&output).map_err(|_| TokenStream::new())
 }