Remove proc-macro-error dependency (#136)

* Don't blindly discard errors

This prevents syn::Error from propagating.

Updates #135.

* Use syn::ParseStream::error

This fails tests.

#135

* Use proc-macro2-diagnostics

Bump MSRV to 1.63 for the new yansi dependency (through
proc-macro2-diagnostics). See
https://github.com/SergioBenitez/yansi/blob/e8247a492e1b/Cargo.toml#L12.

Cargo.toml

@@ -11,7 +11,7 @@ license = "MIT"
 repository = "https://github.com/frondeus/test-case"
 documentation = "https://docs.rs/test-case"
 exclude = ["tests/snapshots/**/*"]
-rust-version = "1.58.1"
+rust-version = "1.63"
 
 [features]
 with-regex = ["regex", "test-case-macros/with-regex"]

crates/test-case-core/Cargo.toml

@@ -22,8 +22,8 @@ doctest = false
 path = "src/lib.rs"
 
 [dependencies]
-cfg-if = "1.0"
-proc-macro2 = { version = "1.0", features = [] }
-proc-macro-error = { version = "1.0", default-features = false }
-quote = "1.0"
-syn = { version = "2.0", features = ["full", "extra-traits"] }
+cfg-if  = "1.0"
+proc-macro2  = { version = "1.0", features = [] }
+proc-macro2-diagnostics = "0.10"
+quote  = "1.0"
+syn  = { version = "2.0", features = ["full", "extra-traits"] }

crates/test-case-core/src/complex_expr.rs

@@ -1,5 +1,6 @@
 use crate::utils::fmt_syn;
 use proc_macro2::Group;
+use proc_macro2::Span;
 use proc_macro2::TokenStream;
 use quote::{quote, TokenStreamExt};
 use std::fmt::{Display, Formatter};
@@ -323,11 +324,11 @@ impl ComplexTestCase {
  expected_regex: input.parse()?,
  })
  } else {
- proc_macro_error::abort!(input.span(), "'with-regex' feature is required to use 'matches-regex' keyword");
+ return Err(input.error("'with-regex' feature is required to use 'matches-regex' keyword"));
  }
  }
  } else {
- proc_macro_error::abort!(input.span(), "cannot parse complex expression")
+ return Err(input.error("cannot parse complex expression"));
  })
  }
 }
@@ -450,7 +451,11 @@ fn regex_assertion(expected_regex: &Expr) -> TokenStream {
 fn not_assertion(not: &ComplexTestCase) -> TokenStream {
  match not {
  ComplexTestCase::Not(_) => {
- proc_macro_error::abort_call_site!("multiple negations on single item are forbidden")
+ use proc_macro2_diagnostics::SpanDiagnosticExt as _;
+
+ Span::call_site()
+ .error("multiple negations on single item are forbidden")
+ .emit_as_expr_tokens()
  }
  ComplexTestCase::And(cases) => negate(and_assertion(cases)),
  ComplexTestCase::Or(cases) => negate(or_assertion(cases)),

crates/test-case-core/src/expr.rs

@@ -193,9 +193,10 @@ where
  Mapping: FnOnce(Option<Inner>) -> TestCaseResult,
  Inner: Parse,
 {
+ let result = (!input.is_empty()).then(|| input.parse()).transpose()?;
  Ok(TestCaseExpression {
  _token: token,
  extra_keywords,
- result: mapping(input.parse::<Inner>().ok()),
+ result: mapping(result),
  })
 }

crates/test-case-core/src/test_case.rs

@@ -17,8 +17,15 @@ pub struct TestCase {
 impl Parse for TestCase {
  fn parse(input: ParseStream) -> Result<Self, Error> {
  let args = Punctuated::parse_separated_nonempty_with(input, Expr::parse)?;
- let expression = input.parse::<TestCaseExpression>().ok();
- let comment = input.parse::<TestCaseComment>().ok();
+ let expression = (!input.is_empty()).then(|| input.parse()).transpose();
+ let comment = (!input.is_empty()).then(|| input.parse()).transpose();
+ // if both are errors, pick the expression error since it is more likely to be informative.
+ //
+ // TODO(https://github.com/frondeus/test-case/issues/135): avoid Result::ok entirely.
+ let (expression, comment) = match (expression, comment) {
+ (Err(expression), Err(_comment)) => return Err(expression),
+ (expression, comment) => (expression.ok().flatten(), comment.ok().flatten()),
+ };
 
  Ok(Self::new_from_parsed(args, expression, comment))
  }

crates/test-case-core/src/test_matrix/mod.rs

@@ -46,9 +46,19 @@ impl Parse for TestMatrix {
  fn parse(input: ParseStream) -> syn::Result<Self> {
  let args: Punctuated<Expr, Token![,]> = Punctuated::parse_separated_nonempty(input)?;
 
+ let expression = (!input.is_empty()).then(|| input.parse()).transpose();
+ let comment = (!input.is_empty()).then(|| input.parse()).transpose();
+ // if both are errors, pick the expression error since it is more likely to be informative.
+ //
+ // TODO(https://github.com/frondeus/test-case/issues/135): avoid Result::ok entirely.
+ let (expression, comment) = match (expression, comment) {
+ (Err(expression), Err(_comment)) => return Err(expression),
+ (expression, comment) => (expression.ok().flatten(), comment.ok().flatten()),
+ };
+
  let mut matrix = TestMatrix {
- expression: input.parse().ok(),
- comment: input.parse().ok(),
+ expression,
+ comment,
  ..Default::default()
  };
 

crates/test-case-macros/Cargo.toml

@@ -23,8 +23,7 @@ proc-macro = true
 path = "src/lib.rs"
 
 [dependencies]
-proc-macro2 = { version = "1.0", features = [] }
-proc-macro-error = { version = "1.0", default-features = false }
-quote = "1.0"
-syn = { version = "2.0", features = ["full", "extra-traits", "parsing"] }
-test-case-core = { version = "3.2.1", path = "../test-case-core", default-features = false }
+proc-macro2 = { version = "1.0", features = [] }
+quote = "1.0"
+syn = { version = "2.0", features = ["full", "extra-traits", "parsing"] }
+test-case-core = { version = "3.2.1", path = "../test-case-core", default-features = false }

crates/test-case-macros/src/lib.rs

@@ -22,7 +22,6 @@ use test_case_core::{TestCase, TestMatrix};
 /// When _expected result_ is provided, it is compared against the actual value generated with _test body_ using `assert_eq!`.
 /// _Test cases_ that don't provide _expected result_ should contain custom assertions within _test body_ or return `Result` similar to `#[test]` macro.
 #[proc_macro_attribute]
-#[proc_macro_error::proc_macro_error]
 pub fn test_case(args: TokenStream, input: TokenStream) -> TokenStream {
  let test_case = parse_macro_input!(args as TestCase);
  let mut item = parse_macro_input!(input as ItemFn);
@@ -50,7 +49,6 @@ pub fn test_case(args: TokenStream, input: TokenStream) -> TokenStream {
 /// _Expected result_ and _Test body_ are the same as they are for the singular `#[test_case(...)]`
 /// macro but are applied to every case generated by `#[test_matrix(...)]`.
 #[proc_macro_attribute]
-#[proc_macro_error::proc_macro_error]
 pub fn test_matrix(args: TokenStream, input: TokenStream) -> TokenStream {
  let matrix = parse_macro_input!(args as TestMatrix);
  let mut item = parse_macro_input!(input as ItemFn);