summaryrefslogtreecommitdiffstats
path: root/tests/ui/macros/stringify.rs
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--tests/ui/macros/stringify.rs378
1 files changed, 179 insertions, 199 deletions
diff --git a/tests/ui/macros/stringify.rs b/tests/ui/macros/stringify.rs
index 70ca00285..6fc12509a 100644
--- a/tests/ui/macros/stringify.rs
+++ b/tests/ui/macros/stringify.rs
@@ -10,7 +10,10 @@
#![feature(coroutines)]
#![feature(decl_macro)]
#![feature(explicit_tail_calls)]
+#![feature(if_let_guard)]
+#![feature(let_chains)]
#![feature(more_qualified_paths)]
+#![feature(never_patterns)]
#![feature(raw_ref_op)]
#![feature(trait_alias)]
#![feature(try_blocks)]
@@ -46,7 +49,7 @@ macro_rules! c1 {
// easy to find the cases where the two pretty-printing approaches give
// different results.
macro_rules! c2 {
- ($frag:ident, [$($tt:tt)*], $s1:literal, $s2:literal) => {
+ ($frag:ident, [$($tt:tt)*], $s1:literal, $s2:literal $(,)?) => {
assert_ne!($s1, $s2, "should use `c1!` instead");
assert_eq!($frag!($($tt)*), $s1);
assert_eq!(stringify!($($tt)*), $s2);
@@ -58,19 +61,13 @@ fn test_block() {
c1!(block, [ {} ], "{}");
c1!(block, [ { true } ], "{ true }");
c1!(block, [ { return } ], "{ return }");
- c2!(block, [ {
- return;
- } ],
- "{ return; }",
- "{ return ; }"
- );
- c2!(block,
+ c1!(block, [ { return; } ], "{ return; }");
+ c1!(block,
[ {
let _;
true
} ],
- "{ let _; true }",
- "{ let _ ; true }"
+ "{ let _; true }"
);
}
@@ -87,17 +84,18 @@ fn test_expr() {
// ExprKind::Call
c1!(expr, [ f() ], "f()");
- c2!(expr, [ f::<u8>() ], "f::<u8>()", "f :: < u8 > ()");
- c2!(expr, [ f::<1>() ], "f::<1>()", "f :: < 1 > ()");
- c2!(expr, [ f::<'a, u8, 1>() ], "f::<'a, u8, 1>()", "f :: < 'a, u8, 1 > ()");
+ c1!(expr, [ f::<u8>() ], "f::<u8>()");
+ c2!(expr, [ f :: < u8>( ) ], "f::<u8>()", "f :: < u8>()");
+ c1!(expr, [ f::<1>() ], "f::<1>()");
+ c1!(expr, [ f::<'a, u8, 1>() ], "f::<'a, u8, 1>()");
c1!(expr, [ f(true) ], "f(true)");
c2!(expr, [ f(true,) ], "f(true)", "f(true,)");
- c2!(expr, [ ()() ], "()()", "() ()");
+ c1!(expr, [ ()() ], "()()");
// ExprKind::MethodCall
c1!(expr, [ x.f() ], "x.f()");
- c2!(expr, [ x.f::<u8>() ], "x.f::<u8>()", "x.f :: < u8 > ()");
- c2!(expr, [ x.collect::<Vec<_>>() ], "x.collect::<Vec<_>>()", "x.collect :: < Vec < _ >> ()");
+ c1!(expr, [ x.f::<u8>() ], "x.f::<u8>()");
+ c1!(expr, [ x.collect::<Vec<_>>() ], "x.collect::<Vec<_>>()");
// ExprKind::Tup
c1!(expr, [ () ], "()");
@@ -109,18 +107,14 @@ fn test_expr() {
c1!(expr, [ true || false ], "true || false");
c1!(expr, [ true || false && false ], "true || false && false");
c1!(expr, [ a < 1 && 2 < b && c > 3 && 4 > d ], "a < 1 && 2 < b && c > 3 && 4 > d");
- c2!(expr, [ a & b & !c ], "a & b & !c", "a & b &! c"); // FIXME
- c2!(expr,
- [ a + b * c - d + -1 * -2 - -3],
- "a + b * c - d + -1 * -2 - -3",
- "a + b * c - d + - 1 * - 2 - - 3"
- );
- c2!(expr, [ x = !y ], "x = !y", "x =! y"); // FIXME
+ c2!(expr, [ a & b & !c ], "a & b & !c", "a & b &!c"); // FIXME
+ c1!(expr, [ a + b * c - d + -1 * -2 - -3], "a + b * c - d + -1 * -2 - -3");
+ c2!(expr, [ x = !y ], "x = !y", "x =!y"); // FIXME
// ExprKind::Unary
- c2!(expr, [ *expr ], "*expr", "* expr");
- c2!(expr, [ !expr ], "!expr", "! expr");
- c2!(expr, [ -expr ], "-expr", "- expr");
+ c1!(expr, [ *expr ], "*expr");
+ c1!(expr, [ !expr ], "!expr");
+ c1!(expr, [ -expr ], "-expr");
// ExprKind::Lit
c1!(expr, [ 'x' ], "'x'");
@@ -129,21 +123,34 @@ fn test_expr() {
// ExprKind::Cast
c1!(expr, [ expr as T ], "expr as T");
- c2!(expr, [ expr as T<u8> ], "expr as T<u8>", "expr as T < u8 >");
+ c1!(expr, [ expr as T<u8> ], "expr as T<u8>");
// ExprKind::Type: there is no syntax for type ascription.
// ExprKind::Let
c1!(expr, [ if let Some(a) = b { c } else { d } ], "if let Some(a) = b { c } else { d }");
+ c1!(expr, [ if let _ = true && false {} ], "if let _ = true && false {}");
+ c1!(expr, [ if let _ = (true && false) {} ], "if let _ = (true && false) {}");
+ macro_rules! c2_if_let {
+ ($expr:expr, $expr_expected:expr, $tokens_expected:expr $(,)?) => {
+ c2!(expr, [ if let _ = $expr {} ], $expr_expected, $tokens_expected);
+ };
+ }
+ c2_if_let!(
+ true && false,
+ "if let _ = (true && false) {}",
+ "if let _ = true && false {}",
+ );
+ c2!(expr,
+ [ match () { _ if let _ = Struct {} => {} } ],
+ "match () { _ if let _ = Struct {} => {} }",
+ "match() { _ if let _ = Struct {} => {} }",
+ );
// ExprKind::If
c1!(expr, [ if true {} ], "if true {}");
- c2!(expr, [ if !true {} ], "if !true {}", "if! true {}"); // FIXME
- c2!(expr,
- [ if ::std::blah() { } else { } ],
- "if ::std::blah() {} else {}",
- "if :: std :: blah() {} else {}"
- );
+ c2!(expr, [ if !true {} ], "if !true {}", "if!true {}"); // FIXME
+ c1!(expr, [ if ::std::blah() { } else { } ], "if ::std::blah() {} else {}");
c1!(expr, [ if let true = true {} else {} ], "if let true = true {} else {}");
c1!(expr,
[ if true {
@@ -158,7 +165,7 @@ fn test_expr() {
} ],
"if true {} else if false {} else {}"
);
- c2!(expr,
+ c1!(expr,
[ if true {
return;
} else if false {
@@ -166,22 +173,21 @@ fn test_expr() {
} else {
0
} ],
- "if true { return; } else if false { 0 } else { 0 }",
- "if true { return ; } else if false { 0 } else { 0 }"
+ "if true { return; } else if false { 0 } else { 0 }"
);
// ExprKind::While
c1!(expr, [ while true {} ], "while true {}");
- c2!(expr, [ 'a: while true {} ], "'a: while true {}", "'a : while true {}");
+ c1!(expr, [ 'a: while true {} ], "'a: while true {}");
c1!(expr, [ while let true = true {} ], "while let true = true {}");
// ExprKind::ForLoop
c1!(expr, [ for _ in x {} ], "for _ in x {}");
- c2!(expr, [ 'a: for _ in x {} ], "'a: for _ in x {}", "'a : for _ in x {}");
+ c1!(expr, [ 'a: for _ in x {} ], "'a: for _ in x {}");
// ExprKind::Loop
c1!(expr, [ loop {} ], "loop {}");
- c2!(expr, [ 'a: loop {} ], "'a: loop {}", "'a : loop {}");
+ c1!(expr, [ 'a: loop {} ], "'a: loop {}");
// ExprKind::Match
c1!(expr, [ match self {} ], "match self {}");
@@ -201,8 +207,8 @@ fn test_expr() {
// ExprKind::Closure
c1!(expr, [ || {} ], "|| {}");
- c2!(expr, [ |x| {} ], "|x| {}", "| x | {}");
- c2!(expr, [ |x: u8| {} ], "|x: u8| {}", "| x : u8 | {}");
+ c1!(expr, [ |x| {} ], "|x| {}");
+ c1!(expr, [ |x: u8| {} ], "|x: u8| {}");
c1!(expr, [ || () ], "|| ()");
c1!(expr, [ move || self ], "move || self");
c1!(expr, [ async || self ], "async || self");
@@ -217,7 +223,7 @@ fn test_expr() {
// ExprKind::Block
c1!(expr, [ {} ], "{}");
c1!(expr, [ unsafe {} ], "unsafe {}");
- c2!(expr, [ 'a: {} ], "'a: {}", "'a : {}");
+ c1!(expr, [ 'a: {} ], "'a: {}");
c1!(expr, [ #[attr] {} ], "#[attr] {}");
c2!(expr,
[
@@ -228,7 +234,7 @@ fn test_expr() {
"{\n\
\x20 #![attr]\n\
}",
- "{ #! [attr] }"
+ "{ #![attr] }"
);
// ExprKind::Async
@@ -252,34 +258,35 @@ fn test_expr() {
c1!(expr, [ expr.0 ], "expr.0");
// ExprKind::Index
- c2!(expr, [ expr[true] ], "expr[true]", "expr [true]");
+ c1!(expr, [ expr[true] ], "expr[true]");
// ExprKind::Range
c1!(expr, [ .. ], "..");
- c2!(expr, [ ..hi ], "..hi", ".. hi");
- c2!(expr, [ lo.. ], "lo..", "lo ..");
- c2!(expr, [ lo..hi ], "lo..hi", "lo .. hi");
- c2!(expr, [ ..=hi ], "..=hi", "..= hi");
- c2!(expr, [ lo..=hi ], "lo..=hi", "lo ..= hi");
- c2!(expr, [ -2..=-1 ], "-2..=-1", "- 2 ..= - 1");
+ c1!(expr, [ ..hi ], "..hi");
+ c1!(expr, [ lo.. ], "lo..");
+ c1!(expr, [ lo..hi ], "lo..hi");
+ c2!(expr, [ lo .. hi ], "lo..hi", "lo .. hi");
+ c1!(expr, [ ..=hi ], "..=hi");
+ c1!(expr, [ lo..=hi ], "lo..=hi");
+ c1!(expr, [ -2..=-1 ], "-2..=-1");
// ExprKind::Underscore
// FIXME: todo
// ExprKind::Path
c1!(expr, [ thing ], "thing");
- c2!(expr, [ m::thing ], "m::thing", "m :: thing");
- c2!(expr, [ self::thing ], "self::thing", "self :: thing");
- c2!(expr, [ crate::thing ], "crate::thing", "crate :: thing");
- c2!(expr, [ Self::thing ], "Self::thing", "Self :: thing");
- c2!(expr, [ <Self as T>::thing ], "<Self as T>::thing", "< Self as T > :: thing");
- c2!(expr, [ Self::<'static> ], "Self::<'static>", "Self :: < 'static >");
+ c1!(expr, [ m::thing ], "m::thing");
+ c1!(expr, [ self::thing ], "self::thing");
+ c1!(expr, [ crate::thing ], "crate::thing");
+ c1!(expr, [ Self::thing ], "Self::thing");
+ c1!(expr, [ <Self as T>::thing ], "<Self as T>::thing");
+ c1!(expr, [ Self::<'static> ], "Self::<'static>");
// ExprKind::AddrOf
- c2!(expr, [ &expr ], "&expr", "& expr");
- c2!(expr, [ &mut expr ], "&mut expr", "& mut expr");
- c2!(expr, [ &raw const expr ], "&raw const expr", "& raw const expr");
- c2!(expr, [ &raw mut expr ], "&raw mut expr", "& raw mut expr");
+ c1!(expr, [ &expr ], "&expr");
+ c1!(expr, [ &mut expr ], "&mut expr");
+ c1!(expr, [ &raw const expr ], "&raw const expr");
+ c1!(expr, [ &raw mut expr ], "&raw mut expr");
// ExprKind::Break
c1!(expr, [ break ], "break");
@@ -300,38 +307,30 @@ fn test_expr() {
// ExprKind::OffsetOf: untestable because this test works pre-expansion.
// ExprKind::MacCall
- c2!(expr, [ mac!(...) ], "mac!(...)", "mac! (...)");
- c2!(expr, [ mac![...] ], "mac![...]", "mac! [...]");
+ c1!(expr, [ mac!(...) ], "mac!(...)");
+ c1!(expr, [ mac![...] ], "mac![...]");
c1!(expr, [ mac! { ... } ], "mac! { ... }");
// ExprKind::Struct
c1!(expr, [ Struct {} ], "Struct {}");
- c2!(expr,
- [ <Struct as Trait>::Type {} ],
- "<Struct as Trait>::Type {}",
- "< Struct as Trait > :: Type {}"
- );
+ c1!(expr, [ <Struct as Trait>::Type {} ], "<Struct as Trait>::Type {}");
c1!(expr, [ Struct { .. } ], "Struct { .. }");
- c2!(expr, [ Struct { ..base } ], "Struct { ..base }", "Struct { .. base }");
+ c1!(expr, [ Struct { ..base } ], "Struct { ..base }");
c1!(expr, [ Struct { x } ], "Struct { x }");
c1!(expr, [ Struct { x, .. } ], "Struct { x, .. }");
- c2!(expr, [ Struct { x, ..base } ], "Struct { x, ..base }", "Struct { x, .. base }");
- c2!(expr, [ Struct { x: true } ], "Struct { x: true }", "Struct { x : true }");
- c2!(expr, [ Struct { x: true, .. } ], "Struct { x: true, .. }", "Struct { x : true, .. }");
- c2!(expr,
- [ Struct { x: true, ..base } ],
- "Struct { x: true, ..base }",
- "Struct { x : true, .. base }"
- );
+ c1!(expr, [ Struct { x, ..base } ], "Struct { x, ..base }");
+ c1!(expr, [ Struct { x: true } ], "Struct { x: true }");
+ c1!(expr, [ Struct { x: true, .. } ], "Struct { x: true, .. }");
+ c1!(expr, [ Struct { x: true, ..base } ], "Struct { x: true, ..base }");
// ExprKind::Repeat
- c2!(expr, [ [(); 0] ], "[(); 0]", "[() ; 0]");
+ c1!(expr, [ [(); 0] ], "[(); 0]");
// ExprKind::Paren
c1!(expr, [ (expr) ], "(expr)");
// ExprKind::Try
- c2!(expr, [ expr? ], "expr?", "expr ?");
+ c1!(expr, [ expr? ], "expr?");
// ExprKind::Yield
c1!(expr, [ yield ], "yield");
@@ -355,51 +354,42 @@ fn test_expr() {
#[test]
fn test_item() {
// ItemKind::ExternCrate
- c2!(item, [ extern crate std; ], "extern crate std;", "extern crate std ;");
- c2!(item,
- [ pub extern crate self as std; ],
- "pub extern crate self as std;",
- "pub extern crate self as std ;"
- );
+ c1!(item, [ extern crate std; ], "extern crate std;");
+ c1!(item, [ pub extern crate self as std; ], "pub extern crate self as std;");
// ItemKind::Use
c2!(item,
[ pub use crate::{a, b::c}; ],
"pub use crate::{a, b::c};",
- "pub use crate :: { a, b :: c } ;"
+ "pub use crate::{ a, b::c };" // FIXME
);
- c2!(item, [ pub use A::*; ], "pub use A::*;", "pub use A :: * ;");
+ c1!(item, [ pub use A::*; ], "pub use A::*;");
// ItemKind::Static
- c2!(item, [ pub static S: () = {}; ], "pub static S: () = {};", "pub static S : () = {} ;");
- c2!(item, [ static mut S: () = {}; ], "static mut S: () = {};", "static mut S : () = {} ;");
- c2!(item, [ static S: (); ], "static S: ();", "static S : () ;");
- c2!(item, [ static mut S: (); ], "static mut S: ();", "static mut S : () ;");
+ c1!(item, [ pub static S: () = {}; ], "pub static S: () = {};");
+ c1!(item, [ static mut S: () = {}; ], "static mut S: () = {};");
+ c1!(item, [ static S: (); ], "static S: ();");
+ c1!(item, [ static mut S: (); ], "static mut S: ();");
// ItemKind::Const
- c2!(item, [ pub const S: () = {}; ], "pub const S: () = {};", "pub const S : () = {} ;");
- c2!(item, [ const S: (); ], "const S: ();", "const S : () ;");
+ c1!(item, [ pub const S: () = {}; ], "pub const S: () = {};");
+ c1!(item, [ const S: (); ], "const S: ();");
// ItemKind::Fn
c1!(item,
[ pub default const async unsafe extern "C" fn f() {} ],
"pub default const async unsafe extern \"C\" fn f() {}"
);
- c2!(item,
- [ fn g<T>(t: Vec<Vec<Vec<T>>>) {} ],
- "fn g<T>(t: Vec<Vec<Vec<T>>>) {}",
- "fn g < T > (t : Vec < Vec < Vec < T >> >) {}"
- );
- c2!(item,
+ c1!(item, [ fn g<T>(t: Vec<Vec<Vec<T>>>) {} ], "fn g<T>(t: Vec<Vec<Vec<T>>>) {}");
+ c1!(item,
[ fn h<'a>(t: &'a Vec<Cell<dyn D>>) {} ],
- "fn h<'a>(t: &'a Vec<Cell<dyn D>>) {}",
- "fn h < 'a > (t : & 'a Vec < Cell < dyn D >>) {}"
+ "fn h<'a>(t: &'a Vec<Cell<dyn D>>) {}"
);
// ItemKind::Mod
- c2!(item, [ pub mod m; ], "pub mod m;", "pub mod m ;");
+ c1!(item, [ pub mod m; ], "pub mod m;");
c1!(item, [ mod m {} ], "mod m {}");
- c2!(item, [ unsafe mod m; ], "unsafe mod m;", "unsafe mod m ;");
+ c1!(item, [ unsafe mod m; ], "unsafe mod m;");
c1!(item, [ unsafe mod m {} ], "unsafe mod m {}");
// ItemKind::ForeignMod
@@ -422,7 +412,7 @@ fn test_item() {
= T;
],
"pub default type Type<'a>: Bound where Self: 'a = T;",
- "pub default type Type < 'a > : Bound where Self : 'a, = T ;"
+ "pub default type Type<'a>: Bound where Self: 'a, = T;"
);
// ItemKind::Enum
@@ -455,13 +445,13 @@ fn test_item() {
\x20 t: T,\n\
\x20 },\n\
}",
- "enum Enum < T > where T : 'a, { Unit, Tuple(T), Struct { t : T }, }"
+ "enum Enum<T> where T: 'a, { Unit, Tuple(T), Struct { t: T }, }"
);
// ItemKind::Struct
- c2!(item, [ pub struct Unit; ], "pub struct Unit;", "pub struct Unit ;");
- c2!(item, [ struct Tuple(); ], "struct Tuple();", "struct Tuple() ;");
- c2!(item, [ struct Tuple(T); ], "struct Tuple(T);", "struct Tuple(T) ;");
+ c1!(item, [ pub struct Unit; ], "pub struct Unit;");
+ c1!(item, [ struct Tuple(); ], "struct Tuple();");
+ c1!(item, [ struct Tuple(T); ], "struct Tuple(T);");
c1!(item, [ struct Struct {} ], "struct Struct {}");
c2!(item,
[
@@ -475,7 +465,7 @@ fn test_item() {
"struct Struct<T> where T: 'a {\n\
\x20 t: T,\n\
}",
- "struct Struct < T > where T : 'a, { t : T, }"
+ "struct Struct<T> where T: 'a, { t: T, }"
);
// ItemKind::Union
@@ -489,7 +479,7 @@ fn test_item() {
"union Union<T> where T: 'a {\n\
\x20 t: T,\n\
}",
- "union Union < T > where T : 'a { t : T, }"
+ "union Union<T> where T: 'a { t: T, }"
);
// ItemKind::Trait
@@ -503,30 +493,25 @@ fn test_item() {
}
],
"trait Trait<'a>: Sized where Self: 'a {}",
- "trait Trait < 'a > : Sized where Self : 'a, {}"
+ "trait Trait<'a>: Sized where Self: 'a, {}"
);
// ItemKind::TraitAlias
- c2!(item,
+ c1!(item,
[ pub trait Trait<T> = Sized where T: 'a; ],
- "pub trait Trait<T> = Sized where T: 'a;",
- "pub trait Trait < T > = Sized where T : 'a ;"
+ "pub trait Trait<T> = Sized where T: 'a;"
);
// ItemKind::Impl
c1!(item, [ pub impl Struct {} ], "pub impl Struct {}");
- c2!(item, [ impl<T> Struct<T> {} ], "impl<T> Struct<T> {}", "impl < T > Struct < T > {}");
+ c1!(item, [ impl<T> Struct<T> {} ], "impl<T> Struct<T> {}");
c1!(item, [ pub impl Trait for Struct {} ], "pub impl Trait for Struct {}");
- c2!(item,
- [ impl<T> const Trait for T {} ],
- "impl<T> const Trait for T {}",
- "impl < T > const Trait for T {}"
- );
- c2!(item, [ impl ~const Struct {} ], "impl ~const Struct {}", "impl ~ const Struct {}");
+ c1!(item, [ impl<T> const Trait for T {} ], "impl<T> const Trait for T {}");
+ c1!(item, [ impl ~const Struct {} ], "impl ~const Struct {}");
// ItemKind::MacCall
- c2!(item, [ mac!(...); ], "mac!(...);", "mac! (...) ;");
- c2!(item, [ mac![...]; ], "mac![...];", "mac! [...] ;");
+ c1!(item, [ mac!(...); ], "mac!(...);");
+ c1!(item, [ mac![...]; ], "mac![...];");
c1!(item, [ mac! { ... } ], "mac! { ... }");
// ItemKind::MacroDef
@@ -536,7 +521,7 @@ fn test_item() {
() => {};
}
],
- "macro_rules! stringify { () => {} ; }"
+ "macro_rules! stringify { () => {}; }"
);
c2!(item,
[ pub macro stringify() {} ],
@@ -550,7 +535,7 @@ fn test_meta() {
c1!(meta, [ k ], "k");
c1!(meta, [ k = "v" ], "k = \"v\"");
c1!(meta, [ list(k1, k2 = "v") ], "list(k1, k2 = \"v\")");
- c2!(meta, [ serde::k ], "serde::k", "serde :: k");
+ c1!(meta, [ serde::k ], "serde::k");
}
#[test]
@@ -567,42 +552,35 @@ fn test_pat() {
// PatKind::Struct
c1!(pat, [ Struct {} ], "Struct {}");
- c2!(pat, [ Struct::<u8> {} ], "Struct::<u8> {}", "Struct :: < u8 > {}");
- c2!(pat, [ Struct::<'static> {} ], "Struct::<'static> {}", "Struct :: < 'static > {}");
+ c1!(pat, [ Struct::<u8> {} ], "Struct::<u8> {}");
+ c2!(pat, [ Struct ::< u8 > {} ], "Struct::<u8> {}", "Struct ::< u8 > {}");
+ c1!(pat, [ Struct::<'static> {} ], "Struct::<'static> {}");
c1!(pat, [ Struct { x } ], "Struct { x }");
- c2!(pat, [ Struct { x: _x } ], "Struct { x: _x }", "Struct { x : _x }");
+ c1!(pat, [ Struct { x: _x } ], "Struct { x: _x }");
c1!(pat, [ Struct { .. } ], "Struct { .. }");
c1!(pat, [ Struct { x, .. } ], "Struct { x, .. }");
- c2!(pat, [ Struct { x: _x, .. } ], "Struct { x: _x, .. }", "Struct { x : _x, .. }");
- c2!(pat,
- [ <Struct as Trait>::Type {} ],
- "<Struct as Trait>::Type {}",
- "< Struct as Trait > :: Type {}"
- );
+ c1!(pat, [ Struct { x: _x, .. } ], "Struct { x: _x, .. }");
+ c1!(pat, [ <Struct as Trait>::Type {} ], "<Struct as Trait>::Type {}");
// PatKind::TupleStruct
c1!(pat, [ Tuple() ], "Tuple()");
- c2!(pat, [ Tuple::<u8>() ], "Tuple::<u8>()", "Tuple :: < u8 > ()");
- c2!(pat, [ Tuple::<'static>() ], "Tuple::<'static>()", "Tuple :: < 'static > ()");
+ c1!(pat, [ Tuple::<u8>() ], "Tuple::<u8>()");
+ c1!(pat, [ Tuple::<'static>() ], "Tuple::<'static>()");
c1!(pat, [ Tuple(x) ], "Tuple(x)");
c1!(pat, [ Tuple(..) ], "Tuple(..)");
c1!(pat, [ Tuple(x, ..) ], "Tuple(x, ..)");
- c2!(pat,
- [ <Struct as Trait>::Type() ],
- "<Struct as Trait>::Type()",
- "< Struct as Trait > :: Type()"
- );
+ c1!(pat, [ <Struct as Trait>::Type() ], "<Struct as Trait>::Type()");
// PatKind::Or
c1!(pat, [ true | false ], "true | false");
c2!(pat, [ | true ], "true", "| true");
- c2!(pat, [ |true| false ], "true | false", "| true | false");
+ c2!(pat, [ |true| false ], "true | false", "|true| false");
// PatKind::Path
- c2!(pat, [ crate::Path ], "crate::Path", "crate :: Path");
- c2!(pat, [ Path::<u8> ], "Path::<u8>", "Path :: < u8 >");
- c2!(pat, [ Path::<'static> ], "Path::<'static>", "Path :: < 'static >");
- c2!(pat, [ <Struct as Trait>::Type ], "<Struct as Trait>::Type", "< Struct as Trait > :: Type");
+ c1!(pat, [ crate::Path ], "crate::Path");
+ c1!(pat, [ Path::<u8> ], "Path::<u8>");
+ c1!(pat, [ Path::<'static> ], "Path::<'static>");
+ c1!(pat, [ <Struct as Trait>::Type ], "<Struct as Trait>::Type");
// PatKind::Tuple
c1!(pat, [ () ], "()");
@@ -613,18 +591,18 @@ fn test_pat() {
c1!(pat, [ box pat ], "box pat");
// PatKind::Ref
- c2!(pat, [ &pat ], "&pat", "& pat");
- c2!(pat, [ &mut pat ], "&mut pat", "& mut pat");
+ c1!(pat, [ &pat ], "&pat");
+ c1!(pat, [ &mut pat ], "&mut pat");
// PatKind::Lit
c1!(pat, [ 1_000_i8 ], "1_000_i8");
// PatKind::Range
- c2!(pat, [ ..1 ], "..1", ".. 1");
- c2!(pat, [ 0.. ], "0..", "0 ..");
- c2!(pat, [ 0..1 ], "0..1", "0 .. 1");
- c2!(pat, [ 0..=1 ], "0..=1", "0 ..= 1");
- c2!(pat, [ -2..=-1 ], "-2..=-1", "- 2 ..= - 1");
+ c1!(pat, [ ..1 ], "..1");
+ c1!(pat, [ 0.. ], "0..");
+ c1!(pat, [ 0..1 ], "0..1");
+ c1!(pat, [ 0..=1 ], "0..=1");
+ c1!(pat, [ -2..=-1 ], "-2..=-1");
// PatKind::Slice
c1!(pat, [ [] ], "[]");
@@ -635,24 +613,28 @@ fn test_pat() {
// PatKind::Rest
c1!(pat, [ .. ], "..");
+ // PatKind::Never
+ c1!(pat, [ Some(!) ], "Some(!)");
+ c1!(pat, [ None | Some(!) ], "None | Some(!)");
+
// PatKind::Paren
c1!(pat, [ (pat) ], "(pat)");
// PatKind::MacCall
- c2!(pat, [ mac!(...) ], "mac!(...)", "mac! (...)");
- c2!(pat, [ mac![...] ], "mac![...]", "mac! [...]");
+ c1!(pat, [ mac!(...) ], "mac!(...)");
+ c1!(pat, [ mac![...] ], "mac![...]");
c1!(pat, [ mac! { ... } ], "mac! { ... }");
}
#[test]
fn test_path() {
c1!(path, [ thing ], "thing");
- c2!(path, [ m::thing ], "m::thing", "m :: thing");
- c2!(path, [ self::thing ], "self::thing", "self :: thing");
- c2!(path, [ crate::thing ], "crate::thing", "crate :: thing");
- c2!(path, [ Self::thing ], "Self::thing", "Self :: thing");
- c2!(path, [ Self<'static> ], "Self<'static>", "Self < 'static >");
- c2!(path, [ Self::<'static> ], "Self<'static>", "Self :: < 'static >");
+ c1!(path, [ m::thing ], "m::thing");
+ c1!(path, [ self::thing ], "self::thing");
+ c1!(path, [ crate::thing ], "crate::thing");
+ c1!(path, [ Self::thing ], "Self::thing");
+ c1!(path, [ Self<'static> ], "Self<'static>");
+ c2!(path, [ Self::<'static> ], "Self<'static>", "Self::<'static>");
c1!(path, [ Self() ], "Self()");
c1!(path, [ Self() -> () ], "Self() -> ()");
}
@@ -662,16 +644,16 @@ fn test_stmt() {
// StmtKind::Local
c2!(stmt, [ let _ ], "let _;", "let _");
c2!(stmt, [ let x = true ], "let x = true;", "let x = true");
- c2!(stmt, [ let x: bool = true ], "let x: bool = true;", "let x : bool = true");
+ c2!(stmt, [ let x: bool = true ], "let x: bool = true;", "let x: bool = true");
c2!(stmt, [ let (a, b) = (1, 2) ], "let (a, b) = (1, 2);", "let(a, b) = (1, 2)"); // FIXME
c2!(stmt,
[ let (a, b): (u32, u32) = (1, 2) ],
"let (a, b): (u32, u32) = (1, 2);",
- "let(a, b) : (u32, u32) = (1, 2)"
+ "let(a, b): (u32, u32) = (1, 2)" // FIXME
);
// StmtKind::Item
- c2!(stmt, [ struct S; ], "struct S;", "struct S ;");
+ c1!(stmt, [ struct S; ], "struct S;");
c1!(stmt, [ struct S {} ], "struct S {}");
// StmtKind::Expr
@@ -684,8 +666,8 @@ fn test_stmt() {
c1!(stmt, [ ; ], ";");
// StmtKind::MacCall
- c2!(stmt, [ mac!(...) ], "mac!(...)", "mac! (...)");
- c2!(stmt, [ mac![...] ], "mac![...]", "mac! [...]");
+ c1!(stmt, [ mac!(...) ], "mac!(...)");
+ c1!(stmt, [ mac![...] ], "mac![...]");
c1!(stmt, [ mac! { ... } ], "mac! { ... }");
}
@@ -695,26 +677,27 @@ fn test_ty() {
c1!(ty, [ [T] ], "[T]");
// TyKind::Array
- c2!(ty, [ [T; 0] ], "[T; 0]", "[T ; 0]");
+ c1!(ty, [ [T; 0] ], "[T; 0]");
// TyKind::Ptr
- c2!(ty, [ *const T ], "*const T", "* const T");
- c2!(ty, [ *mut T ], "*mut T", "* mut T");
+ c1!(ty, [ *const T ], "*const T");
+ c1!(ty, [ *mut T ], "*mut T");
// TyKind::Ref
- c2!(ty, [ &T ], "&T", "& T");
- c2!(ty, [ &mut T ], "&mut T", "& mut T");
- c2!(ty, [ &'a T ], "&'a T", "& 'a T");
- c2!(ty, [ &'a mut [T] ], "&'a mut [T]", "& 'a mut [T]");
- c2!(ty, [ &A<B<C<D<E>>>> ], "&A<B<C<D<E>>>>", "& A < B < C < D < E >> >>");
+ c1!(ty, [ &T ], "&T");
+ c1!(ty, [ &mut T ], "&mut T");
+ c1!(ty, [ &'a T ], "&'a T");
+ c1!(ty, [ &'a mut [T] ], "&'a mut [T]");
+ c1!(ty, [ &A<B<C<D<E>>>> ], "&A<B<C<D<E>>>>");
+ c2!(ty, [ &A<B<C<D<E> > > > ], "&A<B<C<D<E>>>>", "&A<B<C<D<E> > > >");
// TyKind::BareFn
c1!(ty, [ fn() ], "fn()");
c1!(ty, [ fn() -> () ], "fn() -> ()");
c1!(ty, [ fn(u8) ], "fn(u8)");
- c2!(ty, [ fn(x: u8) ], "fn(x: u8)", "fn(x : u8)");
- c2!(ty, [ for<> fn() ], "fn()", "for < > fn()");
- c2!(ty, [ for<'a> fn() ], "for<'a> fn()", "for < 'a > fn()");
+ c1!(ty, [ fn(x: u8) ], "fn(x: u8)");
+ c2!(ty, [ for<> fn() ], "fn()", "for<> fn()");
+ c1!(ty, [ for<'a> fn() ], "for<'a> fn()");
// TyKind::Never
c1!(ty, [ ! ], "!");
@@ -730,28 +713,28 @@ fn test_ty() {
// TyKind::Path
c1!(ty, [ T ], "T");
- c2!(ty, [ Ref<'a> ], "Ref<'a>", "Ref < 'a >");
- c2!(ty, [ PhantomData<T> ], "PhantomData<T>", "PhantomData < T >");
- c2!(ty, [ PhantomData::<T> ], "PhantomData<T>", "PhantomData :: < T >");
+ c1!(ty, [ Ref<'a> ], "Ref<'a>");
+ c1!(ty, [ PhantomData<T> ], "PhantomData<T>");
+ c2!(ty, [ PhantomData::<T> ], "PhantomData<T>", "PhantomData::<T>");
c2!(ty, [ Fn() -> ! ], "Fn() -> !", "Fn() ->!");
c2!(ty, [ Fn(u8) -> ! ], "Fn(u8) -> !", "Fn(u8) ->!"); // FIXME
- c2!(ty, [ <Struct as Trait>::Type ], "<Struct as Trait>::Type", "< Struct as Trait > :: Type");
+ c1!(ty, [ <Struct as Trait>::Type ], "<Struct as Trait>::Type");
// TyKind::TraitObject
c1!(ty, [ dyn Send ], "dyn Send");
c1!(ty, [ dyn Send + 'a ], "dyn Send + 'a");
c1!(ty, [ dyn 'a + Send ], "dyn 'a + Send");
- c2!(ty, [ dyn ?Sized ], "dyn ?Sized", "dyn ? Sized");
- c2!(ty, [ dyn ~const Clone ], "dyn ~const Clone", "dyn ~ const Clone");
- c2!(ty, [ dyn for<'a> Send ], "dyn for<'a> Send", "dyn for < 'a > Send");
+ c1!(ty, [ dyn ?Sized ], "dyn ?Sized");
+ c1!(ty, [ dyn ~const Clone ], "dyn ~const Clone");
+ c1!(ty, [ dyn for<'a> Send ], "dyn for<'a> Send");
// TyKind::ImplTrait
c1!(ty, [ impl Send ], "impl Send");
c1!(ty, [ impl Send + 'a ], "impl Send + 'a");
c1!(ty, [ impl 'a + Send ], "impl 'a + Send");
- c2!(ty, [ impl ?Sized ], "impl ?Sized", "impl ? Sized");
- c2!(ty, [ impl ~const Clone ], "impl ~const Clone", "impl ~ const Clone");
- c2!(ty, [ impl for<'a> Send ], "impl for<'a> Send", "impl for < 'a > Send");
+ c1!(ty, [ impl ?Sized ], "impl ?Sized");
+ c1!(ty, [ impl ~const Clone ], "impl ~const Clone");
+ c1!(ty, [ impl for<'a> Send ], "impl for<'a> Send");
// TyKind::Paren
c1!(ty, [ (T) ], "(T)");
@@ -764,8 +747,8 @@ fn test_ty() {
// TyKind::ImplicitSelf: there is no syntax for this.
// TyKind::MacCall
- c2!(ty, [ mac!(...) ], "mac!(...)", "mac! (...)");
- c2!(ty, [ mac![...] ], "mac![...]", "mac! [...]");
+ c1!(ty, [ mac!(...) ], "mac!(...)");
+ c1!(ty, [ mac![...] ], "mac![...]");
c1!(ty, [ mac! { ... } ], "mac! { ... }");
// TyKind::Err: untestable.
@@ -786,13 +769,13 @@ fn test_vis() {
c2!(vis, [ pub(in crate) ], "pub(in crate) ", "pub(in crate)");
c2!(vis, [ pub(in self) ], "pub(in self) ", "pub(in self)");
c2!(vis, [ pub(in super) ], "pub(in super) ", "pub(in super)");
- c2!(vis, [ pub(in path::to) ], "pub(in path::to) ", "pub(in path :: to)");
- c2!(vis, [ pub(in ::path::to) ], "pub(in ::path::to) ", "pub(in :: path :: to)");
- c2!(vis, [ pub(in self::path::to) ], "pub(in self::path::to) ", "pub(in self :: path :: to)");
+ c2!(vis, [ pub(in path::to) ], "pub(in path::to) ", "pub(in path::to)");
+ c2!(vis, [ pub(in ::path::to) ], "pub(in ::path::to) ", "pub(in ::path::to)");
+ c2!(vis, [ pub(in self::path::to) ], "pub(in self::path::to) ", "pub(in self::path::to)");
c2!(vis,
[ pub(in super::path::to) ],
"pub(in super::path::to) ",
- "pub(in super :: path :: to)"
+ "pub(in super::path::to)"
);
// VisibilityKind::Inherited
@@ -810,7 +793,7 @@ macro_rules! p {
#[test]
fn test_punct() {
- // For all these cases, we must preserve spaces between the tokens.
+ // For all these cases, we should preserve spaces between the tokens.
// Otherwise, any old proc macro that parses pretty-printed code might glue
// together tokens that shouldn't be glued.
p!([ = = < < <= <= == == != != >= >= > > ], "= = < < <= <= == == != != >= >= > >");
@@ -823,10 +806,7 @@ fn test_punct() {
p!([ + + += += - - -= -= * * *= *= / / /= /= ], "+ + += += - - -= -= * * *= *= / / /= /=");
p!([ % % %= %= ^ ^ ^= ^= << << <<= <<= >> >> >>= >>= ],
"% % %= %= ^ ^ ^= ^= << << <<= <<= >> >> >>= >>=");
-
- // For these one we must insert spaces between adjacent tokens, again due
- // to proc macros.
- p!([ +! ?= |> >>@ --> <-- $$ =====> ], "+! ? = | > >> @ - -> <- - $$== == =>"); // FIXME
- p!([ ,; ;, ** @@ $+$ >< <> ?? +== ], ", ; ;, * * @ @ $+ $> < < > ? ? += ="); // FIXME
- p!([ :#!@|$=&*,+;*~? ], ": #! @ | $= & *, + ; * ~ ?"); // FIXME
+ p!([ +! ?= |> >>@ --> <-- $$ =====> ], "+! ?= |> >>@ --> <-- $$=====>");
+ p!([ ,; ;, ** @@ $+$ >< <> ?? +== ], ",; ;, ** @@ $+$>< <> ?? +=="); // FIXME: `$ >` -> `$>`
+ p!([ :#!@|$=&*,+;*~? ], ":#!@|$=&*,+;*~?");
}
generated by cgit v1.2.3 (git 2.39.1) at 2025-01-07 13:28:21 +0000