Run infallible tests natively

trybuild is VERY SLOW and it hides the test content from tooling
(clippy, fmt, rust-analyzer, etc.). These tests must compile and
pass so there is no reason to run them through trybuild.

This change reduces test run time from 8.7s seconds to 0.7s.

The recent-rustc tests are still run through trybuild even though
they do not need to be simply because this avoids adding a build.rs
and build dependency for versioning. Once the MSRV is increased
this can also just go away.

Author: csnover

tests/run-pass/arithmetic.rs tests/pass/arithmetic.rstests/run-pass/arithmetic.rs renamed to tests/pass/arithmetic.rs

@@ -1,4 +1,3 @@
-extern crate peg;
 use arithmetic::expression;
 
 peg::parser!( grammar arithmetic() for str {
@@ -21,6 +20,7 @@ peg::parser!( grammar arithmetic() for str {
         = n:$(['0'..='9']+) { n.parse().unwrap() }
 });
 
+#[test]
 fn main() {
     assert_eq!(expression("1+1"), Ok(2));
     assert_eq!(expression("5*5"), Ok(25));

tests/run-pass/arithmetic_ast.rs tests/pass/arithmetic_ast.rstests/run-pass/arithmetic_ast.rs renamed to tests/pass/arithmetic_ast.rs

@@ -1,4 +1,3 @@
-extern crate peg;
 use peg::parser;
 
 #[derive(Clone, PartialEq, Eq, Debug)]
@@ -8,7 +7,7 @@ pub enum Expression {
     Product(Box<Expression>, Box<Expression>),
 }
 
-parser!{
+parser! {
 /// Doc comment
 grammar arithmetic() for str {
     /// Top level parser rule
@@ -34,29 +33,42 @@ grammar arithmetic() for str {
         = n:$(['0'..='9']+) { Expression::Number(n.parse().unwrap()) }
 }}
 
+#[test]
 fn main() {
-    assert_eq!(arithmetic::expression("1+1"), Ok(Expression::Sum(
-        Box::new(Expression::Number(1)),
-        Box::new(Expression::Number(1)))
-    ));
-    assert_eq!(arithmetic::expression("5*5"), Ok(Expression::Product(
-        Box::new(Expression::Number(5)),
-        Box::new(Expression::Number(5)))
-    ));
-    assert_eq!(arithmetic::expression("2+3*4"), Ok(Expression::Sum(
-        Box::new(Expression::Number(2)),
-        Box::new(Expression::Product(
-            Box::new(Expression::Number(3)),
-            Box::new(Expression::Number(4))
-        )),
-    )));
-    assert_eq!(arithmetic::expression("(2+3) * 4"), Ok(Expression::Product(
-        Box::new(Expression::Sum(
+    assert_eq!(
+        arithmetic::expression("1+1"),
+        Ok(Expression::Sum(
+            Box::new(Expression::Number(1)),
+            Box::new(Expression::Number(1))
+        ))
+    );
+    assert_eq!(
+        arithmetic::expression("5*5"),
+        Ok(Expression::Product(
+            Box::new(Expression::Number(5)),
+            Box::new(Expression::Number(5))
+        ))
+    );
+    assert_eq!(
+        arithmetic::expression("2+3*4"),
+        Ok(Expression::Sum(
             Box::new(Expression::Number(2)),
-            Box::new(Expression::Number(3)),
-        )),
-        Box::new(Expression::Number(4))
-    )));
+            Box::new(Expression::Product(
+                Box::new(Expression::Number(3)),
+                Box::new(Expression::Number(4))
+            )),
+        ))
+    );
+    assert_eq!(
+        arithmetic::expression("(2+3) * 4"),
+        Ok(Expression::Product(
+            Box::new(Expression::Sum(
+                Box::new(Expression::Number(2)),
+                Box::new(Expression::Number(3)),
+            )),
+            Box::new(Expression::Number(4))
+        ))
+    );
     assert!(arithmetic::expression("(22+)+1").is_err());
     assert!(arithmetic::expression("1++1").is_err());
     assert!(arithmetic::expression("3)+1").is_err());

tests/run-pass/arithmetic_infix.rs tests/pass/arithmetic_infix.rstests/run-pass/arithmetic_infix.rs renamed to tests/pass/arithmetic_infix.rs

@@ -1,6 +1,3 @@
-
-extern crate peg;
-
 peg::parser!( grammar arithmetic() for str {
     rule number() -> i64
         = n:$(['0'..='9']+) { n.parse().unwrap() }
@@ -21,11 +18,12 @@ peg::parser!( grammar arithmetic() for str {
     }
 });
 
+#[test]
 fn main() {
     assert_eq!(arithmetic::calculate("3+3*3+3"), Ok(15));
     assert_eq!(arithmetic::calculate("2+2^2^2^2/2+2"), Ok(32772));
     assert_eq!(arithmetic::calculate("1024/2/2/2+1"), Ok(129));
     assert_eq!(arithmetic::calculate("1024/(1+1)/2/2+1"), Ok(129));
     assert_eq!(arithmetic::calculate("-1-2*-2"), Ok(3));
     assert_eq!(arithmetic::calculate("1+3!+1"), Ok(8));
-}
+}

tests/run-pass/arithmetic_infix_ast.rs tests/pass/arithmetic_infix_ast.rstests/run-pass/arithmetic_infix_ast.rs renamed to tests/pass/arithmetic_infix_ast.rs

@@ -1,5 +1,3 @@
-extern crate peg;
-
 peg::parser!( grammar arithmetic() for str {
     rule ident() -> &'input str = $(['a'..='z']+)
     rule haskell_op() -> String = "`" i:ident() "`" [' '|'\n']* { i.to_owned() }
@@ -18,17 +16,20 @@ peg::parser!( grammar arithmetic() for str {
 pub enum InfixAst {
     Ident(String),
     Add(Box<InfixAst>, Box<InfixAst>),
-    Op(String, Box<InfixAst>, Box<InfixAst>)
+    Op(String, Box<InfixAst>, Box<InfixAst>),
 }
 
-fn main(){
-    assert_eq!(arithmetic::expression("a + b `x` c").unwrap(),
+#[test]
+fn main() {
+    assert_eq!(
+        arithmetic::expression("a + b `x` c").unwrap(),
         InfixAst::Add(
             Box::new(InfixAst::Ident("a".to_owned())),
-            Box::new(InfixAst::Op("x".to_owned(),
+            Box::new(InfixAst::Op(
+                "x".to_owned(),
                 Box::new(InfixAst::Ident("b".to_owned())),
                 Box::new(InfixAst::Ident("c".to_owned()))
             ))
         )
     )
-}
+}

…ts/run-pass/arithmetic_infix_ast_span.rs tests/pass/arithmetic_infix_ast_span.rstests/run-pass/arithmetic_infix_ast_span.rs renamed to tests/pass/arithmetic_infix_ast_span.rs tests/run-pass/arithmetic_infix_ast_span.rs renamed to tests/pass/arithmetic_infix_ast_span.rs

@@ -1,5 +1,3 @@
-extern crate peg;
-
 peg::parser!( grammar arithmetic() for str {
     rule ident() -> &'input str = $(['a'..='z']+)
 
@@ -28,8 +26,10 @@ pub enum Op {
     Mul(Box<Node>, Box<Node>),
 }
 
-fn main(){
-    assert_eq!(arithmetic::expression("a+b*c").unwrap(),
+#[test]
+fn main() {
+    assert_eq!(
+        arithmetic::expression("a+b*c").unwrap(),
         Node {
             start: 0,
             end: 5,
@@ -58,4 +58,4 @@ fn main(){
             )
         }
     );
-}
+}

…n-pass/arithmetic_with_left_recursion.rs …s/pass/arithmetic_with_left_recursion.rstests/run-pass/arithmetic_with_left_recursion.rs renamed to tests/pass/arithmetic_with_left_recursion.rs tests/run-pass/arithmetic_with_left_recursion.rs renamed to tests/pass/arithmetic_with_left_recursion.rs

@@ -1,5 +1,3 @@
-extern crate peg;
-
 use arithmetic::sum;
 
 peg::parser!( grammar arithmetic() for str {
@@ -12,6 +10,7 @@ peg::parser!( grammar arithmetic() for str {
         = n:$(['0'..='9']+) { n.parse().unwrap() }
 });
 
+#[test]
 fn main() {
     assert_eq!(sum("1"), Ok(1));
     assert_eq!(sum("1+1"), Ok(2));

…ss/assembly_ast_dyn_type_param_bounds.rs …ss/assembly_ast_dyn_type_param_bounds.rstests/run-pass/assembly_ast_dyn_type_param_bounds.rs renamed to tests/pass/assembly_ast_dyn_type_param_bounds.rs tests/run-pass/assembly_ast_dyn_type_param_bounds.rs renamed to tests/pass/assembly_ast_dyn_type_param_bounds.rs

@@ -1,4 +1,4 @@
-extern crate peg;
+#![allow(unused)]
 use peg::parser;
 
 // C++ in Rust
@@ -13,14 +13,12 @@ trait AsDynOperand<'a> {
     fn as_dyn_operand(self: Box<Self>) -> Box<dyn Operand<'a> + 'a>;
 }
 
-impl<'a, T: /* Sized + */ Operand<'a> + 'a> AsDynOperand<'a> for T {
+impl<'a, T: Operand<'a> + 'a> AsDynOperand<'a> for T {
     fn as_dyn_operand(self: Box<Self>) -> Box<dyn Operand<'a> + 'a> {
         self
     }
 }
 
-
-
 #[derive(Debug)]
 pub struct Program<'a>(Vec<Box<dyn Operation<'a> + 'a>>);
 
@@ -52,7 +50,7 @@ impl<'a> Location<'a> for Global<'a> {}
 struct Literal(i32);
 impl<'a> Operand<'a> for Literal {}
 
-parser!{
+parser! {
 grammar assembly() for str {
     pub rule program() -> Program<'input>
         = op:operation() ** "\n" { Program(op) }
@@ -82,7 +80,7 @@ grammar assembly() for str {
 
     rule operand() -> Box<dyn Operand<'input> + 'input>
         = l:location() {l.as_dyn_operand()} / l:literal() {Box::new(l)}
-    
+
     rule literal() -> Literal
         = n:$(['0'..='9']+) {?
             let n = n.parse::<i32>().map_err(|_| "invalid int literal")?;
@@ -91,31 +89,35 @@ grammar assembly() for str {
 
 }}
 
+#[test]
 fn main() {
-    let parsed = assembly::program("%apple = add 1 @g
+    let parsed = assembly::program(
+        "%apple = add 1 @g
 @b = add 2 %a
 %c = sub 82 @b
-@dog = sub @b 12").unwrap();
+@dog = sub @b 12",
+    )
+    .unwrap();
     let expected = Program(vec![
-        Box::new(Add{
+        Box::new(Add {
             result: Box::new(Register("apple")),
             lhs: Box::new(Literal(1)),
-            rhs: Box::new(Global("g"))
+            rhs: Box::new(Global("g")),
         }),
-        Box::new(Add{
+        Box::new(Add {
             result: Box::new(Global("b")),
             lhs: Box::new(Literal(2)),
-            rhs: Box::new(Register("a"))
+            rhs: Box::new(Register("a")),
         }),
-        Box::new(Sub{
+        Box::new(Sub {
             result: Box::new(Register("c")),
             lhs: Box::new(Literal(82)),
-            rhs: Box::new(Global("b"))
+            rhs: Box::new(Global("b")),
         }),
-        Box::new(Sub{
+        Box::new(Sub {
             result: Box::new(Global("dog")),
             lhs: Box::new(Global("b")),
-            rhs: Box::new(Literal(12))
+            rhs: Box::new(Literal(12)),
         }),
     ]);
     assert_eq!(format!("{parsed:?}"), format!("{expected:?}"));

tests/run-pass/borrow_from_input.rs tests/pass/borrow_from_input.rstests/run-pass/borrow_from_input.rs renamed to tests/pass/borrow_from_input.rs

@@ -1,8 +1,6 @@
-extern crate peg;
-
 peg::parser!(grammar borrows() for str {
     use std::borrow::{ToOwned, Cow};
-   
+
     pub rule borrowed() -> &'input str
         = $(['a'..='z']+)
 
@@ -13,8 +11,9 @@ peg::parser!(grammar borrows() for str {
 
 use self::borrows::*;
 
+#[test]
 fn main() {
     assert_eq!(borrowed("abcd"), Ok("abcd"));
     assert_eq!(&*lifetime_parameter("abcd").unwrap(), "abcd");
     assert_eq!(&*lifetime_parameter("COW").unwrap(), "cow");
-}
+}

tests/run-pass/bytes.rs tests/pass/bytes.rstests/run-pass/bytes.rs renamed to tests/pass/bytes.rs

@@ -1,13 +1,16 @@
-extern crate peg;
 use peg::parser;
 
-parser!{
+parser! {
     grammar byteparser() for [u8] {
         pub rule commands() -> Vec<&'input[u8]> = command()*
         rule command() -> &'input [u8] = ">" val:$([b' ' ..= b'~']+) [0] { val }
     }
 }
 
+#[test]
 fn main() {
-    assert_eq!(byteparser::commands(b">asdf\0>xyz\0"), Ok(vec![&b"asdf"[..], &b"xyz"[..]]));
+    assert_eq!(
+        byteparser::commands(b">asdf\0>xyz\0"),
+        Ok(vec![&b"asdf"[..], &b"xyz"[..]])
+    );
 }

tests/run-pass/conditional_block.rs tests/pass/conditional_block.rstests/run-pass/conditional_block.rs renamed to tests/pass/conditional_block.rs

@@ -1,5 +1,3 @@
-extern crate peg;
-
 peg::parser!( grammar parse() for str {
 
     pub rule dec_byte() -> u8
@@ -37,6 +35,7 @@ peg::parser!( grammar parse() for str {
     }
 });
 
+#[test]
 fn main() {
     assert_eq!(parse::dec_byte("0"), Ok(0));
     assert_eq!(parse::dec_byte("255"), Ok(255));
@@ -49,7 +48,15 @@ fn main() {
     assert!(parse::xml("<a><b><c></b></c></a>").is_err());
     assert!(parse::xml("<a><b></c><c></b></a>").is_err());
 
-    assert!(parse::return_early("a").unwrap_err().expected.tokens().any(|e| e == "number"));
-    assert!(parse::return_early("123").unwrap_err().expected.tokens().any(|e| e == "smaller number"));
+    assert!(parse::return_early("a")
+        .unwrap_err()
+        .expected
+        .tokens()
+        .any(|e| e == "number"));
+    assert!(parse::return_early("123")
+        .unwrap_err()
+        .expected
+        .tokens()
+        .any(|e| e == "smaller number"));
     assert_eq!(parse::return_early("99").unwrap(), 99);
 }